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 * RoleConstants#SITE_MEMBER}. If the group is an organization, then the 464 * default role is {@link RoleConstants#ORGANIZATION_USER}. If the group is 465 * a user or user group, then the default role is {@link 466 * RoleConstants#POWER_USER}. For all other group types, the default role is 467 * {@link RoleConstants#USER}. 468 * </p> 469 * 470 * @param groupId the primary key of the group 471 * @return the default role for the group with the primary key 472 * @throws PortalException if a group with the primary key could not be 473 found, or if a default role could not be found for the group 474 */ 475 @Override 476 public com.liferay.portal.model.Role getDefaultGroupRole(long groupId) 477 throws com.liferay.portal.kernel.exception.PortalException { 478 return _roleLocalService.getDefaultGroupRole(groupId); 479 } 480 481 @Override 482 public com.liferay.portal.kernel.dao.orm.ExportActionableDynamicQuery getExportActionableDynamicQuery( 483 com.liferay.portlet.exportimport.lar.PortletDataContext portletDataContext) { 484 return _roleLocalService.getExportActionableDynamicQuery(portletDataContext); 485 } 486 487 /** 488 * Returns the groupIds of the groups associated with the role. 489 * 490 * @param roleId the roleId of the role 491 * @return long[] the groupIds of groups associated with the role 492 */ 493 @Override 494 public long[] getGroupPrimaryKeys(long roleId) { 495 return _roleLocalService.getGroupPrimaryKeys(roleId); 496 } 497 498 @Override 499 public java.util.List<com.liferay.portal.model.Role> getGroupRelatedRoles( 500 long groupId) 501 throws com.liferay.portal.kernel.exception.PortalException { 502 return _roleLocalService.getGroupRelatedRoles(groupId); 503 } 504 505 @Override 506 public java.util.List<com.liferay.portal.model.Role> getGroupRoles( 507 long groupId) { 508 return _roleLocalService.getGroupRoles(groupId); 509 } 510 511 @Override 512 public java.util.List<com.liferay.portal.model.Role> getGroupRoles( 513 long groupId, int start, int end) { 514 return _roleLocalService.getGroupRoles(groupId, start, end); 515 } 516 517 @Override 518 public java.util.List<com.liferay.portal.model.Role> getGroupRoles( 519 long groupId, int start, int end, 520 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> orderByComparator) { 521 return _roleLocalService.getGroupRoles(groupId, start, end, 522 orderByComparator); 523 } 524 525 @Override 526 public int getGroupRolesCount(long groupId) { 527 return _roleLocalService.getGroupRolesCount(groupId); 528 } 529 530 @Override 531 public com.liferay.portal.model.PersistedModel getPersistedModel( 532 java.io.Serializable primaryKeyObj) 533 throws com.liferay.portal.kernel.exception.PortalException { 534 return _roleLocalService.getPersistedModel(primaryKeyObj); 535 } 536 537 @Override 538 public java.util.List<com.liferay.portal.model.Role> getResourceBlockRoles( 539 long resourceBlockId, java.lang.String className, 540 java.lang.String actionId) { 541 return _roleLocalService.getResourceBlockRoles(resourceBlockId, 542 className, actionId); 543 } 544 545 /** 546 * Returns a map of role names to associated action IDs for the named 547 * resource in the company within the permission scope. 548 * 549 * @param companyId the primary key of the company 550 * @param name the resource name 551 * @param scope the permission scope 552 * @param primKey the primary key of the resource's class 553 * @return the role names and action IDs 554 * @see com.liferay.portal.service.persistence.RoleFinder#findByC_N_S_P( 555 long, String, int, String) 556 */ 557 @Override 558 public java.util.Map<java.lang.String, java.util.List<java.lang.String>> getResourceRoles( 559 long companyId, java.lang.String name, int scope, 560 java.lang.String primKey) { 561 return _roleLocalService.getResourceRoles(companyId, name, scope, 562 primKey); 563 } 564 565 /** 566 * Returns all the roles associated with the action ID in the company within 567 * the permission scope. 568 * 569 * @param companyId the primary key of the company 570 * @param name the resource name 571 * @param scope the permission scope 572 * @param primKey the primary key of the resource's class 573 * @param actionId the name of the resource action 574 * @return the roles 575 * @see com.liferay.portal.service.persistence.RoleFinder#findByC_N_S_P_A( 576 long, String, int, String, String) 577 */ 578 @Override 579 public java.util.List<com.liferay.portal.model.Role> getResourceRoles( 580 long companyId, java.lang.String name, int scope, 581 java.lang.String primKey, java.lang.String actionId) { 582 return _roleLocalService.getResourceRoles(companyId, name, scope, 583 primKey, actionId); 584 } 585 586 /** 587 * Returns the role with the name in the company. 588 * 589 * <p> 590 * The method searches the system roles map first for default roles. If a 591 * role with the name is not found, then the method will query the database. 592 * </p> 593 * 594 * @param companyId the primary key of the company 595 * @param name the role's name 596 * @return the role with the name 597 * @throws PortalException if a role with the name could not be found in the 598 company 599 */ 600 @Override 601 public com.liferay.portal.model.Role getRole(long companyId, 602 java.lang.String name) 603 throws com.liferay.portal.kernel.exception.PortalException { 604 return _roleLocalService.getRole(companyId, name); 605 } 606 607 /** 608 * Returns the role with the primary key. 609 * 610 * @param roleId the primary key of the role 611 * @return the role 612 * @throws PortalException if a role with the primary key could not be found 613 */ 614 @Override 615 public com.liferay.portal.model.Role getRole(long roleId) 616 throws com.liferay.portal.kernel.exception.PortalException { 617 return _roleLocalService.getRole(roleId); 618 } 619 620 /** 621 * Returns the role with the matching UUID and company. 622 * 623 * @param uuid the role's UUID 624 * @param companyId the primary key of the company 625 * @return the matching role 626 * @throws PortalException if a matching role could not be found 627 */ 628 @Override 629 public com.liferay.portal.model.Role getRoleByUuidAndCompanyId( 630 java.lang.String uuid, long companyId) 631 throws com.liferay.portal.kernel.exception.PortalException { 632 return _roleLocalService.getRoleByUuidAndCompanyId(uuid, companyId); 633 } 634 635 /** 636 * Returns all the roles in the company. 637 * 638 * @param companyId the primary key of the company 639 * @return the roles in the company 640 */ 641 @Override 642 public java.util.List<com.liferay.portal.model.Role> getRoles( 643 long companyId) { 644 return _roleLocalService.getRoles(companyId); 645 } 646 647 /** 648 * Returns all the roles with the types. 649 * 650 * @param companyId the primary key of the company 651 * @param types the role types (optionally <code>null</code>) 652 * @return the roles with the types 653 */ 654 @Override 655 public java.util.List<com.liferay.portal.model.Role> getRoles( 656 long companyId, int[] types) { 657 return _roleLocalService.getRoles(companyId, types); 658 } 659 660 /** 661 * Returns all the roles with the primary keys. 662 * 663 * @param roleIds the primary keys of the roles 664 * @return the roles with the primary keys 665 * @throws PortalException if any one of the roles with the primary keys 666 could not be found 667 */ 668 @Override 669 public java.util.List<com.liferay.portal.model.Role> getRoles( 670 long[] roleIds) 671 throws com.liferay.portal.kernel.exception.PortalException { 672 return _roleLocalService.getRoles(roleIds); 673 } 674 675 /** 676 * Returns a range of all the roles. 677 * 678 * <p> 679 * 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. 680 * </p> 681 * 682 * @param start the lower bound of the range of roles 683 * @param end the upper bound of the range of roles (not inclusive) 684 * @return the range of roles 685 */ 686 @Override 687 public java.util.List<com.liferay.portal.model.Role> getRoles(int start, 688 int end) { 689 return _roleLocalService.getRoles(start, end); 690 } 691 692 /** 693 * Returns all the roles of the type and subtype. 694 * 695 * @param type the role's type (optionally <code>0</code>) 696 * @param subtype the role's subtype (optionally <code>null</code>) 697 * @return the roles of the type and subtype 698 */ 699 @Override 700 public java.util.List<com.liferay.portal.model.Role> getRoles(int type, 701 java.lang.String subtype) { 702 return _roleLocalService.getRoles(type, subtype); 703 } 704 705 /** 706 * Returns the number of roles. 707 * 708 * @return the number of roles 709 */ 710 @Override 711 public int getRolesCount() { 712 return _roleLocalService.getRolesCount(); 713 } 714 715 /** 716 * Returns all the roles of the subtype. 717 * 718 * @param subtype the role's subtype (optionally <code>null</code>) 719 * @return the roles of the subtype 720 */ 721 @Override 722 public java.util.List<com.liferay.portal.model.Role> getSubtypeRoles( 723 java.lang.String subtype) { 724 return _roleLocalService.getSubtypeRoles(subtype); 725 } 726 727 /** 728 * Returns the number of roles of the subtype. 729 * 730 * @param subtype the role's subtype (optionally <code>null</code>) 731 * @return the number of roles of the subtype 732 */ 733 @Override 734 public int getSubtypeRolesCount(java.lang.String subtype) { 735 return _roleLocalService.getSubtypeRolesCount(subtype); 736 } 737 738 /** 739 * Returns the team role in the company. 740 * 741 * @param companyId the primary key of the company 742 * @param teamId the primary key of the team 743 * @return the team role in the company 744 * @throws PortalException if a role could not be found in the team and 745 company 746 */ 747 @Override 748 public com.liferay.portal.model.Role getTeamRole(long companyId, long teamId) 749 throws com.liferay.portal.kernel.exception.PortalException { 750 return _roleLocalService.getTeamRole(companyId, teamId); 751 } 752 753 /** 754 * Returns the team role map for the group. 755 * 756 * @param groupId the primary key of the group 757 * @return the team role map for the group 758 * @throws PortalException if a group with the primary key could not be 759 found, if a role could not be found in one of the group's teams, 760 or if a portal exception occurred 761 */ 762 @Override 763 public java.util.Map<com.liferay.portal.model.Team, com.liferay.portal.model.Role> getTeamRoleMap( 764 long groupId) 765 throws com.liferay.portal.kernel.exception.PortalException { 766 return _roleLocalService.getTeamRoleMap(groupId); 767 } 768 769 /** 770 * Returns the team roles in the group. 771 * 772 * @param groupId the primary key of the group 773 * @return the team roles in the group 774 * @throws PortalException if a group with the primary key could not be 775 found, if a role could not be found in one of the group's teams, 776 or if a portal exception occurred 777 */ 778 @Override 779 public java.util.List<com.liferay.portal.model.Role> getTeamRoles( 780 long groupId) 781 throws com.liferay.portal.kernel.exception.PortalException { 782 return _roleLocalService.getTeamRoles(groupId); 783 } 784 785 /** 786 * Returns the team roles in the group, excluding the specified role IDs. 787 * 788 * @param groupId the primary key of the group 789 * @param excludedRoleIds the primary keys of the roles to exclude 790 (optionally <code>null</code>) 791 * @return the team roles in the group, excluding the specified role IDs 792 * @throws PortalException if a group with the primary key could not be 793 found, if a role could not be found in one of the group's teams, 794 or if a portal exception occurred 795 */ 796 @Override 797 public java.util.List<com.liferay.portal.model.Role> getTeamRoles( 798 long groupId, long[] excludedRoleIds) 799 throws com.liferay.portal.kernel.exception.PortalException { 800 return _roleLocalService.getTeamRoles(groupId, excludedRoleIds); 801 } 802 803 /** 804 * Returns all the roles of the type. 805 * 806 * @param type the role's type (optionally <code>0</code>) 807 * @return the range of the roles of the type 808 */ 809 @Override 810 public java.util.List<com.liferay.portal.model.Role> getTypeRoles(int type) { 811 return _roleLocalService.getTypeRoles(type); 812 } 813 814 /** 815 * Returns a range of all the roles of the type. 816 * 817 * @param type the role's type (optionally <code>0</code>) 818 * @param start the lower bound of the range of roles to return 819 * @param end the upper bound of the range of roles to return (not 820 inclusive) 821 * @return the range of the roles of the type 822 */ 823 @Override 824 public java.util.List<com.liferay.portal.model.Role> getTypeRoles( 825 int type, int start, int end) { 826 return _roleLocalService.getTypeRoles(type, start, end); 827 } 828 829 /** 830 * Returns the number of roles of the type. 831 * 832 * @param type the role's type (optionally <code>0</code>) 833 * @return the number of roles of the type 834 */ 835 @Override 836 public int getTypeRolesCount(int type) { 837 return _roleLocalService.getTypeRolesCount(type); 838 } 839 840 /** 841 * Returns all the user's roles within the user group. 842 * 843 * @param userId the primary key of the user 844 * @param groupId the primary key of the group 845 * @return the user's roles within the user group 846 * @see com.liferay.portal.service.persistence.RoleFinder#findByUserGroupGroupRole( 847 long, long) 848 */ 849 @Override 850 public java.util.List<com.liferay.portal.model.Role> getUserGroupGroupRoles( 851 long userId, long groupId) { 852 return _roleLocalService.getUserGroupGroupRoles(userId, groupId); 853 } 854 855 @Override 856 public java.util.List<com.liferay.portal.model.Role> getUserGroupGroupRoles( 857 long userId, long groupId, int start, int end) { 858 return _roleLocalService.getUserGroupGroupRoles(userId, groupId, start, 859 end); 860 } 861 862 @Override 863 public int getUserGroupGroupRolesCount(long userId, long groupId) { 864 return _roleLocalService.getUserGroupGroupRolesCount(userId, groupId); 865 } 866 867 /** 868 * Returns all the user's roles within the user group. 869 * 870 * @param userId the primary key of the user 871 * @param groupId the primary key of the group 872 * @return the user's roles within the user group 873 * @see com.liferay.portal.service.persistence.RoleFinder#findByUserGroupRole( 874 long, long) 875 */ 876 @Override 877 public java.util.List<com.liferay.portal.model.Role> getUserGroupRoles( 878 long userId, long groupId) { 879 return _roleLocalService.getUserGroupRoles(userId, groupId); 880 } 881 882 /** 883 * Returns the userIds of the users associated with the role. 884 * 885 * @param roleId the roleId of the role 886 * @return long[] the userIds of users associated with the role 887 */ 888 @Override 889 public long[] getUserPrimaryKeys(long roleId) { 890 return _roleLocalService.getUserPrimaryKeys(roleId); 891 } 892 893 /** 894 * Returns all the user's roles within the group. 895 * 896 * @param userId the primary key of the user 897 * @param groupId the primary key of the group 898 * @return the user's roles within the group 899 * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long, 900 long) 901 */ 902 @Override 903 public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles( 904 long userId, long groupId) { 905 return _roleLocalService.getUserRelatedRoles(userId, groupId); 906 } 907 908 /** 909 * Returns the union of all the user's roles within the groups. 910 * 911 * @param userId the primary key of the user 912 * @param groupIds the primary keys of the groups 913 * @return the union of all the user's roles within the groups 914 * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long, 915 long[]) 916 */ 917 @Override 918 public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles( 919 long userId, long[] groupIds) { 920 return _roleLocalService.getUserRelatedRoles(userId, groupIds); 921 } 922 923 /** 924 * Returns the union of all the user's roles within the groups. 925 * 926 * @param userId the primary key of the user 927 * @param groups the groups (optionally <code>null</code>) 928 * @return the union of all the user's roles within the groups 929 * @see com.liferay.portal.service.persistence.RoleFinder#findByU_G(long, 930 List) 931 */ 932 @Override 933 public java.util.List<com.liferay.portal.model.Role> getUserRelatedRoles( 934 long userId, java.util.List<com.liferay.portal.model.Group> groups) { 935 return _roleLocalService.getUserRelatedRoles(userId, groups); 936 } 937 938 @Override 939 public java.util.List<com.liferay.portal.model.Role> getUserRoles( 940 long userId) { 941 return _roleLocalService.getUserRoles(userId); 942 } 943 944 @Override 945 public java.util.List<com.liferay.portal.model.Role> getUserRoles( 946 long userId, int start, int end) { 947 return _roleLocalService.getUserRoles(userId, start, end); 948 } 949 950 @Override 951 public java.util.List<com.liferay.portal.model.Role> getUserRoles( 952 long userId, int start, int end, 953 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> orderByComparator) { 954 return _roleLocalService.getUserRoles(userId, start, end, 955 orderByComparator); 956 } 957 958 @Override 959 public int getUserRolesCount(long userId) { 960 return _roleLocalService.getUserRolesCount(userId); 961 } 962 963 @Override 964 public boolean hasGroupRole(long groupId, long roleId) { 965 return _roleLocalService.hasGroupRole(groupId, roleId); 966 } 967 968 @Override 969 public boolean hasGroupRoles(long groupId) { 970 return _roleLocalService.hasGroupRoles(groupId); 971 } 972 973 /** 974 * Returns <code>true</code> if the user is associated with the named 975 * regular role. 976 * 977 * @param userId the primary key of the user 978 * @param companyId the primary key of the company 979 * @param name the name of the role 980 * @param inherited whether to include the user's inherited roles in the 981 search 982 * @return <code>true</code> if the user is associated with the regular 983 role; <code>false</code> otherwise 984 * @throws PortalException if a default user for the company could not be 985 found 986 */ 987 @Override 988 public boolean hasUserRole(long userId, long companyId, 989 java.lang.String name, boolean inherited) 990 throws com.liferay.portal.kernel.exception.PortalException { 991 return _roleLocalService.hasUserRole(userId, companyId, name, inherited); 992 } 993 994 @Override 995 public boolean hasUserRole(long userId, long roleId) { 996 return _roleLocalService.hasUserRole(userId, roleId); 997 } 998 999 @Override 1000 public boolean hasUserRoles(long userId) { 1001 return _roleLocalService.hasUserRoles(userId); 1002 } 1003 1004 /** 1005 * Returns <code>true</code> if the user has any one of the named regular 1006 * roles. 1007 * 1008 * @param userId the primary key of the user 1009 * @param companyId the primary key of the company 1010 * @param names the names of the roles 1011 * @param inherited whether to include the user's inherited roles in the 1012 search 1013 * @return <code>true</code> if the user has any one of the regular roles; 1014 <code>false</code> otherwise 1015 * @throws PortalException if any one of the roles with the names could not 1016 be found in the company or if the default user for the company 1017 could not be found 1018 */ 1019 @Override 1020 public boolean hasUserRoles(long userId, long companyId, 1021 java.lang.String[] names, boolean inherited) 1022 throws com.liferay.portal.kernel.exception.PortalException { 1023 return _roleLocalService.hasUserRoles(userId, companyId, names, 1024 inherited); 1025 } 1026 1027 /** 1028 * Returns a role with the name in the company. 1029 * 1030 * @param companyId the primary key of the company 1031 * @param name the role's name (optionally <code>null</code>) 1032 * @return the role with the name, or <code>null</code> if a role with the 1033 name could not be found in the company 1034 */ 1035 @Override 1036 public com.liferay.portal.model.Role loadFetchRole(long companyId, 1037 java.lang.String name) { 1038 return _roleLocalService.loadFetchRole(companyId, name); 1039 } 1040 1041 /** 1042 * Returns a role with the name in the company. 1043 * 1044 * @param companyId the primary key of the company 1045 * @param name the role's name 1046 * @return the role with the name in the company 1047 * @throws PortalException if a role with the name could not be found in the 1048 company 1049 */ 1050 @Override 1051 public com.liferay.portal.model.Role loadGetRole(long companyId, 1052 java.lang.String name) 1053 throws com.liferay.portal.kernel.exception.PortalException { 1054 return _roleLocalService.loadGetRole(companyId, name); 1055 } 1056 1057 /** 1058 * Returns an ordered range of all the roles that match the keywords, types, 1059 * and params. 1060 * 1061 * <p> 1062 * Useful when paginating results. Returns a maximum of <code>end - 1063 * start</code> instances. <code>start</code> and <code>end</code> are not 1064 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1065 * refers to the first result in the set. Setting both <code>start</code> 1066 * and <code>end</code> to {@link 1067 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1068 * result set. 1069 * </p> 1070 * 1071 * @param companyId the primary key of the company 1072 * @param keywords the keywords (space separated), which may occur in the 1073 role's name or description (optionally <code>null</code>) 1074 * @param types the role types (optionally <code>null</code>) 1075 * @param params the finder parameters. Can specify values for the 1076 "usersRoles" key. For more information, see {@link 1077 com.liferay.portal.service.persistence.RoleFinder} 1078 * @param start the lower bound of the range of roles to return 1079 * @param end the upper bound of the range of roles to return (not 1080 inclusive) 1081 * @param obc the comparator to order the roles (optionally 1082 <code>null</code>) 1083 * @return the ordered range of the matching roles, ordered by 1084 <code>obc</code> 1085 * @see com.liferay.portal.service.persistence.RoleFinder 1086 */ 1087 @Override 1088 public java.util.List<com.liferay.portal.model.Role> search( 1089 long companyId, java.lang.String keywords, java.lang.Integer[] types, 1090 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1091 int start, int end, 1092 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) { 1093 return _roleLocalService.search(companyId, keywords, types, params, 1094 start, end, obc); 1095 } 1096 1097 /** 1098 * Returns an ordered range of all the roles that match the keywords and 1099 * types. 1100 * 1101 * <p> 1102 * Useful when paginating results. Returns a maximum of <code>end - 1103 * start</code> instances. <code>start</code> and <code>end</code> are not 1104 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1105 * refers to the first result in the set. Setting both <code>start</code> 1106 * and <code>end</code> to {@link 1107 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1108 * result set. 1109 * </p> 1110 * 1111 * @param companyId the primary key of the company 1112 * @param keywords the keywords (space separated), which may occur in the 1113 role's name or description (optionally <code>null</code>) 1114 * @param types the role types (optionally <code>null</code>) 1115 * @param start the lower bound of the range of roles to return 1116 * @param end the upper bound of the range of roles to return (not 1117 inclusive) 1118 * @param obc the comparator to order the roles (optionally 1119 <code>null</code>) 1120 * @return the ordered range of the matching roles, ordered by 1121 <code>obc</code> 1122 * @see com.liferay.portal.service.persistence.RoleFinder 1123 */ 1124 @Override 1125 public java.util.List<com.liferay.portal.model.Role> search( 1126 long companyId, java.lang.String keywords, java.lang.Integer[] types, 1127 int start, int end, 1128 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) { 1129 return _roleLocalService.search(companyId, keywords, types, start, end, 1130 obc); 1131 } 1132 1133 /** 1134 * Returns an ordered range of all the roles that match the name, 1135 * description, types, and params. 1136 * 1137 * <p> 1138 * Useful when paginating results. Returns a maximum of <code>end - 1139 * start</code> instances. <code>start</code> and <code>end</code> are not 1140 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1141 * refers to the first result in the set. Setting both <code>start</code> 1142 * and <code>end</code> to {@link 1143 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1144 * result set. 1145 * </p> 1146 * 1147 * @param companyId the primary key of the company 1148 * @param name the role's name (optionally <code>null</code>) 1149 * @param description the role's description (optionally <code>null</code>) 1150 * @param types the role types (optionally <code>null</code>) 1151 * @param params the finder's parameters. Can specify values for the 1152 "usersRoles" key. For more information, see {@link 1153 com.liferay.portal.service.persistence.RoleFinder} 1154 * @param start the lower bound of the range of the roles to return 1155 * @param end the upper bound of the range of the roles to return (not 1156 inclusive) 1157 * @param obc the comparator to order the roles (optionally 1158 <code>null</code>) 1159 * @return the ordered range of the matching roles, ordered by 1160 <code>obc</code> 1161 * @see com.liferay.portal.service.persistence.RoleFinder 1162 */ 1163 @Override 1164 public java.util.List<com.liferay.portal.model.Role> search( 1165 long companyId, java.lang.String name, java.lang.String description, 1166 java.lang.Integer[] types, 1167 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params, 1168 int start, int end, 1169 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) { 1170 return _roleLocalService.search(companyId, name, description, types, 1171 params, start, end, obc); 1172 } 1173 1174 /** 1175 * Returns an ordered range of all the roles that match the name, 1176 * description, and types. 1177 * 1178 * <p> 1179 * Useful when paginating results. Returns a maximum of <code>end - 1180 * start</code> instances. <code>start</code> and <code>end</code> are not 1181 * primary keys, they are indexes in the result set. Thus, <code>0</code> 1182 * refers to the first result in the set. Setting both <code>start</code> 1183 * and <code>end</code> to {@link 1184 * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full 1185 * result set. 1186 * </p> 1187 * 1188 * @param companyId the primary key of the company 1189 * @param name the role's name (optionally <code>null</code>) 1190 * @param description the role's description (optionally <code>null</code>) 1191 * @param types the role types (optionally <code>null</code>) 1192 * @param start the lower bound of the range of the roles to return 1193 * @param end the upper bound of the range of the roles to return (not 1194 inclusive) 1195 * @param obc the comparator to order the roles (optionally 1196 <code>null</code>) 1197 * @return the ordered range of the matching roles, ordered by 1198 <code>obc</code> 1199 * @see com.liferay.portal.service.persistence.RoleFinder 1200 */ 1201 @Override 1202 public java.util.List<com.liferay.portal.model.Role> search( 1203 long companyId, java.lang.String name, java.lang.String description, 1204 java.lang.Integer[] types, int start, int end, 1205 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.Role> obc) { 1206 return _roleLocalService.search(companyId, name, description, types, 1207 start, end, obc); 1208 } 1209 1210 /** 1211 * Returns the number of roles that match the keywords and types. 1212 * 1213 * @param companyId the primary key of the company 1214 * @param keywords the keywords (space separated), which may occur in the 1215 role's name or description (optionally <code>null</code>) 1216 * @param types the role types (optionally <code>null</code>) 1217 * @return the number of matching roles 1218 */ 1219 @Override 1220 public int searchCount(long companyId, java.lang.String keywords, 1221 java.lang.Integer[] types) { 1222 return _roleLocalService.searchCount(companyId, keywords, types); 1223 } 1224 1225 /** 1226 * Returns the number of roles that match the keywords, types and params. 1227 * 1228 * @param companyId the primary key of the company 1229 * @param keywords the keywords (space separated), which may occur in the 1230 role's name or description (optionally <code>null</code>) 1231 * @param types the role types (optionally <code>null</code>) 1232 * @param params the finder parameters. For more information, see {@link 1233 com.liferay.portal.service.persistence.RoleFinder} 1234 * @return the number of matching roles 1235 */ 1236 @Override 1237 public int searchCount(long companyId, java.lang.String keywords, 1238 java.lang.Integer[] types, 1239 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 1240 return _roleLocalService.searchCount(companyId, keywords, types, params); 1241 } 1242 1243 /** 1244 * Returns the number of roles that match the name, description, and types. 1245 * 1246 * @param companyId the primary key of the company 1247 * @param name the role's name (optionally <code>null</code>) 1248 * @param description the role's description (optionally <code>null</code>) 1249 * @param types the role types (optionally <code>null</code>) 1250 * @return the number of matching roles 1251 */ 1252 @Override 1253 public int searchCount(long companyId, java.lang.String name, 1254 java.lang.String description, java.lang.Integer[] types) { 1255 return _roleLocalService.searchCount(companyId, name, description, types); 1256 } 1257 1258 /** 1259 * Returns the number of roles that match the name, description, types, and 1260 * params. 1261 * 1262 * @param companyId the primary key of the company 1263 * @param name the role's name (optionally <code>null</code>) 1264 * @param description the role's description (optionally <code>null</code>) 1265 * @param types the role types (optionally <code>null</code>) 1266 * @param params the finder parameters. Can specify values for the 1267 "usersRoles" key. For more information, see {@link 1268 com.liferay.portal.service.persistence.RoleFinder} 1269 * @return the number of matching roles 1270 */ 1271 @Override 1272 public int searchCount(long companyId, java.lang.String name, 1273 java.lang.String description, java.lang.Integer[] types, 1274 java.util.LinkedHashMap<java.lang.String, java.lang.Object> params) { 1275 return _roleLocalService.searchCount(companyId, name, description, 1276 types, params); 1277 } 1278 1279 /** 1280 * Sets the Spring bean ID for this bean. 1281 * 1282 * @param beanIdentifier the Spring bean ID for this bean 1283 */ 1284 @Override 1285 public void setBeanIdentifier(java.lang.String beanIdentifier) { 1286 _roleLocalService.setBeanIdentifier(beanIdentifier); 1287 } 1288 1289 @Override 1290 public void setGroupRoles(long groupId, long[] roleIds) { 1291 _roleLocalService.setGroupRoles(groupId, roleIds); 1292 } 1293 1294 /** 1295 * @throws PortalException 1296 */ 1297 @Override 1298 public void setUserRoles(long userId, long[] roleIds) 1299 throws com.liferay.portal.kernel.exception.PortalException { 1300 _roleLocalService.setUserRoles(userId, roleIds); 1301 } 1302 1303 /** 1304 * Removes the matching roles associated with the user. The user is 1305 * reindexed after the roles are removed. 1306 * 1307 * @param userId the primary key of the user 1308 * @param roleIds the primary keys of the roles 1309 * @throws PortalException if a user with the primary key could not be found 1310 or if a role with any one of the primary keys could not be found 1311 */ 1312 @Override 1313 public void unsetUserRoles(long userId, long[] roleIds) 1314 throws com.liferay.portal.kernel.exception.PortalException { 1315 _roleLocalService.unsetUserRoles(userId, roleIds); 1316 } 1317 1318 /** 1319 * Updates the role in the database or adds it if it does not yet exist. Also notifies the appropriate model listeners. 1320 * 1321 * @param role the role 1322 * @return the role that was updated 1323 */ 1324 @Override 1325 public com.liferay.portal.model.Role updateRole( 1326 com.liferay.portal.model.Role role) { 1327 return _roleLocalService.updateRole(role); 1328 } 1329 1330 /** 1331 * Updates the role with the primary key. 1332 * 1333 * @param roleId the primary key of the role 1334 * @param name the role's new name 1335 * @param titleMap the new localized titles (optionally <code>null</code>) 1336 to replace those existing for the role 1337 * @param descriptionMap the new localized descriptions (optionally 1338 <code>null</code>) to replace those existing for the role 1339 * @param subtype the role's new subtype (optionally <code>null</code>) 1340 * @param serviceContext the service context to be applied (optionally 1341 <code>null</code>). Can set expando bridge attributes for the 1342 role. 1343 * @return the role with the primary key 1344 * @throws PortalException if a role with the primary could not be found or 1345 if the role's name was invalid 1346 */ 1347 @Override 1348 public com.liferay.portal.model.Role updateRole(long roleId, 1349 java.lang.String name, 1350 java.util.Map<java.util.Locale, java.lang.String> titleMap, 1351 java.util.Map<java.util.Locale, java.lang.String> descriptionMap, 1352 java.lang.String subtype, 1353 com.liferay.portal.service.ServiceContext serviceContext) 1354 throws com.liferay.portal.kernel.exception.PortalException { 1355 return _roleLocalService.updateRole(roleId, name, titleMap, 1356 descriptionMap, subtype, serviceContext); 1357 } 1358 1359 /** 1360 * @deprecated As of 6.1.0, replaced by {@link #getWrappedService} 1361 */ 1362 @Deprecated 1363 public RoleLocalService getWrappedRoleLocalService() { 1364 return _roleLocalService; 1365 } 1366 1367 /** 1368 * @deprecated As of 6.1.0, replaced by {@link #setWrappedService} 1369 */ 1370 @Deprecated 1371 public void setWrappedRoleLocalService(RoleLocalService roleLocalService) { 1372 _roleLocalService = roleLocalService; 1373 } 1374 1375 @Override 1376 public RoleLocalService getWrappedService() { 1377 return _roleLocalService; 1378 } 1379 1380 @Override 1381 public void setWrappedService(RoleLocalService roleLocalService) { 1382 _roleLocalService = roleLocalService; 1383 } 1384 1385 private RoleLocalService _roleLocalService; 1386 }