Java Code Examples for org.keycloak.representations.idm.RoleRepresentation#getName()

public void update(String realm, RoleRepresentation realmRole, Set<String> realmComposites) {
    String roleName = realmRole.getName();

    Set<String> existingRealmCompositeNames = findRealmRoleRealmCompositeNames(realm, roleName);

    if (Objects.equals(realmComposites, existingRealmCompositeNames)) {
        logger.debug("No need to update realm-level role '{}'s composites realm-roles in realm '{}'", roleName, realm);
    } else {
        logger.debug("Update realm-level role '{}'s composites realm-roles in realm '{}'", roleName, realm);

        updateRealmRoleRealmComposites(realm, roleName, existingRealmCompositeNames, realmComposites);
    }
}
 

public void update(String realm, String roleClientId, RoleRepresentation clientRole, Set<String> realmComposites) {
    String roleName = clientRole.getName();
    Set<String> existingRealmCompositeNames = findClientRoleRealmCompositeNames(realm, roleClientId, roleName);

    if (Objects.equals(realmComposites, existingRealmCompositeNames)) {
        logger.debug("No need to update client-level role '{}'s composites realm-roles in realm '{}'", roleName, realm);
    } else {
        logger.debug("Update client-level role '{}'s composites realm-roles in realm '{}'", roleName, realm);
        updateClientRoleRealmComposites(realm, roleClientId, roleName, realmComposites, existingRealmCompositeNames);
    }
}
 

private void createOrUpdateRealmRole(String realm, RoleRepresentation role) {
    String roleName = role.getName();

    Optional<RoleRepresentation> maybeRole = roleRepository.tryToFindRealmRole(realm, roleName);

    if (maybeRole.isPresent()) {
        updateClientIfNeeded(realm, maybeRole.get(), role);
    } else {
        logger.debug("Create realm-level role '{}' in realm '{}'", roleName, realm);
        roleRepository.createRealmRole(realm, role);
    }
}
 

private void createOrUpdateClientRole(String realm, String clientId, RoleRepresentation role) {
    String roleName = role.getName();

    Optional<RoleRepresentation> maybeRole = roleRepository.tryToFindClientRole(realm, clientId, roleName);

    if (maybeRole.isPresent()) {
        updateClientRoleIfNecessary(realm, clientId, maybeRole.get(), role);
    } else {
        logger.debug("Create client-level role '{}' for client '{}' in realm '{}'", roleName, clientId, realm);
        roleRepository.createClientRole(realm, clientId, role);
    }
}
 

private void updateClientIfNeeded(String realm, RoleRepresentation existingRole, RoleRepresentation roleToImport) {
    String roleName = roleToImport.getName();
    RoleRepresentation patchedRole = CloneUtil.deepPatch(existingRole, roleToImport);
    if (roleToImport.getAttributes() != null) {
        patchedRole.setAttributes(roleToImport.getAttributes());
    }

    if (!CloneUtil.deepEquals(existingRole, patchedRole)) {
        logger.debug("Update realm-level role '{}' in realm '{}'", roleName, realm);
        roleRepository.updateRealmRole(realm, patchedRole);
    } else {
        logger.debug("No need to update realm-level '{}' in realm '{}'", roleName, realm);
    }
}
 

private void updateClientRoleIfNecessary(String realm, String clientId, RoleRepresentation existingRole, RoleRepresentation roleToImport) {
    RoleRepresentation patchedRole = CloneUtil.deepPatch(existingRole, roleToImport);
    String roleName = existingRole.getName();

    if (CloneUtil.deepEquals(existingRole, patchedRole)) {
        logger.debug("No need to update client-level role '{}' for client '{}' in realm '{}'", roleName, clientId, realm);
    } else {
        logger.debug("Update client-level role '{}' for client '{}' in realm '{}'", roleName, clientId, realm);
        roleRepository.updateClientRole(realm, clientId, patchedRole);
    }
}
 

/**
 * Create a new role for the realm or client
 *
 * @param rep
 * @return
 */
@POST
@Consumes(MediaType.APPLICATION_JSON)
public Response createRole(final RoleRepresentation rep) {
    auth.roles().requireManage(roleContainer);

    if (rep.getName() == null) {
        throw new BadRequestException();
    }

    try {
        RoleModel role = roleContainer.addRole(rep.getName());
        role.setDescription(rep.getDescription());

        rep.setId(role.getId());

        if (role.isClientRole()) {
            adminEvent.resource(ResourceType.CLIENT_ROLE);
        } else {
            adminEvent.resource(ResourceType.REALM_ROLE);
        }

        adminEvent.operation(OperationType.CREATE).resourcePath(uriInfo, role.getName()).representation(rep).success();

        return Response.created(uriInfo.getAbsolutePathBuilder().path(role.getName()).build()).build();
    } catch (ModelDuplicateException e) {
        return ErrorResponse.exists("Role with name " + rep.getName() + " already exists");
    }
}
 

@Override
public String getName(RoleRepresentation roleRep) {
    if (roleRep.getName() == null)
        throw new IllegalStateException("Realm role to import does not have a name");
    return roleRep.getName();
}
 

public String getName(RoleRepresentation roleRep) {
    if (roleRep.getName() == null)
        throw new IllegalStateException("Client role to import does not have a name");
    return roleRep.getName();
}