Examples with ProvisioningTask org.apache.syncope.core.persistence.api.entity.task.ProvisioningTask used on opensource projects

Example 1 with ProvisioningTask

use of org.apache.syncope.core.persistence.api.entity.task.ProvisioningTask in project syncope by apache.

the class TaskDataBinderImpl method updateSchedTask.

@Override
public void updateSchedTask(final SchedTask task, final SchedTaskTO taskTO, final TaskUtils taskUtils) {
    Class<? extends TaskTO> taskTOClass = taskUtils.taskTOClass();
    if (taskTOClass == null || !taskTOClass.equals(taskTO.getClass())) {
        throw new IllegalArgumentException(String.format("Expected %s, found %s", taskTOClass, taskTO.getClass()));
    }
    if (StringUtils.isBlank(taskTO.getName())) {
        SyncopeClientException sce = SyncopeClientException.build(ClientExceptionType.RequiredValuesMissing);
        sce.getElements().add("name");
        throw sce;
    }
    task.setName(taskTO.getName());
    task.setDescription(taskTO.getDescription());
    task.setCronExpression(taskTO.getCronExpression());
    task.setActive(taskTO.isActive());
    if (task instanceof ProvisioningTask) {
        fill((ProvisioningTask) task, (ProvisioningTaskTO) taskTO);
    }
}

Example 2 with ProvisioningTask

use of org.apache.syncope.core.persistence.api.entity.task.ProvisioningTask in project syncope by apache.

the class TaskDataBinderImpl method createSchedTask.

@Override
public SchedTask createSchedTask(final SchedTaskTO taskTO, final TaskUtils taskUtils) {
    Class<? extends TaskTO> taskTOClass = taskUtils.taskTOClass();
    if (taskTOClass == null || !taskTOClass.equals(taskTO.getClass())) {
        throw new IllegalArgumentException(String.format("Expected %s, found %s", taskTOClass, taskTO.getClass()));
    }
    SchedTask task = taskUtils.newTask();
    task.setStartAt(taskTO.getStartAt());
    task.setCronExpression(taskTO.getCronExpression());
    task.setName(taskTO.getName());
    task.setDescription(taskTO.getDescription());
    task.setActive(taskTO.isActive());
    if (taskUtils.getType() == TaskType.SCHEDULED) {
        Implementation implementation = implementationDAO.find(taskTO.getJobDelegate());
        if (implementation == null) {
            throw new NotFoundException("Implementation " + taskTO.getJobDelegate());
        }
        task.setJobDelegate(implementation);
    } else if (taskTO instanceof ProvisioningTaskTO) {
        ProvisioningTaskTO provisioningTaskTO = (ProvisioningTaskTO) taskTO;
        ExternalResource resource = resourceDAO.find(provisioningTaskTO.getResource());
        if (resource == null) {
            throw new NotFoundException("Resource " + provisioningTaskTO.getResource());
        }
        ((ProvisioningTask) task).setResource(resource);
        fill((ProvisioningTask) task, provisioningTaskTO);
    }
    return task;
}

Example 3 with ProvisioningTask

use of org.apache.syncope.core.persistence.api.entity.task.ProvisioningTask in project syncope by apache.

the class TaskDataBinderImpl method fill.

private void fill(final ProvisioningTask task, final ProvisioningTaskTO taskTO) {
    if (task instanceof PushTask && taskTO instanceof PushTaskTO) {
        PushTask pushTask = (PushTask) task;
        PushTaskTO pushTaskTO = (PushTaskTO) taskTO;
        Implementation jobDelegate = pushTaskTO.getJobDelegate() == null ? implementationDAO.find(ImplementationType.TASKJOB_DELEGATE).stream().filter(impl -> PushJobDelegate.class.getName().equals(impl.getBody())).findFirst().orElse(null) : implementationDAO.find(pushTaskTO.getJobDelegate());
        if (jobDelegate == null) {
            jobDelegate = entityFactory.newEntity(Implementation.class);
            jobDelegate.setKey(PushJobDelegate.class.getSimpleName());
            jobDelegate.setEngine(ImplementationEngine.JAVA);
            jobDelegate.setType(ImplementationType.TASKJOB_DELEGATE);
            jobDelegate.setBody(PushJobDelegate.class.getName());
            jobDelegate = implementationDAO.save(jobDelegate);
        }
        pushTask.setJobDelegate(jobDelegate);
        pushTask.setSourceRealm(realmDAO.findByFullPath(pushTaskTO.getSourceRealm()));
        pushTask.setMatchingRule(pushTaskTO.getMatchingRule() == null ? MatchingRule.LINK : pushTaskTO.getMatchingRule());
        pushTask.setUnmatchingRule(pushTaskTO.getUnmatchingRule() == null ? UnmatchingRule.ASSIGN : pushTaskTO.getUnmatchingRule());
        pushTaskTO.getFilters().forEach((type, fiql) -> {
            AnyType anyType = anyTypeDAO.find(type);
            if (anyType == null) {
                LOG.debug("Invalid AnyType {} specified, ignoring...", type);
            } else {
                PushTaskAnyFilter filter = pushTask.getFilter(anyType).orElse(null);
                if (filter == null) {
                    filter = entityFactory.newEntity(PushTaskAnyFilter.class);
                    filter.setAnyType(anyType);
                    filter.setPushTask(pushTask);
                    pushTask.add(filter);
                }
                filter.setFIQLCond(fiql);
            }
        });
        // remove all filters not contained in the TO
        pushTask.getFilters().removeIf(anyFilter -> !pushTaskTO.getFilters().containsKey(anyFilter.getAnyType().getKey()));
    } else if (task instanceof PullTask && taskTO instanceof PullTaskTO) {
        PullTask pullTask = (PullTask) task;
        PullTaskTO pullTaskTO = (PullTaskTO) taskTO;
        Implementation jobDelegate = pullTaskTO.getJobDelegate() == null ? implementationDAO.find(ImplementationType.TASKJOB_DELEGATE).stream().filter(impl -> PullJobDelegate.class.getName().equals(impl.getBody())).findFirst().orElse(null) : implementationDAO.find(pullTaskTO.getJobDelegate());
        if (jobDelegate == null) {
            jobDelegate = entityFactory.newEntity(Implementation.class);
            jobDelegate.setKey(PullJobDelegate.class.getSimpleName());
            jobDelegate.setEngine(ImplementationEngine.JAVA);
            jobDelegate.setType(ImplementationType.TASKJOB_DELEGATE);
            jobDelegate.setBody(PullJobDelegate.class.getName());
            jobDelegate = implementationDAO.save(jobDelegate);
        }
        pullTask.setJobDelegate(jobDelegate);
        pullTask.setPullMode(pullTaskTO.getPullMode());
        if (pullTaskTO.getReconFilterBuilder() == null) {
            pullTask.setReconFilterBuilder(null);
        } else {
            Implementation reconFilterBuilder = implementationDAO.find(pullTaskTO.getReconFilterBuilder());
            if (reconFilterBuilder == null) {
                LOG.debug("Invalid " + Implementation.class.getSimpleName() + " {}, ignoring...", pullTaskTO.getReconFilterBuilder());
            } else {
                pullTask.setReconFilterBuilder(reconFilterBuilder);
            }
        }
        pullTask.setDestinationRealm(realmDAO.findByFullPath(pullTaskTO.getDestinationRealm()));
        pullTask.setMatchingRule(pullTaskTO.getMatchingRule() == null ? MatchingRule.UPDATE : pullTaskTO.getMatchingRule());
        pullTask.setUnmatchingRule(pullTaskTO.getUnmatchingRule() == null ? UnmatchingRule.PROVISION : pullTaskTO.getUnmatchingRule());
        // validate JEXL expressions from templates and proceed if fine
        templateUtils.check(pullTaskTO.getTemplates(), ClientExceptionType.InvalidPullTask);
        pullTaskTO.getTemplates().forEach((type, template) -> {
            AnyType anyType = anyTypeDAO.find(type);
            if (anyType == null) {
                LOG.debug("Invalid AnyType {} specified, ignoring...", type);
            } else {
                AnyTemplatePullTask anyTemplate = pullTask.getTemplate(anyType).orElse(null);
                if (anyTemplate == null) {
                    anyTemplate = entityFactory.newEntity(AnyTemplatePullTask.class);
                    anyTemplate.setAnyType(anyType);
                    anyTemplate.setPullTask(pullTask);
                    pullTask.add(anyTemplate);
                }
                anyTemplate.set(template);
            }
        });
        // remove all templates not contained in the TO
        pullTask.getTemplates().removeIf(anyTemplate -> !pullTaskTO.getTemplates().containsKey(anyTemplate.getAnyType().getKey()));
        pullTask.setRemediation(pullTaskTO.isRemediation());
    }
    // 3. fill the remaining fields
    task.setPerformCreate(taskTO.isPerformCreate());
    task.setPerformUpdate(taskTO.isPerformUpdate());
    task.setPerformDelete(taskTO.isPerformDelete());
    task.setSyncStatus(taskTO.isSyncStatus());
    taskTO.getActions().forEach(action -> {
        Implementation implementation = implementationDAO.find(action);
        if (implementation == null) {
            LOG.debug("Invalid " + Implementation.class.getSimpleName() + " {}, ignoring...", action);
        } else {
            task.add(implementation);
        }
    });
    // remove all implementations not contained in the TO
    task.getActions().removeIf(implementation -> !taskTO.getActions().contains(implementation.getKey()));
}