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