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