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