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