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