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