001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 /** 020 * Provides a wrapper for {@link RoleLocalService}. 021 * 022 * @author Brian Wing Shun Chan 023 * @see RoleLocalService 024 * @generated 025 */ 026 @ProviderType 027 public class RoleLocalServiceWrapper implements RoleLocalService, 028 ServiceWrapper<RoleLocalService> { 029 public RoleLocalServiceWrapper(RoleLocalService roleLocalService) { 030 _roleLocalService = roleLocalService; 031 } 032 033 @Override 034 public void addGroupRole(long groupId, com.liferay.portal.model.Role role) { 035 _roleLocalService.addGroupRole(groupId, role); 036 } 037 038 @Override 039 public void addGroupRole(long groupId, long roleId) { 040 _roleLocalService.addGroupRole(groupId, roleId); 041 } 042 043 @Override 044 public void addGroupRoles(long groupId, 045 java.util.List<com.liferay.portal.model.Role> Roles) { 046 _roleLocalService.addGroupRoles(groupId, Roles); 047 } 048 049 @Override 050 public void addGroupRoles(long groupId, long[] roleIds) { 051 _roleLocalService.addGroupRoles(groupId, roleIds); 052 } 053 054 /** 055 * Adds the role to the database. Also notifies the appropriate model listeners. 056 * 057 * @param role the role 058 * @return the role that was added 059 */ 060 @Override 061 public com.liferay.portal.model.Role addRole( 062 com.liferay.portal.model.Role role) { 063 return _roleLocalService.addRole(role); 064 } 065 066 /** 067 * Adds a role with additional parameters. The user is reindexed after role 068 * is added. 069 * 070 * @param userId the primary key of the user 071 * @param className the name of the class for which the role is created 072 (optionally <code>null</code>) 073 * @param classPK the primary key of the class for which the role is 074 created (optionally <code>0</code>) 075 * @param name the role's name 076 * @param titleMap the role's localized titles (optionally 077 <code>null</code>) 078 * @param descriptionMap the role's localized descriptions (optionally 079 <code>null</code>) 080 * @param type the role's type (optionally <code>0</code>) 081 * @param subtype the role's subtype (optionally <code>null</code>) 082 * @param serviceContext the service context to be applied (optionally 083 <code>null</code>). Can set expando bridge attributes for the 084 role. 085 * @return the role 086 * @throws PortalException if the class name or the role name were invalid, 087 if the role is a duplicate, or if a user with the primary key 088 could not be found 089 */ 090 @Override 091 public com.liferay.portal.model.Role addRole(long userId, 092 java.lang.String className, long classPK, java.lang.String name, 093 java.util.Map<java.util.Locale, java.lang.String> titleMap, 094 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 095 int type, java.lang.String subtype, 096 com.liferay.portal.service.ServiceContext serviceContext) 097 throws com.liferay.portal.kernel.exception.PortalException { 098 return _roleLocalService.addRole(userId, className, classPK, name, 099 titleMap, descriptionMap, type, subtype, serviceContext); 100 } 101 102 /** 103 * Adds a role. The user is reindexed after role is added. 104 * 105 * @param userId the primary key of the user 106 * @param companyId the primary key of the company 107 * @param name the role's name 108 * @param titleMap the role's localized titles (optionally 109 <code>null</code>) 110 * @param descriptionMap the role's localized descriptions (optionally 111 <code>null</code>) 112 * @param type the role's type (optionally <code>0</code>) 113 * @return the role 114 * @throws PortalException if the class name or the role name were 115 invalid, if the role is a duplicate, or if a user with the 116 primary key could not be found 117 * @deprecated As of 6.2.0, replaced by {@link #addRole(long, String, long, 118 String, Map, Map, int, String, ServiceContext)} 119 */ 120 @Deprecated 121 @Override 122 public com.liferay.portal.model.Role addRole(long userId, long companyId, 123 java.lang.String name, 124 java.util.Map<java.util.Locale, java.lang.String> titleMap, 125 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 126 int type) throws com.liferay.portal.kernel.exception.PortalException { 127 return _roleLocalService.addRole(userId, companyId, name, titleMap, 128 descriptionMap, type); 129 } 130 131 /** 132 * Adds a role with additional parameters. The user is reindexed after role 133 * is added. 134 * 135 * @param userId the primary key of the user 136 * @param companyId the primary key of the company 137 * @param name the role's name 138 * @param titleMap the role's localized titles (optionally 139 <code>null</code>) 140 * @param descriptionMap the role's localized descriptions (optionally 141 <code>null</code>) 142 * @param type the role's type (optionally <code>0</code>) 143 * @param className the name of the class for which the role is created 144 (optionally <code>null</code>) 145 * @param classPK the primary key of the class for which the role is 146 created (optionally <code>0</code>) 147 * @return the role 148 * @throws PortalException if the class name or the role name were 149 invalid, if the role is a duplicate, or if a user with the 150 primary key could not be found 151 * @deprecated As of 6.2.0, replaced by {@link #addRole(long, String, long, 152 String, Map, Map, int, String, ServiceContext)} 153 */ 154 @Deprecated 155 @Override 156 public com.liferay.portal.model.Role addRole(long userId, long companyId, 157 java.lang.String name, 158 java.util.Map<java.util.Locale, java.lang.String> titleMap, 159 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 160 int type, java.lang.String className, long classPK) 161 throws com.liferay.portal.kernel.exception.PortalException { 162 return _roleLocalService.addRole(userId, companyId, name, titleMap, 163 descriptionMap, type, className, classPK); 164 } 165 166 @Override 167 public void addUserRole(long userId, com.liferay.portal.model.Role role) { 168 _roleLocalService.addUserRole(userId, role); 169 } 170 171 @Override 172 public void addUserRole(long userId, long roleId) { 173 _roleLocalService.addUserRole(userId, roleId); 174 } 175 176 /** 177 * @throws PortalException 178 */ 179 @Override 180 public void addUserRoles(long userId, 181 java.util.List<com.liferay.portal.model.Role> Roles) 182 throws com.liferay.portal.kernel.exception.PortalException { 183 _roleLocalService.addUserRoles(userId, Roles); 184 } 185 186 /** 187 * @throws PortalException 188 */ 189 @Override 190 public void addUserRoles(long userId, long[] roleIds) 191 throws com.liferay.portal.kernel.exception.PortalException { 192 _roleLocalService.addUserRoles(userId, roleIds); 193 } 194 195 /** 196 * Checks to ensure that the system roles map has appropriate default roles 197 * in each company. 198 * 199 * @throws PortalException if the current user did not have permission to 200 set applicable permissions on a role 201 */ 202 @Override 203 public void checkSystemRoles() 204 throws com.liferay.portal.kernel.exception.PortalException { 205 _roleLocalService.checkSystemRoles(); 206 } 207 208 /** 209 * Checks to ensure that the system roles map has appropriate default roles 210 * in the company. 211 * 212 * @param companyId the primary key of the company 213 * @throws PortalException if the current user did not have permission to 214 set applicable permissions on a role 215 */ 216 @Override 217 public void checkSystemRoles(long companyId) 218 throws com.liferay.portal.kernel.exception.PortalException { 219 _roleLocalService.checkSystemRoles(companyId); 220 } 221 222 @Override 223 public void clearGroupRoles(long groupId) { 224 _roleLocalService.clearGroupRoles(groupId); 225 } 226 227 @Override 228 public void clearUserRoles(long userId) { 229 _roleLocalService.clearUserRoles(userId); 230 } 231 232 /** 233 * Creates a new role with the primary key. Does not add the role to the database. 234 * 235 * @param roleId the primary key for the new role 236 * @return the new role 237 */ 238 @Override 239 public com.liferay.portal.model.Role createRole(long roleId) { 240 return _roleLocalService.createRole(roleId); 241 } 242 243 @Override 244 public void deleteGroupRole(long groupId, com.liferay.portal.model.Role role) { 245 _roleLocalService.deleteGroupRole(groupId, role); 246 } 247 248 @Override 249 public void deleteGroupRole(long groupId, long roleId) { 250 _roleLocalService.deleteGroupRole(groupId, roleId); 251 } 252 253 @Override 254 public void deleteGroupRoles(long groupId, 255 java.util.List<com.liferay.portal.model.Role> Roles) { 256 _roleLocalService.deleteGroupRoles(groupId, Roles); 257 } 258 259 @Override 260 public void deleteGroupRoles(long groupId, long[] roleIds) { 261 _roleLocalService.deleteGroupRoles(groupId, roleIds); 262 } 263 264 /** 265 * @throws PortalException 266 */ 267 @Override 268 public com.liferay.portal.model.PersistedModel deletePersistedModel( 269 com.liferay.portal.model.PersistedModel persistedModel) 270 throws com.liferay.portal.kernel.exception.PortalException { 271 return _roleLocalService.deletePersistedModel(persistedModel); 272 } 273 274 /** 275 * Deletes the role from the database. Also notifies the appropriate model listeners. 276 * 277 * @param role the role 278 * @return the role that was removed 279 * @throws PortalException 280 */ 281 @Override 282 public com.liferay.portal.model.Role deleteRole( 283 com.liferay.portal.model.Role role) 284 throws com.liferay.portal.kernel.exception.PortalException { 285 return _roleLocalService.deleteRole(role); 286 } 287 288 /** 289 * Deletes the role with the primary key from the database. Also notifies the appropriate model listeners. 290 * 291 * @param roleId the primary key of the role 292 * @return the role that was removed 293 * @throws PortalException if a role with the primary key could not be found 294 */ 295 @Override 296 public com.liferay.portal.model.Role deleteRole(long roleId) 297 throws com.liferay.portal.kernel.exception.PortalException { 298 return _roleLocalService.deleteRole(roleId); 299 } 300 301 @Override 302 public void deleteUserRole(long userId, com.liferay.portal.model.Role role) { 303 _roleLocalService.deleteUserRole(userId, role); 304 } 305 306 @Override 307 public void deleteUserRole(long userId, long roleId) { 308 _roleLocalService.deleteUserRole(userId, roleId); 309 } 310 311 @Override 312 public void deleteUserRoles(long userId, 313 java.util.List<com.liferay.portal.model.Role> Roles) { 314 _roleLocalService.deleteUserRoles(userId, Roles); 315 } 316 317 @Override 318 public void deleteUserRoles(long userId, long[] roleIds) { 319 _roleLocalService.deleteUserRoles(userId, roleIds); 320 } 321 322 @Override 323 public com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery() { 324 return _roleLocalService.dynamicQuery(); 325 } 326 327 /** 328 * Performs a dynamic query on the database and returns the matching rows. 329 * 330 * @param dynamicQuery the dynamic query 331 * @return the matching rows 332 */ 333 @Override 334 public <T> java.util.List<T> dynamicQuery( 335 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 336 return _roleLocalService.dynamicQuery(dynamicQuery); 337 } 338 339 /** 340 * Performs a dynamic query on the database and returns a range of the matching rows. 341 * 342 * <p> 343 * 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.RoleModelImpl}. 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. 344 * </p> 345 * 346 * @param dynamicQuery the dynamic query 347 * @param start the lower bound of the range of model instances 348 * @param end the upper bound of the range of model instances (not inclusive) 349 * @return the range of matching rows 350 */ 351 @Override 352 public <T> java.util.List<T> dynamicQuery( 353 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 354 int end) { 355 return _roleLocalService.dynamicQuery(dynamicQuery, start, end); 356 } 357 358 /** 359 * Performs a dynamic query on the database and returns an ordered range of the matching rows. 360 * 361 * <p> 362 * 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.RoleModelImpl}. 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. 363 * </p> 364 * 365 * @param dynamicQuery the dynamic query 366 * @param start the lower bound of the range of model instances 367 * @param end the upper bound of the range of model instances (not inclusive) 368 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 369 * @return the ordered range of matching rows 370 */ 371 @Override 372 public <T> java.util.List<T> dynamicQuery( 373 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, int start, 374 int end, 375 com.liferay.portal.kernel.util.OrderByComparator<T> orderByComparator) { 376 return _roleLocalService.dynamicQuery(dynamicQuery, start, end, 377 orderByComparator); 378 } 379 380 /** 381 * Returns the number of rows matching the dynamic query. 382 * 383 * @param dynamicQuery the dynamic query 384 * @return the number of rows matching the dynamic query 385 */ 386 @Override 387 public long dynamicQueryCount( 388 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery) { 389 return _roleLocalService.dynamicQueryCount(dynamicQuery); 390 } 391 392 /** 393 * Returns the number of rows matching the dynamic query. 394 * 395 * @param dynamicQuery the dynamic query 396 * @param projection the projection to apply to the query 397 * @return the number of rows matching the dynamic query 398 */ 399 @Override 400 public long dynamicQueryCount( 401 com.liferay.portal.kernel.dao.orm.DynamicQuery dynamicQuery, 402 com.liferay.portal.kernel.dao.orm.Projection projection) { 403 return _roleLocalService.dynamicQueryCount(dynamicQuery, projection); 404 } 405 406 /** 407 * Returns the role with the name in the company. 408 * 409 * <p> 410 * The method searches the system roles map first for default roles. If a 411 * role with the name is not found, then the method will query the database. 412 * </p> 413 * 414 * @param companyId the primary key of the company 415 * @param name the role's name 416 * @return Returns the role with the name or <code>null</code> if a role 417 with the name could not be found in the company 418 */ 419 @Override 420 public com.liferay.portal.model.Role fetchRole(long companyId, 421 java.lang.String name) { 422 return _roleLocalService.fetchRole(companyId, name); 423 } 424 425 @Override 426 public com.liferay.portal.model.Role fetchRole(long roleId) { 427 return _roleLocalService.fetchRole(roleId); 428 } 429 430 /** 431 * Returns the role with the matching UUID and company. 432 * 433 * @param uuid the role's UUID 434 * @param companyId the primary key of the company 435 * @return the matching role, or <code>null</code> if a matching role could not be found 436 */ 437 @Override 438 public com.liferay.portal.model.Role fetchRoleByUuidAndCompanyId( 439 java.lang.String uuid, long companyId) { 440 return _roleLocalService.fetchRoleByUuidAndCompanyId(uuid, companyId); 441 } 442 443 @Override 444 public com.liferay.portal.kernel.dao.orm.ActionableDynamicQuery getActionableDynamicQuery() { 445 return _roleLocalService.getActionableDynamicQuery(); 446 } 447 448 /** 449 * Returns the Spring bean ID for this bean. 450 * 451 * @return the Spring bean ID for this bean 452 */ 453 @Override 454 public java.lang.String getBeanIdentifier() { 455 return _roleLocalService.getBeanIdentifier(); 456 } 457 458 /** 459 * Returns the default role for the group with the primary key. 460 * 461 * <p> 462 * If the group is a site, then the default role is {@link 463 * com.liferay.portal.model.RoleConstants#SITE_MEMBER}. If the group is an 464 * organization, then the default role is {@link 465 * com.liferay.portal.model.RoleConstants#ORGANIZATION_USER}. If the group 466 * is a user or user group, then the default role is {@link 467 * com.liferay.portal.model.RoleConstants#POWER_USER}. For all other group 468 * types, the default role is {@link 469 * com.liferay.portal.model.RoleConstants#USER}. 470 * </p> 471 * 472 * @param groupId the primary key of the group 473 * @return the default role for the group with the primary key 474 * @throws PortalException if a group with the primary key could not be 475 found, or if a default role could not be found for the group 476 */ 477 @Override 478 public com.liferay.portal.model.Role getDefaultGroupRole(long groupId) 479 throws com.liferay.portal.kernel.exception.PortalException { 480 return _roleLocalService.getDefaultGroupRole(groupId); 481 } 482 483 @Override 484 public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery( 485 com.liferay.portlet.exportimport.lar.PortletDataContext portletDataContext) { 486 return _roleLocalService.getExportActionableDynamicQuery(portletDataContext); 487 } 488 489 /** 490 * Returns the groupIds of the groups associated with the role. 491 * 492 * @param roleId the roleId of the role 493 * @return long[] the groupIds of groups associated with the role 494 */ 495 @Override 496 public long[] getGroupPrimaryKeys(long roleId) { 497 return _roleLocalService.getGroupPrimaryKeys(roleId); 498 } 499 500 @Override 501 public java.util.List<com.liferay.portal.model.Role> getGroupRelatedRoles( 502 long groupId) 503 throws com.liferay.portal.kernel.exception.PortalException { 504 return _roleLocalService.getGroupRelatedRoles(groupId); 505 } 506 507 @Override 508 public java.util.List<com.liferay.portal.model.Role> getGroupRoles( 509 long groupId) { 510 return _roleLocalService.getGroupRoles(groupId); 511 } 512 513 @Override 514 public java.util.List<com.liferay.portal.model.Role> getGroupRoles( 515 long groupId, int start, int end) { 516 return _roleLocalService.getGroupRoles(groupId, start, end); 517 } 518 519 @Override 520 public java.util.List<com.liferay.portal.model.Role> getGroupRoles( 521 long groupId, int start, int end, 522 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> orderByComparator) { 523 return _roleLocalService.getGroupRoles(groupId, start, end, 524 orderByComparator); 525 } 526 527 @Override 528 public int getGroupRolesCount(long groupId) { 529 return _roleLocalService.getGroupRolesCount(groupId); 530 } 531 532 @Override 533 public com.liferay.portal.model.PersistedModel getPersistedModel( 534 java.io.Serializable primaryKeyObj) 535 throws com.liferay.portal.kernel.exception.PortalException { 536 return _roleLocalService.getPersistedModel(primaryKeyObj); 537 } 538 539 @Override 540 public java.util.List<com.liferay.portal.model.Role> getResourceBlockRoles( 541 long resourceBlockId, java.lang.String className, 542 java.lang.String actionId) { 543 return _roleLocalService.getResourceBlockRoles(resourceBlockId, 544 className, actionId); 545 } 546 547 /** 548 * Returns a map of role names to associated action IDs for the named 549 * resource in the company within the permission scope. 550 * 551 * @param companyId the primary key of the company 552 * @param name the resource name 553 * @param scope the permission scope 554 * @param primKey the primary key of the resource's class 555 * @return the role names and action IDs 556 * @see com.liferay.portal.service.persistence.RoleFinder#findByC_N_S_P( 557 long, String, int, String) 558 */ 559 @Override 560 public java.util.Map<java.lang.String, java.util.List<java.lang.String>> getResourceRoles( 561 long companyId, java.lang.String name, int scope, 562 java.lang.String primKey) { 563 return _roleLocalService.getResourceRoles(companyId, name, scope, 564 primKey); 565 } 566 567 /** 568 * Returns all the roles associated with the action ID in the company within 569 * the permission scope. 570 * 571 * @param companyId the primary key of the company 572 * @param name the resource name 573 * @param scope the permission scope 574 * @param primKey the primary key of the resource's class 575 * @param actionId the name of the resource action 576 * @return the roles 577 * @see com.liferay.portal.service.persistence.RoleFinder#findByC_N_S_P_A( 578 long, String, int, String, String) 579 */ 580 @Override 581 public java.util.List<com.liferay.portal.model.Role> getResourceRoles( 582 long companyId, java.lang.String name, int scope, 583 java.lang.String primKey, java.lang.String actionId) { 584 return _roleLocalService.getResourceRoles(companyId, name, scope, 585 primKey, actionId); 586 } 587 588 /** 589 * Returns the role with the name in the company. 590 * 591 * <p> 592 * The method searches the system roles map first for default roles. If a 593 * role with the name is not found, then the method will query the database. 594 * </p> 595 * 596 * @param companyId the primary key of the company 597 * @param name the role's name 598 * @return the role with the name 599 * @throws PortalException if a role with the name could not be found in the 600 company 601 */ 602 @Override 603 public com.liferay.portal.model.Role getRole(long companyId, 604 java.lang.String name) 605 throws com.liferay.portal.kernel.exception.PortalException { 606 return _roleLocalService.getRole(companyId, name); 607 } 608 609 /** 610 * Returns the role with the primary key. 611 * 612 * @param roleId the primary key of the role 613 * @return the role 614 * @throws PortalException if a role with the primary key could not be found 615 */ 616 @Override 617 public com.liferay.portal.model.Role getRole(long roleId) 618 throws com.liferay.portal.kernel.exception.PortalException { 619 return _roleLocalService.getRole(roleId); 620 } 621 622 /** 623 * Returns the role with the matching UUID and company. 624 * 625 * @param uuid the role's UUID 626 * @param companyId the primary key of the company 627 * @return the matching role 628 * @throws PortalException if a matching role could not be found 629 */ 630 @Override 631 public com.liferay.portal.model.Role getRoleByUuidAndCompanyId( 632 java.lang.String uuid, long companyId) 633 throws com.liferay.portal.kernel.exception.PortalException { 634 return _roleLocalService.getRoleByUuidAndCompanyId(uuid, companyId); 635 } 636 637 /** 638 * Returns all the roles in the company. 639 * 640 * @param companyId the primary key of the company 641 * @return the roles in the company 642 */ 643 @Override 644 public java.util.List<com.liferay.portal.model.Role> getRoles( 645 long companyId) { 646 return _roleLocalService.getRoles(companyId); 647 } 648 649 /** 650 * Returns all the roles with the types. 651 * 652 * @param companyId the primary key of the company 653 * @param types the role types (optionally <code>null</code>) 654 * @return the roles with the types 655 */ 656 @Override 657 public java.util.List<com.liferay.portal.model.Role> getRoles( 658 long companyId, int[] types) { 659 return _roleLocalService.getRoles(companyId, types); 660 } 661 662 /** 663 * Returns all the roles with the primary keys. 664 * 665 * @param roleIds the primary keys of the roles 666 * @return the roles with the primary keys 667 * @throws PortalException if any one of the roles with the primary keys 668 could not be found 669 */ 670 @Override 671 public java.util.List<com.liferay.portal.model.Role> getRoles( 672 long[] roleIds) 673 throws com.liferay.portal.kernel.exception.PortalException { 674 return _roleLocalService.getRoles(roleIds); 675 } 676 677 /** 678 * Returns a range of all the roles. 679 * 680 * <p> 681 * 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.RoleModelImpl}. 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. 682 * </p> 683 * 684 * @param start the lower bound of the range of roles 685 * @param end the upper bound of the range of roles (not inclusive) 686 * @return the range of roles 687 */ 688 @Override 689 public java.util.List<com.liferay.portal.model.Role> getRoles(int start, 690 int end) { 691 return _roleLocalService.getRoles(start, end); 692 } 693 694 /** 695 * Returns all the roles of the type and subtype. 696 * 697 * @param type the role's type (optionally <code>0</code>) 698 * @param subtype the role's subtype (optionally <code>null</code>) 699 * @return the roles of the type and subtype 700 */ 701 @Override 702 public java.util.List<com.liferay.portal.model.Role> getRoles(int type, 703 java.lang.String subtype) { 704 return _roleLocalService.getRoles(type, subtype); 705 } 706 707 /** 708 * Returns the number of roles. 709 * 710 * @return the number of roles 711 */ 712 @Override 713 public int getRolesCount() { 714 return _roleLocalService.getRolesCount(); 715 } 716 717 /** 718 * Returns all the roles of the subtype. 719 * 720 * @param subtype the role's subtype (optionally <code>null</code>) 721 * @return the roles of the subtype 722 */ 723 @Override 724 public java.util.List<com.liferay.portal.model.Role> getSubtypeRoles( 725 java.lang.String subtype) { 726 return _roleLocalService.getSubtypeRoles(subtype); 727 } 728 729 /** 730 * Returns the number of roles of the subtype. 731 * 732 * @param subtype the role's subtype (optionally <code>null</code>) 733 * @return the number of roles of the subtype 734 */ 735 @Override 736 public int getSubtypeRolesCount(java.lang.String subtype) { 737 return _roleLocalService.getSubtypeRolesCount(subtype); 738 } 739 740 /** 741 * Returns the team role in the company. 742 * 743 * @param companyId the primary key of the company 744 * @param teamId the primary key of the team 745 * @return the team role in the company 746 * @throws PortalException if a role could not be found in the team and 747 company 748 */ 749 @Override 750 public com.liferay.portal.model.Role getTeamRole(long companyId, long teamId) 751 throws com.liferay.portal.kernel.exception.PortalException { 752 return _roleLocalService.getTeamRole(companyId, teamId); 753 } 754 755 /** 756 * Returns the team role map for the group. 757 * 758 * @param groupId the primary key of the group 759 * @return the team role map for the group 760 * @throws PortalException if a group with the primary key could not be 761 found, if a role could not be found in one of the group's teams, 762 or if a portal exception occurred 763 */ 764 @Override 765 public java.util.Map<com.liferay.portal.model.Team, com.liferay.portal.model.Role> getTeamRoleMap( 766 long groupId) 767 throws com.liferay.portal.kernel.exception.PortalException { 768 return _roleLocalService.getTeamRoleMap(groupId); 769 } 770 771 /** 772 * Returns the team roles in the group. 773 * 774 * @param groupId the primary key of the group 775 * @return the team roles in the group 776 * @throws PortalException if a group with the primary key could not be 777 found, if a role could not be found in one of the group's teams, 778 or if a portal exception occurred 779 */ 780 @Override 781 public java.util.List<com.liferay.portal.model.Role> getTeamRoles( 782 long groupId) 783 throws com.liferay.portal.kernel.exception.PortalException { 784 return _roleLocalService.getTeamRoles(groupId); 785 } 786 787 /** 788 * Returns the team roles in the group, excluding the specified role IDs. 789 * 790 * @param groupId the primary key of the group 791 * @param excludedRoleIds the primary keys of the roles to exclude 792 (optionally <code>null</code>) 793 * @return the team roles in the group, excluding the specified role IDs 794 * @throws PortalException if a group with the primary key could not be 795 found, if a role could not be found in one of the group's teams, 796 or if a portal exception occurred 797 */ 798 @Override 799 public java.util.List<com.liferay.portal.model.Role> getTeamRoles( 800 long groupId, long[] excludedRoleIds) 801 throws com.liferay.portal.kernel.exception.PortalException { 802 return _roleLocalService.getTeamRoles(groupId, excludedRoleIds); 803 } 804 805 /** 806 * Returns all the roles of the type. 807 * 808 * @param type the role's type (optionally <code>0</code>) 809 * @return the range of the roles of the type 810 */ 811 @Override 812 public java.util.List<com.liferay.portal.model.Role> getTypeRoles(int type) { 813 return _roleLocalService.getTypeRoles(type); 814 } 815 816 /** 817 * Returns a range of all the roles of the type. 818 * 819 * @param type the role's type (optionally <code>0</code>) 820 * @param start the lower bound of the range of roles to return 821 * @param end the upper bound of the range of roles to return (not 822 inclusive) 823 * @return the range of the roles of the type 824 */ 825 @Override 826 public java.util.List<com.liferay.portal.model.Role> getTypeRoles( 827 int type, int start, int end) { 828 return _roleLocalService.getTypeRoles(type, start, end); 829 } 830 831 /** 832 * Returns the number of roles of the type. 833 * 834 * @param type the role's type (optionally <code>0</code>) 835 * @return the number of roles of the type 836 */ 837 @Override 838 public int getTypeRolesCount(int type) { 839 return _roleLocalService.getTypeRolesCount(type); 840 } 841 842 /** 843 * Returns all the user's roles within the user group. 844 * 845 * @param userId the primary key of the user 846 * @param groupId the primary key of the group 847 * @return the user's roles within the user group 848 * @see com.liferay.portal.service.persistence.RoleFinder#findByUserGroupGroupRole( 849 long, long) 850 */ 851 @Override 852 public java.util.List<com.liferay.portal.model.Role> getUserGroupGroupRoles( 853 long userId, long groupId) { 854 return _roleLocalService.getUserGroupGroupRoles(userId, groupId); 855 } 856 857 @Override 858 public java.util.List<com.liferay.portal.model.Role> getUserGroupGroupRoles( 859 long userId, long groupId, int start, int end) { 860 return _roleLocalService.getUserGroupGroupRoles(userId, groupId, start, 861 end); 862 } 863 864 @Override 865 public int getUserGroupGroupRolesCount(long userId, long groupId) { 866 return _roleLocalService.getUserGroupGroupRolesCount(userId, groupId); 867 } 868 869 /** 870 * Returns all the user's roles within the user group. 871 * 872 * @param userId the primary key of the user 873 * @param groupId the primary key of the group 874 * @return the user's roles within the user group 875 * @see com.liferay.portal.service.persistence.RoleFinder#findByUserGroupRole( 876 long, long) 877 */ 878 @Override 879 public java.util.List<com.liferay.portal.model.Role> getUserGroupRoles( 880 long userId, long groupId) { 881 return _roleLocalService.getUserGroupRoles(userId, groupId); 882 } 883 884 /** 885 * Returns the userIds of the users associated with the role. 886 * 887 * @param roleId the roleId of the role 888 * @return long[] the userIds of users associated with the role 889 */ 890 @Override 891 public long[] getUserPrimaryKeys(long roleId) { 892 return _roleLocalService.getUserPrimaryKeys(roleId); 893 } 894 895 /** 896 * Returns all the user's roles within the group. 897 * 898 * @param userId the primary key of the user 899 * @param groupId the primary key of the group 900 * @return the user's roles within the group 901 * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long, 902 long) 903 */ 904 @Override 905 public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles( 906 long userId, long groupId) { 907 return _roleLocalService.getUserRelatedRoles(userId, groupId); 908 } 909 910 /** 911 * Returns the union of all the user's roles within the groups. 912 * 913 * @param userId the primary key of the user 914 * @param groupIds the primary keys of the groups 915 * @return the union of all the user's roles within the groups 916 * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long, 917 long[]) 918 */ 919 @Override 920 public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles( 921 long userId, long[] groupIds) { 922 return _roleLocalService.getUserRelatedRoles(userId, groupIds); 923 } 924 925 /** 926 * Returns the union of all the user's roles within the groups. 927 * 928 * @param userId the primary key of the user 929 * @param groups the groups (optionally <code>null</code>) 930 * @return the union of all the user's roles within the groups 931 * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long, 932 List) 933 */ 934 @Override 935 public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles( 936 long userId, java.util.List<com.liferay.portal.model.Group> groups) { 937 return _roleLocalService.getUserRelatedRoles(userId, groups); 938 } 939 940 @Override 941 public java.util.List<com.liferay.portal.model.Role> getUserRoles( 942 long userId) { 943 return _roleLocalService.getUserRoles(userId); 944 } 945 946 @Override 947 public java.util.List<com.liferay.portal.model.Role> getUserRoles( 948 long userId, int start, int end) { 949 return _roleLocalService.getUserRoles(userId, start, end); 950 } 951 952 @Override 953 public java.util.List<com.liferay.portal.model.Role> getUserRoles( 954 long userId, int start, int end, 955 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> orderByComparator) { 956 return _roleLocalService.getUserRoles(userId, start, end, 957 orderByComparator); 958 } 959 960 @Override 961 public int getUserRolesCount(long userId) { 962 return _roleLocalService.getUserRolesCount(userId); 963 } 964 965 @Override 966 public boolean hasGroupRole(long groupId, long roleId) { 967 return _roleLocalService.hasGroupRole(groupId, roleId); 968 } 969 970 @Override 971 public boolean hasGroupRoles(long groupId) { 972 return _roleLocalService.hasGroupRoles(groupId); 973 } 974 975 /** 976 * Returns <code>true</code> if the user is associated with the named 977 * regular role. 978 * 979 * @param userId the primary key of the user 980 * @param companyId the primary key of the company 981 * @param name the name of the role 982 * @param inherited whether to include the user's inherited roles in the 983 search 984 * @return <code>true</code> if the user is associated with the regular 985 role; <code>false</code> otherwise 986 * @throws PortalException if a default user for the company could not be 987 found 988 */ 989 @Override 990 public boolean hasUserRole(long userId, long companyId, 991 java.lang.String name, boolean inherited) 992 throws com.liferay.portal.kernel.exception.PortalException { 993 return _roleLocalService.hasUserRole(userId, companyId, name, inherited); 994 } 995 996 @Override 997 public boolean hasUserRole(long userId, long roleId) { 998 return _roleLocalService.hasUserRole(userId, roleId); 999 } 1000 1001 @Override 1002 public boolean hasUserRoles(long userId) { 1003 return _roleLocalService.hasUserRoles(userId); 1004 } 1005 1006 /** 1007 * Returns <code>true</code> if the user has any one of the named regular 1008 * roles. 1009 * 1010 * @param userId the primary key of the user 1011 * @param companyId the primary key of the company 1012 * @param names the names of the roles 1013 * @param inherited whether to include the user's inherited roles in the 1014 search 1015 * @return <code>true</code> if the user has any one of the regular roles; 1016 <code>false</code> otherwise 1017 * @throws PortalException if any one of the roles with the names could not 1018 be found in the company or if the default user for the company 1019 could not be found 1020 */ 1021 @Override 1022 public boolean hasUserRoles(long userId, long companyId, 1023 java.lang.String[] names, boolean inherited) 1024 throws com.liferay.portal.kernel.exception.PortalException { 1025 return _roleLocalService.hasUserRoles(userId, companyId, names, 1026 inherited); 1027 } 1028 1029 /** 1030 * Returns a role with the name in the company. 1031 * 1032 * @param companyId the primary key of the company 1033 * @param name the role's name (optionally <code>null</code>) 1034 * @return the role with the name, or <code>null</code> if a role with the 1035 name could not be found in the company 1036 */ 1037 @Override 1038 public com.liferay.portal.model.Role loadFetchRole(long companyId, 1039 java.lang.String name) { 1040 return _roleLocalService.loadFetchRole(companyId, name); 1041 } 1042 1043 /** 1044 * Returns a role with the name in the company. 1045 * 1046 * @param companyId the primary key of the company 1047 * @param name the role's name 1048 * @return the role with the name in the company 1049 * @throws PortalException if a role with the name could not be found in the 1050 company 1051 */ 1052 @Override 1053 public com.liferay.portal.model.Role loadGetRole(long companyId, 1054 java.lang.String name) 1055 throws com.liferay.portal.kernel.exception.PortalException { 1056 return _roleLocalService.loadGetRole(companyId, name); 1057 } 1058 1059 /** 1060 * Returns an ordered range of all the roles that match the keywords, types, 1061 * and params. 1062 * 1063 * <p> 1064 * Useful when paginating results. Returns a maximum of <code>end - 1065 * start</code> instances. <code>start</code> and <code>end</code> are not 1066 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1067 * refers to the first result in the set. Setting both <code>start</code> 1068 * and <code>end</code> to {@link 1069 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1070 * result set. 1071 * </p> 1072 * 1073 * @param companyId the primary key of the company 1074 * @param keywords the keywords (space separated), which may occur in the 1075 role's name or description (optionally <code>null</code>) 1076 * @param types the role types (optionally <code>null</code>) 1077 * @param params the finder parameters. Can specify values for the 1078 "usersRoles" key. For more information, see {@link 1079 com.liferay.portal.service.persistence.RoleFinder} 1080 * @param start the lower bound of the range of roles to return 1081 * @param end the upper bound of the range of roles to return (not 1082 inclusive) 1083 * @param obc the comparator to order the roles (optionally 1084 <code>null</code>) 1085 * @return the ordered range of the matching roles, ordered by 1086 <code>obc</code> 1087 * @see com.liferay.portal.service.persistence.RoleFinder 1088 */ 1089 @Override 1090 public java.util.List<com.liferay.portal.model.Role> search( 1091 long companyId, java.lang.String keywords, java.lang.Integer[] types, 1092 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1093 int start, int end, 1094 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) { 1095 return _roleLocalService.search(companyId, keywords, types, params, 1096 start, end, obc); 1097 } 1098 1099 /** 1100 * Returns an ordered range of all the roles that match the keywords and 1101 * types. 1102 * 1103 * <p> 1104 * Useful when paginating results. Returns a maximum of <code>end - 1105 * start</code> instances. <code>start</code> and <code>end</code> are not 1106 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1107 * refers to the first result in the set. Setting both <code>start</code> 1108 * and <code>end</code> to {@link 1109 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1110 * result set. 1111 * </p> 1112 * 1113 * @param companyId the primary key of the company 1114 * @param keywords the keywords (space separated), which may occur in the 1115 role's name or description (optionally <code>null</code>) 1116 * @param types the role types (optionally <code>null</code>) 1117 * @param start the lower bound of the range of roles to return 1118 * @param end the upper bound of the range of roles to return (not 1119 inclusive) 1120 * @param obc the comparator to order the roles (optionally 1121 <code>null</code>) 1122 * @return the ordered range of the matching roles, ordered by 1123 <code>obc</code> 1124 * @see com.liferay.portal.service.persistence.RoleFinder 1125 */ 1126 @Override 1127 public java.util.List<com.liferay.portal.model.Role> search( 1128 long companyId, java.lang.String keywords, java.lang.Integer[] types, 1129 int start, int end, 1130 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) { 1131 return _roleLocalService.search(companyId, keywords, types, start, end, 1132 obc); 1133 } 1134 1135 /** 1136 * Returns an ordered range of all the roles that match the name, 1137 * description, types, and params. 1138 * 1139 * <p> 1140 * Useful when paginating results. Returns a maximum of <code>end - 1141 * start</code> instances. <code>start</code> and <code>end</code> are not 1142 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1143 * refers to the first result in the set. Setting both <code>start</code> 1144 * and <code>end</code> to {@link 1145 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1146 * result set. 1147 * </p> 1148 * 1149 * @param companyId the primary key of the company 1150 * @param name the role's name (optionally <code>null</code>) 1151 * @param description the role's description (optionally <code>null</code>) 1152 * @param types the role types (optionally <code>null</code>) 1153 * @param params the finder's parameters. Can specify values for the 1154 "usersRoles" key. For more information, see {@link 1155 com.liferay.portal.service.persistence.RoleFinder} 1156 * @param start the lower bound of the range of the roles to return 1157 * @param end the upper bound of the range of the roles to return (not 1158 inclusive) 1159 * @param obc the comparator to order the roles (optionally 1160 <code>null</code>) 1161 * @return the ordered range of the matching roles, ordered by 1162 <code>obc</code> 1163 * @see com.liferay.portal.service.persistence.RoleFinder 1164 */ 1165 @Override 1166 public java.util.List<com.liferay.portal.model.Role> search( 1167 long companyId, java.lang.String name, java.lang.String description, 1168 java.lang.Integer[] types, 1169 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1170 int start, int end, 1171 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) { 1172 return _roleLocalService.search(companyId, name, description, types, 1173 params, start, end, obc); 1174 } 1175 1176 /** 1177 * Returns an ordered range of all the roles that match the name, 1178 * description, and types. 1179 * 1180 * <p> 1181 * Useful when paginating results. Returns a maximum of <code>end - 1182 * start</code> instances. <code>start</code> and <code>end</code> are not 1183 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1184 * refers to the first result in the set. Setting both <code>start</code> 1185 * and <code>end</code> to {@link 1186 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1187 * result set. 1188 * </p> 1189 * 1190 * @param companyId the primary key of the company 1191 * @param name the role's name (optionally <code>null</code>) 1192 * @param description the role's description (optionally <code>null</code>) 1193 * @param types the role types (optionally <code>null</code>) 1194 * @param start the lower bound of the range of the roles to return 1195 * @param end the upper bound of the range of the roles to return (not 1196 inclusive) 1197 * @param obc the comparator to order the roles (optionally 1198 <code>null</code>) 1199 * @return the ordered range of the matching roles, ordered by 1200 <code>obc</code> 1201 * @see com.liferay.portal.service.persistence.RoleFinder 1202 */ 1203 @Override 1204 public java.util.List<com.liferay.portal.model.Role> search( 1205 long companyId, java.lang.String name, java.lang.String description, 1206 java.lang.Integer[] types, int start, int end, 1207 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) { 1208 return _roleLocalService.search(companyId, name, description, types, 1209 start, end, obc); 1210 } 1211 1212 /** 1213 * Returns the number of roles that match the keywords and types. 1214 * 1215 * @param companyId the primary key of the company 1216 * @param keywords the keywords (space separated), which may occur in the 1217 role's name or description (optionally <code>null</code>) 1218 * @param types the role types (optionally <code>null</code>) 1219 * @return the number of matching roles 1220 */ 1221 @Override 1222 public int searchCount(long companyId, java.lang.String keywords, 1223 java.lang.Integer[] types) { 1224 return _roleLocalService.searchCount(companyId, keywords, types); 1225 } 1226 1227 /** 1228 * Returns the number of roles that match the keywords, types and params. 1229 * 1230 * @param companyId the primary key of the company 1231 * @param keywords the keywords (space separated), which may occur in the 1232 role's name or description (optionally <code>null</code>) 1233 * @param types the role types (optionally <code>null</code>) 1234 * @param params the finder parameters. For more information, see {@link 1235 com.liferay.portal.service.persistence.RoleFinder} 1236 * @return the number of matching roles 1237 */ 1238 @Override 1239 public int searchCount(long companyId, java.lang.String keywords, 1240 java.lang.Integer[] types, 1241 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 1242 return _roleLocalService.searchCount(companyId, keywords, types, params); 1243 } 1244 1245 /** 1246 * Returns the number of roles that match the name, description, and types. 1247 * 1248 * @param companyId the primary key of the company 1249 * @param name the role's name (optionally <code>null</code>) 1250 * @param description the role's description (optionally <code>null</code>) 1251 * @param types the role types (optionally <code>null</code>) 1252 * @return the number of matching roles 1253 */ 1254 @Override 1255 public int searchCount(long companyId, java.lang.String name, 1256 java.lang.String description, java.lang.Integer[] types) { 1257 return _roleLocalService.searchCount(companyId, name, description, types); 1258 } 1259 1260 /** 1261 * Returns the number of roles that match the name, description, types, and 1262 * params. 1263 * 1264 * @param companyId the primary key of the company 1265 * @param name the role's name (optionally <code>null</code>) 1266 * @param description the role's description (optionally <code>null</code>) 1267 * @param types the role types (optionally <code>null</code>) 1268 * @param params the finder parameters. Can specify values for the 1269 "usersRoles" key. For more information, see {@link 1270 com.liferay.portal.service.persistence.RoleFinder} 1271 * @return the number of matching roles 1272 */ 1273 @Override 1274 public int searchCount(long companyId, java.lang.String name, 1275 java.lang.String description, java.lang.Integer[] types, 1276 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 1277 return _roleLocalService.searchCount(companyId, name, description, 1278 types, params); 1279 } 1280 1281 /** 1282 * Sets the Spring bean ID for this bean. 1283 * 1284 * @param beanIdentifier the Spring bean ID for this bean 1285 */ 1286 @Override 1287 public void setBeanIdentifier(java.lang.String beanIdentifier) { 1288 _roleLocalService.setBeanIdentifier(beanIdentifier); 1289 } 1290 1291 @Override 1292 public void setGroupRoles(long groupId, long[] roleIds) { 1293 _roleLocalService.setGroupRoles(groupId, roleIds); 1294 } 1295 1296 /** 1297 * @throws PortalException 1298 */ 1299 @Override 1300 public void setUserRoles(long userId, long[] roleIds) 1301 throws com.liferay.portal.kernel.exception.PortalException { 1302 _roleLocalService.setUserRoles(userId, roleIds); 1303 } 1304 1305 /** 1306 * Removes the matching roles associated with the user. The user is 1307 * reindexed after the roles are removed. 1308 * 1309 * @param userId the primary key of the user 1310 * @param roleIds the primary keys of the roles 1311 * @throws PortalException if a user with the primary key could not be found 1312 or if a role with any one of the primary keys could not be found 1313 */ 1314 @Override 1315 public void unsetUserRoles(long userId, long[] roleIds) 1316 throws com.liferay.portal.kernel.exception.PortalException { 1317 _roleLocalService.unsetUserRoles(userId, roleIds); 1318 } 1319 1320 /** 1321 * Updates the role in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 1322 * 1323 * @param role the role 1324 * @return the role that was updated 1325 */ 1326 @Override 1327 public com.liferay.portal.model.Role updateRole( 1328 com.liferay.portal.model.Role role) { 1329 return _roleLocalService.updateRole(role); 1330 } 1331 1332 /** 1333 * Updates the role with the primary key. 1334 * 1335 * @param roleId the primary key of the role 1336 * @param name the role's new name 1337 * @param titleMap the new localized titles (optionally <code>null</code>) 1338 to replace those existing for the role 1339 * @param descriptionMap the new localized descriptions (optionally 1340 <code>null</code>) to replace those existing for the role 1341 * @param subtype the role's new subtype (optionally <code>null</code>) 1342 * @param serviceContext the service context to be applied (optionally 1343 <code>null</code>). Can set expando bridge attributes for the 1344 role. 1345 * @return the role with the primary key 1346 * @throws PortalException if a role with the primary could not be found or 1347 if the role's name was invalid 1348 */ 1349 @Override 1350 public com.liferay.portal.model.Role updateRole(long roleId, 1351 java.lang.String name, 1352 java.util.Map<java.util.Locale, java.lang.String> titleMap, 1353 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 1354 java.lang.String subtype, 1355 com.liferay.portal.service.ServiceContext serviceContext) 1356 throws com.liferay.portal.kernel.exception.PortalException { 1357 return _roleLocalService.updateRole(roleId, name, titleMap, 1358 descriptionMap, subtype, serviceContext); 1359 } 1360 1361 /** 1362 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 1363 */ 1364 @Deprecated 1365 public RoleLocalService getWrappedRoleLocalService() { 1366 return _roleLocalService; 1367 } 1368 1369 /** 1370 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 1371 */ 1372 @Deprecated 1373 public void setWrappedRoleLocalService(RoleLocalService roleLocalService) { 1374 _roleLocalService = roleLocalService; 1375 } 1376 1377 @Override 1378 public RoleLocalService getWrappedService() { 1379 return _roleLocalService; 1380 } 1381 1382 @Override 1383 public void setWrappedService(RoleLocalService roleLocalService) { 1384 _roleLocalService = roleLocalService; 1385 } 1386 1387 private RoleLocalService _roleLocalService; 1388 }