001    /**
002     * Copyright (c) 2000-2011 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 screen name.
931            *
932            * @param companyId the primary key of the user's company
933            * @param screenName the user's screen name
934            * @return the user with the screen name, or <code>null</code> if a user
935            with the screen name could not be found
936            * @throws SystemException if a system exception occurred
937            */
938            public com.liferay.portal.model.User fetchUserByScreenName(long companyId,
939                    java.lang.String screenName)
940                    throws com.liferay.portal.kernel.exception.SystemException {
941                    return _userLocalService.fetchUserByScreenName(companyId, screenName);
942            }
943    
944            /**
945            * Returns the user with the primary key.
946            *
947            * @param userId the primary key of the user
948            * @return the user with the primary key, or <code>null</code> if a user
949            with the primary key could not be found
950            * @throws SystemException if a system exception occurred
951            */
952            public com.liferay.portal.model.User fetchUserById(long userId)
953                    throws com.liferay.portal.kernel.exception.SystemException {
954                    return _userLocalService.fetchUserById(userId);
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            * Updates a user account that was automatically created when a guest user
1811            * participated in an action (e.g. posting a comment) and only provided his
1812            * name and email address.
1813            *
1814            * @param creatorUserId the primary key of the creator
1815            * @param companyId the primary key of the user's company
1816            * @param autoPassword whether a password should be automatically generated
1817            for the user
1818            * @param password1 the user's password
1819            * @param password2 the user's password confirmation
1820            * @param autoScreenName whether a screen name should be automatically
1821            generated for the user
1822            * @param screenName the user's screen name
1823            * @param emailAddress the user's email address
1824            * @param facebookId the user's facebook ID
1825            * @param openId the user's OpenID
1826            * @param locale the user's locale
1827            * @param firstName the user's first name
1828            * @param middleName the user's middle name
1829            * @param lastName the user's last name
1830            * @param prefixId the user's name prefix ID
1831            * @param suffixId the user's name suffix ID
1832            * @param male whether the user is male
1833            * @param birthdayMonth the user's birthday month (0-based, meaning 0 for
1834            January)
1835            * @param birthdayDay the user's birthday day
1836            * @param birthdayYear the user's birthday year
1837            * @param jobTitle the user's job title
1838            * @param updateUserInformation whether to update the user's information
1839            * @param sendEmail whether to send the user an email notification about
1840            their new account
1841            * @param serviceContext the user's service context (optionally
1842            <code>null</code>). Can set expando bridge attributes for the
1843            user.
1844            * @return the user
1845            * @throws PortalException if the user's information was invalid
1846            * @throws SystemException if a system exception occurred
1847            */
1848            public com.liferay.portal.model.User updateIncompleteUser(
1849                    long creatorUserId, long companyId, boolean autoPassword,
1850                    java.lang.String password1, java.lang.String password2,
1851                    boolean autoScreenName, java.lang.String screenName,
1852                    java.lang.String emailAddress, long facebookId,
1853                    java.lang.String openId, java.util.Locale locale,
1854                    java.lang.String firstName, java.lang.String middleName,
1855                    java.lang.String lastName, int prefixId, int suffixId, boolean male,
1856                    int birthdayMonth, int birthdayDay, int birthdayYear,
1857                    java.lang.String jobTitle, boolean updateUserInformation,
1858                    boolean sendEmail,
1859                    com.liferay.portal.service.ServiceContext serviceContext)
1860                    throws com.liferay.portal.kernel.exception.PortalException,
1861                            com.liferay.portal.kernel.exception.SystemException {
1862                    return _userLocalService.updateIncompleteUser(creatorUserId, companyId,
1863                            autoPassword, password1, password2, autoScreenName, screenName,
1864                            emailAddress, facebookId, openId, locale, firstName, middleName,
1865                            lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay,
1866                            birthdayYear, jobTitle, updateUserInformation, sendEmail,
1867                            serviceContext);
1868            }
1869    
1870            /**
1871            * Returns an ordered range of all the users who match the keywords and
1872            * status, without using the indexer. It is preferable to use the indexed
1873            * version {@link #search(long, String, int, LinkedHashMap, int, int, Sort)}
1874            * instead of this method wherever possible for performance reasons.
1875            *
1876            * <p>
1877            * Useful when paginating results. Returns a maximum of <code>end -
1878            * start</code> instances. <code>start</code> and <code>end</code> are not
1879            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1880            * refers to the first result in the set. Setting both <code>start</code>
1881            * and <code>end</code> to {@link
1882            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1883            * result set.
1884            * </p>
1885            *
1886            * @param companyId the primary key of the user's company
1887            * @param keywords the keywords (space separated), which may occur in the
1888            user's first name, middle name, last name, screen name, or email
1889            address
1890            * @param status the workflow status
1891            * @param params the finder parameters (optionally <code>null</code>). For
1892            more information see {@link
1893            com.liferay.portal.service.persistence.UserFinder}.
1894            * @param start the lower bound of the range of users
1895            * @param end the upper bound of the range of users (not inclusive)
1896            * @param obc the comparator to order the users by (optionally
1897            <code>null</code>)
1898            * @return the matching users
1899            * @throws SystemException if a system exception occurred
1900            * @see com.liferay.portal.service.persistence.UserFinder
1901            */
1902            public java.util.List<com.liferay.portal.model.User> search(
1903                    long companyId, java.lang.String keywords, int status,
1904                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1905                    int start, int end, com.liferay.portal.kernel.util.OrderByComparator obc)
1906                    throws com.liferay.portal.kernel.exception.SystemException {
1907                    return _userLocalService.search(companyId, keywords, status, params,
1908                            start, end, obc);
1909            }
1910    
1911            /**
1912            * Returns an ordered range of all the users who match the keywords and
1913            * status, using the indexer. It is preferable to use this method instead of
1914            * the non-indexed version whenever possible for performance reasons.
1915            *
1916            * <p>
1917            * Useful when paginating results. Returns a maximum of <code>end -
1918            * start</code> instances. <code>start</code> and <code>end</code> are not
1919            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1920            * refers to the first result in the set. Setting both <code>start</code>
1921            * and <code>end</code> to {@link
1922            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1923            * result set.
1924            * </p>
1925            *
1926            * @param companyId the primary key of the user's company
1927            * @param keywords the keywords (space separated), which may occur in the
1928            user's first name, middle name, last name, screen name, or email
1929            address
1930            * @param status the workflow status
1931            * @param params the indexer parameters (optionally <code>null</code>). For
1932            more information see {@link
1933            com.liferay.portlet.usersadmin.util.UserIndexer}.
1934            * @param start the lower bound of the range of users
1935            * @param end the upper bound of the range of users (not inclusive)
1936            * @param sort the field and direction to sort by (optionally
1937            <code>null</code>)
1938            * @return the matching users
1939            * @throws SystemException if a system exception occurred
1940            * @see com.liferay.portlet.usersadmin.util.UserIndexer
1941            */
1942            public com.liferay.portal.kernel.search.Hits search(long companyId,
1943                    java.lang.String keywords, int status,
1944                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1945                    int start, int end, com.liferay.portal.kernel.search.Sort sort)
1946                    throws com.liferay.portal.kernel.exception.SystemException {
1947                    return _userLocalService.search(companyId, keywords, status, params,
1948                            start, end, sort);
1949            }
1950    
1951            /**
1952            * Returns an ordered range of all the users with the status, and whose
1953            * first name, middle name, last name, screen name, and email address match
1954            * the keywords specified for them, without using the indexer. It is
1955            * preferable to use the indexed version {@link #search(long, String,
1956            * String, String, String, String, int, LinkedHashMap, boolean, int, int,
1957            * Sort)} instead of this method wherever possible for performance reasons.
1958            *
1959            * <p>
1960            * Useful when paginating results. Returns a maximum of <code>end -
1961            * start</code> instances. <code>start</code> and <code>end</code> are not
1962            * primary keys, they are indexes in the result set. Thus, <code>0</code>
1963            * refers to the first result in the set. Setting both <code>start</code>
1964            * and <code>end</code> to {@link
1965            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
1966            * result set.
1967            * </p>
1968            *
1969            * @param companyId the primary key of the user's company
1970            * @param firstName the first name keywords (space separated)
1971            * @param middleName the middle name keywords
1972            * @param lastName the last name keywords
1973            * @param screenName the screen name keywords
1974            * @param emailAddress the email address keywords
1975            * @param status the workflow status
1976            * @param params the finder parameters (optionally <code>null</code>). For
1977            more information see {@link
1978            com.liferay.portal.service.persistence.UserFinder}.
1979            * @param andSearch whether every field must match its keywords, or just
1980            one field. For example, &quot;users with the first name 'bob' and
1981            last name 'smith'&quot; vs &quot;users with the first name 'bob'
1982            or the last name 'smith'&quot;.
1983            * @param start the lower bound of the range of users
1984            * @param end the upper bound of the range of users (not inclusive)
1985            * @param obc the comparator to order the users by (optionally
1986            <code>null</code>)
1987            * @return the matching users
1988            * @throws SystemException if a system exception occurred
1989            * @see com.liferay.portal.service.persistence.UserFinder
1990            */
1991            public java.util.List<com.liferay.portal.model.User> search(
1992                    long companyId, java.lang.String firstName,
1993                    java.lang.String middleName, java.lang.String lastName,
1994                    java.lang.String screenName, java.lang.String emailAddress, int status,
1995                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
1996                    boolean andSearch, int start, int end,
1997                    com.liferay.portal.kernel.util.OrderByComparator obc)
1998                    throws com.liferay.portal.kernel.exception.SystemException {
1999                    return _userLocalService.search(companyId, firstName, middleName,
2000                            lastName, screenName, emailAddress, status, params, andSearch,
2001                            start, end, obc);
2002            }
2003    
2004            /**
2005            * Returns an ordered range of all the users with the status, and whose
2006            * first name, middle name, last name, screen name, and email address match
2007            * the keywords specified for them, using the indexer. It is preferable to
2008            * use this method instead of the non-indexed version whenever possible for
2009            * performance reasons.
2010            *
2011            * <p>
2012            * Useful when paginating results. Returns a maximum of <code>end -
2013            * start</code> instances. <code>start</code> and <code>end</code> are not
2014            * primary keys, they are indexes in the result set. Thus, <code>0</code>
2015            * refers to the first result in the set. Setting both <code>start</code>
2016            * and <code>end</code> to {@link
2017            * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full
2018            * result set.
2019            * </p>
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 indexer parameters (optionally <code>null</code>). For
2029            more information see {@link
2030            com.liferay.portlet.usersadmin.util.UserIndexer}.
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            * @param start the lower bound of the range of users
2036            * @param end the upper bound of the range of users (not inclusive)
2037            * @param sort the field and direction to sort by (optionally
2038            <code>null</code>)
2039            * @return the matching users
2040            * @throws SystemException if a system exception occurred
2041            * @see com.liferay.portlet.usersadmin.util.UserIndexer
2042            */
2043            public com.liferay.portal.kernel.search.Hits search(long companyId,
2044                    java.lang.String firstName, java.lang.String middleName,
2045                    java.lang.String lastName, java.lang.String screenName,
2046                    java.lang.String emailAddress, int status,
2047                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2048                    boolean andSearch, int start, int end,
2049                    com.liferay.portal.kernel.search.Sort sort)
2050                    throws com.liferay.portal.kernel.exception.SystemException {
2051                    return _userLocalService.search(companyId, firstName, middleName,
2052                            lastName, screenName, emailAddress, status, params, andSearch,
2053                            start, end, sort);
2054            }
2055    
2056            /**
2057            * Returns the number of users who match the keywords and status.
2058            *
2059            * @param companyId the primary key of the user's company
2060            * @param keywords the keywords (space separated), which may occur in the
2061            user's first name, middle name, last name, screen name, or email
2062            address
2063            * @param status the workflow status
2064            * @param params the finder parameters (optionally <code>null</code>). For
2065            more information see {@link
2066            com.liferay.portal.service.persistence.UserFinder}.
2067            * @return the number matching users
2068            * @throws SystemException if a system exception occurred
2069            */
2070            public int searchCount(long companyId, java.lang.String keywords,
2071                    int status,
2072                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params)
2073                    throws com.liferay.portal.kernel.exception.SystemException {
2074                    return _userLocalService.searchCount(companyId, keywords, status, params);
2075            }
2076    
2077            /**
2078            * Returns the number of users with the status, and whose first name, middle
2079            * name, last name, screen name, and email address match the keywords
2080            * specified for them.
2081            *
2082            * @param companyId the primary key of the user's company
2083            * @param firstName the first name keywords (space separated)
2084            * @param middleName the middle name keywords
2085            * @param lastName the last name keywords
2086            * @param screenName the screen name keywords
2087            * @param emailAddress the email address keywords
2088            * @param status the workflow status
2089            * @param params the finder parameters (optionally <code>null</code>). For
2090            more information see {@link
2091            com.liferay.portal.service.persistence.UserFinder}.
2092            * @param andSearch whether every field must match its keywords, or just
2093            one field. For example, &quot;users with the first name 'bob' and
2094            last name 'smith'&quot; vs &quot;users with the first name 'bob'
2095            or the last name 'smith'&quot;.
2096            * @return the number of matching users
2097            * @throws SystemException if a system exception occurred
2098            */
2099            public int searchCount(long companyId, java.lang.String firstName,
2100                    java.lang.String middleName, java.lang.String lastName,
2101                    java.lang.String screenName, java.lang.String emailAddress, int status,
2102                    java.util.LinkedHashMap<java.lang.String, java.lang.Object> params,
2103                    boolean andSearch)
2104                    throws com.liferay.portal.kernel.exception.SystemException {
2105                    return _userLocalService.searchCount(companyId, firstName, middleName,
2106                            lastName, screenName, emailAddress, status, params, andSearch);
2107            }
2108    
2109            /**
2110            * Sends an email address verification to the user.
2111            *
2112            * @param user the verification email recipient
2113            * @param emailAddress the recipient's email address
2114            * @param serviceContext the service context. Must set the portal URL, main
2115            path, primary key of the layout, remote address, remote host, and
2116            agent for the user.
2117            * @throws PortalException if a portal exception occurred
2118            * @throws SystemException if a system exception occurred
2119            */
2120            public void sendEmailAddressVerification(
2121                    com.liferay.portal.model.User user, java.lang.String emailAddress,
2122                    com.liferay.portal.service.ServiceContext serviceContext)
2123                    throws com.liferay.portal.kernel.exception.PortalException,
2124                            com.liferay.portal.kernel.exception.SystemException {
2125                    _userLocalService.sendEmailAddressVerification(user, emailAddress,
2126                            serviceContext);
2127            }
2128    
2129            /**
2130            * Sends the password email to the user with the email address. The content
2131            * of this email can be specified in <code>portal.properties</code> with the
2132            * <code>admin.email.password</code> keys.
2133            *
2134            * @param companyId the primary key of the user's company
2135            * @param emailAddress the user's email address
2136            * @param fromName the name of the individual that the email should be from
2137            * @param fromAddress the address of the individual that the email should
2138            be from
2139            * @param subject the email subject. If <code>null</code>, the subject
2140            specified in <code>portal.properties</code> will be used.
2141            * @param body the email body. If <code>null</code>, the body specified in
2142            <code>portal.properties</code> will be used.
2143            * @param serviceContext the user's service context
2144            * @throws PortalException if a user with the email address could not be
2145            found
2146            * @throws SystemException if a system exception occurred
2147            */
2148            public void sendPassword(long companyId, java.lang.String emailAddress,
2149                    java.lang.String fromName, java.lang.String fromAddress,
2150                    java.lang.String subject, java.lang.String body,
2151                    com.liferay.portal.service.ServiceContext serviceContext)
2152                    throws com.liferay.portal.kernel.exception.PortalException,
2153                            com.liferay.portal.kernel.exception.SystemException {
2154                    _userLocalService.sendPassword(companyId, emailAddress, fromName,
2155                            fromAddress, subject, body, serviceContext);
2156            }
2157    
2158            /**
2159            * Sets the users in the role, removing and adding users to the role as
2160            * necessary.
2161            *
2162            * @param roleId the primary key of the role
2163            * @param userIds the primary keys of the users
2164            * @throws PortalException if a portal exception occurred
2165            * @throws SystemException if a system exception occurred
2166            */
2167            public void setRoleUsers(long roleId, long[] userIds)
2168                    throws com.liferay.portal.kernel.exception.PortalException,
2169                            com.liferay.portal.kernel.exception.SystemException {
2170                    _userLocalService.setRoleUsers(roleId, userIds);
2171            }
2172    
2173            /**
2174            * Sets the users in the user group, removing and adding users to the user
2175            * group as necessary.
2176            *
2177            * @param userGroupId the primary key of the user group
2178            * @param userIds the primary keys of the users
2179            * @throws PortalException if a portal exception occurred
2180            * @throws SystemException if a system exception occurred
2181            */
2182            public void setUserGroupUsers(long userGroupId, long[] userIds)
2183                    throws com.liferay.portal.kernel.exception.PortalException,
2184                            com.liferay.portal.kernel.exception.SystemException {
2185                    _userLocalService.setUserGroupUsers(userGroupId, userIds);
2186            }
2187    
2188            /**
2189            * Removes the users from the group.
2190            *
2191            * @param groupId the primary key of the group
2192            * @param userIds the primary keys of the users
2193            * @throws PortalException if a portal exception occurred
2194            * @throws SystemException if a system exception occurred
2195            */
2196            public void unsetGroupUsers(long groupId, long[] userIds,
2197                    com.liferay.portal.service.ServiceContext serviceContext)
2198                    throws com.liferay.portal.kernel.exception.PortalException,
2199                            com.liferay.portal.kernel.exception.SystemException {
2200                    _userLocalService.unsetGroupUsers(groupId, userIds, serviceContext);
2201            }
2202    
2203            /**
2204            * Removes the users from the organization.
2205            *
2206            * @param organizationId the primary key of the organization
2207            * @param userIds the primary keys of the users
2208            * @throws PortalException if a portal exception occurred
2209            * @throws SystemException if a system exception occurred
2210            */
2211            public void unsetOrganizationUsers(long organizationId, long[] userIds)
2212                    throws com.liferay.portal.kernel.exception.PortalException,
2213                            com.liferay.portal.kernel.exception.SystemException {
2214                    _userLocalService.unsetOrganizationUsers(organizationId, userIds);
2215            }
2216    
2217            /**
2218            * Removes the users from the password policy.
2219            *
2220            * @param passwordPolicyId the primary key of the password policy
2221            * @param userIds the primary keys of the users
2222            * @throws SystemException if a system exception occurred
2223            */
2224            public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds)
2225                    throws com.liferay.portal.kernel.exception.SystemException {
2226                    _userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds);
2227            }
2228    
2229            /**
2230            * Removes the users from the role.
2231            *
2232            * @param roleId the primary key of the role
2233            * @param users the users
2234            * @throws PortalException if a portal exception occurred
2235            * @throws SystemException if a system exception occurred
2236            */
2237            public void unsetRoleUsers(long roleId,
2238                    java.util.List<com.liferay.portal.model.User> users)
2239                    throws com.liferay.portal.kernel.exception.PortalException,
2240                            com.liferay.portal.kernel.exception.SystemException {
2241                    _userLocalService.unsetRoleUsers(roleId, users);
2242            }
2243    
2244            /**
2245            * Removes the users from the role.
2246            *
2247            * @param roleId the primary key of the role
2248            * @param userIds the primary keys of the users
2249            * @throws PortalException if a portal exception occurred
2250            * @throws SystemException if a system exception occurred
2251            */
2252            public void unsetRoleUsers(long roleId, long[] userIds)
2253                    throws com.liferay.portal.kernel.exception.PortalException,
2254                            com.liferay.portal.kernel.exception.SystemException {
2255                    _userLocalService.unsetRoleUsers(roleId, userIds);
2256            }
2257    
2258            /**
2259            * Removes the users from the team.
2260            *
2261            * @param teamId the primary key of the team
2262            * @param userIds the primary keys of the users
2263            * @throws PortalException if a portal exception occurred
2264            * @throws SystemException if a system exception occurred
2265            */
2266            public void unsetTeamUsers(long teamId, long[] userIds)
2267                    throws com.liferay.portal.kernel.exception.PortalException,
2268                            com.liferay.portal.kernel.exception.SystemException {
2269                    _userLocalService.unsetTeamUsers(teamId, userIds);
2270            }
2271    
2272            /**
2273            * Removes the users from the user group.
2274            *
2275            * @param userGroupId the primary key of the user group
2276            * @param userIds the primary keys of the users
2277            * @throws PortalException if a portal exception occurred
2278            * @throws SystemException if a system exception occurred
2279            */
2280            public void unsetUserGroupUsers(long userGroupId, long[] userIds)
2281                    throws com.liferay.portal.kernel.exception.PortalException,
2282                            com.liferay.portal.kernel.exception.SystemException {
2283                    _userLocalService.unsetUserGroupUsers(userGroupId, userIds);
2284            }
2285    
2286            /**
2287            * Updates whether the user has agreed to the terms of use.
2288            *
2289            * @param userId the primary key of the user
2290            * @param agreedToTermsOfUse whether the user has agreet to the terms of
2291            use
2292            * @return the user
2293            * @throws PortalException if a user with the primary key could not be found
2294            * @throws SystemException if a system exception occurred
2295            */
2296            public com.liferay.portal.model.User updateAgreedToTermsOfUse(long userId,
2297                    boolean agreedToTermsOfUse)
2298                    throws com.liferay.portal.kernel.exception.PortalException,
2299                            com.liferay.portal.kernel.exception.SystemException {
2300                    return _userLocalService.updateAgreedToTermsOfUse(userId,
2301                            agreedToTermsOfUse);
2302            }
2303    
2304            /**
2305            * Updates the user's asset with the new asset categories and tag names,
2306            * removing and adding asset categories and tag names as necessary.
2307            *
2308            * @param userId the primary key of the user
2309            * @param user ID the primary key of the user
2310            * @param assetCategoryIds the primary key's of the new asset categories
2311            * @param assetTagNames the new asset tag names
2312            * @throws PortalException if a user with the primary key could not be found
2313            * @throws SystemException if a system exception occurred
2314            */
2315            public void updateAsset(long userId, com.liferay.portal.model.User user,
2316                    long[] assetCategoryIds, java.lang.String[] assetTagNames)
2317                    throws com.liferay.portal.kernel.exception.PortalException,
2318                            com.liferay.portal.kernel.exception.SystemException {
2319                    _userLocalService.updateAsset(userId, user, assetCategoryIds,
2320                            assetTagNames);
2321            }
2322    
2323            /**
2324            * Updates the user's creation date.
2325            *
2326            * @param userId the primary key of the user
2327            * @param createDate the new creation date
2328            * @return the user
2329            * @throws PortalException if a user with the primary key could not be found
2330            * @throws SystemException if a system exception occurred
2331            */
2332            public com.liferay.portal.model.User updateCreateDate(long userId,
2333                    java.util.Date createDate)
2334                    throws com.liferay.portal.kernel.exception.PortalException,
2335                            com.liferay.portal.kernel.exception.SystemException {
2336                    return _userLocalService.updateCreateDate(userId, createDate);
2337            }
2338    
2339            /**
2340            * Updates the user's email address.
2341            *
2342            * @param userId the primary key of the user
2343            * @param password the user's password
2344            * @param emailAddress1 the user's new email address
2345            * @param emailAddress2 the user's new email address confirmation
2346            * @return the user
2347            * @throws PortalException if a user with the primary key could not be found
2348            * @throws SystemException if a system exception occurred
2349            */
2350            public com.liferay.portal.model.User updateEmailAddress(long userId,
2351                    java.lang.String password, java.lang.String emailAddress1,
2352                    java.lang.String emailAddress2)
2353                    throws com.liferay.portal.kernel.exception.PortalException,
2354                            com.liferay.portal.kernel.exception.SystemException {
2355                    return _userLocalService.updateEmailAddress(userId, password,
2356                            emailAddress1, emailAddress2);
2357            }
2358    
2359            /**
2360            * Updates the user's email address or sends verification email.
2361            *
2362            * @param userId the primary key of the user
2363            * @param password the user's password
2364            * @param emailAddress1 the user's new email address
2365            * @param emailAddress2 the user's new email address confirmation
2366            * @return the user
2367            * @throws PortalException if a user with the primary key could not be found
2368            * @throws SystemException if a system exception occurred
2369            */
2370            public com.liferay.portal.model.User updateEmailAddress(long userId,
2371                    java.lang.String password, java.lang.String emailAddress1,
2372                    java.lang.String emailAddress2,
2373                    com.liferay.portal.service.ServiceContext serviceContext)
2374                    throws com.liferay.portal.kernel.exception.PortalException,
2375                            com.liferay.portal.kernel.exception.SystemException {
2376                    return _userLocalService.updateEmailAddress(userId, password,
2377                            emailAddress1, emailAddress2, serviceContext);
2378            }
2379    
2380            /**
2381            * Updates whether the user has verified email address.
2382            *
2383            * @param userId the primary key of the user
2384            * @param emailAddressVerified whether the user has verified email address
2385            * @return the user
2386            * @throws PortalException if a user with the primary key could not be found
2387            * @throws SystemException if a system exception occurred
2388            */
2389            public com.liferay.portal.model.User updateEmailAddressVerified(
2390                    long userId, boolean emailAddressVerified)
2391                    throws com.liferay.portal.kernel.exception.PortalException,
2392                            com.liferay.portal.kernel.exception.SystemException {
2393                    return _userLocalService.updateEmailAddressVerified(userId,
2394                            emailAddressVerified);
2395            }
2396    
2397            /**
2398            * Updates the user's Facebook ID.
2399            *
2400            * @param userId the primary key of the user
2401            * @param facebookId the user's new Facebook ID
2402            * @return the user
2403            * @throws PortalException if a user with the primary key could not be found
2404            * @throws SystemException if a system exception occurred
2405            */
2406            public com.liferay.portal.model.User updateFacebookId(long userId,
2407                    long facebookId)
2408                    throws com.liferay.portal.kernel.exception.PortalException,
2409                            com.liferay.portal.kernel.exception.SystemException {
2410                    return _userLocalService.updateFacebookId(userId, facebookId);
2411            }
2412    
2413            /**
2414            * Sets the groups the user is in, removing and adding groups as necessary.
2415            *
2416            * @param userId the primary key of the user
2417            * @param newGroupIds the primary keys of the groups
2418            * @throws PortalException if a portal exception occurred
2419            * @throws SystemException if a system exception occurred
2420            */
2421            public void updateGroups(long userId, long[] newGroupIds,
2422                    com.liferay.portal.service.ServiceContext serviceContext)
2423                    throws com.liferay.portal.kernel.exception.PortalException,
2424                            com.liferay.portal.kernel.exception.SystemException {
2425                    _userLocalService.updateGroups(userId, newGroupIds, 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    }