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 regular roles, unless the user already has
071            * these regular roles. The default regular 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 matching UUID and company.
1797            *
1798            * @param uuid the user's UUID
1799            * @param companyId the primary key of the company
1800            * @return the matching user
1801            * @throws PortalException if a matching user could not be found
1802            */
1803            @Override
1804            public com.liferay.portal.model.User getUserByUuidAndCompanyId(
1805                    java.lang.String uuid, long companyId)
1806                    throws com.liferay.portal.kernel.exception.PortalException {
1807                    return _userLocalService.getUserByUuidAndCompanyId(uuid, companyId);
1808            }
1809    
1810            /**
1811            * Returns the userGroupIds of the user groups associated with the user.
1812            *
1813            * @param userId the userId of the user
1814            * @return long[] the userGroupIds of user groups associated with the user
1815            */
1816            @Override
1817            public long[] getUserGroupPrimaryKeys(long userId) {
1818                    return _userLocalService.getUserGroupPrimaryKeys(userId);
1819            }
1820    
1821            @Override
1822            public java.util.List<com.liferay.portal.model.User> getUserGroupUsers(
1823                    long userGroupId) {
1824                    return _userLocalService.getUserGroupUsers(userGroupId);
1825            }
1826    
1827            @Override
1828            public java.util.List<com.liferay.portal.model.User> getUserGroupUsers(
1829                    long userGroupId, int start, int end) {
1830                    return _userLocalService.getUserGroupUsers(userGroupId, start, end);
1831            }
1832    
1833            @Override
1834            public java.util.List<com.liferay.portal.model.User> getUserGroupUsers(
1835                    long userGroupId, int start, int end,
1836                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) {
1837                    return _userLocalService.getUserGroupUsers(userGroupId, start, end,
1838                            orderByComparator);
1839            }
1840    
1841            @Override
1842            public int getUserGroupUsersCount(long userGroupId) {
1843                    return _userLocalService.getUserGroupUsersCount(userGroupId);
1844            }
1845    
1846            /**
1847            * Returns the number of users with the status belonging to the user group.
1848            *
1849            * @param userGroupId the primary key of the user group
1850            * @param status the workflow status
1851            * @return the number of users with the status belonging to the user group
1852            */
1853            @Override
1854            public int getUserGroupUsersCount(long userGroupId, int status)
1855                    throws com.liferay.portal.kernel.exception.PortalException {
1856                    return _userLocalService.getUserGroupUsersCount(userGroupId, status);
1857            }
1858    
1859            /**
1860            * Returns the primary key of the user with the email address.
1861            *
1862            * @param companyId the primary key of the user's company
1863            * @param emailAddress the user's email address
1864            * @return the primary key of the user with the email address
1865            */
1866            @Override
1867            public long getUserIdByEmailAddress(long companyId,
1868                    java.lang.String emailAddress)
1869                    throws com.liferay.portal.kernel.exception.PortalException {
1870                    return _userLocalService.getUserIdByEmailAddress(companyId, emailAddress);
1871            }
1872    
1873            /**
1874            * Returns the primary key of the user with the screen name.
1875            *
1876            * @param companyId the primary key of the user's company
1877            * @param screenName the user's screen name
1878            * @return the primary key of the user with the screen name
1879            */
1880            @Override
1881            public long getUserIdByScreenName(long companyId,
1882                    java.lang.String screenName)
1883                    throws com.liferay.portal.kernel.exception.PortalException {
1884                    return _userLocalService.getUserIdByScreenName(companyId, screenName);
1885            }
1886    
1887            /**
1888            * Returns a range of all the users.
1889            *
1890            * <p>
1891            * 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.
1892            * </p>
1893            *
1894            * @param start the lower bound of the range of users
1895            * @param end the upper bound of the range of users (not inclusive)
1896            * @return the range of users
1897            */
1898            @Override
1899            public java.util.List<com.liferay.portal.model.User> getUsers(int start,
1900                    int end) {
1901                    return _userLocalService.getUsers(start, end);
1902            }
1903    
1904            /**
1905            * Returns the number of users.
1906            *
1907            * @return the number of users
1908            */
1909            @Override
1910            public int getUsersCount() {
1911                    return _userLocalService.getUsersCount();
1912            }
1913    
1914            @Override
1915            public boolean hasGroupUser(long groupId, long userId) {
1916                    return _userLocalService.hasGroupUser(groupId, userId);
1917            }
1918    
1919            @Override
1920            public boolean hasGroupUsers(long groupId) {
1921                    return _userLocalService.hasGroupUsers(groupId);
1922            }
1923    
1924            @Override
1925            public boolean hasOrganizationUser(long organizationId, long userId) {
1926                    return _userLocalService.hasOrganizationUser(organizationId, userId);
1927            }
1928    
1929            @Override
1930            public boolean hasOrganizationUsers(long organizationId) {
1931                    return _userLocalService.hasOrganizationUsers(organizationId);
1932            }
1933    
1934            /**
1935            * Returns <code>true</code> if the password policy has been assigned to the
1936            * user.
1937            *
1938            * @param passwordPolicyId the primary key of the password policy
1939            * @param userId the primary key of the user
1940            * @return <code>true</code> if the password policy is assigned to the user;
1941            <code>false</code> otherwise
1942            */
1943            @Override
1944            public boolean hasPasswordPolicyUser(long passwordPolicyId, long userId) {
1945                    return _userLocalService.hasPasswordPolicyUser(passwordPolicyId, userId);
1946            }
1947    
1948            /**
1949            * Returns <code>true</code> if the user has the role with the name,
1950            * optionally through inheritance.
1951            *
1952            * @param companyId the primary key of the role's company
1953            * @param name the name of the role (must be a regular role, not an
1954            organization, site or provider role)
1955            * @param userId the primary key of the user
1956            * @param inherited whether to include roles inherited from organizations,
1957            sites, etc.
1958            * @return <code>true</code> if the user has the role; <code>false</code>
1959            otherwise
1960            */
1961            @Override
1962            public boolean hasRoleUser(long companyId, java.lang.String name,
1963                    long userId, boolean inherited)
1964                    throws com.liferay.portal.kernel.exception.PortalException {
1965                    return _userLocalService.hasRoleUser(companyId, name, userId, inherited);
1966            }
1967    
1968            @Override
1969            public boolean hasRoleUser(long roleId, long userId) {
1970                    return _userLocalService.hasRoleUser(roleId, userId);
1971            }
1972    
1973            @Override
1974            public boolean hasRoleUsers(long roleId) {
1975                    return _userLocalService.hasRoleUsers(roleId);
1976            }
1977    
1978            @Override
1979            public boolean hasTeamUser(long teamId, long userId) {
1980                    return _userLocalService.hasTeamUser(teamId, userId);
1981            }
1982    
1983            @Override
1984            public boolean hasTeamUsers(long teamId) {
1985                    return _userLocalService.hasTeamUsers(teamId);
1986            }
1987    
1988            @Override
1989            public boolean hasUserGroupUser(long userGroupId, long userId) {
1990                    return _userLocalService.hasUserGroupUser(userGroupId, userId);
1991            }
1992    
1993            @Override
1994            public boolean hasUserGroupUsers(long userGroupId) {
1995                    return _userLocalService.hasUserGroupUsers(userGroupId);
1996            }
1997    
1998            /**
1999            * Returns <code>true</code> if the user's password is expired.
2000            *
2001            * @param user the user
2002            * @return <code>true</code> if the user's password is expired;
2003            <code>false</code> otherwise
2004            */
2005            @Override
2006            public boolean isPasswordExpired(com.liferay.portal.model.User user)
2007                    throws com.liferay.portal.kernel.exception.PortalException {
2008                    return _userLocalService.isPasswordExpired(user);
2009            }
2010    
2011            /**
2012            * Returns <code>true</code> if the password policy is configured to warn
2013            * the user that his password is expiring and the remaining time until
2014            * expiration is equal or less than the configured warning time.
2015            *
2016            * @param user the user
2017            * @return <code>true</code> if the user's password is expiring soon;
2018            <code>false</code> otherwise
2019            */
2020            @Override
2021            public boolean isPasswordExpiringSoon(com.liferay.portal.model.User user)
2022                    throws com.liferay.portal.kernel.exception.PortalException {
2023                    return _userLocalService.isPasswordExpiringSoon(user);
2024            }
2025    
2026            /**
2027            * Returns the default user for the company.
2028            *
2029            * @param companyId the primary key of the company
2030            * @return the default user for the company
2031            */
2032            @Override
2033            public com.liferay.portal.model.User loadGetDefaultUser(long companyId)
2034                    throws com.liferay.portal.kernel.exception.PortalException {
2035                    return _userLocalService.loadGetDefaultUser(companyId);
2036            }
2037    
2038            /**
2039            * Returns an ordered range of all the users with the status, and whose
2040            * first name, middle name, last name, screen name, and email address match
2041            * the keywords specified for them, without using the indexer. It is
2042            * preferable to use the indexed version {@link #search(long, String,
2043            * String, String, String, String, int, LinkedHashMap, boolean, int, int,
2044            * Sort)} instead of this method wherever possible for performance reasons.
2045            *
2046            * <p>
2047            * Useful when paginating results. Returns a maximum of <code>end -
2048            * start</code> instances. <code>start</code> and <code>end</code> are not
2049            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2050            * refers to the first result in the set. Setting both <code>start</code>
2051            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2052            * result set.
2053            * </p>
2054            *
2055            * @param companyId the primary key of the user's company
2056            * @param firstName the first name keywords (space separated)
2057            * @param middleName the middle name keywords
2058            * @param lastName the last name keywords
2059            * @param screenName the screen name keywords
2060            * @param emailAddress the email address keywords
2061            * @param status the workflow status
2062            * @param params the finder parameters (optionally <code>null</code>). For
2063            more information see {@link
2064            com.liferay.portal.service.persistence.UserFinder}.
2065            * @param andSearch whether every field must match its keywords, or just
2066            one field. For example, &quot;users with the first name 'bob' and
2067            last name 'smith'&quot; vs &quot;users with the first name 'bob'
2068            or the last name 'smith'&quot;.
2069            * @param start the lower bound of the range of users
2070            * @param end the upper bound of the range of users (not inclusive)
2071            * @param obc the comparator to order the users by (optionally
2072            <code>null</code>)
2073            * @return the matching users
2074            * @see com.liferay.portal.service.persistence.UserFinder
2075            */
2076            @Override
2077            public java.util.List<com.liferay.portal.model.User> search(
2078                    long companyId, java.lang.String firstName,
2079                    java.lang.String middleName, java.lang.String lastName,
2080                    java.lang.String screenName, java.lang.String emailAddress, int status,
2081                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2082                    boolean andSearch, int start, int end,
2083                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) {
2084                    return _userLocalService.search(companyId, firstName, middleName,
2085                            lastName, screenName, emailAddress, status, params, andSearch,
2086                            start, end, obc);
2087            }
2088    
2089            /**
2090            * Returns an ordered range of all the users with the status, and whose
2091            * first name, middle name, last name, screen name, and email address match
2092            * the keywords specified for them, using the indexer. It is preferable to
2093            * use this method instead of the non-indexed version whenever possible for
2094            * performance reasons.
2095            *
2096            * <p>
2097            * Useful when paginating results. Returns a maximum of <code>end -
2098            * start</code> instances. <code>start</code> and <code>end</code> are not
2099            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2100            * refers to the first result in the set. Setting both <code>start</code>
2101            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2102            * result set.
2103            * </p>
2104            *
2105            * @param companyId the primary key of the user's company
2106            * @param firstName the first name keywords (space separated)
2107            * @param middleName the middle name keywords
2108            * @param lastName the last name keywords
2109            * @param screenName the screen name keywords
2110            * @param emailAddress the email address keywords
2111            * @param status the workflow status
2112            * @param params the indexer parameters (optionally <code>null</code>). For
2113            more information see {@link
2114            com.liferay.portlet.usersadmin.util.UserIndexer}.
2115            * @param andSearch whether every field must match its keywords, or just
2116            one field. For example, &quot;users with the first name 'bob' and
2117            last name 'smith'&quot; vs &quot;users with the first name 'bob'
2118            or the last name 'smith'&quot;.
2119            * @param start the lower bound of the range of users
2120            * @param end the upper bound of the range of users (not inclusive)
2121            * @param sort the field and direction to sort by (optionally
2122            <code>null</code>)
2123            * @return the matching users
2124            * @see com.liferay.portlet.usersadmin.util.UserIndexer
2125            */
2126            @Override
2127            public com.liferay.portal.kernel.search.Hits search(long companyId,
2128                    java.lang.String firstName, java.lang.String middleName,
2129                    java.lang.String lastName, java.lang.String screenName,
2130                    java.lang.String emailAddress, int status,
2131                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2132                    boolean andSearch, int start, int end,
2133                    com.liferay.portal.kernel.search.Sort sort) {
2134                    return _userLocalService.search(companyId, firstName, middleName,
2135                            lastName, screenName, emailAddress, status, params, andSearch,
2136                            start, end, sort);
2137            }
2138    
2139            @Override
2140            public com.liferay.portal.kernel.search.Hits search(long companyId,
2141                    java.lang.String firstName, java.lang.String middleName,
2142                    java.lang.String lastName, java.lang.String screenName,
2143                    java.lang.String emailAddress, int status,
2144                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2145                    boolean andSearch, int start, int end,
2146                    com.liferay.portal.kernel.search.Sort[] sorts) {
2147                    return _userLocalService.search(companyId, firstName, middleName,
2148                            lastName, screenName, emailAddress, status, params, andSearch,
2149                            start, end, sorts);
2150            }
2151    
2152            /**
2153            * Returns an ordered range of all the users who match the keywords and
2154            * status, without using the indexer. It is preferable to use the indexed
2155            * version {@link #search(long, String, int, LinkedHashMap, int, int, Sort)}
2156            * instead of this method wherever possible for performance reasons.
2157            *
2158            * <p>
2159            * Useful when paginating results. Returns a maximum of <code>end -
2160            * start</code> instances. <code>start</code> and <code>end</code> are not
2161            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2162            * refers to the first result in the set. Setting both <code>start</code>
2163            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2164            * result set.
2165            * </p>
2166            *
2167            * @param companyId the primary key of the user's company
2168            * @param keywords the keywords (space separated), which may occur in the
2169            user's first name, middle name, last name, screen name, or email
2170            address
2171            * @param status the workflow status
2172            * @param params the finder parameters (optionally <code>null</code>). For
2173            more information see {@link
2174            com.liferay.portal.service.persistence.UserFinder}.
2175            * @param start the lower bound of the range of users
2176            * @param end the upper bound of the range of users (not inclusive)
2177            * @param obc the comparator to order the users by (optionally
2178            <code>null</code>)
2179            * @return the matching users
2180            * @see com.liferay.portal.service.persistence.UserFinder
2181            */
2182            @Override
2183            public java.util.List<com.liferay.portal.model.User> search(
2184                    long companyId, java.lang.String keywords, int status,
2185                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2186                    int start, int end,
2187                    com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) {
2188                    return _userLocalService.search(companyId, keywords, status, params,
2189                            start, end, obc);
2190            }
2191    
2192            /**
2193            * Returns an ordered range of all the users who match the keywords and
2194            * status, using the indexer. It is preferable to use this method instead of
2195            * the non-indexed version whenever possible for performance reasons.
2196            *
2197            * <p>
2198            * Useful when paginating results. Returns a maximum of <code>end -
2199            * start</code> instances. <code>start</code> and <code>end</code> are not
2200            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2201            * refers to the first result in the set. Setting both <code>start</code>
2202            * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full
2203            * result set.
2204            * </p>
2205            *
2206            * @param companyId the primary key of the user's company
2207            * @param keywords the keywords (space separated), which may occur in the
2208            user's first name, middle name, last name, screen name, or email
2209            address
2210            * @param status the workflow status
2211            * @param params the indexer parameters (optionally <code>null</code>). For
2212            more information see {@link
2213            com.liferay.portlet.usersadmin.util.UserIndexer}.
2214            * @param start the lower bound of the range of users
2215            * @param end the upper bound of the range of users (not inclusive)
2216            * @param sort the field and direction to sort by (optionally
2217            <code>null</code>)
2218            * @return the matching users
2219            * @see com.liferay.portlet.usersadmin.util.UserIndexer
2220            */
2221            @Override
2222            public com.liferay.portal.kernel.search.Hits search(long companyId,
2223                    java.lang.String keywords, int status,
2224                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2225                    int start, int end, com.liferay.portal.kernel.search.Sort sort) {
2226                    return _userLocalService.search(companyId, keywords, status, params,
2227                            start, end, sort);
2228            }
2229    
2230            @Override
2231            public com.liferay.portal.kernel.search.Hits search(long companyId,
2232                    java.lang.String keywords, int status,
2233                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2234                    int start, int end, com.liferay.portal.kernel.search.Sort[] sorts) {
2235                    return _userLocalService.search(companyId, keywords, status, params,
2236                            start, end, sorts);
2237            }
2238    
2239            /**
2240            * Returns the number of users with the status, and whose first name, middle
2241            * name, last name, screen name, and email address match the keywords
2242            * specified for them.
2243            *
2244            * @param companyId the primary key of the user's company
2245            * @param firstName the first name keywords (space separated)
2246            * @param middleName the middle name keywords
2247            * @param lastName the last name keywords
2248            * @param screenName the screen name keywords
2249            * @param emailAddress the email address keywords
2250            * @param status the workflow status
2251            * @param params the finder parameters (optionally <code>null</code>). For
2252            more information see {@link
2253            com.liferay.portal.service.persistence.UserFinder}.
2254            * @param andSearch whether every field must match its keywords, or just
2255            one field. For example, &quot;users with the first name 'bob' and
2256            last name 'smith'&quot; vs &quot;users with the first name 'bob'
2257            or the last name 'smith'&quot;.
2258            * @return the number of matching users
2259            */
2260            @Override
2261            public int searchCount(long companyId, java.lang.String firstName,
2262                    java.lang.String middleName, java.lang.String lastName,
2263                    java.lang.String screenName, java.lang.String emailAddress, int status,
2264                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2265                    boolean andSearch) {
2266                    return _userLocalService.searchCount(companyId, firstName, middleName,
2267                            lastName, screenName, emailAddress, status, params, andSearch);
2268            }
2269    
2270            /**
2271            * Returns the number of users who match the keywords and status.
2272            *
2273            * @param companyId the primary key of the user's company
2274            * @param keywords the keywords (space separated), which may occur in the
2275            user's first name, middle name, last name, screen name, or email
2276            address
2277            * @param status the workflow status
2278            * @param params the finder parameters (optionally <code>null</code>). For
2279            more information see {@link
2280            com.liferay.portal.service.persistence.UserFinder}.
2281            * @return the number matching users
2282            */
2283            @Override
2284            public int searchCount(long companyId, java.lang.String keywords,
2285                    int status,
2286                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) {
2287                    return _userLocalService.searchCount(companyId, keywords, status, params);
2288            }
2289    
2290            @Override
2291            public java.util.Map<java.lang.Long, java.lang.Integer> searchCounts(
2292                    long companyId, int status, long[] groupIds) {
2293                    return _userLocalService.searchCounts(companyId, status, groupIds);
2294            }
2295    
2296            @Override
2297            public java.util.List<com.liferay.portal.model.User> searchSocial(
2298                    long companyId, long[] groupIds, java.lang.String keywords, int start,
2299                    int end) {
2300                    return _userLocalService.searchSocial(companyId, groupIds, keywords,
2301                            start, end);
2302            }
2303    
2304            @Override
2305            public java.util.List<com.liferay.portal.model.User> searchSocial(
2306                    long[] groupIds, long userId, int[] socialRelationTypes,
2307                    java.lang.String keywords, int start, int end)
2308                    throws com.liferay.portal.kernel.exception.PortalException {
2309                    return _userLocalService.searchSocial(groupIds, userId,
2310                            socialRelationTypes, keywords, start, end);
2311            }
2312    
2313            @Override
2314            public java.util.List<com.liferay.portal.model.User> searchSocial(
2315                    long userId, int[] socialRelationTypes, java.lang.String keywords,
2316                    int start, int end)
2317                    throws com.liferay.portal.kernel.exception.PortalException {
2318                    return _userLocalService.searchSocial(userId, socialRelationTypes,
2319                            keywords, start, end);
2320            }
2321    
2322            @Override
2323            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2324                    long companyId, java.lang.String firstName,
2325                    java.lang.String middleName, java.lang.String lastName,
2326                    java.lang.String screenName, java.lang.String emailAddress, int status,
2327                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2328                    boolean andSearch, int start, int end,
2329                    com.liferay.portal.kernel.search.Sort sort)
2330                    throws com.liferay.portal.kernel.exception.PortalException {
2331                    return _userLocalService.searchUsers(companyId, firstName, middleName,
2332                            lastName, screenName, emailAddress, status, params, andSearch,
2333                            start, end, sort);
2334            }
2335    
2336            @Override
2337            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2338                    long companyId, java.lang.String firstName,
2339                    java.lang.String middleName, java.lang.String lastName,
2340                    java.lang.String screenName, java.lang.String emailAddress, int status,
2341                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2342                    boolean andSearch, int start, int end,
2343                    com.liferay.portal.kernel.search.Sort[] sorts)
2344                    throws com.liferay.portal.kernel.exception.PortalException {
2345                    return _userLocalService.searchUsers(companyId, firstName, middleName,
2346                            lastName, screenName, emailAddress, status, params, andSearch,
2347                            start, end, sorts);
2348            }
2349    
2350            @Override
2351            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2352                    long companyId, java.lang.String keywords, int status,
2353                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2354                    int start, int end, com.liferay.portal.kernel.search.Sort sort)
2355                    throws com.liferay.portal.kernel.exception.PortalException {
2356                    return _userLocalService.searchUsers(companyId, keywords, status,
2357                            params, start, end, sort);
2358            }
2359    
2360            @Override
2361            public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers(
2362                    long companyId, java.lang.String keywords, int status,
2363                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2364                    int start, int end, com.liferay.portal.kernel.search.Sort[] sorts)
2365                    throws com.liferay.portal.kernel.exception.PortalException {
2366                    return _userLocalService.searchUsers(companyId, keywords, status,
2367                            params, start, end, sorts);
2368            }
2369    
2370            /**
2371            * Sends an email address verification to the user.
2372            *
2373            * @param user the verification email recipient
2374            * @param emailAddress the recipient's email address
2375            * @param serviceContext the service context to be applied. Must set the
2376            portal URL, main path, primary key of the layout, remote address,
2377            remote host, and agent for the user.
2378            */
2379            @Override
2380            public void sendEmailAddressVerification(
2381                    com.liferay.portal.model.User user, java.lang.String emailAddress,
2382                    com.liferay.portal.service.ServiceContext serviceContext)
2383                    throws com.liferay.portal.kernel.exception.PortalException {
2384                    _userLocalService.sendEmailAddressVerification(user, emailAddress,
2385                            serviceContext);
2386            }
2387    
2388            /**
2389            * Sends the password email to the user with the email address. The content
2390            * of this email can be specified in <code>portal.properties</code> with the
2391            * <code>admin.email.password</code> keys.
2392            *
2393            * @param companyId the primary key of the user's company
2394            * @param emailAddress the user's email address
2395            * @param fromName the name of the individual that the email should be from
2396            * @param fromAddress the address of the individual that the email should be
2397            from
2398            * @param subject the email subject. If <code>null</code>, the subject
2399            specified in <code>portal.properties</code> will be used.
2400            * @param body the email body. If <code>null</code>, the body specified in
2401            <code>portal.properties</code> will be used.
2402            * @param serviceContext the service context to be applied
2403            */
2404            @Override
2405            public boolean sendPassword(long companyId, java.lang.String emailAddress,
2406                    java.lang.String fromName, java.lang.String fromAddress,
2407                    java.lang.String subject, java.lang.String body,
2408                    com.liferay.portal.service.ServiceContext serviceContext)
2409                    throws com.liferay.portal.kernel.exception.PortalException {
2410                    return _userLocalService.sendPassword(companyId, emailAddress,
2411                            fromName, fromAddress, subject, body, serviceContext);
2412            }
2413    
2414            /**
2415            * Sends a password notification email to the user matching the email
2416            * address. The portal's settings determine whether a password is sent
2417            * explicitly or whether a link for resetting the user's password is sent.
2418            * The method sends the email asynchronously and returns before the email is
2419            * sent.
2420            *
2421            * <p>
2422            * The content of the notification email is specified with the
2423            * <code>admin.email.password</code> portal property keys. They can be
2424            * overridden via a <code>portal-ext.properties</code> file or modified
2425            * through the Portal Settings UI.
2426            * </p>
2427            *
2428            * @param companyId the primary key of the user's company
2429            * @param emailAddress the user's email address
2430            * @return <code>true</code> if the notification email includes a new
2431            password; <code>false</code> if the notification email only
2432            contains a reset link
2433            */
2434            @Override
2435            public boolean sendPasswordByEmailAddress(long companyId,
2436                    java.lang.String emailAddress)
2437                    throws com.liferay.portal.kernel.exception.PortalException {
2438                    return _userLocalService.sendPasswordByEmailAddress(companyId,
2439                            emailAddress);
2440            }
2441    
2442            /**
2443            * Sends a password notification email to the user matching the screen name.
2444            * The portal's settings determine whether a password is sent explicitly or
2445            * whether a link for resetting the user's password is sent. The method
2446            * sends the email asynchronously and returns before the email is sent.
2447            *
2448            * <p>
2449            * The content of the notification email is specified with the
2450            * <code>admin.email.password</code> portal property keys. They can be
2451            * overridden via a <code>portal-ext.properties</code> file or modified
2452            * through the Portal Settings UI.
2453            * </p>
2454            *
2455            * @param companyId the primary key of the user's company
2456            * @param screenName the user's screen name
2457            * @return <code>true</code> if the notification email includes a new
2458            password; <code>false</code> if the notification email only
2459            contains a reset link
2460            */
2461            @Override
2462            public boolean sendPasswordByScreenName(long companyId,
2463                    java.lang.String screenName)
2464                    throws com.liferay.portal.kernel.exception.PortalException {
2465                    return _userLocalService.sendPasswordByScreenName(companyId, screenName);
2466            }
2467    
2468            /**
2469            * Sends a password notification email to the user matching the ID. The
2470            * portal's settings determine whether a password is sent explicitly or
2471            * whether a link for resetting the user's password is sent. The method
2472            * sends the email asynchronously and returns before the email is sent.
2473            *
2474            * <p>
2475            * The content of the notification email is specified with the
2476            * <code>admin.email.password</code> portal property keys. They can be
2477            * overridden via a <code>portal-ext.properties</code> file or modified
2478            * through the Portal Settings UI.
2479            * </p>
2480            *
2481            * @param userId the user's primary key
2482            * @return <code>true</code> if the notification email includes a new
2483            password; <code>false</code> if the notification email only
2484            contains a reset link
2485            */
2486            @Override
2487            public boolean sendPasswordByUserId(long userId)
2488                    throws com.liferay.portal.kernel.exception.PortalException {
2489                    return _userLocalService.sendPasswordByUserId(userId);
2490            }
2491    
2492            @Override
2493            public void setGroupUsers(long groupId, long[] userIds) {
2494                    _userLocalService.setGroupUsers(groupId, userIds);
2495            }
2496    
2497            @Override
2498            public void setOrganizationUsers(long organizationId, long[] userIds) {
2499                    _userLocalService.setOrganizationUsers(organizationId, userIds);
2500            }
2501    
2502            /**
2503            * @throws PortalException
2504            */
2505            @Override
2506            public void setRoleUsers(long roleId, long[] userIds)
2507                    throws com.liferay.portal.kernel.exception.PortalException {
2508                    _userLocalService.setRoleUsers(roleId, userIds);
2509            }
2510    
2511            @Override
2512            public void setTeamUsers(long teamId, long[] userIds) {
2513                    _userLocalService.setTeamUsers(teamId, userIds);
2514            }
2515    
2516            /**
2517            * @throws PortalException
2518            */
2519            @Override
2520            public void setUserGroupUsers(long userGroupId, long[] userIds)
2521                    throws com.liferay.portal.kernel.exception.PortalException {
2522                    _userLocalService.setUserGroupUsers(userGroupId, userIds);
2523            }
2524    
2525            /**
2526            * Removes the users from the teams of a group.
2527            *
2528            * @param groupId the primary key of the group
2529            * @param userIds the primary keys of the users
2530            */
2531            @Override
2532            public void unsetGroupTeamsUsers(long groupId, long[] userIds)
2533                    throws com.liferay.portal.kernel.exception.PortalException {
2534                    _userLocalService.unsetGroupTeamsUsers(groupId, userIds);
2535            }
2536    
2537            /**
2538            * Removes the users from the group.
2539            *
2540            * @param groupId the primary key of the group
2541            * @param userIds the primary keys of the users
2542            * @param serviceContext the service context to be applied (optionally
2543            <code>null</code>)
2544            */
2545            @Override
2546            public void unsetGroupUsers(long groupId, long[] userIds,
2547                    com.liferay.portal.service.ServiceContext serviceContext)
2548                    throws com.liferay.portal.kernel.exception.PortalException {
2549                    _userLocalService.unsetGroupUsers(groupId, userIds, serviceContext);
2550            }
2551    
2552            /**
2553            * Removes the users from the organization.
2554            *
2555            * @param organizationId the primary key of the organization
2556            * @param userIds the primary keys of the users
2557            */
2558            @Override
2559            public void unsetOrganizationUsers(long organizationId, long[] userIds)
2560                    throws com.liferay.portal.kernel.exception.PortalException {
2561                    _userLocalService.unsetOrganizationUsers(organizationId, userIds);
2562            }
2563    
2564            /**
2565            * Removes the users from the password policy.
2566            *
2567            * @param passwordPolicyId the primary key of the password policy
2568            * @param userIds the primary keys of the users
2569            */
2570            @Override
2571            public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds) {
2572                    _userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
2573            }
2574    
2575            /**
2576            * Removes the users from the role.
2577            *
2578            * @param roleId the primary key of the role
2579            * @param userIds the primary keys of the users
2580            */
2581            @Override
2582            public void unsetRoleUsers(long roleId, long[] userIds)
2583                    throws com.liferay.portal.kernel.exception.PortalException {
2584                    _userLocalService.unsetRoleUsers(roleId, userIds);
2585            }
2586    
2587            /**
2588            * Removes the users from the role.
2589            *
2590            * @param roleId the primary key of the role
2591            * @param users the users
2592            */
2593            @Override
2594            public void unsetRoleUsers(long roleId,
2595                    java.util.List<com.liferay.portal.model.User> users)
2596                    throws com.liferay.portal.kernel.exception.PortalException {
2597                    _userLocalService.unsetRoleUsers(roleId, users);
2598            }
2599    
2600            /**
2601            * Removes the users from the team.
2602            *
2603            * @param teamId the primary key of the team
2604            * @param userIds the primary keys of the users
2605            */
2606            @Override
2607            public void unsetTeamUsers(long teamId, long[] userIds)
2608                    throws com.liferay.portal.kernel.exception.PortalException {
2609                    _userLocalService.unsetTeamUsers(teamId, userIds);
2610            }
2611    
2612            /**
2613            * Removes the users from the user group.
2614            *
2615            * @param userGroupId the primary key of the user group
2616            * @param userIds the primary keys of the users
2617            */
2618            @Override
2619            public void unsetUserGroupUsers(long userGroupId, long[] userIds)
2620                    throws com.liferay.portal.kernel.exception.PortalException {
2621                    _userLocalService.unsetUserGroupUsers(userGroupId, userIds);
2622            }
2623    
2624            /**
2625            * Updates whether the user has agreed to the terms of use.
2626            *
2627            * @param userId the primary key of the user
2628            * @param agreedToTermsOfUse whether the user has agreet to the terms of
2629            use
2630            * @return the user
2631            */
2632            @Override
2633            public com.liferay.portal.model.User updateAgreedToTermsOfUse(long userId,
2634                    boolean agreedToTermsOfUse)
2635                    throws com.liferay.portal.kernel.exception.PortalException {
2636                    return _userLocalService.updateAgreedToTermsOfUse(userId,
2637                            agreedToTermsOfUse);
2638            }
2639    
2640            /**
2641            * Updates the user's asset with the new asset categories and tag names,
2642            * removing and adding asset categories and tag names as necessary.
2643            *
2644            * @param userId the primary key of the user
2645            * @param user ID the primary key of the user
2646            * @param assetCategoryIds the primary key's of the new asset categories
2647            * @param assetTagNames the new asset tag names
2648            */
2649            @Override
2650            public void updateAsset(long userId, com.liferay.portal.model.User user,
2651                    long[] assetCategoryIds, java.lang.String[] assetTagNames)
2652                    throws com.liferay.portal.kernel.exception.PortalException {
2653                    _userLocalService.updateAsset(userId, user, assetCategoryIds,
2654                            assetTagNames);
2655            }
2656    
2657            /**
2658            * Updates the user's creation date.
2659            *
2660            * @param userId the primary key of the user
2661            * @param createDate the new creation date
2662            * @return the user
2663            */
2664            @Override
2665            public com.liferay.portal.model.User updateCreateDate(long userId,
2666                    java.util.Date createDate)
2667                    throws com.liferay.portal.kernel.exception.PortalException {
2668                    return _userLocalService.updateCreateDate(userId, createDate);
2669            }
2670    
2671            /**
2672            * Updates the user's email address.
2673            *
2674            * @param userId the primary key of the user
2675            * @param password the user's password
2676            * @param emailAddress1 the user's new email address
2677            * @param emailAddress2 the user's new email address confirmation
2678            * @return the user
2679            */
2680            @Override
2681            public com.liferay.portal.model.User updateEmailAddress(long userId,
2682                    java.lang.String password, java.lang.String emailAddress1,
2683                    java.lang.String emailAddress2)
2684                    throws com.liferay.portal.kernel.exception.PortalException {
2685                    return _userLocalService.updateEmailAddress(userId, password,
2686                            emailAddress1, emailAddress2);
2687            }
2688    
2689            /**
2690            * Updates the user's email address or sends verification email.
2691            *
2692            * @param userId the primary key of the user
2693            * @param password the user's password
2694            * @param emailAddress1 the user's new email address
2695            * @param emailAddress2 the user's new email address confirmation
2696            * @param serviceContext the service context to be applied. Must set the
2697            portal URL, main path, primary key of the layout, remote address,
2698            remote host, and agent for the user.
2699            * @return the user
2700            */
2701            @Override
2702            public com.liferay.portal.model.User updateEmailAddress(long userId,
2703                    java.lang.String password, java.lang.String emailAddress1,
2704                    java.lang.String emailAddress2,
2705                    com.liferay.portal.service.ServiceContext serviceContext)
2706                    throws com.liferay.portal.kernel.exception.PortalException {
2707                    return _userLocalService.updateEmailAddress(userId, password,
2708                            emailAddress1, emailAddress2, serviceContext);
2709            }
2710    
2711            /**
2712            * Updates whether the user has verified email address.
2713            *
2714            * @param userId the primary key of the user
2715            * @param emailAddressVerified whether the user has verified email address
2716            * @return the user
2717            */
2718            @Override
2719            public com.liferay.portal.model.User updateEmailAddressVerified(
2720                    long userId, boolean emailAddressVerified)
2721                    throws com.liferay.portal.kernel.exception.PortalException {
2722                    return _userLocalService.updateEmailAddressVerified(userId,
2723                            emailAddressVerified);
2724            }
2725    
2726            /**
2727            * Updates the user's Facebook ID.
2728            *
2729            * @param userId the primary key of the user
2730            * @param facebookId the user's new Facebook ID
2731            * @return the user
2732            */
2733            @Override
2734            public com.liferay.portal.model.User updateFacebookId(long userId,
2735                    long facebookId)
2736                    throws com.liferay.portal.kernel.exception.PortalException {
2737                    return _userLocalService.updateFacebookId(userId, facebookId);
2738            }
2739    
2740            /**
2741            * Sets the groups the user is in, removing and adding groups as necessary.
2742            *
2743            * @param userId the primary key of the user
2744            * @param newGroupIds the primary keys of the groups
2745            * @param serviceContext the service context to be applied (optionally
2746            <code>null</code>)
2747            */
2748            @Override
2749            public void updateGroups(long userId, long[] newGroupIds,
2750                    com.liferay.portal.service.ServiceContext serviceContext)
2751                    throws com.liferay.portal.kernel.exception.PortalException {
2752                    _userLocalService.updateGroups(userId, newGroupIds, serviceContext);
2753            }
2754    
2755            /**
2756            * Updates a user account that was automatically created when a guest user
2757            * participated in an action (e.g. posting a comment) and only provided his
2758            * name and email address.
2759            *
2760            * @param creatorUserId the primary key of the creator
2761            * @param companyId the primary key of the user's company
2762            * @param autoPassword whether a password should be automatically generated
2763            for the user
2764            * @param password1 the user's password
2765            * @param password2 the user's password confirmation
2766            * @param autoScreenName whether a screen name should be automatically
2767            generated for the user
2768            * @param screenName the user's screen name
2769            * @param emailAddress the user's email address
2770            * @param facebookId the user's facebook ID
2771            * @param openId the user's OpenID
2772            * @param locale the user's locale
2773            * @param firstName the user's first name
2774            * @param middleName the user's middle name
2775            * @param lastName the user's last name
2776            * @param prefixId the user's name prefix ID
2777            * @param suffixId the user's name suffix ID
2778            * @param male whether the user is male
2779            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
2780            January)
2781            * @param birthdayDay the user's birthday day
2782            * @param birthdayYear the user's birthday year
2783            * @param jobTitle the user's job title
2784            * @param updateUserInformation whether to update the user's information
2785            * @param sendEmail whether to send the user an email notification about
2786            their new account
2787            * @param serviceContext the service context to be applied (optionally
2788            <code>null</code>). Can set expando bridge attributes for the
2789            user.
2790            * @return the user
2791            */
2792            @Override
2793            public com.liferay.portal.model.User updateIncompleteUser(
2794                    long creatorUserId, long companyId, boolean autoPassword,
2795                    java.lang.String password1, java.lang.String password2,
2796                    boolean autoScreenName, java.lang.String screenName,
2797                    java.lang.String emailAddress, long facebookId,
2798                    java.lang.String openId, java.util.Locale locale,
2799                    java.lang.String firstName, java.lang.String middleName,
2800                    java.lang.String lastName, long prefixId, long suffixId, boolean male,
2801                    int birthdayMonth, int birthdayDay, int birthdayYear,
2802                    java.lang.String jobTitle, boolean updateUserInformation,
2803                    boolean sendEmail,
2804                    com.liferay.portal.service.ServiceContext serviceContext)
2805                    throws com.liferay.portal.kernel.exception.PortalException {
2806                    return _userLocalService.updateIncompleteUser(creatorUserId, companyId,
2807                            autoPassword, password1, password2, autoScreenName, screenName,
2808                            emailAddress, facebookId, openId, locale, firstName, middleName,
2809                            lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
2810                            birthdayYear, jobTitle, updateUserInformation, sendEmail,
2811                            serviceContext);
2812            }
2813    
2814            /**
2815            * Updates the user's job title.
2816            *
2817            * @param userId the primary key of the user
2818            * @param jobTitle the user's job title
2819            * @return the user
2820            */
2821            @Override
2822            public com.liferay.portal.model.User updateJobTitle(long userId,
2823                    java.lang.String jobTitle)
2824                    throws com.liferay.portal.kernel.exception.PortalException {
2825                    return _userLocalService.updateJobTitle(userId, jobTitle);
2826            }
2827    
2828            /**
2829            * Updates the user's last login with the current time and the IP address.
2830            *
2831            * @param userId the primary key of the user
2832            * @param loginIP the IP address the user logged in from
2833            * @return the user
2834            */
2835            @Override
2836            public com.liferay.portal.model.User updateLastLogin(long userId,
2837                    java.lang.String loginIP)
2838                    throws com.liferay.portal.kernel.exception.PortalException {
2839                    return _userLocalService.updateLastLogin(userId, loginIP);
2840            }
2841    
2842            /**
2843            * Updates whether the user is locked out from logging in.
2844            *
2845            * @param user the user
2846            * @param lockout whether the user is locked out
2847            * @return the user
2848            */
2849            @Override
2850            public com.liferay.portal.model.User updateLockout(
2851                    com.liferay.portal.model.User user, boolean lockout)
2852                    throws com.liferay.portal.kernel.exception.PortalException {
2853                    return _userLocalService.updateLockout(user, lockout);
2854            }
2855    
2856            /**
2857            * Updates whether the user is locked out from logging in.
2858            *
2859            * @param companyId the primary key of the user's company
2860            * @param emailAddress the user's email address
2861            * @param lockout whether the user is locked out
2862            * @return the user
2863            */
2864            @Override
2865            public com.liferay.portal.model.User updateLockoutByEmailAddress(
2866                    long companyId, java.lang.String emailAddress, boolean lockout)
2867                    throws com.liferay.portal.kernel.exception.PortalException {
2868                    return _userLocalService.updateLockoutByEmailAddress(companyId,
2869                            emailAddress, lockout);
2870            }
2871    
2872            /**
2873            * Updates whether the user is locked out from logging in.
2874            *
2875            * @param userId the primary key of the user
2876            * @param lockout whether the user is locked out
2877            * @return the user
2878            */
2879            @Override
2880            public com.liferay.portal.model.User updateLockoutById(long userId,
2881                    boolean lockout)
2882                    throws com.liferay.portal.kernel.exception.PortalException {
2883                    return _userLocalService.updateLockoutById(userId, lockout);
2884            }
2885    
2886            /**
2887            * Updates whether the user is locked out from logging in.
2888            *
2889            * @param companyId the primary key of the user's company
2890            * @param screenName the user's screen name
2891            * @param lockout whether the user is locked out
2892            * @return the user
2893            */
2894            @Override
2895            public com.liferay.portal.model.User updateLockoutByScreenName(
2896                    long companyId, java.lang.String screenName, boolean lockout)
2897                    throws com.liferay.portal.kernel.exception.PortalException {
2898                    return _userLocalService.updateLockoutByScreenName(companyId,
2899                            screenName, lockout);
2900            }
2901    
2902            /**
2903            * Updates the user's modified date.
2904            *
2905            * @param userId the primary key of the user
2906            * @param modifiedDate the new modified date
2907            * @return the user
2908            */
2909            @Override
2910            public com.liferay.portal.model.User updateModifiedDate(long userId,
2911                    java.util.Date modifiedDate)
2912                    throws com.liferay.portal.kernel.exception.PortalException {
2913                    return _userLocalService.updateModifiedDate(userId, modifiedDate);
2914            }
2915    
2916            /**
2917            * Updates the user's OpenID.
2918            *
2919            * @param userId the primary key of the user
2920            * @param openId the new OpenID
2921            * @return the user
2922            */
2923            @Override
2924            public com.liferay.portal.model.User updateOpenId(long userId,
2925                    java.lang.String openId)
2926                    throws com.liferay.portal.kernel.exception.PortalException {
2927                    return _userLocalService.updateOpenId(userId, openId);
2928            }
2929    
2930            /**
2931            * Sets the organizations that the user is in, removing and adding
2932            * organizations as necessary.
2933            *
2934            * @param userId the primary key of the user
2935            * @param newOrganizationIds the primary keys of the organizations
2936            * @param serviceContext the service context to be applied. Must set whether
2937            user indexing is enabled.
2938            */
2939            @Override
2940            public void updateOrganizations(long userId, long[] newOrganizationIds,
2941                    com.liferay.portal.service.ServiceContext serviceContext)
2942                    throws com.liferay.portal.kernel.exception.PortalException {
2943                    _userLocalService.updateOrganizations(userId, newOrganizationIds,
2944                            serviceContext);
2945            }
2946    
2947            /**
2948            * Updates the user's password without tracking or validation of the change.
2949            *
2950            * @param userId the primary key of the user
2951            * @param password1 the user's new password
2952            * @param password2 the user's new password confirmation
2953            * @param passwordReset whether the user should be asked to reset their
2954            password the next time they log in
2955            * @return the user
2956            */
2957            @Override
2958            public com.liferay.portal.model.User updatePassword(long userId,
2959                    java.lang.String password1, java.lang.String password2,
2960                    boolean passwordReset)
2961                    throws com.liferay.portal.kernel.exception.PortalException {
2962                    return _userLocalService.updatePassword(userId, password1, password2,
2963                            passwordReset);
2964            }
2965    
2966            /**
2967            * Updates the user's password, optionally with tracking and validation of
2968            * the change.
2969            *
2970            * @param userId the primary key of the user
2971            * @param password1 the user's new password
2972            * @param password2 the user's new password confirmation
2973            * @param passwordReset whether the user should be asked to reset their
2974            password the next time they login
2975            * @param silentUpdate whether the password should be updated without being
2976            tracked, or validated. Primarily used for password imports.
2977            * @return the user
2978            */
2979            @Override
2980            public com.liferay.portal.model.User updatePassword(long userId,
2981                    java.lang.String password1, java.lang.String password2,
2982                    boolean passwordReset, boolean silentUpdate)
2983                    throws com.liferay.portal.kernel.exception.PortalException {
2984                    return _userLocalService.updatePassword(userId, password1, password2,
2985                            passwordReset, silentUpdate);
2986            }
2987    
2988            /**
2989            * Updates the user's password with manually input information. This method
2990            * should only be used when performing maintenance.
2991            *
2992            * @param userId the primary key of the user
2993            * @param password the user's new password
2994            * @param passwordEncrypted the user's new encrypted password
2995            * @param passwordReset whether the user should be asked to reset their
2996            password the next time they login
2997            * @param passwordModifiedDate the new password modified date
2998            * @return the user
2999            */
3000            @Override
3001            public com.liferay.portal.model.User updatePasswordManually(long userId,
3002                    java.lang.String password, boolean passwordEncrypted,
3003                    boolean passwordReset, java.util.Date passwordModifiedDate)
3004                    throws com.liferay.portal.kernel.exception.PortalException {
3005                    return _userLocalService.updatePasswordManually(userId, password,
3006                            passwordEncrypted, passwordReset, passwordModifiedDate);
3007            }
3008    
3009            /**
3010            * Updates whether the user should be asked to reset their password the next
3011            * time they login.
3012            *
3013            * @param userId the primary key of the user
3014            * @param passwordReset whether the user should be asked to reset their
3015            password the next time they login
3016            * @return the user
3017            */
3018            @Override
3019            public com.liferay.portal.model.User updatePasswordReset(long userId,
3020                    boolean passwordReset)
3021                    throws com.liferay.portal.kernel.exception.PortalException {
3022                    return _userLocalService.updatePasswordReset(userId, passwordReset);
3023            }
3024    
3025            /**
3026            * Updates the user's portrait image.
3027            *
3028            * @param userId the primary key of the user
3029            * @param bytes the new portrait image data
3030            * @return the user
3031            */
3032            @Override
3033            public com.liferay.portal.model.User updatePortrait(long userId,
3034                    byte[] bytes)
3035                    throws com.liferay.portal.kernel.exception.PortalException {
3036                    return _userLocalService.updatePortrait(userId, bytes);
3037            }
3038    
3039            /**
3040            * Updates the user's password reset question and answer.
3041            *
3042            * @param userId the primary key of the user
3043            * @param question the user's new password reset question
3044            * @param answer the user's new password reset answer
3045            * @return the user
3046            */
3047            @Override
3048            public com.liferay.portal.model.User updateReminderQuery(long userId,
3049                    java.lang.String question, java.lang.String answer)
3050                    throws com.liferay.portal.kernel.exception.PortalException {
3051                    return _userLocalService.updateReminderQuery(userId, question, answer);
3052            }
3053    
3054            /**
3055            * Updates the user's screen name.
3056            *
3057            * @param userId the primary key of the user
3058            * @param screenName the user's new screen name
3059            * @return the user
3060            */
3061            @Override
3062            public com.liferay.portal.model.User updateScreenName(long userId,
3063                    java.lang.String screenName)
3064                    throws com.liferay.portal.kernel.exception.PortalException {
3065                    return _userLocalService.updateScreenName(userId, screenName);
3066            }
3067    
3068            /**
3069            * Updates the user's workflow status.
3070            *
3071            * @param userId the primary key of the user
3072            * @param status the user's new workflow status
3073            * @return the user
3074            * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int,
3075            ServiceContext)}
3076            */
3077            @Deprecated
3078            @Override
3079            public com.liferay.portal.model.User updateStatus(long userId, int status)
3080                    throws com.liferay.portal.kernel.exception.PortalException {
3081                    return _userLocalService.updateStatus(userId, status);
3082            }
3083    
3084            /**
3085            * Updates the user's workflow status.
3086            *
3087            * @param userId the primary key of the user
3088            * @param status the user's new workflow status
3089            * @param serviceContext the service context to be applied. You can specify
3090            an unencrypted custom password (used by an LDAP listener) for the
3091            user via attribute <code>passwordUnencrypted</code>.
3092            * @return the user
3093            */
3094            @Override
3095            public com.liferay.portal.model.User updateStatus(long userId, int status,
3096                    com.liferay.portal.service.ServiceContext serviceContext)
3097                    throws com.liferay.portal.kernel.exception.PortalException {
3098                    return _userLocalService.updateStatus(userId, status, serviceContext);
3099            }
3100    
3101            /**
3102            * Updates the user in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners.
3103            *
3104            * @param user the user
3105            * @return the user that was updated
3106            */
3107            @Override
3108            public com.liferay.portal.model.User updateUser(
3109                    com.liferay.portal.model.User user) {
3110                    return _userLocalService.updateUser(user);
3111            }
3112    
3113            /**
3114            * Updates the user.
3115            *
3116            * @param userId the primary key of the user
3117            * @param oldPassword the user's old password
3118            * @param newPassword1 the user's new password (optionally
3119            <code>null</code>)
3120            * @param newPassword2 the user's new password confirmation (optionally
3121            <code>null</code>)
3122            * @param passwordReset whether the user should be asked to reset their
3123            password the next time they login
3124            * @param reminderQueryQuestion the user's new password reset question
3125            * @param reminderQueryAnswer the user's new password reset answer
3126            * @param screenName the user's new screen name
3127            * @param emailAddress the user's new email address
3128            * @param facebookId the user's new Facebook ID
3129            * @param openId the user's new OpenID
3130            * @param languageId the user's new language ID
3131            * @param timeZoneId the user's new time zone ID
3132            * @param greeting the user's new greeting
3133            * @param comments the user's new comments
3134            * @param firstName the user's new first name
3135            * @param middleName the user's new middle name
3136            * @param lastName the user's new last name
3137            * @param prefixId the user's new name prefix ID
3138            * @param suffixId the user's new name suffix ID
3139            * @param male whether user is male
3140            * @param birthdayMonth the user's new birthday month (0-based, meaning
3141            0 for January)
3142            * @param birthdayDay the user's new birthday day
3143            * @param birthdayYear the user's birthday year
3144            * @param smsSn the user's new SMS screen name
3145            * @param facebookSn the user's new Facebook screen name
3146            * @param jabberSn the user's new Jabber screen name
3147            * @param skypeSn the user's new Skype screen name
3148            * @param twitterSn the user's new Twitter screen name
3149            * @param jobTitle the user's new job title
3150            * @param groupIds the primary keys of the user's groups
3151            * @param organizationIds the primary keys of the user's organizations
3152            * @param roleIds the primary keys of the user's roles
3153            * @param userGroupRoles the user user's group roles
3154            * @param userGroupIds the primary keys of the user's user groups
3155            * @param serviceContext the service context to be applied (optionally
3156            <code>null</code>). Can set the UUID (with the
3157            <code>uuid</code> attribute), asset category IDs, asset tag
3158            names, and expando bridge attributes for the user.
3159            * @return the user
3160            * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String,
3161            String, String, boolean, String, String, String, String,
3162            long, String, boolean, byte[], String, String, String,
3163            String, String, String, String, long, long, boolean, int,
3164            int, int, String, String, String, String, String, String,
3165            long[], long[], long[], List, long[], ServiceContext)}
3166            */
3167            @Deprecated
3168            @Override
3169            public com.liferay.portal.model.User updateUser(long userId,
3170                    java.lang.String oldPassword, java.lang.String newPassword1,
3171                    java.lang.String newPassword2, boolean passwordReset,
3172                    java.lang.String reminderQueryQuestion,
3173                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
3174                    java.lang.String emailAddress, long facebookId,
3175                    java.lang.String openId, java.lang.String languageId,
3176                    java.lang.String timeZoneId, java.lang.String greeting,
3177                    java.lang.String comments, java.lang.String firstName,
3178                    java.lang.String middleName, java.lang.String lastName, long prefixId,
3179                    long suffixId, boolean male, int birthdayMonth, int birthdayDay,
3180                    int birthdayYear, java.lang.String smsSn, java.lang.String facebookSn,
3181                    java.lang.String jabberSn, java.lang.String skypeSn,
3182                    java.lang.String twitterSn, java.lang.String jobTitle, long[] groupIds,
3183                    long[] organizationIds, long[] roleIds,
3184                    java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles,
3185                    long[] userGroupIds,
3186                    com.liferay.portal.service.ServiceContext serviceContext)
3187                    throws com.liferay.portal.kernel.exception.PortalException {
3188                    return _userLocalService.updateUser(userId, oldPassword, newPassword1,
3189                            newPassword2, passwordReset, reminderQueryQuestion,
3190                            reminderQueryAnswer, screenName, emailAddress, facebookId, openId,
3191                            languageId, timeZoneId, greeting, comments, firstName, middleName,
3192                            lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
3193                            birthdayYear, smsSn, facebookSn, jabberSn, skypeSn, twitterSn,
3194                            jobTitle, groupIds, organizationIds, roleIds, userGroupRoles,
3195                            userGroupIds, serviceContext);
3196            }
3197    
3198            /**
3199            * Updates the user.
3200            *
3201            * @param userId the primary key of the user
3202            * @param oldPassword the user's old password
3203            * @param newPassword1 the user's new password (optionally
3204            <code>null</code>)
3205            * @param newPassword2 the user's new password confirmation (optionally
3206            <code>null</code>)
3207            * @param passwordReset whether the user should be asked to reset their
3208            password the next time they login
3209            * @param reminderQueryQuestion the user's new password reset question
3210            * @param reminderQueryAnswer the user's new password reset answer
3211            * @param screenName the user's new screen name
3212            * @param emailAddress the user's new email address
3213            * @param facebookId the user's new Facebook ID
3214            * @param openId the user's new OpenID
3215            * @param portrait whether to update the user's portrait image
3216            * @param portraitBytes the new portrait image data
3217            * @param languageId the user's new language ID
3218            * @param timeZoneId the user's new time zone ID
3219            * @param greeting the user's new greeting
3220            * @param comments the user's new comments
3221            * @param firstName the user's new first name
3222            * @param middleName the user's new middle name
3223            * @param lastName the user's new last name
3224            * @param prefixId the user's new name prefix ID
3225            * @param suffixId the user's new name suffix ID
3226            * @param male whether user is male
3227            * @param birthdayMonth the user's new birthday month (0-based, meaning 0
3228            for January)
3229            * @param birthdayDay the user's new birthday day
3230            * @param birthdayYear the user's birthday year
3231            * @param smsSn the user's new SMS screen name
3232            * @param facebookSn the user's new Facebook screen name
3233            * @param jabberSn the user's new Jabber screen name
3234            * @param skypeSn the user's new Skype screen name
3235            * @param twitterSn the user's new Twitter screen name
3236            * @param jobTitle the user's new job title
3237            * @param groupIds the primary keys of the user's groups
3238            * @param organizationIds the primary keys of the user's organizations
3239            * @param roleIds the primary keys of the user's roles
3240            * @param userGroupRoles the user user's group roles
3241            * @param userGroupIds the primary keys of the user's user groups
3242            * @param serviceContext the service context to be applied (optionally
3243            <code>null</code>). Can set the UUID (with the <code>uuid</code>
3244            attribute), asset category IDs, asset tag names, and expando
3245            bridge attributes for the user.
3246            * @return the user
3247            */
3248            @Override
3249            public com.liferay.portal.model.User updateUser(long userId,
3250                    java.lang.String oldPassword, java.lang.String newPassword1,
3251                    java.lang.String newPassword2, boolean passwordReset,
3252                    java.lang.String reminderQueryQuestion,
3253                    java.lang.String reminderQueryAnswer, java.lang.String screenName,
3254                    java.lang.String emailAddress, long facebookId,
3255                    java.lang.String openId, boolean portrait, byte[] portraitBytes,
3256                    java.lang.String languageId, java.lang.String timeZoneId,
3257                    java.lang.String greeting, java.lang.String comments,
3258                    java.lang.String firstName, java.lang.String middleName,
3259                    java.lang.String lastName, long prefixId, long suffixId, boolean male,
3260                    int birthdayMonth, int birthdayDay, int birthdayYear,
3261                    java.lang.String smsSn, java.lang.String facebookSn,
3262                    java.lang.String jabberSn, java.lang.String skypeSn,
3263                    java.lang.String twitterSn, java.lang.String jobTitle, long[] groupIds,
3264                    long[] organizationIds, long[] roleIds,
3265                    java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles,
3266                    long[] userGroupIds,
3267                    com.liferay.portal.service.ServiceContext serviceContext)
3268                    throws com.liferay.portal.kernel.exception.PortalException {
3269                    return _userLocalService.updateUser(userId, oldPassword, newPassword1,
3270                            newPassword2, passwordReset, reminderQueryQuestion,
3271                            reminderQueryAnswer, screenName, emailAddress, facebookId, openId,
3272                            portrait, portraitBytes, languageId, timeZoneId, greeting,
3273                            comments, firstName, middleName, lastName, prefixId, suffixId,
3274                            male, birthdayMonth, birthdayDay, birthdayYear, smsSn, facebookSn,
3275                            jabberSn, skypeSn, twitterSn, jobTitle, groupIds, organizationIds,
3276                            roleIds, userGroupRoles, userGroupIds, serviceContext);
3277            }
3278    
3279            /**
3280            * Verifies the email address of the ticket.
3281            *
3282            * @param ticketKey the ticket key
3283            */
3284            @Override
3285            public void verifyEmailAddress(java.lang.String ticketKey)
3286                    throws com.liferay.portal.kernel.exception.PortalException {
3287                    _userLocalService.verifyEmailAddress(ticketKey);
3288            }
3289    
3290            @Override
3291            public UserLocalService getWrappedService() {
3292                    return _userLocalService;
3293            }
3294    
3295            @Override
3296            public void setWrappedService(UserLocalService userLocalService) {
3297                    _userLocalService = userLocalService;
3298            }
3299    
3300            private UserLocalService _userLocalService;
3301    }