Source code

001package org.apache.archiva.redback.rest.services.v2;
002/*
003 * Licensed to the Apache Software Foundation (ASF) under one
004 * or more contributor license agreements.  See the NOTICE file
005 * distributed with this work for additional information
006 * regarding copyright ownership.  The ASF licenses this file
007 * to you under the Apache License, Version 2.0 (the
008 * "License"); you may not use this file except in compliance
009 * with the License.  You may obtain a copy of the License at
010 *
011 *   http://www.apache.org/licenses/LICENSE-2.0
012 *
013 * Unless required by applicable law or agreed to in writing,
014 * software distributed under the License is distributed on an
015 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
016 * KIND, either express or implied.  See the License for the
017 * specific language governing permissions and limitations
018 * under the License.
019 */
020
021import org.apache.archiva.components.rest.model.PagedResult;
022import org.apache.archiva.components.rest.util.QueryHelper;
023import org.apache.archiva.components.rest.util.RestUtil;
024import org.apache.archiva.redback.rbac.RBACManager;
025import org.apache.archiva.redback.rbac.RbacManagerException;
026import org.apache.archiva.redback.rbac.RbacObjectNotFoundException;
027import org.apache.archiva.redback.rest.api.MessageKeys;
028import org.apache.archiva.redback.rest.api.model.ErrorMessage;
029import org.apache.archiva.redback.rest.api.model.v2.Role;
030import org.apache.archiva.redback.rest.api.model.v2.RoleInfo;
031import org.apache.archiva.redback.rest.api.model.v2.RoleTemplate;
032import org.apache.archiva.redback.rest.api.model.v2.UserInfo;
033import org.apache.archiva.redback.rest.api.services.RedbackServiceException;
034import org.apache.archiva.redback.rest.api.services.v2.RoleService;
035import org.apache.archiva.redback.role.PermanentRoleDeletionInvalid;
036import org.apache.archiva.redback.role.RoleExistsException;
037import org.apache.archiva.redback.role.RoleManager;
038import org.apache.archiva.redback.role.RoleManagerException;
039import org.apache.archiva.redback.role.RoleNotFoundException;
040import org.apache.archiva.redback.role.util.RoleModelUtils;
041import org.apache.archiva.redback.users.User;
042import org.apache.archiva.redback.users.UserManager;
043import org.apache.archiva.redback.users.UserManagerException;
044import org.apache.archiva.redback.users.UserNotFoundException;
045import org.apache.commons.lang3.StringUtils;
046import org.slf4j.Logger;
047import org.slf4j.LoggerFactory;
048import org.springframework.stereotype.Service;
049
050import javax.inject.Inject;
051import javax.inject.Named;
052import javax.servlet.http.HttpServletRequest;
053import javax.servlet.http.HttpServletResponse;
054import javax.ws.rs.core.Context;
055import javax.ws.rs.core.Response;
056import javax.ws.rs.core.UriInfo;
057import java.util.Comparator;
058import java.util.HashMap;
059import java.util.List;
060import java.util.Map;
061import java.util.Optional;
062import java.util.Set;
063import java.util.function.BiPredicate;
064import java.util.function.Predicate;
065import java.util.stream.Collectors;
066
067/**
068 * @author Olivier Lamy
069 * @since 1.3
070 */
071@Service("v2.roleService#rest")
072public class DefaultRoleService extends BaseRedbackService
073    implements RoleService
074{
075
076    private Logger log = LoggerFactory.getLogger( DefaultRoleService.class );
077
078    private RoleManager roleManager;
079
080    @Context
081    private HttpServletRequest httpServletRequest;
082
083    @Context
084    private HttpServletResponse httpServletResponse;
085
086    @Context
087    private UriInfo uriInfo;
088
089    private static final String[] DEFAULT_SEARCH_FIELDS = {"id", "name", "description"};
090    private static final Map<String, BiPredicate<String, org.apache.archiva.redback.rbac.Role>> FILTER_MAP = new HashMap<>( );
091    private static final Map<String, Comparator<org.apache.archiva.redback.rbac.Role>> ORDER_MAP = new HashMap<>( );
092    private static final QueryHelper<org.apache.archiva.redback.rbac.Role> QUERY_HELPER;
093
094    static
095    {
096
097        QUERY_HELPER = new QueryHelper<>( FILTER_MAP, ORDER_MAP, DEFAULT_SEARCH_FIELDS );
098        QUERY_HELPER.addStringFilter( "id", org.apache.archiva.redback.rbac.Role::getId );
099        QUERY_HELPER.addStringFilter( "name", org.apache.archiva.redback.rbac.Role::getName );
100        QUERY_HELPER.addStringFilter( "description", org.apache.archiva.redback.rbac.Role::getDescription );
101        QUERY_HELPER.addBooleanFilter( "assignable", org.apache.archiva.redback.rbac.Role::isAssignable );
102
103        // The simple Comparator.comparing(attribute) is not null safe
104        // As there are attributes that may have a null value, we have to use a comparator with nullsLast(naturalOrder)
105        // and the wrapping Comparator.nullsLast(Comparator.comparing(attribute)) does not work, because the attribute is not checked by the nullsLast-Comparator
106        QUERY_HELPER.addNullsafeFieldComparator( "name", org.apache.archiva.redback.rbac.Role::getName );
107        QUERY_HELPER.addNullsafeFieldComparator( "id", org.apache.archiva.redback.rbac.Role::getId );
108        QUERY_HELPER.addNullsafeFieldComparator( "resource", org.apache.archiva.redback.rbac.Role::getResource );
109        QUERY_HELPER.addNullsafeFieldComparator( "assignable", org.apache.archiva.redback.rbac.Role::isAssignable );
110        QUERY_HELPER.addNullsafeFieldComparator( "description", org.apache.archiva.redback.rbac.Role::getDescription );
111        QUERY_HELPER.addNullsafeFieldComparator( "template_instance", org.apache.archiva.redback.rbac.Role::isTemplateInstance );
112    }
113
114    @Inject
115    public DefaultRoleService( RoleManager roleManager,
116                               @Named(value = "rbacManager#default") RBACManager rbacManager,
117                               @Named(value = "userManager#default") UserManager userManager )
118    {
119        super( rbacManager, userManager );
120        this.roleManager = roleManager;
121
122        log.debug( "use rbacManager impl: {}", rbacManager.getClass().getName() );
123        log.debug( "use userManager impl: {}", userManager.getClass().getName() );
124    }
125
126    @Override
127    public PagedResult<RoleInfo> getAllRoles( String searchTerm, Integer offset, Integer limit, List<String> orderBy, String order ) throws RedbackServiceException
128    {
129        boolean ascending = isAscending( order );
130        try
131        {
132            // UserQuery does not work here, because the configurable user manager does only return the query for
133            // the first user manager in the list. So we have to fetch the whole role list
134            List<? extends org.apache.archiva.redback.rbac.Role> rawRoles = rbacManager.getAllRoles( );
135            Predicate<org.apache.archiva.redback.rbac.Role> filter = QUERY_HELPER.getQueryFilter( searchTerm );
136            long size = rawRoles.stream( ).filter( filter ).count( );
137            List<RoleInfo> users = rawRoles.stream( )
138                .filter( filter )
139                .sorted( QUERY_HELPER.getComparator( orderBy, ascending ) ).skip( offset ).limit( limit )
140                .map( role -> {
141                    try
142                    {
143                        return Optional.of( getRoleInfo( role ) );
144                    }
145                    catch ( RedbackServiceException e )
146                    {
147                        return Optional.<RoleInfo>empty();
148                    }
149                } ).filter(Optional::isPresent)
150                .map(Optional::get)
151                .collect( Collectors.toList( ) );
152            return new PagedResult<>( (int) size, offset, limit, users );
153        }
154        catch ( RbacManagerException e )
155        {
156            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL , e.getMessage( )) );
157        }
158
159    }
160
161    @Override
162    public RoleInfo getRole( String roleId ) throws RedbackServiceException
163    {
164        try
165        {
166            org.apache.archiva.redback.rbac.Role rbacRole = rbacManager.getRoleById( roleId );
167            RoleInfo role = getRoleInfo( rbacRole );
168            return role;
169        }
170        catch ( RbacObjectNotFoundException e )
171        {
172            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, roleId ), 404 );
173        }
174        catch ( RbacManagerException e )
175        {
176            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
177        }
178    }
179
180    @Override
181    public Response checkRole( String roleId ) throws RedbackServiceException
182    {
183        try
184        {
185            org.apache.archiva.redback.rbac.Role rbacRole = rbacManager.getRoleById( roleId );
186            if (rbacRole==null) {
187                return Response.status( 404 ).build();
188            } else
189            {
190                return Response.ok( ).build( );
191            }
192        }
193        catch ( RbacObjectNotFoundException e )
194        {
195            return Response.status( 404 ).build();
196        }
197        catch ( RbacManagerException e )
198        {
199            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
200        }
201    }
202
203
204
205    @Override
206    public RoleInfo moveTemplatedRole( String templateId, String oldResource, String newResource )
207        throws RedbackServiceException
208    {
209        try
210        {
211            if (StringUtils.isEmpty( templateId ) || StringUtils.isEmpty( oldResource ) || StringUtils.isEmpty( newResource )) {
212                throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND ), 404 );
213            }
214            boolean sourceExists = roleManager.templatedRoleExists( templateId, oldResource );
215            if (!sourceExists) {
216                throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_INSTANCE_NOT_FOUND, templateId, oldResource ), 404 );
217            }
218            boolean destExists = roleManager.templatedRoleExists( templateId, newResource );
219            if (destExists) {
220                httpServletResponse.setHeader( "Location", uriInfo.getAbsolutePathBuilder().path("../../..").path(newResource).build(  ).normalize().toString() );
221                throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_INSTANCE_EXISTS, templateId, newResource ), 303 );
222            }
223            String roleId = roleManager.moveTemplatedRole( templateId, oldResource, newResource );
224            httpServletResponse.setHeader( "Location", uriInfo.getAbsolutePathBuilder().path("../../..").path(newResource).build(  ).normalize().toString() );
225            httpServletResponse.setStatus( 201 );
226            return getRoleInfo( rbacManager.getRoleById( roleId ) );
227        }
228        catch ( RoleExistsException e ) {
229            httpServletResponse.setHeader( "Location", uriInfo.getAbsolutePathBuilder().path("../../..").path(newResource).build(  ).normalize().toString() );
230            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_INSTANCE_EXISTS, templateId, newResource ), 303 );
231        }
232        catch ( RoleManagerException e )
233        {
234            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLEMANAGER_FAIL, e.getMessage( ) ) );
235        }
236        catch ( RbacManagerException e )
237        {
238            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
239        }
240    }
241
242
243    @Override
244    public Response checkTemplateRole( String templateId, String resource )
245        throws RedbackServiceException
246    {
247        try
248        {
249            if (roleManager.templatedRoleExists( templateId, resource )) {
250                return Response.ok( ).build( );
251            } else {
252                return Response.status( 404 ).build();
253            }
254        }
255        catch ( RoleManagerException e )
256        {
257            throw new RedbackServiceException( e.getMessage() );
258        }
259
260    }
261
262    @Override
263    public RoleInfo createTemplatedRole( String templateId, String resource )
264        throws RedbackServiceException
265    {
266        if (StringUtils.isEmpty( templateId )) {
267            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND ), 404 );
268        }
269        if (StringUtils.isEmpty( resource )) {
270            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND ), 404 );
271        }
272        try
273        {
274            boolean exists = roleManager.templatedRoleExists( templateId, resource );
275            String roleId = roleManager.createTemplatedRole( templateId, resource );
276            httpServletResponse.setHeader( "Location", uriInfo.getAbsolutePathBuilder().path("../../..").path(roleId).build(  ).normalize().toString() );
277            if (exists)
278            {
279                httpServletResponse.setStatus( 200 );
280            } else {
281                httpServletResponse.setStatus( 201 );
282            }
283            return getRoleInfo( rbacManager.getRoleById( roleId ) );
284        } catch (RoleNotFoundException e) {
285            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, templateId, resource ), 404 );
286        } catch (RoleExistsException e) {
287            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_INSTANCE_EXISTS, templateId, resource ), 303 );
288        }
289        catch ( RoleManagerException e )
290        {
291            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLEMANAGER_FAIL, e.getMessage( ) ) );
292        }
293        catch ( RbacManagerException e )
294        {
295            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
296        }
297    }
298
299    @Override
300    public Response removeTemplatedRole( String templateId, String resource )
301        throws RedbackServiceException
302    {
303
304        try
305        {
306            roleManager.removeTemplatedRole( templateId, resource );
307            return Response.ok( ).build( );
308        }
309        catch ( PermanentRoleDeletionInvalid e ) {
310            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_DELETION_WITH_PERMANENT_FLAG, RoleModelUtils.getRoleId( templateId, resource ) ), 400 );
311        }
312        catch ( RoleNotFoundException e ) {
313            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_INSTANCE_NOT_FOUND, templateId, resource ), 404 );
314        }
315        catch ( RoleManagerException e )
316        {
317            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLEMANAGER_FAIL, e.getMessage( ) ) );
318        }
319    }
320
321
322
323    @Override
324    public RoleInfo assignRole( String roleId, String userId )
325        throws RedbackServiceException
326    {
327        try
328        {
329            userManager.findUser( userId );
330            roleManager.assignRole( roleId, userId );
331            return getRoleInfo( rbacManager.getRoleById( roleId ) );
332        }
333        catch ( RoleNotFoundException e ) {
334            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, e.getMessage( ) ), 404 );
335        }
336        catch ( RoleManagerException e )
337        {
338            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLEMANAGER_FAIL, e.getMessage( ) ) );
339        }
340        catch ( UserNotFoundException e )
341        {
342            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_USER_NOT_FOUND, e.getMessage( ) ), 404 );
343        }
344        catch ( UserManagerException e )
345        {
346            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_USERMANAGER_FAIL, e.getMessage( ) ) );
347        }
348        catch ( RbacObjectNotFoundException e )
349        {
350            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
351        }
352        catch ( RbacManagerException e )
353        {
354            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
355        }
356    }
357
358
359    @Override
360    public RoleInfo assignTemplatedRole( String templateId, String resource, String userId )
361        throws RedbackServiceException
362    {
363        try
364        {
365            userManager.findUser( userId );
366            roleManager.assignTemplatedRole( templateId, resource, userId );
367            String roleId = RoleModelUtils.getRoleId( templateId, resource );
368            return getRoleInfo( rbacManager.getRoleById( roleId ) );
369
370        }
371        catch ( RoleNotFoundException e ) {
372            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, e.getMessage( ) ), 404 );
373        }
374        catch ( RoleManagerException e )
375        {
376            throw new RedbackServiceException( e.getMessage() );
377        }
378        catch ( UserNotFoundException e )
379        {
380            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_USER_NOT_FOUND, e.getMessage( ) ), 404 );
381        }
382        catch ( UserManagerException e )
383        {
384            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_USERMANAGER_FAIL, e.getMessage( ) ) );
385        }
386        catch ( RbacObjectNotFoundException e )
387        {
388            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
389        }
390        catch ( RbacManagerException e )
391        {
392            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
393        }
394    }
395
396    @Override
397    public RoleInfo deleteRoleAssignment( String roleId, String userId )
398        throws RedbackServiceException
399    {
400        try
401        {
402            userManager.findUser( userId );
403            roleManager.unassignRole( roleId, userId );
404            return getRoleInfo( rbacManager.getRoleById( roleId ) );
405        }
406        catch ( RoleNotFoundException e ) {
407            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, e.getMessage( ) ), 404 );
408        }
409        catch ( RoleManagerException e )
410        {
411            throw new RedbackServiceException( e.getMessage() );
412        }
413        catch ( UserNotFoundException e )
414        {
415            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_USER_NOT_FOUND, e.getMessage( ) ), 404 );
416        }
417        catch ( UserManagerException e )
418        {
419            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_USERMANAGER_FAIL, e.getMessage( ) ) );
420        }
421        catch ( RbacObjectNotFoundException e )
422        {
423            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, e.getMessage( ) ), 404 );
424        }
425        catch ( RbacManagerException e )
426        {
427            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
428        }
429    }
430
431    @Override
432    public PagedResult<UserInfo> getRoleUsers( String roleId, String recurse,
433                                               String searchTerm, Integer offset, Integer limit, List<String> orderBy, String order )  throws RedbackServiceException
434    {
435        boolean ascending = isAscending( order );
436        boolean recursePresent = RestUtil.isFlagSet( uriInfo, "recurse" );
437        boolean parentsOnly = "parentsOnly".equals( recurse );
438        try
439        {
440            org.apache.archiva.redback.rbac.Role rbacRole = rbacManager.getRoleById( roleId );
441            List<User> rawUsers = recursePresent ? getAssignedRedbackUsersRecursive( rbacRole, parentsOnly ) : getAssignedRedbackUsers( rbacRole );
442            return getUserInfoPagedResult( rawUsers, searchTerm, offset, limit, orderBy, ascending );
443        }
444        catch ( RbacObjectNotFoundException e )
445        {
446            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, e.getMessage( ) ), 404 );
447        }
448        catch ( RbacManagerException e )
449        {
450            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
451        }
452    }
453
454    @Override
455    public PagedResult<UserInfo> getUnassignedUsers( String roleId, String recurse, String searchTerm, Integer offset, Integer limit, List<String> orderBy, String order ) throws RedbackServiceException
456    {
457        boolean ascending = isAscending( order );
458        boolean recursePresent = RestUtil.isFlagSet( uriInfo, "recurse" );
459        boolean parentsOnly = "parentsOnly".equals( recurse );
460        try
461        {
462            org.apache.archiva.redback.rbac.Role rbacRole = rbacManager.getRoleById( roleId );
463            final Set<String> assignedUsers = (recursePresent ? getAssignedRedbackUsersRecursive( rbacRole, parentsOnly ) : getAssignedRedbackUsers( rbacRole ))
464                .stream( ).map( user -> user.getId()  ).collect( Collectors.toSet());
465            List<? extends User> rawUsers = userManager.getUsers( ascending ).stream( ).filter( user -> !assignedUsers.contains( user.getId( ) ) ).collect( Collectors.toList( ) );
466            return getUserInfoPagedResult( rawUsers, searchTerm, offset, limit, orderBy, ascending );
467        }
468        catch ( RbacObjectNotFoundException e )
469        {
470            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, e.getMessage( ) ), 404 );
471        }
472        catch ( RbacManagerException e )
473        {
474            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage( ) ) );
475        }
476        catch ( UserManagerException e )
477        {
478            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_USERMANAGER_FAIL, e.getMessage( ) ) );
479        }
480    }
481
482    @Override
483    public RoleInfo updateRole( String roleId, Role role ) throws RedbackServiceException
484    {
485        try
486        {
487            if (role==null) {
488                throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_EMPTY_DATA ), 400 );
489            }
490            if ( !StringUtils.equals( roleId, role.getId( ) ) )
491            {
492                throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_ID_INVALID ), 422 );
493            }
494            org.apache.archiva.redback.rbac.Role rbacRole = rbacManager.getRoleById( roleId );
495            if (StringUtils.isNotEmpty( role.getName()) && !StringUtils.equals(rbacRole.getName(), role.getName()) ) {
496                rbacRole.setName( role.getName( ) );
497            }
498            if (StringUtils.isNotEmpty( role.getDescription()) && !StringUtils.equals(rbacRole.getDescription(), role.getDescription()) ) {
499                rbacRole.setDescription( role.getDescription( ) );
500            }
501            if (role.isPermanent()!=null && rbacRole.isPermanent()!=role.isPermanent().booleanValue()) {
502                rbacRole.setPermanent( role.isPermanent( ) );
503            }
504            if (role.isAssignable()!=null && rbacRole.isAssignable()!=role.isAssignable().booleanValue()) {
505                rbacRole.setAssignable( role.isAssignable( ) );
506            }
507            if (role.getAssignedUsers()!=null && role.getAssignedUsers().size()>0) {
508                role.getAssignedUsers().stream().forEach( user ->
509                {
510                    try
511                    {
512                        roleManager.assignRole( role.getId( ), user.getUserId( ) );
513                    }
514                    catch ( RoleManagerException e )
515                    {
516                        // silently ignore
517                    }
518                }
519                );
520            }
521            org.apache.archiva.redback.rbac.Role updatedRole = rbacManager.saveRole( rbacRole );
522            return getRoleInfo( updatedRole );
523        }
524        catch (RbacObjectNotFoundException e) {
525            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_ROLE_NOT_FOUND, roleId ), 404 );
526        }
527        catch ( RbacManagerException e )
528        {
529            throw new RedbackServiceException( ErrorMessage.of( MessageKeys.ERR_RBACMANAGER_FAIL, e.getMessage() ));
530        }
531    }
532
533
534    @Override
535    public List<RoleTemplate> getTemplates( ) throws RedbackServiceException
536    {
537        return roleManager.getModel( ).getApplications( ).stream( ).flatMap( app ->
538            app.getTemplates( ).stream( ).map( modelTempl -> RoleTemplate.of( app, modelTempl ) )
539        ).collect( Collectors.toList( ) );
540    }
541
542
543}