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    }