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