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