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 that match the dynamic query. 987 * 988 * @param dynamicQuery the dynamic query 989 * @return the number of rows that match 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 that match 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 that match 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 /** 2240 * Returns an ordered range of all the users who match the keywords and 2241 * status, without using the indexer. It is preferable to use the indexed 2242 * version {@link #search(long, String, int, LinkedHashMap, int, int, Sort)} 2243 * instead of this method wherever possible for performance reasons. 2244 * 2245 * <p> 2246 * Useful when paginating results. Returns a maximum of <code>end - 2247 * start</code> instances. <code>start</code> and <code>end</code> are not 2248 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2249 * refers to the first result in the set. Setting both <code>start</code> 2250 * and <code>end</code> to {@link 2251 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2252 * result set. 2253 * </p> 2254 * 2255 * @param companyId the primary key of the user's company 2256 * @param keywords the keywords (space separated), which may occur in the 2257 user's first name, middle name, last name, screen name, or email 2258 address 2259 * @param status the workflow status 2260 * @param params the finder parameters (optionally <code>null</code>). For 2261 more information see {@link 2262 com.liferay.portal.service.persistence.UserFinder}. 2263 * @param start the lower bound of the range of users 2264 * @param end the upper bound of the range of users (not inclusive) 2265 * @param obc the comparator to order the users by (optionally 2266 <code>null</code>) 2267 * @return the matching users 2268 * @see com.liferay.portal.service.persistence.UserFinder 2269 */ 2270 @Override 2271 public java.util.List<com.liferay.portal.model.User> search( 2272 long companyId, java.lang.String keywords, int status, 2273 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2274 int start, int end, 2275 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) { 2276 return _userLocalService.search(companyId, keywords, status, params, 2277 start, end, obc); 2278 } 2279 2280 /** 2281 * Returns an ordered range of all the users who match the keywords and 2282 * status, using the indexer. It is preferable to use this method instead of 2283 * the non-indexed version whenever possible for performance reasons. 2284 * 2285 * <p> 2286 * Useful when paginating results. Returns a maximum of <code>end - 2287 * start</code> instances. <code>start</code> and <code>end</code> are not 2288 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2289 * refers to the first result in the set. Setting both <code>start</code> 2290 * and <code>end</code> to {@link 2291 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 2292 * result set. 2293 * </p> 2294 * 2295 * @param companyId the primary key of the user's company 2296 * @param keywords the keywords (space separated), which may occur in the 2297 user's first name, middle name, last name, screen name, or email 2298 address 2299 * @param status the workflow status 2300 * @param params the indexer parameters (optionally <code>null</code>). For 2301 more information see {@link 2302 com.liferay.portlet.usersadmin.util.UserIndexer}. 2303 * @param start the lower bound of the range of users 2304 * @param end the upper bound of the range of users (not inclusive) 2305 * @param sort the field and direction to sort by (optionally 2306 <code>null</code>) 2307 * @return the matching users 2308 * @see com.liferay.portlet.usersadmin.util.UserIndexer 2309 */ 2310 @Override 2311 public com.liferay.portal.kernel.search.Hits search(long companyId, 2312 java.lang.String keywords, int status, 2313 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2314 int start, int end, com.liferay.portal.kernel.search.Sort sort) { 2315 return _userLocalService.search(companyId, keywords, status, params, 2316 start, end, sort); 2317 } 2318 2319 /** 2320 * Returns the number of users with the status, and whose first name, middle 2321 * name, last name, screen name, and email address match the keywords 2322 * specified for them. 2323 * 2324 * @param companyId the primary key of the user's company 2325 * @param firstName the first name keywords (space separated) 2326 * @param middleName the middle name keywords 2327 * @param lastName the last name keywords 2328 * @param screenName the screen name keywords 2329 * @param emailAddress the email address keywords 2330 * @param status the workflow status 2331 * @param params the finder parameters (optionally <code>null</code>). For 2332 more information see {@link 2333 com.liferay.portal.service.persistence.UserFinder}. 2334 * @param andSearch whether every field must match its keywords, or just 2335 one field. For example, "users with the first name 'bob' and 2336 last name 'smith'" vs "users with the first name 'bob' 2337 or the last name 'smith'". 2338 * @return the number of matching users 2339 */ 2340 @Override 2341 public int searchCount(long companyId, java.lang.String firstName, 2342 java.lang.String middleName, java.lang.String lastName, 2343 java.lang.String screenName, java.lang.String emailAddress, int status, 2344 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2345 boolean andSearch) { 2346 return _userLocalService.searchCount(companyId, firstName, middleName, 2347 lastName, screenName, emailAddress, status, params, andSearch); 2348 } 2349 2350 /** 2351 * Returns the number of users who match the keywords and status. 2352 * 2353 * @param companyId the primary key of the user's company 2354 * @param keywords the keywords (space separated), which may occur in the 2355 user's first name, middle name, last name, screen name, or email 2356 address 2357 * @param status the workflow status 2358 * @param params the finder parameters (optionally <code>null</code>). For 2359 more information see {@link 2360 com.liferay.portal.service.persistence.UserFinder}. 2361 * @return the number matching users 2362 */ 2363 @Override 2364 public int searchCount(long companyId, java.lang.String keywords, 2365 int status, 2366 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2367 return _userLocalService.searchCount(companyId, keywords, status, params); 2368 } 2369 2370 @Override 2371 public java.util.List<com.liferay.portal.model.User> searchSocial( 2372 long companyId, long[] groupIds, java.lang.String keywords, int start, 2373 int end) { 2374 return _userLocalService.searchSocial(companyId, groupIds, keywords, 2375 start, end); 2376 } 2377 2378 @Override 2379 public java.util.List<com.liferay.portal.model.User> searchSocial( 2380 long[] groupIds, long userId, int[] socialRelationTypes, 2381 java.lang.String keywords, int start, int end) 2382 throws com.liferay.portal.kernel.exception.PortalException { 2383 return _userLocalService.searchSocial(groupIds, userId, 2384 socialRelationTypes, keywords, start, end); 2385 } 2386 2387 @Override 2388 public java.util.List<com.liferay.portal.model.User> searchSocial( 2389 long userId, int[] socialRelationTypes, java.lang.String keywords, 2390 int start, int end) 2391 throws com.liferay.portal.kernel.exception.PortalException { 2392 return _userLocalService.searchSocial(userId, socialRelationTypes, 2393 keywords, start, end); 2394 } 2395 2396 @Override 2397 public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers( 2398 long companyId, java.lang.String firstName, 2399 java.lang.String middleName, java.lang.String lastName, 2400 java.lang.String screenName, java.lang.String emailAddress, int status, 2401 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2402 boolean andSearch, int start, int end, 2403 com.liferay.portal.kernel.search.Sort sort) 2404 throws com.liferay.portal.kernel.exception.PortalException { 2405 return _userLocalService.searchUsers(companyId, firstName, middleName, 2406 lastName, screenName, emailAddress, status, params, andSearch, 2407 start, end, sort); 2408 } 2409 2410 @Override 2411 public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers( 2412 long companyId, java.lang.String keywords, int status, 2413 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2414 int start, int end, com.liferay.portal.kernel.search.Sort sort) 2415 throws com.liferay.portal.kernel.exception.PortalException { 2416 return _userLocalService.searchUsers(companyId, keywords, status, 2417 params, start, end, sort); 2418 } 2419 2420 /** 2421 * Sends an email address verification to the user. 2422 * 2423 * @param user the verification email recipient 2424 * @param emailAddress the recipient's email address 2425 * @param serviceContext the service context to be applied. Must set the 2426 portal URL, main path, primary key of the layout, remote address, 2427 remote host, and agent for the user. 2428 * @throws PortalException if a portal exception occurred 2429 */ 2430 @Override 2431 public void sendEmailAddressVerification( 2432 com.liferay.portal.model.User user, java.lang.String emailAddress, 2433 com.liferay.portal.service.ServiceContext serviceContext) 2434 throws com.liferay.portal.kernel.exception.PortalException { 2435 _userLocalService.sendEmailAddressVerification(user, emailAddress, 2436 serviceContext); 2437 } 2438 2439 /** 2440 * Sends the password email to the user with the email address. The content 2441 * of this email can be specified in <code>portal.properties</code> with the 2442 * <code>admin.email.password</code> keys. 2443 * 2444 * @param companyId the primary key of the user's company 2445 * @param emailAddress the user's email address 2446 * @param fromName the name of the individual that the email should be from 2447 * @param fromAddress the address of the individual that the email should 2448 be from 2449 * @param subject the email subject. If <code>null</code>, the subject 2450 specified in <code>portal.properties</code> will be used. 2451 * @param body the email body. If <code>null</code>, the body specified in 2452 <code>portal.properties</code> will be used. 2453 * @param serviceContext the service context to be applied 2454 * @throws PortalException if a user with the email address could not be 2455 found 2456 */ 2457 @Override 2458 public boolean sendPassword(long companyId, java.lang.String emailAddress, 2459 java.lang.String fromName, java.lang.String fromAddress, 2460 java.lang.String subject, java.lang.String body, 2461 com.liferay.portal.service.ServiceContext serviceContext) 2462 throws com.liferay.portal.kernel.exception.PortalException { 2463 return _userLocalService.sendPassword(companyId, emailAddress, 2464 fromName, fromAddress, subject, body, serviceContext); 2465 } 2466 2467 @Override 2468 public boolean sendPasswordByEmailAddress(long companyId, 2469 java.lang.String emailAddress) 2470 throws com.liferay.portal.kernel.exception.PortalException { 2471 return _userLocalService.sendPasswordByEmailAddress(companyId, 2472 emailAddress); 2473 } 2474 2475 @Override 2476 public boolean sendPasswordByScreenName(long companyId, 2477 java.lang.String screenName) 2478 throws com.liferay.portal.kernel.exception.PortalException { 2479 return _userLocalService.sendPasswordByScreenName(companyId, screenName); 2480 } 2481 2482 @Override 2483 public boolean sendPasswordByUserId(long userId) 2484 throws com.liferay.portal.kernel.exception.PortalException { 2485 return _userLocalService.sendPasswordByUserId(userId); 2486 } 2487 2488 /** 2489 * Sets the Spring bean ID for this bean. 2490 * 2491 * @param beanIdentifier the Spring bean ID for this bean 2492 */ 2493 @Override 2494 public void setBeanIdentifier(java.lang.String beanIdentifier) { 2495 _userLocalService.setBeanIdentifier(beanIdentifier); 2496 } 2497 2498 @Override 2499 public void setGroupUsers(long groupId, long[] userIds) { 2500 _userLocalService.setGroupUsers(groupId, userIds); 2501 } 2502 2503 @Override 2504 public void setOrganizationUsers(long organizationId, long[] userIds) { 2505 _userLocalService.setOrganizationUsers(organizationId, userIds); 2506 } 2507 2508 /** 2509 * @throws PortalException 2510 */ 2511 @Override 2512 public void setRoleUsers(long roleId, long[] userIds) 2513 throws com.liferay.portal.kernel.exception.PortalException { 2514 _userLocalService.setRoleUsers(roleId, userIds); 2515 } 2516 2517 @Override 2518 public void setTeamUsers(long teamId, long[] userIds) { 2519 _userLocalService.setTeamUsers(teamId, userIds); 2520 } 2521 2522 /** 2523 * @throws PortalException 2524 */ 2525 @Override 2526 public void setUserGroupUsers(long userGroupId, long[] userIds) 2527 throws com.liferay.portal.kernel.exception.PortalException { 2528 _userLocalService.setUserGroupUsers(userGroupId, userIds); 2529 } 2530 2531 /** 2532 * Removes the users from the teams of a group. 2533 * 2534 * @param groupId the primary key of the group 2535 * @param userIds the primary keys of the users 2536 * @throws PortalException if a portal exception occurred 2537 */ 2538 @Override 2539 public void unsetGroupTeamsUsers(long groupId, long[] userIds) 2540 throws com.liferay.portal.kernel.exception.PortalException { 2541 _userLocalService.unsetGroupTeamsUsers(groupId, userIds); 2542 } 2543 2544 /** 2545 * Removes the users from the group. 2546 * 2547 * @param groupId the primary key of the group 2548 * @param userIds the primary keys of the users 2549 * @param serviceContext the service context to be applied (optionally 2550 <code>null</code>) 2551 * @throws PortalException if a portal exception occurred 2552 */ 2553 @Override 2554 public void unsetGroupUsers(long groupId, long[] userIds, 2555 com.liferay.portal.service.ServiceContext serviceContext) 2556 throws com.liferay.portal.kernel.exception.PortalException { 2557 _userLocalService.unsetGroupUsers(groupId, userIds, serviceContext); 2558 } 2559 2560 /** 2561 * Removes the users from the organization. 2562 * 2563 * @param organizationId the primary key of the organization 2564 * @param userIds the primary keys of the users 2565 * @throws PortalException if a portal exception occurred 2566 */ 2567 @Override 2568 public void unsetOrganizationUsers(long organizationId, long[] userIds) 2569 throws com.liferay.portal.kernel.exception.PortalException { 2570 _userLocalService.unsetOrganizationUsers(organizationId, userIds); 2571 } 2572 2573 /** 2574 * Removes the users from the password policy. 2575 * 2576 * @param passwordPolicyId the primary key of the password policy 2577 * @param userIds the primary keys of the users 2578 */ 2579 @Override 2580 public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds) { 2581 _userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds); 2582 } 2583 2584 /** 2585 * Removes the users from the role. 2586 * 2587 * @param roleId the primary key of the role 2588 * @param userIds the primary keys of the users 2589 * @throws PortalException if a portal exception occurred 2590 */ 2591 @Override 2592 public void unsetRoleUsers(long roleId, long[] userIds) 2593 throws com.liferay.portal.kernel.exception.PortalException { 2594 _userLocalService.unsetRoleUsers(roleId, userIds); 2595 } 2596 2597 /** 2598 * Removes the users from the role. 2599 * 2600 * @param roleId the primary key of the role 2601 * @param users the users 2602 * @throws PortalException if a portal exception occurred 2603 */ 2604 @Override 2605 public void unsetRoleUsers(long roleId, 2606 java.util.List<com.liferay.portal.model.User> users) 2607 throws com.liferay.portal.kernel.exception.PortalException { 2608 _userLocalService.unsetRoleUsers(roleId, users); 2609 } 2610 2611 /** 2612 * Removes the users from the team. 2613 * 2614 * @param teamId the primary key of the team 2615 * @param userIds the primary keys of the users 2616 * @throws PortalException if a portal exception occurred 2617 */ 2618 @Override 2619 public void unsetTeamUsers(long teamId, long[] userIds) 2620 throws com.liferay.portal.kernel.exception.PortalException { 2621 _userLocalService.unsetTeamUsers(teamId, userIds); 2622 } 2623 2624 /** 2625 * Removes the users from the user group. 2626 * 2627 * @param userGroupId the primary key of the user group 2628 * @param userIds the primary keys of the users 2629 * @throws PortalException if a portal exception occurred 2630 */ 2631 @Override 2632 public void unsetUserGroupUsers(long userGroupId, long[] userIds) 2633 throws com.liferay.portal.kernel.exception.PortalException { 2634 _userLocalService.unsetUserGroupUsers(userGroupId, userIds); 2635 } 2636 2637 /** 2638 * Updates whether the user has agreed to the terms of use. 2639 * 2640 * @param userId the primary key of the user 2641 * @param agreedToTermsOfUse whether the user has agreet to the terms of 2642 use 2643 * @return the user 2644 * @throws PortalException if a user with the primary key could not be found 2645 */ 2646 @Override 2647 public com.liferay.portal.model.User updateAgreedToTermsOfUse(long userId, 2648 boolean agreedToTermsOfUse) 2649 throws com.liferay.portal.kernel.exception.PortalException { 2650 return _userLocalService.updateAgreedToTermsOfUse(userId, 2651 agreedToTermsOfUse); 2652 } 2653 2654 /** 2655 * Updates the user's asset with the new asset categories and tag names, 2656 * removing and adding asset categories and tag names as necessary. 2657 * 2658 * @param userId the primary key of the user 2659 * @param user ID the primary key of the user 2660 * @param assetCategoryIds the primary key's of the new asset categories 2661 * @param assetTagNames the new asset tag names 2662 * @throws PortalException if a user with the primary key could not be found 2663 */ 2664 @Override 2665 public void updateAsset(long userId, com.liferay.portal.model.User user, 2666 long[] assetCategoryIds, java.lang.String[] assetTagNames) 2667 throws com.liferay.portal.kernel.exception.PortalException { 2668 _userLocalService.updateAsset(userId, user, assetCategoryIds, 2669 assetTagNames); 2670 } 2671 2672 /** 2673 * Updates the user's creation date. 2674 * 2675 * @param userId the primary key of the user 2676 * @param createDate the new creation date 2677 * @return the user 2678 * @throws PortalException if a user with the primary key could not be found 2679 */ 2680 @Override 2681 public com.liferay.portal.model.User updateCreateDate(long userId, 2682 java.util.Date createDate) 2683 throws com.liferay.portal.kernel.exception.PortalException { 2684 return _userLocalService.updateCreateDate(userId, createDate); 2685 } 2686 2687 /** 2688 * Updates the user's email address. 2689 * 2690 * @param userId the primary key of the user 2691 * @param password the user's password 2692 * @param emailAddress1 the user's new email address 2693 * @param emailAddress2 the user's new email address confirmation 2694 * @return the user 2695 * @throws PortalException if a user with the primary key could not be found 2696 */ 2697 @Override 2698 public com.liferay.portal.model.User updateEmailAddress(long userId, 2699 java.lang.String password, java.lang.String emailAddress1, 2700 java.lang.String emailAddress2) 2701 throws com.liferay.portal.kernel.exception.PortalException { 2702 return _userLocalService.updateEmailAddress(userId, password, 2703 emailAddress1, emailAddress2); 2704 } 2705 2706 /** 2707 * Updates the user's email address or sends verification email. 2708 * 2709 * @param userId the primary key of the user 2710 * @param password the user's password 2711 * @param emailAddress1 the user's new email address 2712 * @param emailAddress2 the user's new email address confirmation 2713 * @param serviceContext the service context to be applied. Must set the 2714 portal URL, main path, primary key of the layout, remote address, 2715 remote host, and agent for the user. 2716 * @return the user 2717 * @throws PortalException if a user with the primary key could not be found 2718 */ 2719 @Override 2720 public com.liferay.portal.model.User updateEmailAddress(long userId, 2721 java.lang.String password, java.lang.String emailAddress1, 2722 java.lang.String emailAddress2, 2723 com.liferay.portal.service.ServiceContext serviceContext) 2724 throws com.liferay.portal.kernel.exception.PortalException { 2725 return _userLocalService.updateEmailAddress(userId, password, 2726 emailAddress1, emailAddress2, serviceContext); 2727 } 2728 2729 /** 2730 * Updates whether the user has verified email address. 2731 * 2732 * @param userId the primary key of the user 2733 * @param emailAddressVerified whether the user has verified email address 2734 * @return the user 2735 * @throws PortalException if a user with the primary key could not be found 2736 */ 2737 @Override 2738 public com.liferay.portal.model.User updateEmailAddressVerified( 2739 long userId, boolean emailAddressVerified) 2740 throws com.liferay.portal.kernel.exception.PortalException { 2741 return _userLocalService.updateEmailAddressVerified(userId, 2742 emailAddressVerified); 2743 } 2744 2745 /** 2746 * Updates the user's Facebook ID. 2747 * 2748 * @param userId the primary key of the user 2749 * @param facebookId the user's new Facebook ID 2750 * @return the user 2751 * @throws PortalException if a user with the primary key could not be found 2752 */ 2753 @Override 2754 public com.liferay.portal.model.User updateFacebookId(long userId, 2755 long facebookId) 2756 throws com.liferay.portal.kernel.exception.PortalException { 2757 return _userLocalService.updateFacebookId(userId, facebookId); 2758 } 2759 2760 /** 2761 * Sets the groups the user is in, removing and adding groups as necessary. 2762 * 2763 * @param userId the primary key of the user 2764 * @param newGroupIds the primary keys of the groups 2765 * @param serviceContext the service context to be applied (optionally 2766 <code>null</code>) 2767 * @throws PortalException if a portal exception occurred 2768 */ 2769 @Override 2770 public void updateGroups(long userId, long[] newGroupIds, 2771 com.liferay.portal.service.ServiceContext serviceContext) 2772 throws com.liferay.portal.kernel.exception.PortalException { 2773 _userLocalService.updateGroups(userId, newGroupIds, serviceContext); 2774 } 2775 2776 /** 2777 * Updates a user account that was automatically created when a guest user 2778 * participated in an action (e.g. posting a comment) and only provided his 2779 * name and email address. 2780 * 2781 * @param creatorUserId the primary key of the creator 2782 * @param companyId the primary key of the user's company 2783 * @param autoPassword whether a password should be automatically generated 2784 for the user 2785 * @param password1 the user's password 2786 * @param password2 the user's password confirmation 2787 * @param autoScreenName whether a screen name should be automatically 2788 generated for the user 2789 * @param screenName the user's screen name 2790 * @param emailAddress the user's email address 2791 * @param facebookId the user's facebook ID 2792 * @param openId the user's OpenID 2793 * @param locale the user's locale 2794 * @param firstName the user's first name 2795 * @param middleName the user's middle name 2796 * @param lastName the user's last name 2797 * @param prefixId the user's name prefix ID 2798 * @param suffixId the user's name suffix ID 2799 * @param male whether the user is male 2800 * @param birthdayMonth the user's birthday month (0-based, meaning 0 for 2801 January) 2802 * @param birthdayDay the user's birthday day 2803 * @param birthdayYear the user's birthday year 2804 * @param jobTitle the user's job title 2805 * @param updateUserInformation whether to update the user's information 2806 * @param sendEmail whether to send the user an email notification about 2807 their new account 2808 * @param serviceContext the service context to be applied (optionally 2809 <code>null</code>). Can set expando bridge attributes for the 2810 user. 2811 * @return the user 2812 * @throws PortalException if the user's information was invalid 2813 */ 2814 @Override 2815 public com.liferay.portal.model.User updateIncompleteUser( 2816 long creatorUserId, long companyId, boolean autoPassword, 2817 java.lang.String password1, java.lang.String password2, 2818 boolean autoScreenName, java.lang.String screenName, 2819 java.lang.String emailAddress, long facebookId, 2820 java.lang.String openId, java.util.Locale locale, 2821 java.lang.String firstName, java.lang.String middleName, 2822 java.lang.String lastName, int prefixId, int suffixId, boolean male, 2823 int birthdayMonth, int birthdayDay, int birthdayYear, 2824 java.lang.String jobTitle, boolean updateUserInformation, 2825 boolean sendEmail, 2826 com.liferay.portal.service.ServiceContext serviceContext) 2827 throws com.liferay.portal.kernel.exception.PortalException { 2828 return _userLocalService.updateIncompleteUser(creatorUserId, companyId, 2829 autoPassword, password1, password2, autoScreenName, screenName, 2830 emailAddress, facebookId, openId, locale, firstName, middleName, 2831 lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay, 2832 birthdayYear, jobTitle, updateUserInformation, sendEmail, 2833 serviceContext); 2834 } 2835 2836 /** 2837 * Updates the user's job title. 2838 * 2839 * @param userId the primary key of the user 2840 * @param jobTitle the user's job title 2841 * @return the user 2842 * @throws PortalException if a user with the primary key could not be found 2843 or if a contact could not be found matching the user's contact ID 2844 */ 2845 @Override 2846 public com.liferay.portal.model.User updateJobTitle(long userId, 2847 java.lang.String jobTitle) 2848 throws com.liferay.portal.kernel.exception.PortalException { 2849 return _userLocalService.updateJobTitle(userId, jobTitle); 2850 } 2851 2852 /** 2853 * Updates the user's last login with the current time and the IP address. 2854 * 2855 * @param userId the primary key of the user 2856 * @param loginIP the IP address the user logged in from 2857 * @return the user 2858 * @throws PortalException if a user with the primary key could not be found 2859 */ 2860 @Override 2861 public com.liferay.portal.model.User updateLastLogin(long userId, 2862 java.lang.String loginIP) 2863 throws com.liferay.portal.kernel.exception.PortalException { 2864 return _userLocalService.updateLastLogin(userId, loginIP); 2865 } 2866 2867 /** 2868 * Updates whether the user is locked out from logging in. 2869 * 2870 * @param user the user 2871 * @param lockout whether the user is locked out 2872 * @return the user 2873 * @throws PortalException if a portal exception occurred 2874 */ 2875 @Override 2876 public com.liferay.portal.model.User updateLockout( 2877 com.liferay.portal.model.User user, boolean lockout) 2878 throws com.liferay.portal.kernel.exception.PortalException { 2879 return _userLocalService.updateLockout(user, lockout); 2880 } 2881 2882 /** 2883 * Updates whether the user is locked out from logging in. 2884 * 2885 * @param companyId the primary key of the user's company 2886 * @param emailAddress the user's email address 2887 * @param lockout whether the user is locked out 2888 * @return the user 2889 * @throws PortalException if a user with the email address could not be 2890 found 2891 */ 2892 @Override 2893 public com.liferay.portal.model.User updateLockoutByEmailAddress( 2894 long companyId, java.lang.String emailAddress, boolean lockout) 2895 throws com.liferay.portal.kernel.exception.PortalException { 2896 return _userLocalService.updateLockoutByEmailAddress(companyId, 2897 emailAddress, lockout); 2898 } 2899 2900 /** 2901 * Updates whether the user is locked out from logging in. 2902 * 2903 * @param userId the primary key of the user 2904 * @param lockout whether the user is locked out 2905 * @return the user 2906 * @throws PortalException if a user with the primary key could not be found 2907 */ 2908 @Override 2909 public com.liferay.portal.model.User updateLockoutById(long userId, 2910 boolean lockout) 2911 throws com.liferay.portal.kernel.exception.PortalException { 2912 return _userLocalService.updateLockoutById(userId, lockout); 2913 } 2914 2915 /** 2916 * Updates whether the user is locked out from logging in. 2917 * 2918 * @param companyId the primary key of the user's company 2919 * @param screenName the user's screen name 2920 * @param lockout whether the user is locked out 2921 * @return the user 2922 * @throws PortalException if a user with the screen name could not be found 2923 */ 2924 @Override 2925 public com.liferay.portal.model.User updateLockoutByScreenName( 2926 long companyId, java.lang.String screenName, boolean lockout) 2927 throws com.liferay.portal.kernel.exception.PortalException { 2928 return _userLocalService.updateLockoutByScreenName(companyId, 2929 screenName, lockout); 2930 } 2931 2932 /** 2933 * Updates the user's modified date. 2934 * 2935 * @param userId the primary key of the user 2936 * @param modifiedDate the new modified date 2937 * @return the user 2938 * @throws PortalException if a user with the primary key could not be found 2939 */ 2940 @Override 2941 public com.liferay.portal.model.User updateModifiedDate(long userId, 2942 java.util.Date modifiedDate) 2943 throws com.liferay.portal.kernel.exception.PortalException { 2944 return _userLocalService.updateModifiedDate(userId, modifiedDate); 2945 } 2946 2947 /** 2948 * Updates the user's OpenID. 2949 * 2950 * @param userId the primary key of the user 2951 * @param openId the new OpenID 2952 * @return the user 2953 * @throws PortalException if a user with the primary key could not be found 2954 */ 2955 @Override 2956 public com.liferay.portal.model.User updateOpenId(long userId, 2957 java.lang.String openId) 2958 throws com.liferay.portal.kernel.exception.PortalException { 2959 return _userLocalService.updateOpenId(userId, openId); 2960 } 2961 2962 /** 2963 * Sets the organizations that the user is in, removing and adding 2964 * organizations as necessary. 2965 * 2966 * @param userId the primary key of the user 2967 * @param newOrganizationIds the primary keys of the organizations 2968 * @param serviceContext the service context to be applied. Must set 2969 whether user indexing is enabled. 2970 * @throws PortalException if a user with the primary key could not be found 2971 */ 2972 @Override 2973 public void updateOrganizations(long userId, long[] newOrganizationIds, 2974 com.liferay.portal.service.ServiceContext serviceContext) 2975 throws com.liferay.portal.kernel.exception.PortalException { 2976 _userLocalService.updateOrganizations(userId, newOrganizationIds, 2977 serviceContext); 2978 } 2979 2980 /** 2981 * Updates the user's password without tracking or validation of the change. 2982 * 2983 * @param userId the primary key of the user 2984 * @param password1 the user's new password 2985 * @param password2 the user's new password confirmation 2986 * @param passwordReset whether the user should be asked to reset their 2987 password the next time they log in 2988 * @return the user 2989 * @throws PortalException if a user with the primary key could not be found 2990 */ 2991 @Override 2992 public com.liferay.portal.model.User updatePassword(long userId, 2993 java.lang.String password1, java.lang.String password2, 2994 boolean passwordReset) 2995 throws com.liferay.portal.kernel.exception.PortalException { 2996 return _userLocalService.updatePassword(userId, password1, password2, 2997 passwordReset); 2998 } 2999 3000 /** 3001 * Updates the user's password, optionally with tracking and validation of 3002 * the change. 3003 * 3004 * @param userId the primary key of the user 3005 * @param password1 the user's new password 3006 * @param password2 the user's new password confirmation 3007 * @param passwordReset whether the user should be asked to reset their 3008 password the next time they login 3009 * @param silentUpdate whether the password should be updated without being 3010 tracked, or validated. Primarily used for password imports. 3011 * @return the user 3012 * @throws PortalException if a user with the primary key could not be found 3013 */ 3014 @Override 3015 public com.liferay.portal.model.User updatePassword(long userId, 3016 java.lang.String password1, java.lang.String password2, 3017 boolean passwordReset, boolean silentUpdate) 3018 throws com.liferay.portal.kernel.exception.PortalException { 3019 return _userLocalService.updatePassword(userId, password1, password2, 3020 passwordReset, silentUpdate); 3021 } 3022 3023 /** 3024 * Updates the user's password with manually input information. This method 3025 * should only be used when performing maintenance. 3026 * 3027 * @param userId the primary key of the user 3028 * @param password the user's new password 3029 * @param passwordEncrypted the user's new encrypted password 3030 * @param passwordReset whether the user should be asked to reset their 3031 password the next time they login 3032 * @param passwordModifiedDate the new password modified date 3033 * @return the user 3034 * @throws PortalException if a user with the primary key could not be found 3035 */ 3036 @Override 3037 public com.liferay.portal.model.User updatePasswordManually(long userId, 3038 java.lang.String password, boolean passwordEncrypted, 3039 boolean passwordReset, java.util.Date passwordModifiedDate) 3040 throws com.liferay.portal.kernel.exception.PortalException { 3041 return _userLocalService.updatePasswordManually(userId, password, 3042 passwordEncrypted, passwordReset, passwordModifiedDate); 3043 } 3044 3045 /** 3046 * Updates whether the user should be asked to reset their password the next 3047 * time they login. 3048 * 3049 * @param userId the primary key of the user 3050 * @param passwordReset whether the user should be asked to reset their 3051 password the next time they login 3052 * @return the user 3053 * @throws PortalException if a user with the primary key could not be found 3054 */ 3055 @Override 3056 public com.liferay.portal.model.User updatePasswordReset(long userId, 3057 boolean passwordReset) 3058 throws com.liferay.portal.kernel.exception.PortalException { 3059 return _userLocalService.updatePasswordReset(userId, passwordReset); 3060 } 3061 3062 /** 3063 * Updates the user's portrait image. 3064 * 3065 * @param userId the primary key of the user 3066 * @param bytes the new portrait image data 3067 * @return the user 3068 * @throws PortalException if a user with the primary key could not be found 3069 or if the new portrait was invalid 3070 */ 3071 @Override 3072 public com.liferay.portal.model.User updatePortrait(long userId, 3073 byte[] bytes) 3074 throws com.liferay.portal.kernel.exception.PortalException { 3075 return _userLocalService.updatePortrait(userId, bytes); 3076 } 3077 3078 /** 3079 * Updates the user's password reset question and answer. 3080 * 3081 * @param userId the primary key of the user 3082 * @param question the user's new password reset question 3083 * @param answer the user's new password reset answer 3084 * @return the user 3085 * @throws PortalException if a user with the primary key could not be found 3086 or if the new question or answer were invalid 3087 */ 3088 @Override 3089 public com.liferay.portal.model.User updateReminderQuery(long userId, 3090 java.lang.String question, java.lang.String answer) 3091 throws com.liferay.portal.kernel.exception.PortalException { 3092 return _userLocalService.updateReminderQuery(userId, question, answer); 3093 } 3094 3095 /** 3096 * Updates the user's screen name. 3097 * 3098 * @param userId the primary key of the user 3099 * @param screenName the user's new screen name 3100 * @return the user 3101 * @throws PortalException if a user with the primary key could not be found 3102 or if the new screen name was invalid 3103 */ 3104 @Override 3105 public com.liferay.portal.model.User updateScreenName(long userId, 3106 java.lang.String screenName) 3107 throws com.liferay.portal.kernel.exception.PortalException { 3108 return _userLocalService.updateScreenName(userId, screenName); 3109 } 3110 3111 /** 3112 * Updates the user's workflow status. 3113 * 3114 * @param userId the primary key of the user 3115 * @param status the user's new workflow status 3116 * @return the user 3117 * @throws PortalException if a user with the primary key could not be 3118 found 3119 * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int, 3120 ServiceContext)} 3121 */ 3122 @Deprecated 3123 @Override 3124 public com.liferay.portal.model.User updateStatus(long userId, int status) 3125 throws com.liferay.portal.kernel.exception.PortalException { 3126 return _userLocalService.updateStatus(userId, status); 3127 } 3128 3129 /** 3130 * Updates the user's workflow status. 3131 * 3132 * @param userId the primary key of the user 3133 * @param status the user's new workflow status 3134 * @param serviceContext the service context to be applied. You can specify 3135 an unencrypted custom password (used by an LDAP listener) for the 3136 user via attribute <code>passwordUnencrypted</code>. 3137 * @return the user 3138 * @throws PortalException if a user with the primary key could not be found 3139 */ 3140 @Override 3141 public com.liferay.portal.model.User updateStatus(long userId, int status, 3142 com.liferay.portal.service.ServiceContext serviceContext) 3143 throws com.liferay.portal.kernel.exception.PortalException { 3144 return _userLocalService.updateStatus(userId, status, serviceContext); 3145 } 3146 3147 /** 3148 * Updates the user in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 3149 * 3150 * @param user the user 3151 * @return the user that was updated 3152 */ 3153 @Override 3154 public com.liferay.portal.model.User updateUser( 3155 com.liferay.portal.model.User user) { 3156 return _userLocalService.updateUser(user); 3157 } 3158 3159 /** 3160 * Updates the user. 3161 * 3162 * @param userId the primary key of the user 3163 * @param oldPassword the user's old password 3164 * @param newPassword1 the user's new password (optionally 3165 <code>null</code>) 3166 * @param newPassword2 the user's new password confirmation (optionally 3167 <code>null</code>) 3168 * @param passwordReset whether the user should be asked to reset their 3169 password the next time they login 3170 * @param reminderQueryQuestion the user's new password reset question 3171 * @param reminderQueryAnswer the user's new password reset answer 3172 * @param screenName the user's new screen name 3173 * @param emailAddress the user's new email address 3174 * @param facebookId the user's new Facebook ID 3175 * @param openId the user's new OpenID 3176 * @param languageId the user's new language ID 3177 * @param timeZoneId the user's new time zone ID 3178 * @param greeting the user's new greeting 3179 * @param comments the user's new comments 3180 * @param firstName the user's new first name 3181 * @param middleName the user's new middle name 3182 * @param lastName the user's new last name 3183 * @param prefixId the user's new name prefix ID 3184 * @param suffixId the user's new name suffix ID 3185 * @param male whether user is male 3186 * @param birthdayMonth the user's new birthday month (0-based, meaning 3187 0 for January) 3188 * @param birthdayDay the user's new birthday day 3189 * @param birthdayYear the user's birthday year 3190 * @param smsSn the user's new SMS screen name 3191 * @param aimSn the user's new AIM screen name 3192 * @param facebookSn the user's new Facebook screen name 3193 * @param icqSn the user's new ICQ screen name 3194 * @param jabberSn the user's new Jabber screen name 3195 * @param msnSn the user's new MSN screen name 3196 * @param mySpaceSn the user's new MySpace screen name 3197 * @param skypeSn the user's new Skype screen name 3198 * @param twitterSn the user's new Twitter screen name 3199 * @param ymSn the user's new Yahoo! Messenger screen name 3200 * @param jobTitle the user's new job title 3201 * @param groupIds the primary keys of the user's groups 3202 * @param organizationIds the primary keys of the user's organizations 3203 * @param roleIds the primary keys of the user's roles 3204 * @param userGroupRoles the user user's group roles 3205 * @param userGroupIds the primary keys of the user's user groups 3206 * @param serviceContext the service context to be applied (optionally 3207 <code>null</code>). Can set the UUID (with the 3208 <code>uuid</code> attribute), asset category IDs, asset tag 3209 names, and expando bridge attributes for the user. 3210 * @return the user 3211 * @throws PortalException if a user with the primary key could not be 3212 found or if the new information was invalid 3213 * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String, 3214 String, String, boolean, String, String, String, String, 3215 long, String, String, String, String, String, String, String, 3216 String, int, int, boolean, int, int, int, String, String, 3217 String, String, String, String, String, String, String, 3218 String, String, long[], long[], long[], java.util.List, 3219 long[], boolean, byte[], ServiceContext)} 3220 */ 3221 @Deprecated 3222 @Override 3223 public com.liferay.portal.model.User updateUser(long userId, 3224 java.lang.String oldPassword, java.lang.String newPassword1, 3225 java.lang.String newPassword2, boolean passwordReset, 3226 java.lang.String reminderQueryQuestion, 3227 java.lang.String reminderQueryAnswer, java.lang.String screenName, 3228 java.lang.String emailAddress, long facebookId, 3229 java.lang.String openId, java.lang.String languageId, 3230 java.lang.String timeZoneId, java.lang.String greeting, 3231 java.lang.String comments, java.lang.String firstName, 3232 java.lang.String middleName, java.lang.String lastName, int prefixId, 3233 int suffixId, boolean male, int birthdayMonth, int birthdayDay, 3234 int birthdayYear, java.lang.String smsSn, java.lang.String aimSn, 3235 java.lang.String facebookSn, java.lang.String icqSn, 3236 java.lang.String jabberSn, java.lang.String msnSn, 3237 java.lang.String mySpaceSn, java.lang.String skypeSn, 3238 java.lang.String twitterSn, java.lang.String ymSn, 3239 java.lang.String jobTitle, long[] groupIds, long[] organizationIds, 3240 long[] roleIds, 3241 java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles, 3242 long[] userGroupIds, 3243 com.liferay.portal.service.ServiceContext serviceContext) 3244 throws com.liferay.portal.kernel.exception.PortalException { 3245 return _userLocalService.updateUser(userId, oldPassword, newPassword1, 3246 newPassword2, passwordReset, reminderQueryQuestion, 3247 reminderQueryAnswer, screenName, emailAddress, facebookId, openId, 3248 languageId, timeZoneId, greeting, comments, firstName, middleName, 3249 lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay, 3250 birthdayYear, smsSn, aimSn, facebookSn, icqSn, jabberSn, msnSn, 3251 mySpaceSn, skypeSn, twitterSn, ymSn, jobTitle, groupIds, 3252 organizationIds, roleIds, userGroupRoles, userGroupIds, 3253 serviceContext); 3254 } 3255 3256 /** 3257 * Updates the user. 3258 * 3259 * @param userId the primary key of the user 3260 * @param oldPassword the user's old password 3261 * @param newPassword1 the user's new password (optionally 3262 <code>null</code>) 3263 * @param newPassword2 the user's new password confirmation (optionally 3264 <code>null</code>) 3265 * @param passwordReset whether the user should be asked to reset their 3266 password the next time they login 3267 * @param reminderQueryQuestion the user's new password reset question 3268 * @param reminderQueryAnswer the user's new password reset answer 3269 * @param screenName the user's new screen name 3270 * @param emailAddress the user's new email address 3271 * @param facebookId the user's new Facebook ID 3272 * @param openId the user's new OpenID 3273 * @param portrait whether to update the user's portrait image 3274 * @param portraitBytes the new portrait image data 3275 * @param languageId the user's new language ID 3276 * @param timeZoneId the user's new time zone ID 3277 * @param greeting the user's new greeting 3278 * @param comments the user's new comments 3279 * @param firstName the user's new first name 3280 * @param middleName the user's new middle name 3281 * @param lastName the user's new last name 3282 * @param prefixId the user's new name prefix ID 3283 * @param suffixId the user's new name suffix ID 3284 * @param male whether user is male 3285 * @param birthdayMonth the user's new birthday month (0-based, meaning 0 3286 for January) 3287 * @param birthdayDay the user's new birthday day 3288 * @param birthdayYear the user's birthday year 3289 * @param smsSn the user's new SMS screen name 3290 * @param aimSn the user's new AIM screen name 3291 * @param facebookSn the user's new Facebook screen name 3292 * @param icqSn the user's new ICQ screen name 3293 * @param jabberSn the user's new Jabber screen name 3294 * @param msnSn the user's new MSN screen name 3295 * @param mySpaceSn the user's new MySpace screen name 3296 * @param skypeSn the user's new Skype screen name 3297 * @param twitterSn the user's new Twitter screen name 3298 * @param ymSn the user's new Yahoo! Messenger screen name 3299 * @param jobTitle the user's new job title 3300 * @param groupIds the primary keys of the user's groups 3301 * @param organizationIds the primary keys of the user's organizations 3302 * @param roleIds the primary keys of the user's roles 3303 * @param userGroupRoles the user user's group roles 3304 * @param userGroupIds the primary keys of the user's user groups 3305 * @param serviceContext the service context to be applied (optionally 3306 <code>null</code>). Can set the UUID (with the <code>uuid</code> 3307 attribute), asset category IDs, asset tag names, and expando 3308 bridge attributes for the user. 3309 * @return the user 3310 * @throws PortalException if a user with the primary key could not be found 3311 or if the new information was invalid 3312 */ 3313 @Override 3314 public com.liferay.portal.model.User updateUser(long userId, 3315 java.lang.String oldPassword, java.lang.String newPassword1, 3316 java.lang.String newPassword2, boolean passwordReset, 3317 java.lang.String reminderQueryQuestion, 3318 java.lang.String reminderQueryAnswer, java.lang.String screenName, 3319 java.lang.String emailAddress, long facebookId, 3320 java.lang.String openId, boolean portrait, byte[] portraitBytes, 3321 java.lang.String languageId, java.lang.String timeZoneId, 3322 java.lang.String greeting, java.lang.String comments, 3323 java.lang.String firstName, java.lang.String middleName, 3324 java.lang.String lastName, int prefixId, int suffixId, boolean male, 3325 int birthdayMonth, int birthdayDay, int birthdayYear, 3326 java.lang.String smsSn, java.lang.String aimSn, 3327 java.lang.String facebookSn, java.lang.String icqSn, 3328 java.lang.String jabberSn, java.lang.String msnSn, 3329 java.lang.String mySpaceSn, java.lang.String skypeSn, 3330 java.lang.String twitterSn, java.lang.String ymSn, 3331 java.lang.String jobTitle, long[] groupIds, long[] organizationIds, 3332 long[] roleIds, 3333 java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles, 3334 long[] userGroupIds, 3335 com.liferay.portal.service.ServiceContext serviceContext) 3336 throws com.liferay.portal.kernel.exception.PortalException { 3337 return _userLocalService.updateUser(userId, oldPassword, newPassword1, 3338 newPassword2, passwordReset, reminderQueryQuestion, 3339 reminderQueryAnswer, screenName, emailAddress, facebookId, openId, 3340 portrait, portraitBytes, languageId, timeZoneId, greeting, 3341 comments, firstName, middleName, lastName, prefixId, suffixId, 3342 male, birthdayMonth, birthdayDay, birthdayYear, smsSn, aimSn, 3343 facebookSn, icqSn, jabberSn, msnSn, mySpaceSn, skypeSn, twitterSn, 3344 ymSn, jobTitle, groupIds, organizationIds, roleIds, userGroupRoles, 3345 userGroupIds, serviceContext); 3346 } 3347 3348 /** 3349 * Verifies the email address of the ticket. 3350 * 3351 * @param ticketKey the ticket key 3352 * @throws PortalException if a ticket matching the ticket key could not be 3353 found, if the ticket has expired, if the ticket is an email 3354 address ticket, or if the email address is invalid 3355 */ 3356 @Override 3357 public void verifyEmailAddress(java.lang.String ticketKey) 3358 throws com.liferay.portal.kernel.exception.PortalException { 3359 _userLocalService.verifyEmailAddress(ticketKey); 3360 } 3361 3362 /** 3363 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 3364 */ 3365 @Deprecated 3366 public UserLocalService getWrappedUserLocalService() { 3367 return _userLocalService; 3368 } 3369 3370 /** 3371 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 3372 */ 3373 @Deprecated 3374 public void setWrappedUserLocalService(UserLocalService userLocalService) { 3375 _userLocalService = userLocalService; 3376 } 3377 3378 @Override 3379 public UserLocalService getWrappedService() { 3380 return _userLocalService; 3381 } 3382 3383 @Override 3384 public void setWrappedService(UserLocalService userLocalService) { 3385 _userLocalService = userLocalService; 3386 } 3387 3388 private UserLocalService _userLocalService; 3389 }