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