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