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

Example 76 with Task

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

the class ConfigurationSwitchInstanceBulkActionIntegrationTest method testSwitchSuccess.

@Test
public void testSwitchSuccess() {
    // prepare all data
    String previousInstanceIdOne = getHelper().createName();
    String previousInstanceIdTwo = getHelper().createName();
    String newInstanceId = getHelper().createName();
    // 
    // create events
    IdmEntityEventDto eventOne = createEvent(previousInstanceIdOne);
    IdmEntityEventDto eventTwo = createEvent(previousInstanceIdTwo);
    // 
    // create LRT
    IdmLongRunningTaskDto taskOne = createTask(previousInstanceIdOne);
    IdmLongRunningTaskDto taskTwo = createTask(previousInstanceIdTwo);
    // 
    // create scheduledTasks
    Task scheduledTaskOne = createScheduledTask(previousInstanceIdOne);
    Task scheduledTaskTwo = createScheduledTask(previousInstanceIdTwo);
    // 
    IdmBulkActionDto bulkAction = this.findBulkAction(IdmConfiguration.class, ConfigurationSwitchInstanceBulkAction.NAME);
    Map<String, Object> properties = new HashMap<>();
    properties.put(ConfigurationSwitchInstanceBulkAction.PROPERTY_PREVIOUS_INSTANCE_ID, previousInstanceIdOne);
    properties.put(ConfigurationSwitchInstanceBulkAction.PROPERTY_NEW_INSTANCE_ID, newInstanceId);
    bulkAction.setProperties(properties);
    // prevalidate
    ResultModels models = bulkActionManager.prevalidate(bulkAction);
    Assert.assertFalse(models.getInfos().isEmpty());
    // change
    IdmBulkActionDto processAction = bulkActionManager.processAction(bulkAction);
    checkResultLrt(processAction, 1l, null, null);
    // 
    Assert.assertEquals(newInstanceId, entityEventService.get(eventOne).getInstanceId());
    Assert.assertEquals(previousInstanceIdTwo, entityEventService.get(eventTwo).getInstanceId());
    // 
    Assert.assertEquals(newInstanceId, schedulerManager.getTask(scheduledTaskOne.getId()).getInstanceId());
    Assert.assertEquals(previousInstanceIdTwo, schedulerManager.getTask(scheduledTaskTwo.getId()).getInstanceId());
    // 
    Assert.assertEquals(newInstanceId, longRunningTaskService.get(taskOne.getId()).getInstanceId());
    Assert.assertEquals(previousInstanceIdTwo, longRunningTaskService.get(taskTwo.getId()).getInstanceId());
    // 
    // clean up created, just for sure
    entityEventService.delete(eventOne);
    entityEventService.delete(eventTwo);
    schedulerManager.deleteTask(scheduledTaskOne.getId());
    schedulerManager.deleteTask(scheduledTaskTwo.getId());
    longRunningTaskService.delete(taskOne);
    longRunningTaskService.delete(taskTwo);
}

Example 77 with Task

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

the class ContractSynchronizationExecutor method save.

/**
 * Save entity
 *
 * @param entity
 * @param skipProvisioning
 * @return
 */
@Override
protected IdmIdentityContractDto save(IdmIdentityContractDto entity, boolean skipProvisioning, SynchronizationContext context) {
    if (entity.getIdentity() == null) {
        throw new ProvisioningException(AccResultCode.SYNCHRONIZATION_IDM_FIELD_CANNOT_BE_NULL, ImmutableMap.of("property", CONTRACT_IDENTITY_FIELD));
    }
    EntityEvent<IdmIdentityContractDto> event = new IdentityContractEvent(contractService.isNew(entity) ? IdentityContractEventType.CREATE : IdentityContractEventType.UPDATE, entity, ImmutableMap.of(ProvisioningService.SKIP_PROVISIONING, skipProvisioning));
    // We do not want execute HR processes for every contract. We need start
    // them for every identity only once.
    // For this we skip them now. HR processes must be start after whole
    // sync finished (by using dependent scheduled task)!
    event.getProperties().put(IdmIdentityContractService.SKIP_HR_PROCESSES, Boolean.TRUE);
    // 
    // We don't want recalculate automatic role by attribute recalculation for every
    // contract.
    // Recalculation will be started only once.
    event.getProperties().put(AutomaticRoleManager.SKIP_RECALCULATION, Boolean.TRUE);
    EventContext<IdmIdentityContractDto> publishContext = contractService.publish(event);
    IdmIdentityContractDto contract = publishContext.getContent();
    // We need to flag recalculation for contract immediately to prevent synchronization ends before flag is created by NOTIFY event asynchronously.
    Map<String, Serializable> properties = new HashMap<>();
    EventResult<IdmIdentityContractDto> lastResult = publishContext.getLastResult();
    if (lastResult != null) {
        // original contract as property
        properties.put(EntityEvent.EVENT_PROPERTY_ORIGINAL_SOURCE, lastResult.getEvent().getOriginalSource());
    }
    if (contract.isValidNowOrInFuture()) {
        entityStateManager.createState(contract, OperationState.BLOCKED, CoreResultCode.AUTOMATIC_ROLE_SKIPPED, properties);
    } else {
        entityStateManager.createState(contract, OperationState.BLOCKED, CoreResultCode.AUTOMATIC_ROLE_SKIPPED_INVALID_CONTRACT, properties);
    }
    // 
    if (entity.getEmbedded().containsKey(SYNC_CONTRACT_FIELD)) {
        SyncIdentityContractDto syncContract = (SyncIdentityContractDto) entity.getEmbedded().get(SYNC_CONTRACT_FIELD);
        // Positions
        IdmContractPositionFilter positionFilter = new IdmContractPositionFilter();
        positionFilter.setIdentityContractId(contract.getId());
        List<IdmContractPositionDto> currentPositions = contractPositionService.find(positionFilter, null).getContent();
        // Search positions to delete
        List<IdmContractPositionDto> positionsToDelete = currentPositions.stream().filter(position -> {
            return position.getWorkPosition() != null && !syncContract.getPositions().contains(new IdmTreeNodeDto(position.getWorkPosition()));
        }).collect(Collectors.toList());
        // Search positions to add
        List<IdmTreeNodeDto> positionsToAdd = syncContract.getPositions().stream().filter(position -> {
            return !currentPositions.stream().filter(currentPosition -> {
                return position.getId().equals(currentPosition.getWorkPosition());
            }).findFirst().isPresent();
        }).collect(Collectors.toList());
        // Create new positions
        positionsToAdd.forEach(position -> {
            IdmContractPositionDto contractPosition = new IdmContractPositionDto();
            contractPosition.setIdentityContract(contract.getId());
            contractPosition.setWorkPosition(position.getId());
            // 
            EntityEvent<IdmContractPositionDto> positionEvent = new ContractPositionEvent(ContractPositionEventType.CREATE, contractPosition, ImmutableMap.of(ProvisioningService.SKIP_PROVISIONING, skipProvisioning, AutomaticRoleManager.SKIP_RECALCULATION, Boolean.TRUE));
            contractPosition = contractPositionService.publish(positionEvent).getContent();
            // We need to flag recalculation for contract immediately to prevent synchronization ends before flag is created by NOTIFY event asynchronously.
            if (contract.isValidNowOrInFuture()) {
                entityStateManager.createState(contractPosition, OperationState.BLOCKED, CoreResultCode.AUTOMATIC_ROLE_SKIPPED, null);
            }
        });
        // Delete positions - should be after new positions are created (prevent to drop and create => delete is sync).
        positionsToDelete.forEach(position -> {
            EntityEvent<IdmContractPositionDto> positionEvent = new ContractPositionEvent(ContractPositionEventType.DELETE, position, ImmutableMap.of(ProvisioningService.SKIP_PROVISIONING, skipProvisioning, AutomaticRoleManager.SKIP_RECALCULATION, Boolean.TRUE));
            contractPositionService.publish(positionEvent);
        });
        // Guarantees
        IdmContractGuaranteeFilter guaranteeFilter = new IdmContractGuaranteeFilter();
        guaranteeFilter.setIdentityContractId(contract.getId());
        List<IdmContractGuaranteeDto> currentGuarantees = guaranteeService.find(guaranteeFilter, null).getContent();
        // Search guarantees to delete
        List<IdmContractGuaranteeDto> guaranteesToDelete = currentGuarantees.stream().filter(sysImplementer -> {
            return sysImplementer.getGuarantee() != null && !syncContract.getGuarantees().contains(new IdmIdentityDto(sysImplementer.getGuarantee()));
        }).collect(Collectors.toList());
        // Search guarantees to add
        List<IdmIdentityDto> guaranteesToAdd = syncContract.getGuarantees().stream().filter(identity -> {
            return !currentGuarantees.stream().filter(currentGuarrantee -> {
                return identity.getId().equals(currentGuarrantee.getGuarantee());
            }).findFirst().isPresent();
        }).collect(Collectors.toList());
        // Delete guarantees
        guaranteesToDelete.forEach(guarantee -> {
            EntityEvent<IdmContractGuaranteeDto> guaranteeEvent = new ContractGuaranteeEvent(ContractGuaranteeEventType.DELETE, guarantee, ImmutableMap.of(ProvisioningService.SKIP_PROVISIONING, skipProvisioning));
            guaranteeService.publish(guaranteeEvent);
        });
        // Create new guarantees
        guaranteesToAdd.forEach(identity -> {
            IdmContractGuaranteeDto guarantee = new IdmContractGuaranteeDto();
            guarantee.setIdentityContract(contract.getId());
            guarantee.setGuarantee(identity.getId());
            // 
            EntityEvent<IdmContractGuaranteeDto> guaranteeEvent = new ContractGuaranteeEvent(ContractGuaranteeEventType.CREATE, guarantee, ImmutableMap.of(ProvisioningService.SKIP_PROVISIONING, skipProvisioning));
            guaranteeService.publish(guaranteeEvent);
        });
    }
    return contract;
}

Example 78 with Task

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

the class ContractSynchronizationExecutor method findTask.

/**
 * Find quartz task for given task type. If existed more then one task for same
 * type, then is using that with name "Default". If none with this name exists,
 * then is used first.
 *
 * @param taskType
 * @return
 */
private Task findTask(Class<? extends SchedulableTaskExecutor<?>> taskType) {
    List<Task> tasks = schedulerService.getAllTasksByType(taskType);
    if (tasks.size() == 1) {
        return tasks.get(0);
    }
    if (tasks.isEmpty()) {
        return null;
    }
    Task defaultTask = tasks.stream().filter(task -> {
        return DEFAULT_TASK.equals(task.getDescription());
    }).findFirst().orElse(null);
    if (defaultTask != null) {
        return defaultTask;
    }
    return tasks.get(0);
}

Example 79 with Task

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

the class DefaultProvisioningExecutorIntegrationTest method testAsynchronousQueueSynchronized.

@Test
public void testAsynchronousQueueSynchronized() throws Exception {
    // 
    // schedule task to process queue async
    Task task = new Task();
    task.setInstanceId(configurationService.getInstanceId());
    task.setTaskType(ProvisioningQueueTaskExecutor.class);
    task = schedulerManager.createTask(task);
    CronTaskTrigger trigger = new CronTaskTrigger();
    trigger.setTaskId(task.getId());
    trigger.setCron("0/5 * * * * ?");
    // 
    schedulerManager.createTrigger(task.getId(), trigger);
    // 
    // turn on async processing
    getHelper().enableAsynchronousProcessing();
    // 
    try {
        int count = 50;
        // system with asynchronous provisioning
        SysSystemDto system = getHelper().createTestResourceSystem(true);
        system.setQueue(true);
        system = systemService.save(system);
        // 
        IdmIdentityDto identity = getHelper().createIdentity((GuardedString) null);
        IdmRoleDto role = getHelper().createRole();
        getHelper().createRoleSystem(role, system);
        getHelper().createIdentityRole(identity, role);
        // 
        for (int index = 0; index < count; index++) {
            // async provisioning by the notify event
            entityEventManager.changedEntity(identity);
            Thread.sleep(25);
        }
        // 
        IdmEntityEventFilter eventFilter = new IdmEntityEventFilter();
        eventFilter.setOwnerId(identity.getId());
        eventFilter.setTransactionId(identity.getTransactionId());
        eventFilter.setStates(Lists.newArrayList(OperationState.CREATED, OperationState.RUNNING));
        getHelper().waitForResult(res -> {
            return entityEventService.find(eventFilter, PageRequest.of(0, 1)).getTotalElements() != 0;
        });
        // 
        // check archive is executed
        SysProvisioningOperationFilter filter = new SysProvisioningOperationFilter();
        filter.setEntityIdentifier(identity.getId());
        getHelper().waitForResult(res -> {
            return provisioningArchiveService.find(filter, null).getContent().isEmpty();
        });
        List<SysProvisioningArchiveDto> archives = provisioningArchiveService.find(filter, null).getContent();
        Assert.assertFalse(archives.isEmpty());
        Assert.assertTrue(archives.stream().allMatch(a -> a.getResultState().isSuccessful()));
    } finally {
        schedulerManager.deleteTask(task.getId());
        getHelper().disableAsynchronousProcessing();
    }
}

Example 80 with Task

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

the class SchedulerControllerRestTest method testFindByText.

@Test
public void testFindByText() {
    // create two tasks
    Task taskOne = createTask(TestSchedulableTask.class, "mock", "mock" + getHelper().createName());
    Task taskTwo = createTask(TestRegistrableSchedulableTask.class, "mock", "mock" + getHelper().createName());
    TaskFilter filter = new TaskFilter();
    filter.setText("SchedulableTask");
    List<Task> results = find(filter, null);
    // 
    Assert.assertFalse(results.isEmpty());
    Assert.assertTrue(results.stream().anyMatch(t -> t.getId().equals(taskOne.getId())));
    Assert.assertTrue(results.stream().anyMatch(t -> t.getId().equals(taskTwo.getId())));
    // 
    filter.setText("mock");
    results = find(filter, null);
    Assert.assertFalse(results.isEmpty());
    Assert.assertTrue(results.stream().anyMatch(t -> t.getId().equals(taskOne.getId())));
    Assert.assertTrue(results.stream().anyMatch(t -> t.getId().equals(taskTwo.getId())));
    // 
    filter.setText(TestRegistrableSchedulableTask.class.getSimpleName());
    results = find(filter, null);
    Assert.assertFalse(results.isEmpty());
    Assert.assertTrue(results.stream().allMatch(t -> !t.getId().equals(taskOne.getId())));
    Assert.assertTrue(results.stream().anyMatch(t -> t.getId().equals(taskTwo.getId())));
    // 
    filter.setText(taskOne.getDescription());
    results = find(filter, null);
    Assert.assertEquals(1, results.size());
    Assert.assertTrue(results.stream().allMatch(t -> t.getId().equals(taskOne.getId())));
}