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