Examples with Task org.estatio.module.capex.dom.task.Task used on opensource projects

Example 1 with Task

use of org.estatio.module.capex.dom.task.Task in project estatio by estatio.

the class StateTransitionRepositoryGeneric method create.

@Programmatic
public <DO, ST extends StateTransitionAbstract<DO, ST, STT, S>, STT extends StateTransitionType<DO, ST, STT, S>, S extends State<S>> ST create(final DO domainObject, final STT transitionType, final S fromState, final IPartyRoleType taskAssignToIfAny, final Person personToAssignToIfAny, final String taskDescription, final Class<ST> stateTransitionClass) {
    final Task taskIfAny = createTaskIfRequired(taskAssignToIfAny, personToAssignToIfAny, taskDescription, stateTransitionClass, domainObject);
    final ST stateTransition = createTransition(domainObject, transitionType, fromState, taskIfAny, stateTransitionClass);
    return stateTransition;
}

Example 2 with Task

use of org.estatio.module.capex.dom.task.Task in project estatio by estatio.

the class StateTransitionRepositoryGeneric method deleteFor.

@Programmatic
public <DO, ST extends StateTransitionAbstract<DO, ST, STT, S>, STT extends StateTransitionType<DO, ST, STT, S>, S extends State<S>> void deleteFor(final DO domainObject, final Class<ST> stateTransitionClass) {
    final List<ST> stateTransitions = findByDomainObject(domainObject, stateTransitionClass);
    for (ST transition : stateTransitions) {
        Task taskToRemove = null;
        if (transition.getTask() != null) {
            taskToRemove = transition.getTask();
        }
        repositoryService.removeAndFlush(transition);
        if (taskToRemove != null) {
            repositoryService.removeAndFlush(taskToRemove);
        }
    }
    transactionService.flushTransaction();
}

Example 3 with Task

use of org.estatio.module.capex.dom.task.Task in project estatio by estatio.

the class StateTransitionRepositoryGeneric method createTaskIfRequired.

protected <DO, ST extends StateTransitionAbstract<DO, ST, STT, S>, STT extends StateTransitionType<DO, ST, STT, S>, S extends State<S>> Task createTaskIfRequired(final IPartyRoleType iRoleAssignTo, final Person personToAssignToIfAny, final String taskDescription, final Class<ST> stateTransitionClass, final DO domainObject) {
    if (iRoleAssignTo == null) {
        return null;
    }
    final LocalDateTime createdOn = clockService.nowAsLocalDateTime();
    final String transitionObjectType = metaModelService3.toObjectType(stateTransitionClass);
    final Person assignToIfAny = personToAssignToIfAny != null ? personToAssignToIfAny : partyRoleTypeService.onlyMemberOfElseNone(iRoleAssignTo, domainObject);
    final PartyRoleType roleAssignTo = iRoleAssignTo.findOrCreateUsing(partyRoleTypeRepository);
    final Task task = new Task(roleAssignTo, assignToIfAny, taskDescription, createdOn, transitionObjectType);
    repositoryService.persist(task);
    return task;
}

Example 4 with Task

use of org.estatio.module.capex.dom.task.Task in project estatio by estatio.

the class StateTransitionService method completeTransition.

private <DO, ST extends StateTransition<DO, ST, STT, S>, STT extends StateTransitionType<DO, ST, STT, S>, S extends State<S>> ST completeTransition(final DO domainObject, final ST transitionToComplete, final String comment, final NatureOfTransition natureOfTransition) {
    final STT transitionType = transitionToComplete.getTransitionType();
    final StateTransitionEvent<DO, ST, STT, S> event = transitionType.newStateTransitionEvent(domainObject, transitionToComplete);
    // transitioning
    event.setPhase(StateTransitionEvent.Phase.TRANSITIONING);
    eventBusService.post(event);
    final Task taskIfAny = transitionToComplete.getTask();
    if (taskIfAny != null) {
        if (transitionType.advancePolicyFor(domainObject, serviceRegistry2).isAutomatic() && natureOfTransition == NatureOfTransition.AUTOMATIC) {
            transitionToComplete.setTask(null);
            repositoryService.removeAndFlush(taskIfAny);
            transitionToComplete.setTask(null);
        }
    }
    // transition
    final Class<ST> stateTransitionClass = transitionClassFor(transitionType);
    transitionType.applyTo(domainObject, stateTransitionClass, serviceRegistry2);
    // mark tasks as complete
    transitionToComplete.completed(comment, natureOfTransition);
    event.setPhase(StateTransitionEvent.Phase.TRANSITIONED);
    eventBusService.post(event);
    return transitionToComplete;
}

Example 5 with Task

use of org.estatio.module.capex.dom.task.Task in project estatio by estatio.

the class StateTransitionService method pendingTransitionIfPossible.

private <DO, ST extends StateTransition<DO, ST, STT, S>, STT extends StateTransitionType<DO, ST, STT, S>, S extends State<S>> ST pendingTransitionIfPossible(final DO domainObject, final Class<ST> stateTransitionClass, final STT requestedTransitionTypeIfAny, final Person personToAssignNextToIfAny, final String nextTaskDescriptionIfAny) {
    // check the override, if any
    if (requestedTransitionTypeIfAny != null) {
        boolean canTransition = requestedTransitionTypeIfAny.canTransitionFromCurrentStateAndIsMatch(domainObject, serviceRegistry2);
        if (!canTransition) {
            // what's been requested is a no-go.
            return null;
        }
    }
    // determine what previously was determined as the pending (if any)
    ST pendingTransitionIfAny = pendingTransitionOf(domainObject, stateTransitionClass);
    // what we now think as the pending (if any)
    STT nextTransitionType = null;
    // current state
    final ST mostRecentTransitionIfAny = mostRecentlyCompletedTransitionOf(domainObject, stateTransitionClass);
    final S currentStateIfAny = mostRecentTransitionIfAny != null ? mostRecentTransitionIfAny.getTransitionType().getToState() : null;
    if (requestedTransitionTypeIfAny != null) {
        nextTransitionType = requestedTransitionTypeIfAny;
    } else {
        if (mostRecentTransitionIfAny != null) {
            // use most recent transition to determine the next transition (since one hasn't been requested)
            final STT mostRecentTransitionType = mostRecentTransitionIfAny.getTransitionType();
            final NextTransitionSearchStrategy<DO, ST, STT, S> transitionStrategy = mostRecentTransitionType.getNextTransitionSearchStrategy();
            if (transitionStrategy != null) {
                nextTransitionType = transitionStrategy.nextTransitionType(domainObject, mostRecentTransitionType, serviceRegistry2);
            }
        } else {
            // can't proceed because unable to determine current state, and no transition specified
            return null;
        }
    }
    // if pending has changed, then reconcile
    STT pendingTransitionType = pendingTransitionIfAny != null ? pendingTransitionIfAny.getTransitionType() : null;
    if (pendingTransitionType != nextTransitionType) {
        if (pendingTransitionType != null) {
            if (nextTransitionType != null) {
                final Task taskIfAny = pendingTransitionIfAny.getTask();
                repositoryService.remove(pendingTransitionIfAny);
                if (taskIfAny != null) {
                    repositoryService.removeAndFlush(taskIfAny);
                }
                pendingTransitionType = nextTransitionType;
                pendingTransitionIfAny = createPendingTransition(domainObject, currentStateIfAny, nextTransitionType, personToAssignNextToIfAny, nextTaskDescriptionIfAny);
            } else {
                // in this branch the transition strategy for the most recently completed transition
                // must have returned null for nextTransitionType, and yet a pending transition does exist
                // (pendingTransitionType is not null).  This can only have come about if that pending
                // transition was created directly (using createPendingTransition(...)).
                // We don't want to discard this pending transition, so we use instead update nextTransitionType
                // to this existing pending value.
                nextTransitionType = pendingTransitionType;
            }
        } else {
            // pendingTransitionType == null, so nextTransitionType != null because of outer if
            pendingTransitionIfAny = createPendingTransition(domainObject, currentStateIfAny, nextTransitionType, personToAssignNextToIfAny, nextTaskDescriptionIfAny);
            pendingTransitionType = nextTransitionType;
        }
    }
    if (pendingTransitionType == null) {
        return null;
    }
    if (domainObject instanceof Stateful) {
        final Stateful stateful = (Stateful) domainObject;
        final S currentStateAccordingToDomainObject = stateful.getStateOf(stateTransitionClass);
        if (currentStateAccordingToDomainObject == null && mostRecentTransitionIfAny != null) {
            // self-healing
            stateful.setStateOf(stateTransitionClass, mostRecentTransitionIfAny.getToState());
        }
    }
    final Task taskIfAny = pendingTransitionIfAny.getTask();
    if (taskIfAny != null) {
        final PartyRoleType roleAssignedTo = taskIfAny.getAssignedTo();
        final IPartyRoleType iRoleShouldBeAssignedTo = pendingTransitionType.getTaskAssignmentStrategy().getAssignTo(domainObject, serviceRegistry2);
        // always overwrite the role
        final PartyRoleType roleShouldBeAssignedTo = partyRoleTypeRepository.findOrCreate(iRoleShouldBeAssignedTo);
        if (roleAssignedTo != roleShouldBeAssignedTo) {
            taskIfAny.setAssignedTo(roleShouldBeAssignedTo);
        }
        // only overwrite the person if not actually assigned
        final Person personAssignedToIfAny = taskIfAny.getPersonAssignedTo();
        if (personAssignedToIfAny == null) {
            if (iRoleShouldBeAssignedTo != null) {
                Person person = partyRoleTypeService.onlyMemberOfElseNone(iRoleShouldBeAssignedTo, domainObject);
                taskIfAny.setPersonAssignedTo(person);
            }
        }
    }
    if (!pendingTransitionType.isGuardSatisfied(domainObject, serviceRegistry2)) {
        // (there must be a guard prohibiting it for this particular domain object)
        return null;
    }
    // if requestedTransitionTypeIfAny != null, then this is an explicit action, so automatic doesn't apply...
    if (requestedTransitionTypeIfAny != null) {
        return pendingTransitionIfAny;
    }
    final AdvancePolicy advancePolicy = nextTransitionType.advancePolicyFor(domainObject, serviceRegistry2);
    if (advancePolicy.isAutomatic() && pendingTransitionType.isAutoGuardSatisfied(domainObject, serviceRegistry2)) {
        return pendingTransitionIfAny;
    }
    return null;
}