Examples with IdmRoleTreeNodeDto eu.bcvsolutions.idm.core.api.dto.IdmRoleTreeNodeDto used on opensource projects

Example 46 with IdmRoleTreeNodeDto

use of eu.bcvsolutions.idm.core.api.dto.IdmRoleTreeNodeDto in project CzechIdMng by bcvsolutions.

the class IdmRoleTreeNodeControllerRestTest method testFindByName.

@Test
public void testFindByName() {
    IdmRoleTreeNodeDto roleOne = prepareDto();
    roleOne.setName(getHelper().createName());
    IdmRoleTreeNodeDto roleOneCreated = createDto(roleOne);
    // other
    createDto();
    // 
    MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
    parameters.add("name", roleOne.getName());
    List<IdmRoleTreeNodeDto> roles = find(parameters);
    Assert.assertEquals(1, roles.size());
    Assert.assertTrue(roles.stream().anyMatch(r -> r.getId().equals(roleOneCreated.getId())));
}

Example 47 with IdmRoleTreeNodeDto

use of eu.bcvsolutions.idm.core.api.dto.IdmRoleTreeNodeDto in project CzechIdMng by bcvsolutions.

the class DefaultIdmRoleTreeNodeService method delete.

/**
 * Publish {@link RoleTreeNodeEvent} only.
 *
 * @see {@link RoleTreeNodeDeleteProcessor}
 */
@Override
@Transactional(noRollbackFor = AcceptedException.class)
public void delete(IdmRoleTreeNodeDto roleTreeNode, BasePermission... permission) {
    Assert.notNull(roleTreeNode);
    checkAccess(this.getEntity(roleTreeNode.getId()), permission);
    // 
    LOG.debug("Deleting automatic role [{}] - [{}] - [{}]", roleTreeNode.getRole(), roleTreeNode.getTreeNode(), roleTreeNode.getRecursionType());
    // 
    EventContext<IdmRoleTreeNodeDto> context = entityEventManager.process(new RoleTreeNodeEvent(RoleTreeNodeEventType.DELETE, roleTreeNode));
    // 
    if (context.isSuspended()) {
        throw new AcceptedException();
    }
}

Example 48 with IdmRoleTreeNodeDto

use of eu.bcvsolutions.idm.core.api.dto.IdmRoleTreeNodeDto in project CzechIdMng by bcvsolutions.

the class TreeTypeDeleteBulkActionIntegrationTest method testForceDelete.

@Test
public void testForceDelete() {
    logout();
    loginAsAdmin();
    // create sub tree nodes, automatic roles, contract, contract positions, system mapping and sync
    IdmTreeTypeDto treeType = getHelper().createTreeType();
    SysSystemDto system = getHelper().createTestResourceSystem(true, getHelper().createName());
    SysSystemMappingFilter filter = new SysSystemMappingFilter();
    filter.setSystemId(system.getId());
    SysSystemMappingDto mapping = systemMappingService.find(filter, null).getContent().get(0);
    mapping.setTreeType(treeType.getId());
    mapping = systemMappingService.save(mapping);
    SysSyncConfigDto syncConfig = new SysSyncConfigDto();
    syncConfig.setName(getHelper().createName());
    syncConfig.setSystemMapping(mapping.getId());
    // finds mapped attributes in existing system
    SysSystemAttributeMappingFilter attributeFilter = new SysSystemAttributeMappingFilter();
    attributeFilter.setSystemId(system.getId());
    attributeFilter.setName(TestHelper.ATTRIBUTE_MAPPING_NAME);
    SysSystemAttributeMappingDto attribute = attributeMappingService.find(attributeFilter, null).getContent().get(0);
    syncConfig.setCorrelationAttribute(attribute.getId());
    syncConfig = (SysSyncConfigDto) syncService.save(syncConfig);
    IdmRoleDto role = getHelper().createRole();
    getHelper().createRoleSystem(role, system);
    // 
    IdmTreeNodeDto treeNode = getHelper().createTreeNode(treeType, null, null);
    IdmTreeNodeDto subTreeNode = getHelper().createTreeNode(treeType, (String) null, treeNode);
    IdmTreeNodeDto subSubTreeNode = getHelper().createTreeNode(treeType, (String) null, subTreeNode);
    IdmTreeNodeDto otherTreeNode = getHelper().createTreeNode();
    IdmIdentityDto identity = getHelper().createIdentity((GuardedString) null);
    IdmIdentityContractDto contract = getHelper().createContract(identity, subTreeNode);
    IdmContractPositionDto contractPosition = getHelper().createContractPosition(contract, subSubTreeNode);
    IdmIdentityRoleDto assignedRoleOne = getHelper().createIdentityRole(contract, role);
    IdmIdentityRoleDto assignedRoleTwo = getHelper().createIdentityRole(contractPosition, role);
    IdmIdentityRoleDto assignedRoleOther = getHelper().createIdentityRole(getHelper().getPrimeContract(identity), role);
    IdmRoleTreeNodeDto automaticRole = getHelper().createRoleTreeNode(role, treeNode, RecursionType.DOWN, false);
    // 
    // 3 manual, 2 automatic
    Assert.assertEquals(5, identityRoleService.findAllByIdentity(identity.getId()).size());
    // 
    // remove tree type
    Map<String, Object> properties = new HashMap<>();
    properties.put(EntityEventProcessor.PROPERTY_FORCE_DELETE, Boolean.TRUE);
    // delete by bulk action
    IdmBulkActionDto bulkAction = this.findBulkAction(IdmTreeType.class, TreeTypeDeleteBulkAction.NAME);
    bulkAction.setIdentifiers(Sets.newHashSet(treeType.getId()));
    bulkAction.setProperties(properties);
    IdmBulkActionDto processAction = bulkActionManager.processAction(bulkAction);
    // 
    checkResultLrt(processAction, 1l, 0l, 0l);
    // 
    Assert.assertNull(treeTypeService.get(treeType));
    Assert.assertNull(treeNodeService.get(treeNode));
    Assert.assertNull(treeNodeService.get(subTreeNode));
    Assert.assertNull(treeNodeService.get(subSubTreeNode));
    Assert.assertNull(treeNodeService.get(subSubTreeNode));
    Assert.assertNotNull(identityRoleService.get(assignedRoleOne));
    Assert.assertNotNull(identityRoleService.get(assignedRoleTwo));
    Assert.assertNull(identityContractService.get(contract).getWorkPosition());
    Assert.assertNull(contractPositionService.get(contractPosition).getWorkPosition());
    Assert.assertNull(roleTreeNodeService.get(automaticRole));
    Assert.assertNull(systemMappingService.get(mapping));
    Assert.assertNull(attributeMappingService.get(attribute));
    Assert.assertNull(syncService.get(syncConfig));
    // 
    Assert.assertNotNull(treeNodeService.get(otherTreeNode));
    Assert.assertNotNull(getHelper().getPrimeContract(identity));
    Assert.assertNotNull(identityRoleService.get(assignedRoleOther));
}

Example 49 with IdmRoleTreeNodeDto

use of eu.bcvsolutions.idm.core.api.dto.IdmRoleTreeNodeDto in project CzechIdMng by bcvsolutions.

the class ContractPositionAutomaticRoleProcessor method process.

@Override
public EventResult<IdmContractPositionDto> process(EntityEvent<IdmContractPositionDto> event) {
    // flag can be processed afterwards
    if (getBooleanProperty(AutomaticRoleManager.SKIP_RECALCULATION, event.getProperties())) {
        IdmContractPositionDto contractPosition = event.getContent();
        LOG.debug("Automatic roles are skipped for position [{}], state [AUTOMATIC_ROLE_SKIPPED] for position will be created only.", contractPosition.getId());
        // 
        entityStateManager.createState(contractPosition, OperationState.BLOCKED, CoreResultCode.AUTOMATIC_ROLE_SKIPPED, null);
        // 
        return new DefaultEventResult<>(event, this);
    }
    // 
    IdmContractPositionDto contractPosition = event.getContent();
    IdmIdentityContractDto contract = DtoUtils.getEmbedded(contractPosition, IdmContractPosition_.identityContract);
    // 
    UUID newPosition = contractPosition.getWorkPosition();
    // 
    // check automatic roles - if position or contract was enabled
    // work positions has some difference or validity changes
    List<IdmIdentityRoleDto> assignedRoles = identityRoleService.findAllByContractPosition(contractPosition.getId());
    // and automatic roles given by contracts position
    if (!assignedRoles.isEmpty()) {
        assignedRoles = assignedRoles.stream().filter(autoRole -> {
            // just for sure, other contract position supports automatic role by tree structure only for now
            AbstractIdmAutomaticRoleDto automaticRoleDto = DtoUtils.getEmbedded(autoRole, IdmIdentityRole_.automaticRole, (AbstractIdmAutomaticRoleDto) null);
            if (automaticRoleDto instanceof IdmRoleTreeNodeDto) {
                return true;
            }
            return false;
        }).collect(Collectors.toList());
    }
    // 
    Set<UUID> previousAutomaticRoles = assignedRoles.stream().filter(identityRole -> {
        return identityRole.getAutomaticRole() != null;
    }).map(identityRole -> {
        return identityRole.getAutomaticRole();
    }).collect(Collectors.toSet());
    Set<IdmRoleTreeNodeDto> addedAutomaticRoles = new HashSet<>();
    if (newPosition != null) {
        addedAutomaticRoles = roleTreeNodeService.getAutomaticRolesByTreeNode(newPosition);
    }
    // prevent to remove newly added or still exists roles
    Set<UUID> removedAutomaticRoles = new HashSet<>(previousAutomaticRoles);
    removedAutomaticRoles.removeAll(addedAutomaticRoles.stream().map(IdmRoleTreeNodeDto::getId).collect(Collectors.toList()));
    addedAutomaticRoles.removeIf(a -> {
        return previousAutomaticRoles.contains(a.getId());
    });
    List<IdmConceptRoleRequestDto> concepts = new ArrayList<>(removedAutomaticRoles.size() + addedAutomaticRoles.size());
    // 
    for (UUID removedAutomaticRole : removedAutomaticRoles) {
        Iterator<IdmIdentityRoleDto> iter = assignedRoles.iterator();
        while (iter.hasNext()) {
            IdmIdentityRoleDto identityRole = iter.next();
            if (Objects.equals(identityRole.getAutomaticRole(), removedAutomaticRole)) {
                // check, if role will be added by new automatic roles and prevent removing
                IdmRoleTreeNodeDto addedAutomaticRole = getByRole(identityRole.getRole(), addedAutomaticRoles);
                if (addedAutomaticRole == null) {
                    // remove assigned role
                    IdmConceptRoleRequestDto conceptRoleRequest = new IdmConceptRoleRequestDto();
                    conceptRoleRequest.setIdentityRole(identityRole.getId());
                    conceptRoleRequest.setRole(identityRole.getRole());
                    conceptRoleRequest.setOperation(ConceptRoleRequestOperation.REMOVE);
                    // 
                    concepts.add(conceptRoleRequest);
                    // 
                    iter.remove();
                } else {
                    // change relation only
                    IdmConceptRoleRequestDto conceptRoleRequest = new IdmConceptRoleRequestDto();
                    conceptRoleRequest.setIdentityRole(identityRole.getId());
                    conceptRoleRequest.setAutomaticRole(addedAutomaticRole.getId());
                    conceptRoleRequest.setIdentityContract(contract.getId());
                    conceptRoleRequest.setContractPosition(contractPosition.getId());
                    conceptRoleRequest.setValidFrom(contract.getValidFrom());
                    conceptRoleRequest.setValidTill(contract.getValidTill());
                    conceptRoleRequest.setRole(identityRole.getRole());
                    conceptRoleRequest.setOperation(ConceptRoleRequestOperation.UPDATE);
                    // 
                    concepts.add(conceptRoleRequest);
                    // 
                    // new automatic role is not needed
                    addedAutomaticRoles.remove(addedAutomaticRole);
                }
            }
        }
    }
    // add identity roles
    for (AbstractIdmAutomaticRoleDto autoRole : addedAutomaticRoles) {
        IdmConceptRoleRequestDto conceptRoleRequest = new IdmConceptRoleRequestDto();
        conceptRoleRequest.setIdentityContract(contract.getId());
        conceptRoleRequest.setContractPosition(contractPosition.getId());
        conceptRoleRequest.setValidFrom(contract.getValidFrom());
        conceptRoleRequest.setValidTill(contract.getValidTill());
        conceptRoleRequest.setRole(autoRole.getRole());
        conceptRoleRequest.setAutomaticRole(autoRole.getId());
        conceptRoleRequest.setOperation(ConceptRoleRequestOperation.ADD);
        // 
        concepts.add(conceptRoleRequest);
    }
    // 
    if (!concepts.isEmpty()) {
        IdmRoleRequestDto roleRequest = (IdmRoleRequestDto) event.getProperties().get(IdentityContractUpdateByAutomaticRoleProcessor.EVENT_PROPERTY_REQUEST);
        if (roleRequest != null) {
            // add concept into single request
            // single request will be executed by parent event
            roleRequest.getConceptRoles().addAll(concepts);
        } else {
            // execute new request
            roleRequest = new IdmRoleRequestDto();
            roleRequest.setConceptRoles(concepts);
            roleRequest.setApplicant(contract.getIdentity());
            roleRequest = roleRequestService.startConcepts(new RoleRequestEvent(RoleRequestEventType.EXCECUTE, roleRequest), event);
        }
        event.getProperties().put(IdentityContractUpdateByAutomaticRoleProcessor.EVENT_PROPERTY_REQUEST, roleRequest);
    }
    // 
    return new DefaultEventResult<>(event, this);
}

Example 50 with IdmRoleTreeNodeDto

use of eu.bcvsolutions.idm.core.api.dto.IdmRoleTreeNodeDto in project CzechIdMng by bcvsolutions.

the class IdentityContractCreateByAutomaticRoleProcessor method process.

@Override
public EventResult<IdmIdentityContractDto> process(EntityEvent<IdmIdentityContractDto> event) {
    IdmIdentityContractDto contract = event.getContent();
    // flag can be processed afterwards
    if (getBooleanProperty(AutomaticRoleManager.SKIP_RECALCULATION, event.getProperties())) {
        LOG.debug("Automatic roles are skipped for contract [{}], state [AUTOMATIC_ROLE_SKIPPED] for position will be created only.", contract.getId());
        // 
        entityStateManager.createState(contract, OperationState.BLOCKED, CoreResultCode.AUTOMATIC_ROLE_SKIPPED, null);
        // 
        return new DefaultEventResult<>(event, this);
    }
    // get related automatic roles
    Set<IdmRoleTreeNodeDto> automaticRoles = roleTreeNodeService.getAutomaticRolesByTreeNode(contract.getWorkPosition());
    if (automaticRoles.isEmpty()) {
        return new DefaultEventResult<>(event, this);
    }
    // assign automatic roles by role request
    List<IdmConceptRoleRequestDto> concepts = automaticRoles.stream().map(autoRole -> {
        IdmConceptRoleRequestDto conceptRoleRequest = new IdmConceptRoleRequestDto();
        conceptRoleRequest.setIdentityContract(contract.getId());
        conceptRoleRequest.setValidFrom(contract.getValidFrom());
        conceptRoleRequest.setValidTill(contract.getValidTill());
        conceptRoleRequest.setRole(autoRole.getRole());
        conceptRoleRequest.setAutomaticRole(autoRole.getId());
        conceptRoleRequest.setOperation(ConceptRoleRequestOperation.ADD);
        // 
        return conceptRoleRequest;
    }).collect(Collectors.toList());
    // 
    IdmRoleRequestDto roleRequest = new IdmRoleRequestDto();
    roleRequest.setConceptRoles(concepts);
    roleRequest.setApplicant(contract.getIdentity());
    roleRequest = roleRequestService.startConcepts(new RoleRequestEvent(RoleRequestEventType.EXCECUTE, roleRequest), event);
    // 
    return new DefaultEventResult<>(event, this);
}