@Override public RoleModel getRoleById(String id) { if (updated != null) return updated.getRoleById(id); return cacheSession.getRoleById(id, this); }
@Override public Set<RoleModel> getRoleMappings(RealmModel realm, String userId) { Set<RoleModel> set = new HashSet<>(); TypedQuery<FederatedUserRoleMappingEntity> query = em.createNamedQuery("feduserRoleMappings", FederatedUserRoleMappingEntity.class); query.setParameter("userId", userId); List<FederatedUserRoleMappingEntity> results = query.getResultList(); if (results.size() == 0) return set; for (FederatedUserRoleMappingEntity entity : results) { RoleModel role = realm.getRoleById(entity.getRoleId()); set.add(role); } return set; }
@Override public Set<RoleModel> getScopeMappings() { TypedQuery<String> query = em.createNamedQuery("clientScopeRoleMappingIds", String.class); query.setParameter("clientScope", getEntity()); List<String> ids = query.getResultList(); Set<RoleModel> roles = new HashSet<RoleModel>(); for (String roleId : ids) { RoleModel role = realm.getRoleById(roleId); if (role == null) continue; roles.add(role); } return roles; }
@Override public Set<RoleModel> getRoleMappings() { // we query ids only as the role might be cached and following the @ManyToOne will result in a load // even if we're getting just the id. TypedQuery<String> query = em.createNamedQuery("userRoleMappingIds", String.class); query.setParameter("user", getEntity()); List<String> ids = query.getResultList(); Set<RoleModel> roles = new HashSet<RoleModel>(); for (String roleId : ids) { RoleModel roleById = realm.getRoleById(roleId); if (roleById == null) continue; roles.add(roleById); } return roles; }
@Override public Set<RoleModel> getRoleMappings() { // we query ids only as the role might be cached and following the @ManyToOne will result in a load // even if we're getting just the id. TypedQuery<String> query = em.createNamedQuery("groupRoleMappingIds", String.class); query.setParameter("group", getEntity()); List<String> ids = query.getResultList(); Set<RoleModel> roles = new HashSet<RoleModel>(); for (String roleId : ids) { RoleModel roleById = realm.getRoleById(roleId); if (roleById == null) continue; roles.add(roleById); } return roles; }
@Override public Set<RoleModel> getComposites() { if (updated != null) return updated.getComposites(); Set<RoleModel> set = new HashSet<RoleModel>(); for (String id : cached.getComposites()) { RoleModel role = realm.getRoleById(id); if (role == null) { throw new IllegalStateException("Could not find composite: " + id); } set.add(role); } return set; }
public static List<RoleModel> getAllRolesOfUser(RealmModel realm, UserModel user) { MongoUserEntity userEntity = ((UserAdapter)user).getUser(); List<String> roleIds = userEntity.getRoleIds(); if (roleIds == null || roleIds.isEmpty()) { return Collections.emptyList(); } List<RoleModel> roles = new LinkedList<RoleModel>(); for (String roleId : roleIds) { RoleModel role = realm.getRoleById(roleId); if (role != null) { roles.add(role); } } return roles; }
private void addScopes(RealmModel realm, ClientModel client, ClientEntity clientEntity) { for (String scopeId : clientEntity.getScopeIds()) { RoleModel scope = realm.getRoleById(scopeId); client.addScopeMapping(scope); } }
@Override public RoleModel getRoleById(String id) { if (isUpdated()) return updated.getRoleById(id); return cacheSession.getRoleById(id, this); }
@Override public Set<RoleModel> getRoleMappings(RealmModel realm, String userId) { FederatedUser userEntity = getUserById(userId); if (userEntity == null || userEntity.getRoleIds() == null || userEntity.getRoleIds().isEmpty()) return Collections.EMPTY_SET; Set<RoleModel> roles = new HashSet<>(); for (String roleId : userEntity.getRoleIds()) { RoleModel role = realm.getRoleById(roleId); if (role != null) roles.add(role); } return roles; }
@Override public Set<RoleModel> getRoleMappings() { if (group.getRoleIds() == null || group.getRoleIds().isEmpty()) return Collections.EMPTY_SET; Set<RoleModel> roles = new HashSet<>(); for (String id : group.getRoleIds()) { RoleModel roleById = realm.getRoleById(id); if (roleById == null) { throw new ModelException("role does not exist in group role mappings"); } roles.add(roleById); } return roles; }
@Override public Set<RoleModel> getComposites() { if (isUpdated()) return updated.getComposites(); if (composites == null) { composites = new HashSet<RoleModel>(); for (String id : cached.getComposites()) { RoleModel role = realm.getRoleById(id); if (role == null) { throw new IllegalStateException("Could not find composite in role " + getName() + ": " + id); } composites.add(role); } } return composites; }
private void fillCompositeRoles(Map<String, RoleEntity> rolesMap, RoleContainerModel roleContainer, RealmModel realm) { for (RoleModel role : roleContainer.getRoles()) { RoleEntity roleEntity = rolesMap.get(role.getId()); if (roleEntity.getCompositeRoleIds() == null) { continue; } for (String compositeRoleId : roleEntity.getCompositeRoleIds()) { RoleModel compositeRole = realm.getRoleById(compositeRoleId); role.addCompositeRole(compositeRole); } } }
role = realm.getRoleById(roleName);
@Override public void onExport(Policy policy, PolicyRepresentation representation, AuthorizationProvider authorizationProvider) { Map<String, String> config = new HashMap<>(); Set<RolePolicyRepresentation.RoleDefinition> roles = toRepresentation(policy, authorizationProvider).getRoles(); for (RolePolicyRepresentation.RoleDefinition roleDefinition : roles) { RoleModel role = authorizationProvider.getRealm().getRoleById(roleDefinition.getId()); if (role.isClientRole()) { roleDefinition.setId(ClientModel.class.cast(role.getContainer()).getClientId() + "/" + role.getName()); } else { roleDefinition.setId(role.getName()); } } try { config.put("roles", JsonSerialization.writeValueAsString(roles)); } catch (IOException cause) { throw new RuntimeException("Failed to export role policy [" + policy.getName() + "]", cause); } representation.setConfig(config); }
RoleModel role = realm.getRoleById(definition.getId());
@Override public void evaluate(Evaluation evaluation) { Policy policy = evaluation.getPolicy(); Set<RolePolicyRepresentation.RoleDefinition> roleIds = representationFunction.apply(policy, evaluation.getAuthorizationProvider()).getRoles(); AuthorizationProvider authorizationProvider = evaluation.getAuthorizationProvider(); RealmModel realm = authorizationProvider.getKeycloakSession().getContext().getRealm(); Identity identity = evaluation.getContext().getIdentity(); for (RolePolicyRepresentation.RoleDefinition roleDefinition : roleIds) { RoleModel role = realm.getRoleById(roleDefinition.getId()); if (role != null) { boolean hasRole = hasRole(identity, role, realm); if (!hasRole && roleDefinition.isRequired()) { evaluation.deny(); return; } else if (hasRole) { evaluation.grant(); } } } }
RoleModel role = realm.getRoleById(roleId); user.grantRole(role);
private UserConsentModel toConsentModel(RealmModel realm, UserConsentEntity entity) { ClientModel client = realm.getClientById(entity.getClientId()); if (client == null) { throw new ModelException("Client with id " + entity.getClientId() + " is not available"); } UserConsentModel model = new UserConsentModel(client); model.setCreatedDate(entity.getCreatedDate()); model.setLastUpdatedDate(entity.getLastUpdatedDate()); for (String roleId : entity.getGrantedRoles()) { RoleModel roleModel = realm.getRoleById(roleId); if (roleModel != null) { model.addGrantedRole(roleModel); } } for (String protMapperId : entity.getGrantedProtocolMappers()) { ProtocolMapperModel protocolMapper = client.getProtocolMapperById(protMapperId); model.addGrantedProtocolMapper(protocolMapper); } return model; }