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 roles, unless the user already has these 071 * roles. The default 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 java.util.List<com.liferay.portal.model.User> getInheritedRoleUsers( 1233 long roleId, int start, int end, 1234 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) 1235 throws com.liferay.portal.kernel.exception.PortalException { 1236 return _userLocalService.getInheritedRoleUsers(roleId, start, end, obc); 1237 } 1238 1239 /** 1240 * Returns all the users who have not had any announcements of the type 1241 * delivered, excluding the default user. 1242 * 1243 * @param type the type of announcement 1244 * @return the users who have not had any annoucements of the type delivered 1245 */ 1246 @Override 1247 public java.util.List<com.liferay.portal.model.User> getNoAnnouncementsDeliveries( 1248 java.lang.String type) { 1249 return _userLocalService.getNoAnnouncementsDeliveries(type); 1250 } 1251 1252 /** 1253 * Returns all the users who do not have any contacts. 1254 * 1255 * @return the users who do not have any contacts 1256 */ 1257 @Override 1258 public java.util.List<com.liferay.portal.model.User> getNoContacts() { 1259 return _userLocalService.getNoContacts(); 1260 } 1261 1262 /** 1263 * Returns all the users who do not belong to any groups, excluding the 1264 * default user. 1265 * 1266 * @return the users who do not belong to any groups 1267 */ 1268 @Override 1269 public java.util.List<com.liferay.portal.model.User> getNoGroups() { 1270 return _userLocalService.getNoGroups(); 1271 } 1272 1273 /** 1274 * Returns the OSGi service identifier. 1275 * 1276 * @return the OSGi service identifier 1277 */ 1278 @Override 1279 public java.lang.String getOSGiServiceIdentifier() { 1280 return _userLocalService.getOSGiServiceIdentifier(); 1281 } 1282 1283 /** 1284 * Returns the organizationIds of the organizations associated with the user. 1285 * 1286 * @param userId the userId of the user 1287 * @return long[] the organizationIds of organizations associated with the user 1288 */ 1289 @Override 1290 public long[] getOrganizationPrimaryKeys(long userId) { 1291 return _userLocalService.getOrganizationPrimaryKeys(userId); 1292 } 1293 1294 /** 1295 * Returns the primary keys of all the users belonging to the organization. 1296 * 1297 * @param organizationId the primary key of the organization 1298 * @return the primary keys of the users belonging to the organization 1299 */ 1300 @Override 1301 public long[] getOrganizationUserIds(long organizationId) { 1302 return _userLocalService.getOrganizationUserIds(organizationId); 1303 } 1304 1305 @Override 1306 public java.util.List<com.liferay.portal.model.User> getOrganizationUsers( 1307 long organizationId) { 1308 return _userLocalService.getOrganizationUsers(organizationId); 1309 } 1310 1311 @Override 1312 public java.util.List<com.liferay.portal.model.User> getOrganizationUsers( 1313 long organizationId, int start, int end) { 1314 return _userLocalService.getOrganizationUsers(organizationId, start, end); 1315 } 1316 1317 @Override 1318 public java.util.List<com.liferay.portal.model.User> getOrganizationUsers( 1319 long organizationId, int start, int end, 1320 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) { 1321 return _userLocalService.getOrganizationUsers(organizationId, start, 1322 end, orderByComparator); 1323 } 1324 1325 @Override 1326 public int getOrganizationUsersCount(long organizationId) { 1327 return _userLocalService.getOrganizationUsersCount(organizationId); 1328 } 1329 1330 /** 1331 * Returns the number of users with the status belonging to the 1332 * organization. 1333 * 1334 * @param organizationId the primary key of the organization 1335 * @param status the workflow status 1336 * @return the number of users with the status belonging to the organization 1337 */ 1338 @Override 1339 public int getOrganizationUsersCount(long organizationId, int status) 1340 throws com.liferay.portal.kernel.exception.PortalException { 1341 return _userLocalService.getOrganizationUsersCount(organizationId, 1342 status); 1343 } 1344 1345 @Override 1346 public com.liferay.portal.model.PersistedModel getPersistedModel( 1347 java.io.Serializable primaryKeyObj) 1348 throws com.liferay.portal.kernel.exception.PortalException { 1349 return _userLocalService.getPersistedModel(primaryKeyObj); 1350 } 1351 1352 /** 1353 * Returns the roleIds of the roles associated with the user. 1354 * 1355 * @param userId the userId of the user 1356 * @return long[] the roleIds of roles associated with the user 1357 */ 1358 @Override 1359 public long[] getRolePrimaryKeys(long userId) { 1360 return _userLocalService.getRolePrimaryKeys(userId); 1361 } 1362 1363 /** 1364 * Returns the primary keys of all the users belonging to the role. 1365 * 1366 * @param roleId the primary key of the role 1367 * @return the primary keys of the users belonging to the role 1368 */ 1369 @Override 1370 public long[] getRoleUserIds(long roleId) { 1371 return _userLocalService.getRoleUserIds(roleId); 1372 } 1373 1374 @Override 1375 public java.util.List<com.liferay.portal.model.User> getRoleUsers( 1376 long roleId) { 1377 return _userLocalService.getRoleUsers(roleId); 1378 } 1379 1380 @Override 1381 public java.util.List<com.liferay.portal.model.User> getRoleUsers( 1382 long roleId, int start, int end) { 1383 return _userLocalService.getRoleUsers(roleId, start, end); 1384 } 1385 1386 @Override 1387 public java.util.List<com.liferay.portal.model.User> getRoleUsers( 1388 long roleId, int start, int end, 1389 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) { 1390 return _userLocalService.getRoleUsers(roleId, start, end, 1391 orderByComparator); 1392 } 1393 1394 @Override 1395 public int getRoleUsersCount(long roleId) { 1396 return _userLocalService.getRoleUsersCount(roleId); 1397 } 1398 1399 /** 1400 * Returns the number of users with the status belonging to the role. 1401 * 1402 * @param roleId the primary key of the role 1403 * @param status the workflow status 1404 * @return the number of users with the status belonging to the role 1405 */ 1406 @Override 1407 public int getRoleUsersCount(long roleId, int status) 1408 throws com.liferay.portal.kernel.exception.PortalException { 1409 return _userLocalService.getRoleUsersCount(roleId, status); 1410 } 1411 1412 @Override 1413 public java.util.List<com.liferay.portal.model.User> getSocialUsers( 1414 long userId, int socialRelationType, 1415 java.lang.String socialRelationTypeComparator, int start, int end, 1416 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) 1417 throws com.liferay.portal.kernel.exception.PortalException { 1418 return _userLocalService.getSocialUsers(userId, socialRelationType, 1419 socialRelationTypeComparator, start, end, obc); 1420 } 1421 1422 /** 1423 * Returns an ordered range of all the users with a social relation of the 1424 * type with the user. 1425 * 1426 * <p> 1427 * Useful when paginating results. Returns a maximum of <code>end - 1428 * start</code> instances. <code>start</code> and <code>end</code> are not 1429 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1430 * refers to the first result in the set. Setting both <code>start</code> 1431 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1432 * result set. 1433 * </p> 1434 * 1435 * @param userId the primary key of the user 1436 * @param socialRelationType the type of social relation. The possible 1437 types can be found in {@link SocialRelationConstants}. 1438 * @param start the lower bound of the range of users 1439 * @param end the upper bound of the range of users (not inclusive) 1440 * @param obc the comparator to order the users by (optionally 1441 <code>null</code>) 1442 * @return the ordered range of users with a social relation of the type 1443 with the user 1444 * @deprecated As of 7.0.0, replaced by {@link #getSocialUsers(long, int, 1445 String, int, int, OrderByComparator)} 1446 */ 1447 @Deprecated 1448 @Override 1449 public java.util.List<com.liferay.portal.model.User> getSocialUsers( 1450 long userId, int socialRelationType, int start, int end, 1451 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) 1452 throws com.liferay.portal.kernel.exception.PortalException { 1453 return _userLocalService.getSocialUsers(userId, socialRelationType, 1454 start, end, obc); 1455 } 1456 1457 /** 1458 * Returns an ordered range of all the users with a social relation with the 1459 * user. 1460 * 1461 * <p> 1462 * Useful when paginating results. Returns a maximum of <code>end - 1463 * start</code> instances. <code>start</code> and <code>end</code> are not 1464 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1465 * refers to the first result in the set. Setting both <code>start</code> 1466 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1467 * result set. 1468 * </p> 1469 * 1470 * @param userId the primary key of the user 1471 * @param start the lower bound of the range of users 1472 * @param end the upper bound of the range of users (not inclusive) 1473 * @param obc the comparator to order the users by (optionally 1474 <code>null</code>) 1475 * @return the ordered range of users with a social relation with the 1476 user 1477 * @deprecated As of 7.0.0, replaced by {@link #getSocialUsers(long, int, 1478 String, int, int, OrderByComparator)} 1479 */ 1480 @Deprecated 1481 @Override 1482 public java.util.List<com.liferay.portal.model.User> getSocialUsers( 1483 long userId, int start, int end, 1484 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) 1485 throws com.liferay.portal.kernel.exception.PortalException { 1486 return _userLocalService.getSocialUsers(userId, start, end, obc); 1487 } 1488 1489 /** 1490 * Returns an ordered range of all the users with a mutual social relation 1491 * of the type with both of the given users. 1492 * 1493 * <p> 1494 * Useful when paginating results. Returns a maximum of <code>end - 1495 * start</code> instances. <code>start</code> and <code>end</code> are not 1496 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1497 * refers to the first result in the set. Setting both <code>start</code> 1498 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1499 * result set. 1500 * </p> 1501 * 1502 * @param userId1 the primary key of the first user 1503 * @param userId2 the primary key of the second user 1504 * @param socialRelationType the type of social relation. The possible 1505 types can be found in {@link SocialRelationConstants}. 1506 * @param start the lower bound of the range of users 1507 * @param end the upper bound of the range of users (not inclusive) 1508 * @param obc the comparator to order the users by (optionally 1509 <code>null</code>) 1510 * @return the ordered range of users with a mutual social relation of the 1511 type with the user 1512 */ 1513 @Override 1514 public java.util.List<com.liferay.portal.model.User> getSocialUsers( 1515 long userId1, long userId2, int socialRelationType, int start, int end, 1516 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) 1517 throws com.liferay.portal.kernel.exception.PortalException { 1518 return _userLocalService.getSocialUsers(userId1, userId2, 1519 socialRelationType, start, end, obc); 1520 } 1521 1522 /** 1523 * Returns an ordered range of all the users with a mutual social relation 1524 * with both of the given users. 1525 * 1526 * <p> 1527 * Useful when paginating results. Returns a maximum of <code>end - 1528 * start</code> instances. <code>start</code> and <code>end</code> are not 1529 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1530 * refers to the first result in the set. Setting both <code>start</code> 1531 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 1532 * result set. 1533 * </p> 1534 * 1535 * @param userId1 the primary key of the first user 1536 * @param userId2 the primary key of the second user 1537 * @param start the lower bound of the range of users 1538 * @param end the upper bound of the range of users (not inclusive) 1539 * @param obc the comparator to order the users by (optionally 1540 <code>null</code>) 1541 * @return the ordered range of users with a mutual social relation with the 1542 user 1543 */ 1544 @Override 1545 public java.util.List<com.liferay.portal.model.User> getSocialUsers( 1546 long userId1, long userId2, int start, int end, 1547 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) 1548 throws com.liferay.portal.kernel.exception.PortalException { 1549 return _userLocalService.getSocialUsers(userId1, userId2, start, end, 1550 obc); 1551 } 1552 1553 /** 1554 * Returns the number of users with a social relation with the user. 1555 * 1556 * @param userId the primary key of the user 1557 * @return the number of users with a social relation with the user 1558 * @deprecated As of 7.0.0, replaced by {@link #getSocialUsersCount(long, 1559 int, String)} 1560 */ 1561 @Deprecated 1562 @Override 1563 public int getSocialUsersCount(long userId) 1564 throws com.liferay.portal.kernel.exception.PortalException { 1565 return _userLocalService.getSocialUsersCount(userId); 1566 } 1567 1568 /** 1569 * Returns the number of users with a social relation of the type with the 1570 * user. 1571 * 1572 * @param userId the primary key of the user 1573 * @param socialRelationType the type of social relation. The possible 1574 types can be found in {@link SocialRelationConstants}. 1575 * @return the number of users with a social relation of the type with 1576 the user 1577 * @deprecated As of 7.0.0, replaced by {@link #getSocialUsersCount(long, 1578 int, String)} 1579 */ 1580 @Deprecated 1581 @Override 1582 public int getSocialUsersCount(long userId, int socialRelationType) 1583 throws com.liferay.portal.kernel.exception.PortalException { 1584 return _userLocalService.getSocialUsersCount(userId, socialRelationType); 1585 } 1586 1587 /** 1588 * Returns the number of users with a social relation with the user. 1589 * 1590 * @param userId the primary key of the user 1591 * @param socialRelationType the type of social relation. The possible 1592 types can be found in {@link SocialRelationConstants}. 1593 * @return the number of users with a social relation with the user 1594 */ 1595 @Override 1596 public int getSocialUsersCount(long userId, int socialRelationType, 1597 java.lang.String socialRelationTypeComparator) 1598 throws com.liferay.portal.kernel.exception.PortalException { 1599 return _userLocalService.getSocialUsersCount(userId, 1600 socialRelationType, socialRelationTypeComparator); 1601 } 1602 1603 /** 1604 * Returns the number of users with a mutual social relation with both of 1605 * the given users. 1606 * 1607 * @param userId1 the primary key of the first user 1608 * @param userId2 the primary key of the second user 1609 * @return the number of users with a mutual social relation with the user 1610 */ 1611 @Override 1612 public int getSocialUsersCount(long userId1, long userId2) 1613 throws com.liferay.portal.kernel.exception.PortalException { 1614 return _userLocalService.getSocialUsersCount(userId1, userId2); 1615 } 1616 1617 /** 1618 * Returns the number of users with a mutual social relation of the type 1619 * with both of the given users. 1620 * 1621 * @param userId1 the primary key of the first user 1622 * @param userId2 the primary key of the second user 1623 * @param socialRelationType the type of social relation. The possible 1624 types can be found in {@link SocialRelationConstants}. 1625 * @return the number of users with a mutual social relation of the type 1626 with the user 1627 */ 1628 @Override 1629 public int getSocialUsersCount(long userId1, long userId2, 1630 int socialRelationType) 1631 throws com.liferay.portal.kernel.exception.PortalException { 1632 return _userLocalService.getSocialUsersCount(userId1, userId2, 1633 socialRelationType); 1634 } 1635 1636 /** 1637 * Returns the teamIds of the teams associated with the user. 1638 * 1639 * @param userId the userId of the user 1640 * @return long[] the teamIds of teams associated with the user 1641 */ 1642 @Override 1643 public long[] getTeamPrimaryKeys(long userId) { 1644 return _userLocalService.getTeamPrimaryKeys(userId); 1645 } 1646 1647 @Override 1648 public java.util.List<com.liferay.portal.model.User> getTeamUsers( 1649 long teamId) { 1650 return _userLocalService.getTeamUsers(teamId); 1651 } 1652 1653 @Override 1654 public java.util.List<com.liferay.portal.model.User> getTeamUsers( 1655 long teamId, int start, int end) { 1656 return _userLocalService.getTeamUsers(teamId, start, end); 1657 } 1658 1659 @Override 1660 public java.util.List<com.liferay.portal.model.User> getTeamUsers( 1661 long teamId, int start, int end, 1662 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) { 1663 return _userLocalService.getTeamUsers(teamId, start, end, 1664 orderByComparator); 1665 } 1666 1667 @Override 1668 public int getTeamUsersCount(long teamId) { 1669 return _userLocalService.getTeamUsersCount(teamId); 1670 } 1671 1672 /** 1673 * Returns the user with the primary key. 1674 * 1675 * @param userId the primary key of the user 1676 * @return the user 1677 * @throws PortalException if a user with the primary key could not be found 1678 */ 1679 @Override 1680 public com.liferay.portal.model.User getUser(long userId) 1681 throws com.liferay.portal.kernel.exception.PortalException { 1682 return _userLocalService.getUser(userId); 1683 } 1684 1685 /** 1686 * Returns the user with the contact ID. 1687 * 1688 * @param contactId the user's contact ID 1689 * @return the user with the contact ID 1690 */ 1691 @Override 1692 public com.liferay.portal.model.User getUserByContactId(long contactId) 1693 throws com.liferay.portal.kernel.exception.PortalException { 1694 return _userLocalService.getUserByContactId(contactId); 1695 } 1696 1697 /** 1698 * Returns the user with the email address. 1699 * 1700 * @param companyId the primary key of the user's company 1701 * @param emailAddress the user's email address 1702 * @return the user with the email address 1703 */ 1704 @Override 1705 public com.liferay.portal.model.User getUserByEmailAddress(long companyId, 1706 java.lang.String emailAddress) 1707 throws com.liferay.portal.kernel.exception.PortalException { 1708 return _userLocalService.getUserByEmailAddress(companyId, emailAddress); 1709 } 1710 1711 /** 1712 * Returns the user with the Facebook ID. 1713 * 1714 * @param companyId the primary key of the user's company 1715 * @param facebookId the user's Facebook ID 1716 * @return the user with the Facebook ID 1717 */ 1718 @Override 1719 public com.liferay.portal.model.User getUserByFacebookId(long companyId, 1720 long facebookId) 1721 throws com.liferay.portal.kernel.exception.PortalException { 1722 return _userLocalService.getUserByFacebookId(companyId, facebookId); 1723 } 1724 1725 /** 1726 * Returns the user with the primary key from the company. 1727 * 1728 * @param companyId the primary key of the user's company 1729 * @param userId the primary key of the user 1730 * @return the user with the primary key 1731 */ 1732 @Override 1733 public com.liferay.portal.model.User getUserById(long companyId, long userId) 1734 throws com.liferay.portal.kernel.exception.PortalException { 1735 return _userLocalService.getUserById(companyId, userId); 1736 } 1737 1738 /** 1739 * Returns the user with the primary key. 1740 * 1741 * @param userId the primary key of the user 1742 * @return the user with the primary key 1743 */ 1744 @Override 1745 public com.liferay.portal.model.User getUserById(long userId) 1746 throws com.liferay.portal.kernel.exception.PortalException { 1747 return _userLocalService.getUserById(userId); 1748 } 1749 1750 /** 1751 * Returns the user with the OpenID. 1752 * 1753 * @param companyId the primary key of the user's company 1754 * @param openId the user's OpenID 1755 * @return the user with the OpenID 1756 */ 1757 @Override 1758 public com.liferay.portal.model.User getUserByOpenId(long companyId, 1759 java.lang.String openId) 1760 throws com.liferay.portal.kernel.exception.PortalException { 1761 return _userLocalService.getUserByOpenId(companyId, openId); 1762 } 1763 1764 /** 1765 * Returns the user with the portrait ID. 1766 * 1767 * @param portraitId the user's portrait ID 1768 * @return the user with the portrait ID 1769 */ 1770 @Override 1771 public com.liferay.portal.model.User getUserByPortraitId(long portraitId) 1772 throws com.liferay.portal.kernel.exception.PortalException { 1773 return _userLocalService.getUserByPortraitId(portraitId); 1774 } 1775 1776 /** 1777 * Returns the user with the screen name. 1778 * 1779 * @param companyId the primary key of the user's company 1780 * @param screenName the user's screen name 1781 * @return the user with the screen name 1782 */ 1783 @Override 1784 public com.liferay.portal.model.User getUserByScreenName(long companyId, 1785 java.lang.String screenName) 1786 throws com.liferay.portal.kernel.exception.PortalException { 1787 return _userLocalService.getUserByScreenName(companyId, screenName); 1788 } 1789 1790 /** 1791 * Returns the user with the UUID. 1792 * 1793 * @param uuid the user's UUID 1794 * @return the user with the UUID 1795 * @deprecated As of 6.2.0, replaced by {@link 1796 #getUserByUuidAndCompanyId(String, long)} 1797 */ 1798 @Deprecated 1799 @Override 1800 public com.liferay.portal.model.User getUserByUuid(java.lang.String uuid) 1801 throws com.liferay.portal.kernel.exception.PortalException { 1802 return _userLocalService.getUserByUuid(uuid); 1803 } 1804 1805 /** 1806 * Returns the user with the matching UUID and company. 1807 * 1808 * @param uuid the user's UUID 1809 * @param companyId the primary key of the company 1810 * @return the matching user 1811 * @throws PortalException if a matching user could not be found 1812 */ 1813 @Override 1814 public com.liferay.portal.model.User getUserByUuidAndCompanyId( 1815 java.lang.String uuid, long companyId) 1816 throws com.liferay.portal.kernel.exception.PortalException { 1817 return _userLocalService.getUserByUuidAndCompanyId(uuid, companyId); 1818 } 1819 1820 /** 1821 * Returns the userGroupIds of the user groups associated with the user. 1822 * 1823 * @param userId the userId of the user 1824 * @return long[] the userGroupIds of user groups associated with the user 1825 */ 1826 @Override 1827 public long[] getUserGroupPrimaryKeys(long userId) { 1828 return _userLocalService.getUserGroupPrimaryKeys(userId); 1829 } 1830 1831 @Override 1832 public java.util.List<com.liferay.portal.model.User> getUserGroupUsers( 1833 long userGroupId) { 1834 return _userLocalService.getUserGroupUsers(userGroupId); 1835 } 1836 1837 @Override 1838 public java.util.List<com.liferay.portal.model.User> getUserGroupUsers( 1839 long userGroupId, int start, int end) { 1840 return _userLocalService.getUserGroupUsers(userGroupId, start, end); 1841 } 1842 1843 @Override 1844 public java.util.List<com.liferay.portal.model.User> getUserGroupUsers( 1845 long userGroupId, int start, int end, 1846 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator) { 1847 return _userLocalService.getUserGroupUsers(userGroupId, start, end, 1848 orderByComparator); 1849 } 1850 1851 @Override 1852 public int getUserGroupUsersCount(long userGroupId) { 1853 return _userLocalService.getUserGroupUsersCount(userGroupId); 1854 } 1855 1856 /** 1857 * Returns the number of users with the status belonging to the user group. 1858 * 1859 * @param userGroupId the primary key of the user group 1860 * @param status the workflow status 1861 * @return the number of users with the status belonging to the user group 1862 */ 1863 @Override 1864 public int getUserGroupUsersCount(long userGroupId, int status) 1865 throws com.liferay.portal.kernel.exception.PortalException { 1866 return _userLocalService.getUserGroupUsersCount(userGroupId, status); 1867 } 1868 1869 /** 1870 * Returns the primary key of the user with the email address. 1871 * 1872 * @param companyId the primary key of the user's company 1873 * @param emailAddress the user's email address 1874 * @return the primary key of the user with the email address 1875 */ 1876 @Override 1877 public long getUserIdByEmailAddress(long companyId, 1878 java.lang.String emailAddress) 1879 throws com.liferay.portal.kernel.exception.PortalException { 1880 return _userLocalService.getUserIdByEmailAddress(companyId, emailAddress); 1881 } 1882 1883 /** 1884 * Returns the primary key of the user with the screen name. 1885 * 1886 * @param companyId the primary key of the user's company 1887 * @param screenName the user's screen name 1888 * @return the primary key of the user with the screen name 1889 */ 1890 @Override 1891 public long getUserIdByScreenName(long companyId, 1892 java.lang.String screenName) 1893 throws com.liferay.portal.kernel.exception.PortalException { 1894 return _userLocalService.getUserIdByScreenName(companyId, screenName); 1895 } 1896 1897 /** 1898 * Returns a range of all the users. 1899 * 1900 * <p> 1901 * 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. 1902 * </p> 1903 * 1904 * @param start the lower bound of the range of users 1905 * @param end the upper bound of the range of users (not inclusive) 1906 * @return the range of users 1907 */ 1908 @Override 1909 public java.util.List<com.liferay.portal.model.User> getUsers(int start, 1910 int end) { 1911 return _userLocalService.getUsers(start, end); 1912 } 1913 1914 /** 1915 * Returns the number of users. 1916 * 1917 * @return the number of users 1918 */ 1919 @Override 1920 public int getUsersCount() { 1921 return _userLocalService.getUsersCount(); 1922 } 1923 1924 @Override 1925 public boolean hasGroupUser(long groupId, long userId) { 1926 return _userLocalService.hasGroupUser(groupId, userId); 1927 } 1928 1929 @Override 1930 public boolean hasGroupUsers(long groupId) { 1931 return _userLocalService.hasGroupUsers(groupId); 1932 } 1933 1934 @Override 1935 public boolean hasOrganizationUser(long organizationId, long userId) { 1936 return _userLocalService.hasOrganizationUser(organizationId, userId); 1937 } 1938 1939 @Override 1940 public boolean hasOrganizationUsers(long organizationId) { 1941 return _userLocalService.hasOrganizationUsers(organizationId); 1942 } 1943 1944 /** 1945 * Returns <code>true</code> if the password policy has been assigned to the 1946 * user. 1947 * 1948 * @param passwordPolicyId the primary key of the password policy 1949 * @param userId the primary key of the user 1950 * @return <code>true</code> if the password policy is assigned to the user; 1951 <code>false</code> otherwise 1952 */ 1953 @Override 1954 public boolean hasPasswordPolicyUser(long passwordPolicyId, long userId) { 1955 return _userLocalService.hasPasswordPolicyUser(passwordPolicyId, userId); 1956 } 1957 1958 /** 1959 * Returns <code>true</code> if the user has the role with the name, 1960 * optionally through inheritance. 1961 * 1962 * @param companyId the primary key of the role's company 1963 * @param name the name of the role (must be a regular role, not an 1964 organization, site or provider role) 1965 * @param userId the primary key of the user 1966 * @param inherited whether to include roles inherited from organizations, 1967 sites, etc. 1968 * @return <code>true</code> if the user has the role; <code>false</code> 1969 otherwise 1970 */ 1971 @Override 1972 public boolean hasRoleUser(long companyId, java.lang.String name, 1973 long userId, boolean inherited) 1974 throws com.liferay.portal.kernel.exception.PortalException { 1975 return _userLocalService.hasRoleUser(companyId, name, userId, inherited); 1976 } 1977 1978 @Override 1979 public boolean hasRoleUser(long roleId, long userId) { 1980 return _userLocalService.hasRoleUser(roleId, userId); 1981 } 1982 1983 @Override 1984 public boolean hasRoleUsers(long roleId) { 1985 return _userLocalService.hasRoleUsers(roleId); 1986 } 1987 1988 @Override 1989 public boolean hasTeamUser(long teamId, long userId) { 1990 return _userLocalService.hasTeamUser(teamId, userId); 1991 } 1992 1993 @Override 1994 public boolean hasTeamUsers(long teamId) { 1995 return _userLocalService.hasTeamUsers(teamId); 1996 } 1997 1998 @Override 1999 public boolean hasUserGroupUser(long userGroupId, long userId) { 2000 return _userLocalService.hasUserGroupUser(userGroupId, userId); 2001 } 2002 2003 @Override 2004 public boolean hasUserGroupUsers(long userGroupId) { 2005 return _userLocalService.hasUserGroupUsers(userGroupId); 2006 } 2007 2008 /** 2009 * Returns <code>true</code> if the user's password is expired. 2010 * 2011 * @param user the user 2012 * @return <code>true</code> if the user's password is expired; 2013 <code>false</code> otherwise 2014 */ 2015 @Override 2016 public boolean isPasswordExpired(com.liferay.portal.model.User user) 2017 throws com.liferay.portal.kernel.exception.PortalException { 2018 return _userLocalService.isPasswordExpired(user); 2019 } 2020 2021 /** 2022 * Returns <code>true</code> if the password policy is configured to warn 2023 * the user that his password is expiring and the remaining time until 2024 * expiration is equal or less than the configured warning time. 2025 * 2026 * @param user the user 2027 * @return <code>true</code> if the user's password is expiring soon; 2028 <code>false</code> otherwise 2029 */ 2030 @Override 2031 public boolean isPasswordExpiringSoon(com.liferay.portal.model.User user) 2032 throws com.liferay.portal.kernel.exception.PortalException { 2033 return _userLocalService.isPasswordExpiringSoon(user); 2034 } 2035 2036 /** 2037 * Returns the default user for the company. 2038 * 2039 * @param companyId the primary key of the company 2040 * @return the default user for the company 2041 */ 2042 @Override 2043 public com.liferay.portal.model.User loadGetDefaultUser(long companyId) 2044 throws com.liferay.portal.kernel.exception.PortalException { 2045 return _userLocalService.loadGetDefaultUser(companyId); 2046 } 2047 2048 /** 2049 * Returns an ordered range of all the users with the status, and whose 2050 * first name, middle name, last name, screen name, and email address match 2051 * the keywords specified for them, without using the indexer. It is 2052 * preferable to use the indexed version {@link #search(long, String, 2053 * String, String, String, String, int, LinkedHashMap, boolean, int, int, 2054 * Sort)} instead of this method wherever possible for performance reasons. 2055 * 2056 * <p> 2057 * Useful when paginating results. Returns a maximum of <code>end - 2058 * start</code> instances. <code>start</code> and <code>end</code> are not 2059 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2060 * refers to the first result in the set. Setting both <code>start</code> 2061 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2062 * result set. 2063 * </p> 2064 * 2065 * @param companyId the primary key of the user's company 2066 * @param firstName the first name keywords (space separated) 2067 * @param middleName the middle name keywords 2068 * @param lastName the last name keywords 2069 * @param screenName the screen name keywords 2070 * @param emailAddress the email address keywords 2071 * @param status the workflow status 2072 * @param params the finder parameters (optionally <code>null</code>). For 2073 more information see {@link 2074 com.liferay.portal.service.persistence.UserFinder}. 2075 * @param andSearch whether every field must match its keywords, or just 2076 one field. For example, "users with the first name 'bob' and 2077 last name 'smith'" vs "users with the first name 'bob' 2078 or the last name 'smith'". 2079 * @param start the lower bound of the range of users 2080 * @param end the upper bound of the range of users (not inclusive) 2081 * @param obc the comparator to order the users by (optionally 2082 <code>null</code>) 2083 * @return the matching users 2084 * @see com.liferay.portal.service.persistence.UserFinder 2085 */ 2086 @Override 2087 public java.util.List<com.liferay.portal.model.User> search( 2088 long companyId, java.lang.String firstName, 2089 java.lang.String middleName, java.lang.String lastName, 2090 java.lang.String screenName, java.lang.String emailAddress, int status, 2091 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2092 boolean andSearch, int start, int end, 2093 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) { 2094 return _userLocalService.search(companyId, firstName, middleName, 2095 lastName, screenName, emailAddress, status, params, andSearch, 2096 start, end, obc); 2097 } 2098 2099 /** 2100 * Returns an ordered range of all the users with the status, and whose 2101 * first name, middle name, last name, screen name, and email address match 2102 * the keywords specified for them, using the indexer. It is preferable to 2103 * use this method instead of the non-indexed version whenever possible for 2104 * performance reasons. 2105 * 2106 * <p> 2107 * Useful when paginating results. Returns a maximum of <code>end - 2108 * start</code> instances. <code>start</code> and <code>end</code> are not 2109 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2110 * refers to the first result in the set. Setting both <code>start</code> 2111 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2112 * result set. 2113 * </p> 2114 * 2115 * @param companyId the primary key of the user's company 2116 * @param firstName the first name keywords (space separated) 2117 * @param middleName the middle name keywords 2118 * @param lastName the last name keywords 2119 * @param screenName the screen name keywords 2120 * @param emailAddress the email address keywords 2121 * @param status the workflow status 2122 * @param params the indexer parameters (optionally <code>null</code>). For 2123 more information see {@link 2124 com.liferay.portlet.usersadmin.util.UserIndexer}. 2125 * @param andSearch whether every field must match its keywords, or just 2126 one field. For example, "users with the first name 'bob' and 2127 last name 'smith'" vs "users with the first name 'bob' 2128 or the last name 'smith'". 2129 * @param start the lower bound of the range of users 2130 * @param end the upper bound of the range of users (not inclusive) 2131 * @param sort the field and direction to sort by (optionally 2132 <code>null</code>) 2133 * @return the matching users 2134 * @see com.liferay.portlet.usersadmin.util.UserIndexer 2135 */ 2136 @Override 2137 public com.liferay.portal.kernel.search.Hits search(long companyId, 2138 java.lang.String firstName, java.lang.String middleName, 2139 java.lang.String lastName, java.lang.String screenName, 2140 java.lang.String emailAddress, int status, 2141 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2142 boolean andSearch, int start, int end, 2143 com.liferay.portal.kernel.search.Sort sort) { 2144 return _userLocalService.search(companyId, firstName, middleName, 2145 lastName, screenName, emailAddress, status, params, andSearch, 2146 start, end, sort); 2147 } 2148 2149 @Override 2150 public com.liferay.portal.kernel.search.Hits search(long companyId, 2151 java.lang.String firstName, java.lang.String middleName, 2152 java.lang.String lastName, java.lang.String screenName, 2153 java.lang.String emailAddress, int status, 2154 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2155 boolean andSearch, int start, int end, 2156 com.liferay.portal.kernel.search.Sort[] sorts) { 2157 return _userLocalService.search(companyId, firstName, middleName, 2158 lastName, screenName, emailAddress, status, params, andSearch, 2159 start, end, sorts); 2160 } 2161 2162 /** 2163 * Returns an ordered range of all the users who match the keywords and 2164 * status, without using the indexer. It is preferable to use the indexed 2165 * version {@link #search(long, String, int, LinkedHashMap, int, int, Sort)} 2166 * instead of this method wherever possible for performance reasons. 2167 * 2168 * <p> 2169 * Useful when paginating results. Returns a maximum of <code>end - 2170 * start</code> instances. <code>start</code> and <code>end</code> are not 2171 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2172 * refers to the first result in the set. Setting both <code>start</code> 2173 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2174 * result set. 2175 * </p> 2176 * 2177 * @param companyId the primary key of the user's company 2178 * @param keywords the keywords (space separated), which may occur in the 2179 user's first name, middle name, last name, screen name, or email 2180 address 2181 * @param status the workflow status 2182 * @param params the finder parameters (optionally <code>null</code>). For 2183 more information see {@link 2184 com.liferay.portal.service.persistence.UserFinder}. 2185 * @param start the lower bound of the range of users 2186 * @param end the upper bound of the range of users (not inclusive) 2187 * @param obc the comparator to order the users by (optionally 2188 <code>null</code>) 2189 * @return the matching users 2190 * @see com.liferay.portal.service.persistence.UserFinder 2191 */ 2192 @Override 2193 public java.util.List<com.liferay.portal.model.User> search( 2194 long companyId, java.lang.String keywords, int status, 2195 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2196 int start, int end, 2197 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> obc) { 2198 return _userLocalService.search(companyId, keywords, status, params, 2199 start, end, obc); 2200 } 2201 2202 /** 2203 * Returns an ordered range of all the users who match the keywords and 2204 * status, using the indexer. It is preferable to use this method instead of 2205 * the non-indexed version whenever possible for performance reasons. 2206 * 2207 * <p> 2208 * Useful when paginating results. Returns a maximum of <code>end - 2209 * start</code> instances. <code>start</code> and <code>end</code> are not 2210 * primary keys, they are indexes in the result set. Thus, <code>0</code> 2211 * refers to the first result in the set. Setting both <code>start</code> 2212 * and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full 2213 * result set. 2214 * </p> 2215 * 2216 * @param companyId the primary key of the user's company 2217 * @param keywords the keywords (space separated), which may occur in the 2218 user's first name, middle name, last name, screen name, or email 2219 address 2220 * @param status the workflow status 2221 * @param params the indexer parameters (optionally <code>null</code>). For 2222 more information see {@link 2223 com.liferay.portlet.usersadmin.util.UserIndexer}. 2224 * @param start the lower bound of the range of users 2225 * @param end the upper bound of the range of users (not inclusive) 2226 * @param sort the field and direction to sort by (optionally 2227 <code>null</code>) 2228 * @return the matching users 2229 * @see com.liferay.portlet.usersadmin.util.UserIndexer 2230 */ 2231 @Override 2232 public com.liferay.portal.kernel.search.Hits search(long companyId, 2233 java.lang.String keywords, int status, 2234 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2235 int start, int end, com.liferay.portal.kernel.search.Sort sort) { 2236 return _userLocalService.search(companyId, keywords, status, params, 2237 start, end, sort); 2238 } 2239 2240 @Override 2241 public com.liferay.portal.kernel.search.Hits search(long companyId, 2242 java.lang.String keywords, int status, 2243 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2244 int start, int end, com.liferay.portal.kernel.search.Sort[] sorts) { 2245 return _userLocalService.search(companyId, keywords, status, params, 2246 start, end, sorts); 2247 } 2248 2249 /** 2250 * Returns the number of users with the status, and whose first name, middle 2251 * name, last name, screen name, and email address match the keywords 2252 * specified for them. 2253 * 2254 * @param companyId the primary key of the user's company 2255 * @param firstName the first name keywords (space separated) 2256 * @param middleName the middle name keywords 2257 * @param lastName the last name keywords 2258 * @param screenName the screen name keywords 2259 * @param emailAddress the email address keywords 2260 * @param status the workflow status 2261 * @param params the finder parameters (optionally <code>null</code>). For 2262 more information see {@link 2263 com.liferay.portal.service.persistence.UserFinder}. 2264 * @param andSearch whether every field must match its keywords, or just 2265 one field. For example, "users with the first name 'bob' and 2266 last name 'smith'" vs "users with the first name 'bob' 2267 or the last name 'smith'". 2268 * @return the number of matching users 2269 */ 2270 @Override 2271 public int searchCount(long companyId, java.lang.String firstName, 2272 java.lang.String middleName, java.lang.String lastName, 2273 java.lang.String screenName, java.lang.String emailAddress, int status, 2274 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2275 boolean andSearch) { 2276 return _userLocalService.searchCount(companyId, firstName, middleName, 2277 lastName, screenName, emailAddress, status, params, andSearch); 2278 } 2279 2280 /** 2281 * Returns the number of users who match the keywords and status. 2282 * 2283 * @param companyId the primary key of the user's company 2284 * @param keywords the keywords (space separated), which may occur in the 2285 user's first name, middle name, last name, screen name, or email 2286 address 2287 * @param status the workflow status 2288 * @param params the finder parameters (optionally <code>null</code>). For 2289 more information see {@link 2290 com.liferay.portal.service.persistence.UserFinder}. 2291 * @return the number matching users 2292 */ 2293 @Override 2294 public int searchCount(long companyId, java.lang.String keywords, 2295 int status, 2296 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 2297 return _userLocalService.searchCount(companyId, keywords, status, params); 2298 } 2299 2300 @Override 2301 public java.util.Map<java.lang.Long, java.lang.Integer> searchCounts( 2302 long companyId, int status, long[] groupIds) { 2303 return _userLocalService.searchCounts(companyId, status, groupIds); 2304 } 2305 2306 @Override 2307 public java.util.List<com.liferay.portal.model.User> searchSocial( 2308 long companyId, long[] groupIds, java.lang.String keywords, int start, 2309 int end) { 2310 return _userLocalService.searchSocial(companyId, groupIds, keywords, 2311 start, end); 2312 } 2313 2314 @Override 2315 public java.util.List<com.liferay.portal.model.User> searchSocial( 2316 long[] groupIds, long userId, int[] socialRelationTypes, 2317 java.lang.String keywords, int start, int end) 2318 throws com.liferay.portal.kernel.exception.PortalException { 2319 return _userLocalService.searchSocial(groupIds, userId, 2320 socialRelationTypes, keywords, start, end); 2321 } 2322 2323 @Override 2324 public java.util.List<com.liferay.portal.model.User> searchSocial( 2325 long userId, int[] socialRelationTypes, java.lang.String keywords, 2326 int start, int end) 2327 throws com.liferay.portal.kernel.exception.PortalException { 2328 return _userLocalService.searchSocial(userId, socialRelationTypes, 2329 keywords, start, end); 2330 } 2331 2332 @Override 2333 public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers( 2334 long companyId, java.lang.String firstName, 2335 java.lang.String middleName, java.lang.String lastName, 2336 java.lang.String screenName, java.lang.String emailAddress, int status, 2337 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2338 boolean andSearch, int start, int end, 2339 com.liferay.portal.kernel.search.Sort sort) 2340 throws com.liferay.portal.kernel.exception.PortalException { 2341 return _userLocalService.searchUsers(companyId, firstName, middleName, 2342 lastName, screenName, emailAddress, status, params, andSearch, 2343 start, end, sort); 2344 } 2345 2346 @Override 2347 public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers( 2348 long companyId, java.lang.String firstName, 2349 java.lang.String middleName, java.lang.String lastName, 2350 java.lang.String screenName, java.lang.String emailAddress, int status, 2351 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2352 boolean andSearch, int start, int end, 2353 com.liferay.portal.kernel.search.Sort[] sorts) 2354 throws com.liferay.portal.kernel.exception.PortalException { 2355 return _userLocalService.searchUsers(companyId, firstName, middleName, 2356 lastName, screenName, emailAddress, status, params, andSearch, 2357 start, end, sorts); 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 sort) 2365 throws com.liferay.portal.kernel.exception.PortalException { 2366 return _userLocalService.searchUsers(companyId, keywords, status, 2367 params, start, end, sort); 2368 } 2369 2370 @Override 2371 public com.liferay.portal.kernel.search.BaseModelSearchResult<com.liferay.portal.model.User> searchUsers( 2372 long companyId, java.lang.String keywords, int status, 2373 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 2374 int start, int end, com.liferay.portal.kernel.search.Sort[] sorts) 2375 throws com.liferay.portal.kernel.exception.PortalException { 2376 return _userLocalService.searchUsers(companyId, keywords, status, 2377 params, start, end, sorts); 2378 } 2379 2380 /** 2381 * Sends an email address verification to the user. 2382 * 2383 * @param user the verification email recipient 2384 * @param emailAddress the recipient's email address 2385 * @param serviceContext the service context to be applied. Must set the 2386 portal URL, main path, primary key of the layout, remote address, 2387 remote host, and agent for the user. 2388 */ 2389 @Override 2390 public void sendEmailAddressVerification( 2391 com.liferay.portal.model.User user, java.lang.String emailAddress, 2392 com.liferay.portal.service.ServiceContext serviceContext) 2393 throws com.liferay.portal.kernel.exception.PortalException { 2394 _userLocalService.sendEmailAddressVerification(user, emailAddress, 2395 serviceContext); 2396 } 2397 2398 /** 2399 * Sends the password email to the user with the email address. The content 2400 * of this email can be specified in <code>portal.properties</code> with the 2401 * <code>admin.email.password</code> keys. 2402 * 2403 * @param companyId the primary key of the user's company 2404 * @param emailAddress the user's email address 2405 * @param fromName the name of the individual that the email should be from 2406 * @param fromAddress the address of the individual that the email should be 2407 from 2408 * @param subject the email subject. If <code>null</code>, the subject 2409 specified in <code>portal.properties</code> will be used. 2410 * @param body the email body. If <code>null</code>, the body specified in 2411 <code>portal.properties</code> will be used. 2412 * @param serviceContext the service context to be applied 2413 */ 2414 @Override 2415 public boolean sendPassword(long companyId, java.lang.String emailAddress, 2416 java.lang.String fromName, java.lang.String fromAddress, 2417 java.lang.String subject, java.lang.String body, 2418 com.liferay.portal.service.ServiceContext serviceContext) 2419 throws com.liferay.portal.kernel.exception.PortalException { 2420 return _userLocalService.sendPassword(companyId, emailAddress, 2421 fromName, fromAddress, subject, body, serviceContext); 2422 } 2423 2424 /** 2425 * Sends a password notification email to the user matching the email 2426 * address. The portal's settings determine whether a password is sent 2427 * explicitly or whether a link for resetting the user's password is sent. 2428 * The method sends the email asynchronously and returns before the email is 2429 * sent. 2430 * 2431 * <p> 2432 * The content of the notification email is specified with the 2433 * <code>admin.email.password</code> portal property keys. They can be 2434 * overridden via a <code>portal-ext.properties</code> file or modified 2435 * through the Portal Settings UI. 2436 * </p> 2437 * 2438 * @param companyId the primary key of the user's company 2439 * @param emailAddress the user's email address 2440 * @return <code>true</code> if the notification email includes a new 2441 password; <code>false</code> if the notification email only 2442 contains a reset link 2443 */ 2444 @Override 2445 public boolean sendPasswordByEmailAddress(long companyId, 2446 java.lang.String emailAddress) 2447 throws com.liferay.portal.kernel.exception.PortalException { 2448 return _userLocalService.sendPasswordByEmailAddress(companyId, 2449 emailAddress); 2450 } 2451 2452 /** 2453 * Sends a password notification email to the user matching the screen name. 2454 * The portal's settings determine whether a password is sent explicitly or 2455 * whether a link for resetting the user's password is sent. The method 2456 * sends the email asynchronously and returns before the email is sent. 2457 * 2458 * <p> 2459 * The content of the notification email is specified with the 2460 * <code>admin.email.password</code> portal property keys. They can be 2461 * overridden via a <code>portal-ext.properties</code> file or modified 2462 * through the Portal Settings UI. 2463 * </p> 2464 * 2465 * @param companyId the primary key of the user's company 2466 * @param screenName the user's screen name 2467 * @return <code>true</code> if the notification email includes a new 2468 password; <code>false</code> if the notification email only 2469 contains a reset link 2470 */ 2471 @Override 2472 public boolean sendPasswordByScreenName(long companyId, 2473 java.lang.String screenName) 2474 throws com.liferay.portal.kernel.exception.PortalException { 2475 return _userLocalService.sendPasswordByScreenName(companyId, screenName); 2476 } 2477 2478 /** 2479 * Sends a password notification email to the user matching the ID. The 2480 * portal's settings determine whether a password is sent explicitly or 2481 * whether a link for resetting the user's password is sent. The method 2482 * sends the email asynchronously and returns before the email is sent. 2483 * 2484 * <p> 2485 * The content of the notification email is specified with the 2486 * <code>admin.email.password</code> portal property keys. They can be 2487 * overridden via a <code>portal-ext.properties</code> file or modified 2488 * through the Portal Settings UI. 2489 * </p> 2490 * 2491 * @param userId the user's primary key 2492 * @return <code>true</code> if the notification email includes a new 2493 password; <code>false</code> if the notification email only 2494 contains a reset link 2495 */ 2496 @Override 2497 public boolean sendPasswordByUserId(long userId) 2498 throws com.liferay.portal.kernel.exception.PortalException { 2499 return _userLocalService.sendPasswordByUserId(userId); 2500 } 2501 2502 @Override 2503 public void setGroupUsers(long groupId, long[] userIds) { 2504 _userLocalService.setGroupUsers(groupId, userIds); 2505 } 2506 2507 @Override 2508 public void setOrganizationUsers(long organizationId, long[] userIds) { 2509 _userLocalService.setOrganizationUsers(organizationId, userIds); 2510 } 2511 2512 /** 2513 * @throws PortalException 2514 */ 2515 @Override 2516 public void setRoleUsers(long roleId, long[] userIds) 2517 throws com.liferay.portal.kernel.exception.PortalException { 2518 _userLocalService.setRoleUsers(roleId, userIds); 2519 } 2520 2521 @Override 2522 public void setTeamUsers(long teamId, long[] userIds) { 2523 _userLocalService.setTeamUsers(teamId, userIds); 2524 } 2525 2526 /** 2527 * @throws PortalException 2528 */ 2529 @Override 2530 public void setUserGroupUsers(long userGroupId, long[] userIds) 2531 throws com.liferay.portal.kernel.exception.PortalException { 2532 _userLocalService.setUserGroupUsers(userGroupId, userIds); 2533 } 2534 2535 /** 2536 * Removes the users from the teams of a group. 2537 * 2538 * @param groupId the primary key of the group 2539 * @param userIds the primary keys of the users 2540 */ 2541 @Override 2542 public void unsetGroupTeamsUsers(long groupId, long[] userIds) 2543 throws com.liferay.portal.kernel.exception.PortalException { 2544 _userLocalService.unsetGroupTeamsUsers(groupId, userIds); 2545 } 2546 2547 /** 2548 * Removes the users from the group. 2549 * 2550 * @param groupId the primary key of the group 2551 * @param userIds the primary keys of the users 2552 * @param serviceContext the service context to be applied (optionally 2553 <code>null</code>) 2554 */ 2555 @Override 2556 public void unsetGroupUsers(long groupId, long[] userIds, 2557 com.liferay.portal.service.ServiceContext serviceContext) 2558 throws com.liferay.portal.kernel.exception.PortalException { 2559 _userLocalService.unsetGroupUsers(groupId, userIds, serviceContext); 2560 } 2561 2562 /** 2563 * Removes the users from the organization. 2564 * 2565 * @param organizationId the primary key of the organization 2566 * @param userIds the primary keys of the users 2567 */ 2568 @Override 2569 public void unsetOrganizationUsers(long organizationId, long[] userIds) 2570 throws com.liferay.portal.kernel.exception.PortalException { 2571 _userLocalService.unsetOrganizationUsers(organizationId, userIds); 2572 } 2573 2574 /** 2575 * Removes the users from the password policy. 2576 * 2577 * @param passwordPolicyId the primary key of the password policy 2578 * @param userIds the primary keys of the users 2579 */ 2580 @Override 2581 public void unsetPasswordPolicyUsers(long passwordPolicyId, long[] userIds) { 2582 _userLocalService.unsetPasswordPolicyUsers(passwordPolicyId, userIds); 2583 } 2584 2585 /** 2586 * Removes the users from the role. 2587 * 2588 * @param roleId the primary key of the role 2589 * @param userIds the primary keys of the users 2590 */ 2591 @Override 2592 public void unsetRoleUsers(long roleId, long[] userIds) 2593 throws com.liferay.portal.kernel.exception.PortalException { 2594 _userLocalService.unsetRoleUsers(roleId, userIds); 2595 } 2596 2597 /** 2598 * Removes the users from the role. 2599 * 2600 * @param roleId the primary key of the role 2601 * @param users the users 2602 */ 2603 @Override 2604 public void unsetRoleUsers(long roleId, 2605 java.util.List<com.liferay.portal.model.User> users) 2606 throws com.liferay.portal.kernel.exception.PortalException { 2607 _userLocalService.unsetRoleUsers(roleId, users); 2608 } 2609 2610 /** 2611 * Removes the users from the team. 2612 * 2613 * @param teamId the primary key of the team 2614 * @param userIds the primary keys of the users 2615 */ 2616 @Override 2617 public void unsetTeamUsers(long teamId, long[] userIds) 2618 throws com.liferay.portal.kernel.exception.PortalException { 2619 _userLocalService.unsetTeamUsers(teamId, userIds); 2620 } 2621 2622 /** 2623 * Removes the users from the user group. 2624 * 2625 * @param userGroupId the primary key of the user group 2626 * @param userIds the primary keys of the users 2627 */ 2628 @Override 2629 public void unsetUserGroupUsers(long userGroupId, long[] userIds) 2630 throws com.liferay.portal.kernel.exception.PortalException { 2631 _userLocalService.unsetUserGroupUsers(userGroupId, userIds); 2632 } 2633 2634 /** 2635 * Updates whether the user has agreed to the terms of use. 2636 * 2637 * @param userId the primary key of the user 2638 * @param agreedToTermsOfUse whether the user has agreet to the terms of 2639 use 2640 * @return the user 2641 */ 2642 @Override 2643 public com.liferay.portal.model.User updateAgreedToTermsOfUse(long userId, 2644 boolean agreedToTermsOfUse) 2645 throws com.liferay.portal.kernel.exception.PortalException { 2646 return _userLocalService.updateAgreedToTermsOfUse(userId, 2647 agreedToTermsOfUse); 2648 } 2649 2650 /** 2651 * Updates the user's asset with the new asset categories and tag names, 2652 * removing and adding asset categories and tag names as necessary. 2653 * 2654 * @param userId the primary key of the user 2655 * @param user ID the primary key of the user 2656 * @param assetCategoryIds the primary key's of the new asset categories 2657 * @param assetTagNames the new asset tag names 2658 */ 2659 @Override 2660 public void updateAsset(long userId, com.liferay.portal.model.User user, 2661 long[] assetCategoryIds, java.lang.String[] assetTagNames) 2662 throws com.liferay.portal.kernel.exception.PortalException { 2663 _userLocalService.updateAsset(userId, user, assetCategoryIds, 2664 assetTagNames); 2665 } 2666 2667 /** 2668 * Updates the user's creation date. 2669 * 2670 * @param userId the primary key of the user 2671 * @param createDate the new creation date 2672 * @return the user 2673 */ 2674 @Override 2675 public com.liferay.portal.model.User updateCreateDate(long userId, 2676 java.util.Date createDate) 2677 throws com.liferay.portal.kernel.exception.PortalException { 2678 return _userLocalService.updateCreateDate(userId, createDate); 2679 } 2680 2681 /** 2682 * Updates the user's email address. 2683 * 2684 * @param userId the primary key of the user 2685 * @param password the user's password 2686 * @param emailAddress1 the user's new email address 2687 * @param emailAddress2 the user's new email address confirmation 2688 * @return the user 2689 */ 2690 @Override 2691 public com.liferay.portal.model.User updateEmailAddress(long userId, 2692 java.lang.String password, java.lang.String emailAddress1, 2693 java.lang.String emailAddress2) 2694 throws com.liferay.portal.kernel.exception.PortalException { 2695 return _userLocalService.updateEmailAddress(userId, password, 2696 emailAddress1, emailAddress2); 2697 } 2698 2699 /** 2700 * Updates the user's email address or sends verification email. 2701 * 2702 * @param userId the primary key of the user 2703 * @param password the user's password 2704 * @param emailAddress1 the user's new email address 2705 * @param emailAddress2 the user's new email address confirmation 2706 * @param serviceContext the service context to be applied. Must set the 2707 portal URL, main path, primary key of the layout, remote address, 2708 remote host, and agent for the user. 2709 * @return the user 2710 */ 2711 @Override 2712 public com.liferay.portal.model.User updateEmailAddress(long userId, 2713 java.lang.String password, java.lang.String emailAddress1, 2714 java.lang.String emailAddress2, 2715 com.liferay.portal.service.ServiceContext serviceContext) 2716 throws com.liferay.portal.kernel.exception.PortalException { 2717 return _userLocalService.updateEmailAddress(userId, password, 2718 emailAddress1, emailAddress2, serviceContext); 2719 } 2720 2721 /** 2722 * Updates whether the user has verified email address. 2723 * 2724 * @param userId the primary key of the user 2725 * @param emailAddressVerified whether the user has verified email address 2726 * @return the user 2727 */ 2728 @Override 2729 public com.liferay.portal.model.User updateEmailAddressVerified( 2730 long userId, boolean emailAddressVerified) 2731 throws com.liferay.portal.kernel.exception.PortalException { 2732 return _userLocalService.updateEmailAddressVerified(userId, 2733 emailAddressVerified); 2734 } 2735 2736 /** 2737 * Updates the user's Facebook ID. 2738 * 2739 * @param userId the primary key of the user 2740 * @param facebookId the user's new Facebook ID 2741 * @return the user 2742 */ 2743 @Override 2744 public com.liferay.portal.model.User updateFacebookId(long userId, 2745 long facebookId) 2746 throws com.liferay.portal.kernel.exception.PortalException { 2747 return _userLocalService.updateFacebookId(userId, facebookId); 2748 } 2749 2750 /** 2751 * Sets the groups the user is in, removing and adding groups as necessary. 2752 * 2753 * @param userId the primary key of the user 2754 * @param newGroupIds the primary keys of the groups 2755 * @param serviceContext the service context to be applied (optionally 2756 <code>null</code>) 2757 */ 2758 @Override 2759 public void updateGroups(long userId, long[] newGroupIds, 2760 com.liferay.portal.service.ServiceContext serviceContext) 2761 throws com.liferay.portal.kernel.exception.PortalException { 2762 _userLocalService.updateGroups(userId, newGroupIds, serviceContext); 2763 } 2764 2765 /** 2766 * Updates a user account that was automatically created when a guest user 2767 * participated in an action (e.g. posting a comment) and only provided his 2768 * name and email address. 2769 * 2770 * @param creatorUserId the primary key of the creator 2771 * @param companyId the primary key of the user's company 2772 * @param autoPassword whether a password should be automatically generated 2773 for the user 2774 * @param password1 the user's password 2775 * @param password2 the user's password confirmation 2776 * @param autoScreenName whether a screen name should be automatically 2777 generated for the user 2778 * @param screenName the user's screen name 2779 * @param emailAddress the user's email address 2780 * @param facebookId the user's facebook ID 2781 * @param openId the user's OpenID 2782 * @param locale the user's locale 2783 * @param firstName the user's first name 2784 * @param middleName the user's middle name 2785 * @param lastName the user's last name 2786 * @param prefixId the user's name prefix ID 2787 * @param suffixId the user's name suffix ID 2788 * @param male whether the user is male 2789 * @param birthdayMonth the user's birthday month (0-based, meaning 0 for 2790 January) 2791 * @param birthdayDay the user's birthday day 2792 * @param birthdayYear the user's birthday year 2793 * @param jobTitle the user's job title 2794 * @param updateUserInformation whether to update the user's information 2795 * @param sendEmail whether to send the user an email notification about 2796 their new account 2797 * @param serviceContext the service context to be applied (optionally 2798 <code>null</code>). Can set expando bridge attributes for the 2799 user. 2800 * @return the user 2801 */ 2802 @Override 2803 public com.liferay.portal.model.User updateIncompleteUser( 2804 long creatorUserId, long companyId, boolean autoPassword, 2805 java.lang.String password1, java.lang.String password2, 2806 boolean autoScreenName, java.lang.String screenName, 2807 java.lang.String emailAddress, long facebookId, 2808 java.lang.String openId, java.util.Locale locale, 2809 java.lang.String firstName, java.lang.String middleName, 2810 java.lang.String lastName, long prefixId, long suffixId, boolean male, 2811 int birthdayMonth, int birthdayDay, int birthdayYear, 2812 java.lang.String jobTitle, boolean updateUserInformation, 2813 boolean sendEmail, 2814 com.liferay.portal.service.ServiceContext serviceContext) 2815 throws com.liferay.portal.kernel.exception.PortalException { 2816 return _userLocalService.updateIncompleteUser(creatorUserId, companyId, 2817 autoPassword, password1, password2, autoScreenName, screenName, 2818 emailAddress, facebookId, openId, locale, firstName, middleName, 2819 lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay, 2820 birthdayYear, jobTitle, updateUserInformation, sendEmail, 2821 serviceContext); 2822 } 2823 2824 /** 2825 * Updates the user's job title. 2826 * 2827 * @param userId the primary key of the user 2828 * @param jobTitle the user's job title 2829 * @return the user 2830 */ 2831 @Override 2832 public com.liferay.portal.model.User updateJobTitle(long userId, 2833 java.lang.String jobTitle) 2834 throws com.liferay.portal.kernel.exception.PortalException { 2835 return _userLocalService.updateJobTitle(userId, jobTitle); 2836 } 2837 2838 /** 2839 * Updates the user's last login with the current time and the IP address. 2840 * 2841 * @param userId the primary key of the user 2842 * @param loginIP the IP address the user logged in from 2843 * @return the user 2844 */ 2845 @Override 2846 public com.liferay.portal.model.User updateLastLogin(long userId, 2847 java.lang.String loginIP) 2848 throws com.liferay.portal.kernel.exception.PortalException { 2849 return _userLocalService.updateLastLogin(userId, loginIP); 2850 } 2851 2852 /** 2853 * Updates whether the user is locked out from logging in. 2854 * 2855 * @param user the user 2856 * @param lockout whether the user is locked out 2857 * @return the user 2858 */ 2859 @Override 2860 public com.liferay.portal.model.User updateLockout( 2861 com.liferay.portal.model.User user, boolean lockout) 2862 throws com.liferay.portal.kernel.exception.PortalException { 2863 return _userLocalService.updateLockout(user, lockout); 2864 } 2865 2866 /** 2867 * Updates whether the user is locked out from logging in. 2868 * 2869 * @param companyId the primary key of the user's company 2870 * @param emailAddress the user's email address 2871 * @param lockout whether the user is locked out 2872 * @return the user 2873 */ 2874 @Override 2875 public com.liferay.portal.model.User updateLockoutByEmailAddress( 2876 long companyId, java.lang.String emailAddress, boolean lockout) 2877 throws com.liferay.portal.kernel.exception.PortalException { 2878 return _userLocalService.updateLockoutByEmailAddress(companyId, 2879 emailAddress, lockout); 2880 } 2881 2882 /** 2883 * Updates whether the user is locked out from logging in. 2884 * 2885 * @param userId the primary key of the user 2886 * @param lockout whether the user is locked out 2887 * @return the user 2888 */ 2889 @Override 2890 public com.liferay.portal.model.User updateLockoutById(long userId, 2891 boolean lockout) 2892 throws com.liferay.portal.kernel.exception.PortalException { 2893 return _userLocalService.updateLockoutById(userId, lockout); 2894 } 2895 2896 /** 2897 * Updates whether the user is locked out from logging in. 2898 * 2899 * @param companyId the primary key of the user's company 2900 * @param screenName the user's screen name 2901 * @param lockout whether the user is locked out 2902 * @return the user 2903 */ 2904 @Override 2905 public com.liferay.portal.model.User updateLockoutByScreenName( 2906 long companyId, java.lang.String screenName, boolean lockout) 2907 throws com.liferay.portal.kernel.exception.PortalException { 2908 return _userLocalService.updateLockoutByScreenName(companyId, 2909 screenName, lockout); 2910 } 2911 2912 /** 2913 * Updates the user's modified date. 2914 * 2915 * @param userId the primary key of the user 2916 * @param modifiedDate the new modified date 2917 * @return the user 2918 */ 2919 @Override 2920 public com.liferay.portal.model.User updateModifiedDate(long userId, 2921 java.util.Date modifiedDate) 2922 throws com.liferay.portal.kernel.exception.PortalException { 2923 return _userLocalService.updateModifiedDate(userId, modifiedDate); 2924 } 2925 2926 /** 2927 * Updates the user's OpenID. 2928 * 2929 * @param userId the primary key of the user 2930 * @param openId the new OpenID 2931 * @return the user 2932 */ 2933 @Override 2934 public com.liferay.portal.model.User updateOpenId(long userId, 2935 java.lang.String openId) 2936 throws com.liferay.portal.kernel.exception.PortalException { 2937 return _userLocalService.updateOpenId(userId, openId); 2938 } 2939 2940 /** 2941 * Sets the organizations that the user is in, removing and adding 2942 * organizations as necessary. 2943 * 2944 * @param userId the primary key of the user 2945 * @param newOrganizationIds the primary keys of the organizations 2946 * @param serviceContext the service context to be applied. Must set whether 2947 user indexing is enabled. 2948 */ 2949 @Override 2950 public void updateOrganizations(long userId, long[] newOrganizationIds, 2951 com.liferay.portal.service.ServiceContext serviceContext) 2952 throws com.liferay.portal.kernel.exception.PortalException { 2953 _userLocalService.updateOrganizations(userId, newOrganizationIds, 2954 serviceContext); 2955 } 2956 2957 /** 2958 * Updates the user's password without tracking or validation of the change. 2959 * 2960 * @param userId the primary key of the user 2961 * @param password1 the user's new password 2962 * @param password2 the user's new password confirmation 2963 * @param passwordReset whether the user should be asked to reset their 2964 password the next time they log in 2965 * @return the user 2966 */ 2967 @Override 2968 public com.liferay.portal.model.User updatePassword(long userId, 2969 java.lang.String password1, java.lang.String password2, 2970 boolean passwordReset) 2971 throws com.liferay.portal.kernel.exception.PortalException { 2972 return _userLocalService.updatePassword(userId, password1, password2, 2973 passwordReset); 2974 } 2975 2976 /** 2977 * Updates the user's password, optionally with tracking and validation of 2978 * the change. 2979 * 2980 * @param userId the primary key of the user 2981 * @param password1 the user's new password 2982 * @param password2 the user's new password confirmation 2983 * @param passwordReset whether the user should be asked to reset their 2984 password the next time they login 2985 * @param silentUpdate whether the password should be updated without being 2986 tracked, or validated. Primarily used for password imports. 2987 * @return the user 2988 */ 2989 @Override 2990 public com.liferay.portal.model.User updatePassword(long userId, 2991 java.lang.String password1, java.lang.String password2, 2992 boolean passwordReset, boolean silentUpdate) 2993 throws com.liferay.portal.kernel.exception.PortalException { 2994 return _userLocalService.updatePassword(userId, password1, password2, 2995 passwordReset, silentUpdate); 2996 } 2997 2998 /** 2999 * Updates the user's password with manually input information. This method 3000 * should only be used when performing maintenance. 3001 * 3002 * @param userId the primary key of the user 3003 * @param password the user's new password 3004 * @param passwordEncrypted the user's new encrypted password 3005 * @param passwordReset whether the user should be asked to reset their 3006 password the next time they login 3007 * @param passwordModifiedDate the new password modified date 3008 * @return the user 3009 */ 3010 @Override 3011 public com.liferay.portal.model.User updatePasswordManually(long userId, 3012 java.lang.String password, boolean passwordEncrypted, 3013 boolean passwordReset, java.util.Date passwordModifiedDate) 3014 throws com.liferay.portal.kernel.exception.PortalException { 3015 return _userLocalService.updatePasswordManually(userId, password, 3016 passwordEncrypted, passwordReset, passwordModifiedDate); 3017 } 3018 3019 /** 3020 * Updates whether the user should be asked to reset their password the next 3021 * time they login. 3022 * 3023 * @param userId the primary key of the user 3024 * @param passwordReset whether the user should be asked to reset their 3025 password the next time they login 3026 * @return the user 3027 */ 3028 @Override 3029 public com.liferay.portal.model.User updatePasswordReset(long userId, 3030 boolean passwordReset) 3031 throws com.liferay.portal.kernel.exception.PortalException { 3032 return _userLocalService.updatePasswordReset(userId, passwordReset); 3033 } 3034 3035 /** 3036 * Updates the user's portrait image. 3037 * 3038 * @param userId the primary key of the user 3039 * @param bytes the new portrait image data 3040 * @return the user 3041 */ 3042 @Override 3043 public com.liferay.portal.model.User updatePortrait(long userId, 3044 byte[] bytes) 3045 throws com.liferay.portal.kernel.exception.PortalException { 3046 return _userLocalService.updatePortrait(userId, bytes); 3047 } 3048 3049 /** 3050 * Updates the user's password reset question and answer. 3051 * 3052 * @param userId the primary key of the user 3053 * @param question the user's new password reset question 3054 * @param answer the user's new password reset answer 3055 * @return the user 3056 */ 3057 @Override 3058 public com.liferay.portal.model.User updateReminderQuery(long userId, 3059 java.lang.String question, java.lang.String answer) 3060 throws com.liferay.portal.kernel.exception.PortalException { 3061 return _userLocalService.updateReminderQuery(userId, question, answer); 3062 } 3063 3064 /** 3065 * Updates the user's screen name. 3066 * 3067 * @param userId the primary key of the user 3068 * @param screenName the user's new screen name 3069 * @return the user 3070 */ 3071 @Override 3072 public com.liferay.portal.model.User updateScreenName(long userId, 3073 java.lang.String screenName) 3074 throws com.liferay.portal.kernel.exception.PortalException { 3075 return _userLocalService.updateScreenName(userId, screenName); 3076 } 3077 3078 /** 3079 * Updates the user's workflow status. 3080 * 3081 * @param userId the primary key of the user 3082 * @param status the user's new workflow status 3083 * @return the user 3084 * @deprecated As of 7.0.0, replaced by {@link #updateStatus(long, int, 3085 ServiceContext)} 3086 */ 3087 @Deprecated 3088 @Override 3089 public com.liferay.portal.model.User updateStatus(long userId, int status) 3090 throws com.liferay.portal.kernel.exception.PortalException { 3091 return _userLocalService.updateStatus(userId, status); 3092 } 3093 3094 /** 3095 * Updates the user's workflow status. 3096 * 3097 * @param userId the primary key of the user 3098 * @param status the user's new workflow status 3099 * @param serviceContext the service context to be applied. You can specify 3100 an unencrypted custom password (used by an LDAP listener) for the 3101 user via attribute <code>passwordUnencrypted</code>. 3102 * @return the user 3103 */ 3104 @Override 3105 public com.liferay.portal.model.User updateStatus(long userId, int status, 3106 com.liferay.portal.service.ServiceContext serviceContext) 3107 throws com.liferay.portal.kernel.exception.PortalException { 3108 return _userLocalService.updateStatus(userId, status, serviceContext); 3109 } 3110 3111 /** 3112 * Updates the user in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 3113 * 3114 * @param user the user 3115 * @return the user that was updated 3116 */ 3117 @Override 3118 public com.liferay.portal.model.User updateUser( 3119 com.liferay.portal.model.User user) { 3120 return _userLocalService.updateUser(user); 3121 } 3122 3123 /** 3124 * Updates the user. 3125 * 3126 * @param userId the primary key of the user 3127 * @param oldPassword the user's old password 3128 * @param newPassword1 the user's new password (optionally 3129 <code>null</code>) 3130 * @param newPassword2 the user's new password confirmation (optionally 3131 <code>null</code>) 3132 * @param passwordReset whether the user should be asked to reset their 3133 password the next time they login 3134 * @param reminderQueryQuestion the user's new password reset question 3135 * @param reminderQueryAnswer the user's new password reset answer 3136 * @param screenName the user's new screen name 3137 * @param emailAddress the user's new email address 3138 * @param facebookId the user's new Facebook ID 3139 * @param openId the user's new OpenID 3140 * @param languageId the user's new language ID 3141 * @param timeZoneId the user's new time zone ID 3142 * @param greeting the user's new greeting 3143 * @param comments the user's new comments 3144 * @param firstName the user's new first name 3145 * @param middleName the user's new middle name 3146 * @param lastName the user's new last name 3147 * @param prefixId the user's new name prefix ID 3148 * @param suffixId the user's new name suffix ID 3149 * @param male whether user is male 3150 * @param birthdayMonth the user's new birthday month (0-based, meaning 3151 0 for January) 3152 * @param birthdayDay the user's new birthday day 3153 * @param birthdayYear the user's birthday year 3154 * @param smsSn the user's new SMS screen name 3155 * @param facebookSn the user's new Facebook screen name 3156 * @param jabberSn the user's new Jabber screen name 3157 * @param skypeSn the user's new Skype screen name 3158 * @param twitterSn the user's new Twitter screen name 3159 * @param jobTitle the user's new job title 3160 * @param groupIds the primary keys of the user's groups 3161 * @param organizationIds the primary keys of the user's organizations 3162 * @param roleIds the primary keys of the user's roles 3163 * @param userGroupRoles the user user's group roles 3164 * @param userGroupIds the primary keys of the user's user groups 3165 * @param serviceContext the service context to be applied (optionally 3166 <code>null</code>). Can set the UUID (with the 3167 <code>uuid</code> attribute), asset category IDs, asset tag 3168 names, and expando bridge attributes for the user. 3169 * @return the user 3170 * @deprecated As of 7.0.0, replaced by {@link #updateUser(long, String, 3171 String, String, boolean, String, String, String, String, 3172 long, String, boolean, byte[], String, String, String, 3173 String, String, String, String, int, int, boolean, int, int, 3174 int, String, String, String, String, String, String, String, 3175 String, String, String, String, long[], long[], long[], List, 3176 long[], ServiceContext)} 3177 */ 3178 @Deprecated 3179 @Override 3180 public com.liferay.portal.model.User updateUser(long userId, 3181 java.lang.String oldPassword, java.lang.String newPassword1, 3182 java.lang.String newPassword2, boolean passwordReset, 3183 java.lang.String reminderQueryQuestion, 3184 java.lang.String reminderQueryAnswer, java.lang.String screenName, 3185 java.lang.String emailAddress, long facebookId, 3186 java.lang.String openId, java.lang.String languageId, 3187 java.lang.String timeZoneId, java.lang.String greeting, 3188 java.lang.String comments, java.lang.String firstName, 3189 java.lang.String middleName, java.lang.String lastName, long prefixId, 3190 long suffixId, boolean male, int birthdayMonth, int birthdayDay, 3191 int birthdayYear, java.lang.String smsSn, java.lang.String facebookSn, 3192 java.lang.String jabberSn, java.lang.String skypeSn, 3193 java.lang.String twitterSn, java.lang.String jobTitle, long[] groupIds, 3194 long[] organizationIds, long[] roleIds, 3195 java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles, 3196 long[] userGroupIds, 3197 com.liferay.portal.service.ServiceContext serviceContext) 3198 throws com.liferay.portal.kernel.exception.PortalException { 3199 return _userLocalService.updateUser(userId, oldPassword, newPassword1, 3200 newPassword2, passwordReset, reminderQueryQuestion, 3201 reminderQueryAnswer, screenName, emailAddress, facebookId, openId, 3202 languageId, timeZoneId, greeting, comments, firstName, middleName, 3203 lastName, prefixId, suffixId, male, birthdayMonth, birthdayDay, 3204 birthdayYear, smsSn, facebookSn, jabberSn, skypeSn, twitterSn, 3205 jobTitle, groupIds, organizationIds, roleIds, userGroupRoles, 3206 userGroupIds, serviceContext); 3207 } 3208 3209 /** 3210 * Updates the user. 3211 * 3212 * @param userId the primary key of the user 3213 * @param oldPassword the user's old password 3214 * @param newPassword1 the user's new password (optionally 3215 <code>null</code>) 3216 * @param newPassword2 the user's new password confirmation (optionally 3217 <code>null</code>) 3218 * @param passwordReset whether the user should be asked to reset their 3219 password the next time they login 3220 * @param reminderQueryQuestion the user's new password reset question 3221 * @param reminderQueryAnswer the user's new password reset answer 3222 * @param screenName the user's new screen name 3223 * @param emailAddress the user's new email address 3224 * @param facebookId the user's new Facebook ID 3225 * @param openId the user's new OpenID 3226 * @param portrait whether to update the user's portrait image 3227 * @param portraitBytes the new portrait image data 3228 * @param languageId the user's new language ID 3229 * @param timeZoneId the user's new time zone ID 3230 * @param greeting the user's new greeting 3231 * @param comments the user's new comments 3232 * @param firstName the user's new first name 3233 * @param middleName the user's new middle name 3234 * @param lastName the user's new last name 3235 * @param prefixId the user's new name prefix ID 3236 * @param suffixId the user's new name suffix ID 3237 * @param male whether user is male 3238 * @param birthdayMonth the user's new birthday month (0-based, meaning 0 3239 for January) 3240 * @param birthdayDay the user's new birthday day 3241 * @param birthdayYear the user's birthday year 3242 * @param smsSn the user's new SMS screen name 3243 * @param facebookSn the user's new Facebook screen name 3244 * @param jabberSn the user's new Jabber screen name 3245 * @param skypeSn the user's new Skype screen name 3246 * @param twitterSn the user's new Twitter screen name 3247 * @param jobTitle the user's new job title 3248 * @param groupIds the primary keys of the user's groups 3249 * @param organizationIds the primary keys of the user's organizations 3250 * @param roleIds the primary keys of the user's roles 3251 * @param userGroupRoles the user user's group roles 3252 * @param userGroupIds the primary keys of the user's user groups 3253 * @param serviceContext the service context to be applied (optionally 3254 <code>null</code>). Can set the UUID (with the <code>uuid</code> 3255 attribute), asset category IDs, asset tag names, and expando 3256 bridge attributes for the user. 3257 * @return the user 3258 */ 3259 @Override 3260 public com.liferay.portal.model.User updateUser(long userId, 3261 java.lang.String oldPassword, java.lang.String newPassword1, 3262 java.lang.String newPassword2, boolean passwordReset, 3263 java.lang.String reminderQueryQuestion, 3264 java.lang.String reminderQueryAnswer, java.lang.String screenName, 3265 java.lang.String emailAddress, long facebookId, 3266 java.lang.String openId, boolean portrait, byte[] portraitBytes, 3267 java.lang.String languageId, java.lang.String timeZoneId, 3268 java.lang.String greeting, java.lang.String comments, 3269 java.lang.String firstName, java.lang.String middleName, 3270 java.lang.String lastName, long prefixId, long suffixId, boolean male, 3271 int birthdayMonth, int birthdayDay, int birthdayYear, 3272 java.lang.String smsSn, java.lang.String facebookSn, 3273 java.lang.String jabberSn, java.lang.String skypeSn, 3274 java.lang.String twitterSn, java.lang.String jobTitle, long[] groupIds, 3275 long[] organizationIds, long[] roleIds, 3276 java.util.List<com.liferay.portal.model.UserGroupRole> userGroupRoles, 3277 long[] userGroupIds, 3278 com.liferay.portal.service.ServiceContext serviceContext) 3279 throws com.liferay.portal.kernel.exception.PortalException { 3280 return _userLocalService.updateUser(userId, oldPassword, newPassword1, 3281 newPassword2, passwordReset, reminderQueryQuestion, 3282 reminderQueryAnswer, screenName, emailAddress, facebookId, openId, 3283 portrait, portraitBytes, languageId, timeZoneId, greeting, 3284 comments, firstName, middleName, lastName, prefixId, suffixId, 3285 male, birthdayMonth, birthdayDay, birthdayYear, smsSn, facebookSn, 3286 jabberSn, skypeSn, twitterSn, jobTitle, groupIds, organizationIds, 3287 roleIds, userGroupRoles, userGroupIds, serviceContext); 3288 } 3289 3290 /** 3291 * Verifies the email address of the ticket. 3292 * 3293 * @param ticketKey the ticket key 3294 */ 3295 @Override 3296 public void verifyEmailAddress(java.lang.String ticketKey) 3297 throws com.liferay.portal.kernel.exception.PortalException { 3298 _userLocalService.verifyEmailAddress(ticketKey); 3299 } 3300 3301 /** 3302 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 3303 */ 3304 @Deprecated 3305 public UserLocalService getWrappedUserLocalService() { 3306 return _userLocalService; 3307 } 3308 3309 /** 3310 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 3311 */ 3312 @Deprecated 3313 public void setWrappedUserLocalService(UserLocalService userLocalService) { 3314 _userLocalService = userLocalService; 3315 } 3316 3317 @Override 3318 public UserLocalService getWrappedService() { 3319 return _userLocalService; 3320 } 3321 3322 @Override 3323 public void setWrappedService(UserLocalService userLocalService) { 3324 _userLocalService = userLocalService; 3325 } 3326 3327 private UserLocalService _userLocalService; 3328 }