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