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