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