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, int prefixId, int 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, int prefixId, int 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.portal.kernel.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 boolean, 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 @Override 2514 public boolean sendPasswordByEmailAddress(long companyId, 2515 java.lang.String emailAddress) 2516 throws com.liferay.portal.kernel.exception.PortalException { 2517 return _userLocalService.sendPasswordByEmailAddress(companyId, 2518 emailAddress); 2519 } 2520 2521 @Override 2522 public boolean sendPasswordByScreenName(long companyId, 2523 java.lang.String screenName) 2524 throws com.liferay.portal.kernel.exception.PortalException { 2525 return _userLocalService.sendPasswordByScreenName(companyId, screenName); 2526 } 2527 2528 @Override 2529 public boolean sendPasswordByUserId(long userId) 2530 throws com.liferay.portal.kernel.exception.PortalException { 2531 return _userLocalService.sendPasswordByUserId(userId); 2532 } 2533 2534 /** 2535 * Sets the Spring bean ID for this bean. 2536 * 2537 * @param beanIdentifier the Spring bean ID for this bean 2538 */ 2539 @Override 2540 public void setBeanIdentifier(java.lang.String beanIdentifier) { 2541 _userLocalService.setBeanIdentifier(beanIdentifier); 2542 } 2543 2544 @Override 2545 public void setGroupUsers(long groupId, long[] userIds) { 2546 _userLocalService.setGroupUsers(groupId, userIds); 2547 } 2548 2549 @Override 2550 public void setOrganizationUsers(long organizationId, long[] userIds) { 2551 _userLocalService.setOrganizationUsers(organizationId, userIds); 2552 } 2553 2554 /** 2555 * @throws PortalException 2556 */ 2557 @Override 2558 public void setRoleUsers(long roleId, long[] userIds) 2559 throws com.liferay.portal.kernel.exception.PortalException { 2560 _userLocalService.setRoleUsers(roleId, userIds); 2561 } 2562 2563 @Override 2564 public void setTeamUsers(long teamId, long[] userIds) { 2565 _userLocalService.setTeamUsers(teamId, userIds); 2566 } 2567 2568 /** 2569 * @throws PortalException 2570 */ 2571 @Override 2572 public void setUserGroupUsers(long userGroupId, long[] userIds) 2573 throws com.liferay.portal.kernel.exception.PortalException { 2574 _userLocalService.setUserGroupUsers(userGroupId, userIds); 2575 } 2576 2577 /** 2578 * Removes the users from the teams of a group. 2579 * 2580 * @param groupId the primary key of the group 2581 * @param userIds the primary keys of the users 2582 * @throws PortalException if a portal exception occurred 2583 */ 2584 @Override 2585 public void unsetGroupTeamsUsers(long groupId, long[] userIds) 2586 throws com.liferay.portal.kernel.exception.PortalException { 2587 _userLocalService.unsetGroupTeamsUsers(groupId, userIds); 2588 } 2589 2590 /** 2591 * Removes the users from the group. 2592 * 2593 * @param groupId the primary key of the group 2594 * @param userIds the primary keys of the users 2595 * @param serviceContext the service context to be applied (optionally 2596 <code>null</code>) 2597 * @throws PortalException if a portal exception occurred 2598 */ 2599 @Override 2600 public void unsetGroupUsers(long groupId, long[] userIds, 2601 com.liferay.portal.service.ServiceContext serviceContext) 2602 throws com.liferay.portal.kernel.exception.PortalException { 2603 _userLocalService.unsetGroupUsers(groupId, userIds, serviceContext); 2604 } 2605 2606 /** 2607 * Removes the users from the organization. 2608 * 2609 * @param organizationId the primary key of the organization 2610 * @param userIds the primary keys of the users 2611 * @throws PortalException if a portal exception occurred 2612 */ 2613 @Override 2614 public void unsetOrganizationUsers(long organizationId, long[] userIds) 2615 throws com.liferay.portal.kernel.exception.PortalException { 2616 _userLocalService.unsetOrganizationUsers(organizationId, userIds); 2617 } 2618 2619 /** 2620 * Removes the users from the password policy. 2621 * 2622 * @param passwordPolicyId the primary key of the password policy 2623 * @param userIds the primary keys of the users 2624 */ 2625 @Override 2626 public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds) { 2627 _userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds); 2628 } 2629 2630 /** 2631 * Removes the users from the role. 2632 * 2633 * @param roleId the primary key of the role 2634 * @param userIds the primary keys of the users 2635 * @throws PortalException if a portal exception occurred 2636 */ 2637 @Override 2638 public void unsetRoleUsers(long roleId, long[] userIds) 2639 throws com.liferay.portal.kernel.exception.PortalException { 2640 _userLocalService.unsetRoleUsers(roleId, userIds); 2641 } 2642 2643 /** 2644 * Removes the users from the role. 2645 * 2646 * @param roleId the primary key of the role 2647 * @param users the users 2648 * @throws PortalException if a portal exception occurred 2649 */ 2650 @Override 2651 public void unsetRoleUsers(long roleId, 2652 java.util.List<com.liferay.portal.model.User> users) 2653 throws com.liferay.portal.kernel.exception.PortalException { 2654 _userLocalService.unsetRoleUsers(roleId, users); 2655 } 2656 2657 /** 2658 * Removes the users from the team. 2659 * 2660 * @param teamId the primary key of the team 2661 * @param userIds the primary keys of the users 2662 * @throws PortalException if a portal exception occurred 2663 */ 2664 @Override 2665 public void unsetTeamUsers(long teamId, long[] userIds) 2666 throws com.liferay.portal.kernel.exception.PortalException { 2667 _userLocalService.unsetTeamUsers(teamId, userIds); 2668 } 2669 2670 /** 2671 * Removes the users from the user group. 2672 * 2673 * @param userGroupId the primary key of the user group 2674 * @param userIds the primary keys of the users 2675 * @throws PortalException if a portal exception occurred 2676 */ 2677 @Override 2678 public void unsetUserGroupUsers(long userGroupId, long[] userIds) 2679 throws com.liferay.portal.kernel.exception.PortalException { 2680 _userLocalService.unsetUserGroupUsers(userGroupId, userIds); 2681 } 2682 2683 /** 2684 * Updates whether the user has agreed to the terms of use. 2685 * 2686 * @param userId the primary key of the user 2687 * @param agreedToTermsOfUse whether the user has agreet to the terms of 2688 use 2689 * @return the user 2690 * @throws PortalException if a user with the primary key could not be found 2691 */ 2692 @Override 2693 public com.liferay.portal.model.User updateAgreedToTermsOfUse(long userId, 2694 boolean agreedToTermsOfUse) 2695 throws com.liferay.portal.kernel.exception.PortalException { 2696 return _userLocalService.updateAgreedToTermsOfUse(userId, 2697 agreedToTermsOfUse); 2698 } 2699 2700 /** 2701 * Updates the user's asset with the new asset categories and tag names, 2702 * removing and adding asset categories and tag names as necessary. 2703 * 2704 * @param userId the primary key of the user 2705 * @param user ID the primary key of the user 2706 * @param assetCategoryIds the primary key's of the new asset categories 2707 * @param assetTagNames the new asset tag names 2708 * @throws PortalException if a user with the primary key could not be found 2709 */ 2710 @Override 2711 public void updateAsset(long userId, com.liferay.portal.model.User user, 2712 long[] assetCategoryIds, java.lang.String[] assetTagNames) 2713 throws com.liferay.portal.kernel.exception.PortalException { 2714 _userLocalService.updateAsset(userId, user, assetCategoryIds, 2715 assetTagNames); 2716 } 2717 2718 /** 2719 * Updates the user's creation date. 2720 * 2721 * @param userId the primary key of the user 2722 * @param createDate the new creation date 2723 * @return the user 2724 * @throws PortalException if a user with the primary key could not be found 2725 */ 2726 @Override 2727 public com.liferay.portal.model.User updateCreateDate(long userId, 2728 java.util.Date createDate) 2729 throws com.liferay.portal.kernel.exception.PortalException { 2730 return _userLocalService.updateCreateDate(userId, createDate); 2731 } 2732 2733 /** 2734 * Updates the user's email address. 2735 * 2736 * @param userId the primary key of the user 2737 * @param password the user's password 2738 * @param emailAddress1 the user's new email address 2739 * @param emailAddress2 the user's new email address confirmation 2740 * @return the user 2741 * @throws PortalException if a user with the primary key could not be found 2742 */ 2743 @Override 2744 public com.liferay.portal.model.User updateEmailAddress(long userId, 2745 java.lang.String password, java.lang.String emailAddress1, 2746 java.lang.String emailAddress2) 2747 throws com.liferay.portal.kernel.exception.PortalException { 2748 return _userLocalService.updateEmailAddress(userId, password, 2749 emailAddress1, emailAddress2); 2750 } 2751 2752 /** 2753 * Updates the user's email address or sends verification email. 2754 * 2755 * @param userId the primary key of the user 2756 * @param password the user's password 2757 * @param emailAddress1 the user's new email address 2758 * @param emailAddress2 the user's new email address confirmation 2759 * @param serviceContext the service context to be applied. Must set the 2760 portal URL, main path, primary key of the layout, remote address, 2761 remote host, and agent for the user. 2762 * @return the user 2763 * @throws PortalException if a user with the primary key could not be found 2764 */ 2765 @Override 2766 public com.liferay.portal.model.User updateEmailAddress(long userId, 2767 java.lang.String password, java.lang.String emailAddress1, 2768 java.lang.String emailAddress2, 2769 com.liferay.portal.service.ServiceContext serviceContext) 2770 throws com.liferay.portal.kernel.exception.PortalException { 2771 return _userLocalService.updateEmailAddress(userId, password, 2772 emailAddress1, emailAddress2, serviceContext); 2773 } 2774 2775 /** 2776 * Updates whether the user has verified email address. 2777 * 2778 * @param userId the primary key of the user 2779 * @param emailAddressVerified whether the user has verified email address 2780 * @return the user 2781 * @throws PortalException if a user with the primary key could not be found 2782 */ 2783 @Override 2784 public com.liferay.portal.model.User updateEmailAddressVerified( 2785 long userId, boolean emailAddressVerified) 2786 throws com.liferay.portal.kernel.exception.PortalException { 2787 return _userLocalService.updateEmailAddressVerified(userId, 2788 emailAddressVerified); 2789 } 2790 2791 /** 2792 * Updates the user's Facebook ID. 2793 * 2794 * @param userId the primary key of the user 2795 * @param facebookId the user's new Facebook ID 2796 * @return the user 2797 * @throws PortalException if a user with the primary key could not be found 2798 */ 2799 @Override 2800 public com.liferay.portal.model.User updateFacebookId(long userId, 2801 long facebookId) 2802 throws com.liferay.portal.kernel.exception.PortalException { 2803 return _userLocalService.updateFacebookId(userId, facebookId); 2804 } 2805 2806 /** 2807 * Sets the groups the user is in, removing and adding groups as necessary. 2808 * 2809 * @param userId the primary key of the user 2810 * @param newGroupIds the primary keys of the groups 2811 * @param serviceContext the service context to be applied (optionally 2812 <code>null</code>) 2813 * @throws PortalException if a portal exception occurred 2814 */ 2815 @Override 2816 public void updateGroups(long userId, long[] newGroupIds, 2817 com.liferay.portal.service.ServiceContext serviceContext) 2818 throws com.liferay.portal.kernel.exception.PortalException { 2819 _userLocalService.updateGroups(userId, newGroupIds, serviceContext); 2820 } 2821 2822 /** 2823 * Updates a user account that was automatically created when a guest user 2824 * participated in an action (e.g. posting a comment) and only provided his 2825 * name and email address. 2826 * 2827 * @param creatorUserId the primary key of the creator 2828 * @param companyId the primary key of the user's company 2829 * @param autoPassword whether a password should be automatically generated 2830 for the user 2831 * @param password1 the user's password 2832 * @param password2 the user's password confirmation 2833 * @param autoScreenName whether a screen name should be automatically 2834 generated for the user 2835 * @param screenName the user's screen name 2836 * @param emailAddress the user's email address 2837 * @param facebookId the user's facebook ID 2838 * @param openId the user's OpenID 2839 * @param locale the user's locale 2840 * @param firstName the user's first name 2841 * @param middleName the user's middle name 2842 * @param lastName the user's last name 2843 * @param prefixId the user's name prefix ID 2844 * @param suffixId the user's name suffix ID 2845 * @param male whether the user is male 2846 * @param birthdayMonth the user's birthday month (0-based, meaning 0 for 2847 January) 2848 * @param birthdayDay the user's birthday day 2849 * @param birthdayYear the user's birthday year 2850 * @param jobTitle the user's job title 2851 * @param updateUserInformation whether to update the user's information 2852 * @param sendEmail whether to send the user an email notification about 2853 their new account 2854 * @param serviceContext the service context to be applied (optionally 2855 <code>null</code>). Can set expando bridge attributes for the 2856 user. 2857 * @return the user 2858 * @throws PortalException if the user's information was invalid 2859 */ 2860 @Override 2861 public com.liferay.portal.model.User updateIncompleteUser( 2862 long creatorUserId, long companyId, boolean autoPassword, 2863 java.lang.String password1, java.lang.String password2, 2864 boolean autoScreenName, java.lang.String screenName, 2865 java.lang.String emailAddress, long facebookId, 2866 java.lang.String openId, java.util.Locale locale, 2867 java.lang.String firstName, java.lang.String middleName, 2868 java.lang.String lastName, int prefixId, int suffixId, boolean male, 2869 int birthdayMonth, int birthdayDay, int birthdayYear, 2870 java.lang.String jobTitle, boolean updateUserInformation, 2871 boolean sendEmail, 2872 com.liferay.portal.service.ServiceContext serviceContext) 2873 throws com.liferay.portal.kernel.exception.PortalException { 2874 return _userLocalService.updateIncompleteUser(creatorUserId, companyId, 2875 autoPassword, password1, password2, autoScreenName, screenName, 2876 emailAddress, facebookId, openId, locale, firstName, middleName, 2877 lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay, 2878 birthdayYear, jobTitle, updateUserInformation, sendEmail, 2879 serviceContext); 2880 } 2881 2882 /** 2883 * Updates the user's job title. 2884 * 2885 * @param userId the primary key of the user 2886 * @param jobTitle the user's job title 2887 * @return the user 2888 * @throws PortalException if a user with the primary key could not be found 2889 or if a contact could not be found matching the user's contact ID 2890 */ 2891 @Override 2892 public com.liferay.portal.model.User updateJobTitle(long userId, 2893 java.lang.String jobTitle) 2894 throws com.liferay.portal.kernel.exception.PortalException { 2895 return _userLocalService.updateJobTitle(userId, jobTitle); 2896 } 2897 2898 /** 2899 * Updates the user's last login with the current time and the IP address. 2900 * 2901 * @param userId the primary key of the user 2902 * @param loginIP the IP address the user logged in from 2903 * @return the user 2904 * @throws PortalException if a user with the primary key could not be found 2905 */ 2906 @Override 2907 public com.liferay.portal.model.User updateLastLogin(long userId, 2908 java.lang.String loginIP) 2909 throws com.liferay.portal.kernel.exception.PortalException { 2910 return _userLocalService.updateLastLogin(userId, loginIP); 2911 } 2912 2913 /** 2914 * Updates whether the user is locked out from logging in. 2915 * 2916 * @param user the user 2917 * @param lockout whether the user is locked out 2918 * @return the user 2919 * @throws PortalException if a portal exception occurred 2920 */ 2921 @Override 2922 public com.liferay.portal.model.User updateLockout( 2923 com.liferay.portal.model.User user, boolean lockout) 2924 throws com.liferay.portal.kernel.exception.PortalException { 2925 return _userLocalService.updateLockout(user, lockout); 2926 } 2927 2928 /** 2929 * Updates whether the user is locked out from logging in. 2930 * 2931 * @param companyId the primary key of the user's company 2932 * @param emailAddress the user's email address 2933 * @param lockout whether the user is locked out 2934 * @return the user 2935 * @throws PortalException if a user with the email address could not be 2936 found 2937 */ 2938 @Override 2939 public com.liferay.portal.model.User updateLockoutByEmailAddress( 2940 long companyId, java.lang.String emailAddress, boolean lockout) 2941 throws com.liferay.portal.kernel.exception.PortalException { 2942 return _userLocalService.updateLockoutByEmailAddress(companyId, 2943 emailAddress, lockout); 2944 } 2945 2946 /** 2947 * Updates whether the user is locked out from logging in. 2948 * 2949 * @param userId the primary key of the user 2950 * @param lockout whether the user is locked out 2951 * @return the user 2952 * @throws PortalException if a user with the primary key could not be found 2953 */ 2954 @Override 2955 public com.liferay.portal.model.User updateLockoutById(long userId, 2956 boolean lockout) 2957 throws com.liferay.portal.kernel.exception.PortalException { 2958 return _userLocalService.updateLockoutById(userId, lockout); 2959 } 2960 2961 /** 2962 * Updates whether the user is locked out from logging in. 2963 * 2964 * @param companyId the primary key of the user's company 2965 * @param screenName the user's screen name 2966 * @param lockout whether the user is locked out 2967 * @return the user 2968 * @throws PortalException if a user with the screen name could not be found 2969 */ 2970 @Override 2971 public com.liferay.portal.model.User updateLockoutByScreenName( 2972 long companyId, java.lang.String screenName, boolean lockout) 2973 throws com.liferay.portal.kernel.exception.PortalException { 2974 return _userLocalService.updateLockoutByScreenName(companyId, 2975 screenName, lockout); 2976 } 2977 2978 /** 2979 * Updates the user's modified date. 2980 * 2981 * @param userId the primary key of the user 2982 * @param modifiedDate the new modified date 2983 * @return the user 2984 * @throws PortalException if a user with the primary key could not be found 2985 */ 2986 @Override 2987 public com.liferay.portal.model.User updateModifiedDate(long userId, 2988 java.util.Date modifiedDate) 2989 throws com.liferay.portal.kernel.exception.PortalException { 2990 return _userLocalService.updateModifiedDate(userId, modifiedDate); 2991 } 2992 2993 /** 2994 * Updates the user's OpenID. 2995 * 2996 * @param userId the primary key of the user 2997 * @param openId the new OpenID 2998 * @return the user 2999 * @throws PortalException if a user with the primary key could not be found 3000 */ 3001 @Override 3002 public com.liferay.portal.model.User updateOpenId(long userId, 3003 java.lang.String openId) 3004 throws com.liferay.portal.kernel.exception.PortalException { 3005 return _userLocalService.updateOpenId(userId, openId); 3006 } 3007 3008 /** 3009 * Sets the organizations that the user is in, removing and adding 3010 * organizations as necessary. 3011 * 3012 * @param userId the primary key of the user 3013 * @param newOrganizationIds the primary keys of the organizations 3014 * @param serviceContext the service context to be applied. Must set 3015 whether user indexing is enabled. 3016 * @throws PortalException if a user with the primary key could not be found 3017 */ 3018 @Override 3019 public void updateOrganizations(long userId, long[] newOrganizationIds, 3020 com.liferay.portal.service.ServiceContext serviceContext) 3021 throws com.liferay.portal.kernel.exception.PortalException { 3022 _userLocalService.updateOrganizations(userId, newOrganizationIds, 3023 serviceContext); 3024 } 3025 3026 /** 3027 * Updates the user's password without tracking or validation of the change. 3028 * 3029 * @param userId the primary key of the user 3030 * @param password1 the user's new password 3031 * @param password2 the user's new password confirmation 3032 * @param passwordReset whether the user should be asked to reset their 3033 password the next time they log in 3034 * @return the user 3035 * @throws PortalException if a user with the primary key could not be found 3036 */ 3037 @Override 3038 public com.liferay.portal.model.User updatePassword(long userId, 3039 java.lang.String password1, java.lang.String password2, 3040 boolean passwordReset) 3041 throws com.liferay.portal.kernel.exception.PortalException { 3042 return _userLocalService.updatePassword(userId, password1, password2, 3043 passwordReset); 3044 } 3045 3046 /** 3047 * Updates the user's password, optionally with tracking and validation of 3048 * the change. 3049 * 3050 * @param userId the primary key of the user 3051 * @param password1 the user's new password 3052 * @param password2 the user's new password confirmation 3053 * @param passwordReset whether the user should be asked to reset their 3054 password the next time they login 3055 * @param silentUpdate whether the password should be updated without being 3056 tracked, or validated. Primarily used for password imports. 3057 * @return the user 3058 * @throws PortalException if a user with the primary key could not be found 3059 */ 3060 @Override 3061 public com.liferay.portal.model.User updatePassword(long userId, 3062 java.lang.String password1, java.lang.String password2, 3063 boolean passwordReset, boolean silentUpdate) 3064 throws com.liferay.portal.kernel.exception.PortalException { 3065 return _userLocalService.updatePassword(userId, password1, password2, 3066 passwordReset, silentUpdate); 3067 } 3068 3069 /** 3070 * Updates the user's password with manually input information. This method 3071 * should only be used when performing maintenance. 3072 * 3073 * @param userId the primary key of the user 3074 * @param password the user's new password 3075 * @param passwordEncrypted the user's new encrypted password 3076 * @param passwordReset whether the user should be asked to reset their 3077 password the next time they login 3078 * @param passwordModifiedDate the new password modified date 3079 * @return the user 3080 * @throws PortalException if a user with the primary key could not be found 3081 */ 3082 @Override 3083 public com.liferay.portal.model.User updatePasswordManually(long userId, 3084 java.lang.String password, boolean passwordEncrypted, 3085 boolean passwordReset, java.util.Date passwordModifiedDate) 3086 throws com.liferay.portal.kernel.exception.PortalException { 3087 return _userLocalService.updatePasswordManually(userId, password, 3088 passwordEncrypted, passwordReset, passwordModifiedDate); 3089 } 3090 3091 /** 3092 * Updates whether the user should be asked to reset their password the next 3093 * time they login. 3094 * 3095 * @param userId the primary key of the user 3096 * @param passwordReset whether the user should be asked to reset their 3097 password the next time they login 3098 * @return the user 3099 * @throws PortalException if a user with the primary key could not be found 3100 */ 3101 @Override 3102 public com.liferay.portal.model.User updatePasswordReset(long userId, 3103 boolean passwordReset) 3104 throws com.liferay.portal.kernel.exception.PortalException { 3105 return _userLocalService.updatePasswordReset(userId, passwordReset); 3106 } 3107 3108 /** 3109 * Updates the user's portrait image. 3110 * 3111 * @param userId the primary key of the user 3112 * @param bytes the new portrait image data 3113 * @return the user 3114 * @throws PortalException if a user with the primary key could not be found 3115 or if the new portrait was invalid 3116 */ 3117 @Override 3118 public com.liferay.portal.model.User updatePortrait(long userId, 3119 byte[] bytes) 3120 throws com.liferay.portal.kernel.exception.PortalException { 3121 return _userLocalService.updatePortrait(userId, bytes); 3122 } 3123 3124 /** 3125 * Updates the user's password reset question and answer. 3126 * 3127 * @param userId the primary key of the user 3128 * @param question the user's new password reset question 3129 * @param answer the user's new password reset answer 3130 * @return the user 3131 * @throws PortalException if a user with the primary key could not be found 3132 or if the new question or answer were invalid 3133 */ 3134 @Override 3135 public com.liferay.portal.model.User updateReminderQuery(long userId, 3136 java.lang.String question, java.lang.String answer) 3137 throws com.liferay.portal.kernel.exception.PortalException { 3138 return _userLocalService.updateReminderQuery(userId, question, answer); 3139 } 3140 3141 /** 3142 * Updates the user's screen name. 3143 * 3144 * @param userId the primary key of the user 3145 * @param screenName the user's new screen name 3146 * @return the user 3147 * @throws PortalException if a user with the primary key could not be found 3148 or if the new screen name was invalid 3149 */ 3150 @Override 3151 public com.liferay.portal.model.User updateScreenName(long userId, 3152 java.lang.String screenName) 3153 throws com.liferay.portal.kernel.exception.PortalException { 3154 return _userLocalService.updateScreenName(userId, screenName); 3155 } 3156 3157 /** 3158 * Updates the user's workflow status. 3159 * 3160 * @param userId the primary key of the user 3161 * @param status the user's new workflow status 3162 * @return the user 3163 * @throws PortalException if a user with the primary key could not be 3164 found 3165 * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int, 3166 ServiceContext)} 3167 */ 3168 @Deprecated 3169 @Override 3170 public com.liferay.portal.model.User updateStatus(long userId, int status) 3171 throws com.liferay.portal.kernel.exception.PortalException { 3172 return _userLocalService.updateStatus(userId, status); 3173 } 3174 3175 /** 3176 * Updates the user's workflow status. 3177 * 3178 * @param userId the primary key of the user 3179 * @param status the user's new workflow status 3180 * @param serviceContext the service context to be applied. You can specify 3181 an unencrypted custom password (used by an LDAP listener) for the 3182 user via attribute <code>passwordUnencrypted</code>. 3183 * @return the user 3184 * @throws PortalException if a user with the primary key could not be found 3185 */ 3186 @Override 3187 public com.liferay.portal.model.User updateStatus(long userId, int status, 3188 com.liferay.portal.service.ServiceContext serviceContext) 3189 throws com.liferay.portal.kernel.exception.PortalException { 3190 return _userLocalService.updateStatus(userId, status, serviceContext); 3191 } 3192 3193 /** 3194 * Updates the user in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 3195 * 3196 * @param user the user 3197 * @return the user that was updated 3198 */ 3199 @Override 3200 public com.liferay.portal.model.User updateUser( 3201 com.liferay.portal.model.User user) { 3202 return _userLocalService.updateUser(user); 3203 } 3204 3205 /** 3206 * Updates the user. 3207 * 3208 * @param userId the primary key of the user 3209 * @param oldPassword the user's old password 3210 * @param newPassword1 the user's new password (optionally 3211 <code>null</code>) 3212 * @param newPassword2 the user's new password confirmation (optionally 3213 <code>null</code>) 3214 * @param passwordReset whether the user should be asked to reset their 3215 password the next time they login 3216 * @param reminderQueryQuestion the user's new password reset question 3217 * @param reminderQueryAnswer the user's new password reset answer 3218 * @param screenName the user's new screen name 3219 * @param emailAddress the user's new email address 3220 * @param facebookId the user's new Facebook ID 3221 * @param openId the user's new OpenID 3222 * @param languageId the user's new language ID 3223 * @param timeZoneId the user's new time zone ID 3224 * @param greeting the user's new greeting 3225 * @param comments the user's new comments 3226 * @param firstName the user's new first name 3227 * @param middleName the user's new middle name 3228 * @param lastName the user's new last name 3229 * @param prefixId the user's new name prefix ID 3230 * @param suffixId the user's new name suffix ID 3231 * @param male whether user is male 3232 * @param birthdayMonth the user's new birthday month (0-based, meaning 3233 0 for January) 3234 * @param birthdayDay the user's new birthday day 3235 * @param birthdayYear the user's birthday year 3236 * @param smsSn the user's new SMS screen name 3237 * @param aimSn the user's new AIM screen name 3238 * @param facebookSn the user's new Facebook screen name 3239 * @param icqSn the user's new ICQ screen name 3240 * @param jabberSn the user's new Jabber screen name 3241 * @param msnSn the user's new MSN screen name 3242 * @param mySpaceSn the user's new MySpace screen name 3243 * @param skypeSn the user's new Skype screen name 3244 * @param twitterSn the user's new Twitter screen name 3245 * @param ymSn the user's new Yahoo! Messenger screen name 3246 * @param jobTitle the user's new job title 3247 * @param groupIds the primary keys of the user's groups 3248 * @param organizationIds the primary keys of the user's organizations 3249 * @param roleIds the primary keys of the user's roles 3250 * @param userGroupRoles the user user's group roles 3251 * @param userGroupIds the primary keys of the user's user groups 3252 * @param serviceContext the service context to be applied (optionally 3253 <code>null</code>). Can set the UUID (with the 3254 <code>uuid</code> attribute), asset category IDs, asset tag 3255 names, and expando bridge attributes for the user. 3256 * @return the user 3257 * @throws PortalException if a user with the primary key could not be 3258 found or if the new information was invalid 3259 * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String, 3260 String, String, boolean, String, String, String, String, 3261 long, String, String, String, String, String, String, String, 3262 String, int, int, boolean, int, int, int, String, String, 3263 String, String, String, String, String, String, String, 3264 String, String, long[], long[], long[], java.util.List, 3265 long[], boolean, byte[], ServiceContext)} 3266 */ 3267 @Deprecated 3268 @Override 3269 public com.liferay.portal.model.User updateUser(long userId, 3270 java.lang.String oldPassword, java.lang.String newPassword1, 3271 java.lang.String newPassword2, boolean passwordReset, 3272 java.lang.String reminderQueryQuestion, 3273 java.lang.String reminderQueryAnswer, java.lang.String screenName, 3274 java.lang.String emailAddress, long facebookId, 3275 java.lang.String openId, java.lang.String languageId, 3276 java.lang.String timeZoneId, java.lang.String greeting, 3277 java.lang.String comments, java.lang.String firstName, 3278 java.lang.String middleName, java.lang.String lastName, int prefixId, 3279 int suffixId, boolean male, int birthdayMonth, int birthdayDay, 3280 int birthdayYear, java.lang.String smsSn, java.lang.String aimSn, 3281 java.lang.String facebookSn, java.lang.String icqSn, 3282 java.lang.String jabberSn, java.lang.String msnSn, 3283 java.lang.String mySpaceSn, java.lang.String skypeSn, 3284 java.lang.String twitterSn, java.lang.String ymSn, 3285 java.lang.String jobTitle, long[] groupIds, long[] organizationIds, 3286 long[] roleIds, 3287 java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles, 3288 long[] userGroupIds, 3289 com.liferay.portal.service.ServiceContext serviceContext) 3290 throws com.liferay.portal.kernel.exception.PortalException { 3291 return _userLocalService.updateUser(userId, oldPassword, newPassword1, 3292 newPassword2, passwordReset, reminderQueryQuestion, 3293 reminderQueryAnswer, screenName, emailAddress, facebookId, openId, 3294 languageId, timeZoneId, greeting, comments, firstName, middleName, 3295 lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay, 3296 birthdayYear, smsSn, aimSn, facebookSn, icqSn, jabberSn, msnSn, 3297 mySpaceSn, skypeSn, twitterSn, ymSn, jobTitle, groupIds, 3298 organizationIds, roleIds, userGroupRoles, userGroupIds, 3299 serviceContext); 3300 } 3301 3302 /** 3303 * Updates the user. 3304 * 3305 * @param userId the primary key of the user 3306 * @param oldPassword the user's old password 3307 * @param newPassword1 the user's new password (optionally 3308 <code>null</code>) 3309 * @param newPassword2 the user's new password confirmation (optionally 3310 <code>null</code>) 3311 * @param passwordReset whether the user should be asked to reset their 3312 password the next time they login 3313 * @param reminderQueryQuestion the user's new password reset question 3314 * @param reminderQueryAnswer the user's new password reset answer 3315 * @param screenName the user's new screen name 3316 * @param emailAddress the user's new email address 3317 * @param facebookId the user's new Facebook ID 3318 * @param openId the user's new OpenID 3319 * @param portrait whether to update the user's portrait image 3320 * @param portraitBytes the new portrait image data 3321 * @param languageId the user's new language ID 3322 * @param timeZoneId the user's new time zone ID 3323 * @param greeting the user's new greeting 3324 * @param comments the user's new comments 3325 * @param firstName the user's new first name 3326 * @param middleName the user's new middle name 3327 * @param lastName the user's new last name 3328 * @param prefixId the user's new name prefix ID 3329 * @param suffixId the user's new name suffix ID 3330 * @param male whether user is male 3331 * @param birthdayMonth the user's new birthday month (0-based, meaning 0 3332 for January) 3333 * @param birthdayDay the user's new birthday day 3334 * @param birthdayYear the user's birthday year 3335 * @param smsSn the user's new SMS screen name 3336 * @param aimSn the user's new AIM screen name 3337 * @param facebookSn the user's new Facebook screen name 3338 * @param icqSn the user's new ICQ screen name 3339 * @param jabberSn the user's new Jabber screen name 3340 * @param msnSn the user's new MSN screen name 3341 * @param mySpaceSn the user's new MySpace screen name 3342 * @param skypeSn the user's new Skype screen name 3343 * @param twitterSn the user's new Twitter screen name 3344 * @param ymSn the user's new Yahoo! Messenger screen name 3345 * @param jobTitle the user's new job title 3346 * @param groupIds the primary keys of the user's groups 3347 * @param organizationIds the primary keys of the user's organizations 3348 * @param roleIds the primary keys of the user's roles 3349 * @param userGroupRoles the user user's group roles 3350 * @param userGroupIds the primary keys of the user's user groups 3351 * @param serviceContext the service context to be applied (optionally 3352 <code>null</code>). Can set the UUID (with the <code>uuid</code> 3353 attribute), asset category IDs, asset tag names, and expando 3354 bridge attributes for the user. 3355 * @return the user 3356 * @throws PortalException if a user with the primary key could not be found 3357 or if the new information was invalid 3358 */ 3359 @Override 3360 public com.liferay.portal.model.User updateUser(long userId, 3361 java.lang.String oldPassword, java.lang.String newPassword1, 3362 java.lang.String newPassword2, boolean passwordReset, 3363 java.lang.String reminderQueryQuestion, 3364 java.lang.String reminderQueryAnswer, java.lang.String screenName, 3365 java.lang.String emailAddress, long facebookId, 3366 java.lang.String openId, boolean portrait, byte[] portraitBytes, 3367 java.lang.String languageId, java.lang.String timeZoneId, 3368 java.lang.String greeting, java.lang.String comments, 3369 java.lang.String firstName, java.lang.String middleName, 3370 java.lang.String lastName, int prefixId, int suffixId, boolean male, 3371 int birthdayMonth, int birthdayDay, int birthdayYear, 3372 java.lang.String smsSn, java.lang.String aimSn, 3373 java.lang.String facebookSn, java.lang.String icqSn, 3374 java.lang.String jabberSn, java.lang.String msnSn, 3375 java.lang.String mySpaceSn, java.lang.String skypeSn, 3376 java.lang.String twitterSn, java.lang.String ymSn, 3377 java.lang.String jobTitle, long[] groupIds, long[] organizationIds, 3378 long[] roleIds, 3379 java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles, 3380 long[] userGroupIds, 3381 com.liferay.portal.service.ServiceContext serviceContext) 3382 throws com.liferay.portal.kernel.exception.PortalException { 3383 return _userLocalService.updateUser(userId, oldPassword, newPassword1, 3384 newPassword2, passwordReset, reminderQueryQuestion, 3385 reminderQueryAnswer, screenName, emailAddress, facebookId, openId, 3386 portrait, portraitBytes, languageId, timeZoneId, greeting, 3387 comments, firstName, middleName, lastName, prefixId, suffixId, 3388 male, birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, 3389 facebookSn, icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, 3390 ymSn, jobTitle, groupIds, organizationIds, roleIds, userGroupRoles, 3391 userGroupIds, serviceContext); 3392 } 3393 3394 /** 3395 * Verifies the email address of the ticket. 3396 * 3397 * @param ticketKey the ticket key 3398 * @throws PortalException if a ticket matching the ticket key could not be 3399 found, if the ticket has expired, if the ticket is an email 3400 address ticket, or if the email address is invalid 3401 */ 3402 @Override 3403 public void verifyEmailAddress(java.lang.String ticketKey) 3404 throws com.liferay.portal.kernel.exception.PortalException { 3405 _userLocalService.verifyEmailAddress(ticketKey); 3406 } 3407 3408 /** 3409 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 3410 */ 3411 @Deprecated 3412 public UserLocalService getWrappedUserLocalService() { 3413 return _userLocalService; 3414 } 3415 3416 /** 3417 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 3418 */ 3419 @Deprecated 3420 public void setWrappedUserLocalService(UserLocalService userLocalService) { 3421 _userLocalService = userLocalService; 3422 } 3423 3424 @Override 3425 public UserLocalService getWrappedService() { 3426 return _userLocalService; 3427 } 3428 3429 @Override 3430 public void setWrappedService(UserLocalService userLocalService) { 3431 _userLocalService = userLocalService; 3432 } 3433 3434 private UserLocalService _userLocalService; 3435 }