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