cz.wicketstuff.boss.flow.processor.basic.SimpleFlowProcessor Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of boss-flow Show documentation
Workflow control and configuration java framework
There is a newer version: 1.3.1
/*
 * Et netera, http://boss.etnetera.cz - Copyright (C) 2012 
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License (version 2.1) as published by the Free Software
 * Foundation.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 *
 * See the GNU Lesser General Public License for more details:
 * http://www.gnu.org/licenses/lgpl-3.0.txt
 * 
 */
package cz.wicketstuff.boss.flow.processor.basic;

import java.io.Serializable;

import cz.wicketstuff.boss.flow.FlowException;
import cz.wicketstuff.boss.flow.model.IFlowCarter;
import cz.wicketstuff.boss.flow.model.IFlowState;
import cz.wicketstuff.boss.flow.model.IFlowTransition;
import cz.wicketstuff.boss.flow.processor.FlowPersistingException;
import cz.wicketstuff.boss.flow.processor.IFlowCarterFactory;
import cz.wicketstuff.boss.flow.processor.IFlowStateChangeListener;
import cz.wicketstuff.boss.flow.processor.IFlowStateDataFactory;
import cz.wicketstuff.boss.flow.processor.IFlowStatePersister;
import cz.wicketstuff.boss.flow.processor.IFlowStateProcessor;
import cz.wicketstuff.boss.flow.processor.IFlowStateResolver;
import cz.wicketstuff.boss.flow.processor.IFlowStateValidationListener;
import cz.wicketstuff.boss.flow.processor.IFlowTransitionChangeListener;
import cz.wicketstuff.boss.flow.processor.IFlowTransitionResolver;
import cz.wicketstuff.boss.flow.processor.NoSuchStateException;
import cz.wicketstuff.boss.flow.processor.NoSuchTransitionException;
import cz.wicketstuff.boss.flow.processor.StateDataException;
import cz.wicketstuff.boss.flow.util.Comparators;
import cz.wicketstuff.boss.flow.util.listener.IPriority;
import cz.wicketstuff.boss.flow.validation.IFlowStateValidator;
import cz.wicketstuff.boss.flow.validation.IFlowValidation;

public class SimpleFlowProcessor extends AbstractFlowProcessor {

	private static final long serialVersionUID = 1L;
	
	private Integer flowId;
	private String flowName;
	private IFlowState defaultInitialState;
	
	private IFlowCarterFactory carterFactory;
	private IFlowStateDataFactory stateDataFactory;
	
	private IFlowStateProcessor stateProcessor;
	private IFlowStateValidator stateValidator;
	
	private IFlowStateChangeListener stateChangeListener;
	private IFlowTransitionChangeListener transitionChangeListener;
	private IFlowStateValidationListener stateValidationListener;
	
	private IFlowStateResolver stateResolver;
	private IFlowTransitionResolver transitionResolver;
	
	private IFlowStatePersister flowStatePersister;
	
	private int priority = 0;
	
	public SimpleFlowProcessor() {
		super();
	}

	@Override
	public IFlowCarter initFlow(Long flowProcessId, T payload, String initialStateName) throws FlowException {
		return initFlow(flowProcessId, payload, getStateResolver().resolveState(initialStateName));
	}

	@Override
	public boolean invokeTransition(IFlowCarter flow, String transitionName)
			throws FlowException {
		return invokeTransition(flow, resolveTransition(flow, transitionName));
	}


	@Override
	public Integer getFlowId() {
		return flowId;
	}

	public void setFlowId(Integer flowId) {
		this.flowId = flowId;
	}

	@Override
	public String getFlowName() {
		return flowName;
	}

	public void setFlowName(String flowName) {
		this.flowName = flowName;
	}

	@Override
	public IFlowState getDefaultInitialState() {
		return defaultInitialState;
	}
	
	public void setDefaultInitialState(IFlowState defaultInitialState) {
		this.defaultInitialState = defaultInitialState;
	}

	@Override
	public IFlowCarter createFlowCarter(Long flowProcessId, IFlowState initialState) throws FlowException {
		return getCarterFactory().createFlowCarter(flowProcessId, initialState);
	}

	@Override
	public IFlowValidation validateState(IFlowCarter flow) {
		return getStateValidator().validateState(flow);
	}
	
	@Override
	public void processState(IFlowCarter flow) throws FlowException {
		getStateProcessor().processState(flow);
		
	}

	@Override
	public void onStateValid(IFlowCarter flow) {
		if(getStateValidationListener() != null)
			getStateValidationListener().onStateValid(flow);
	}

	@Override
	public void onStateInvalid(IFlowCarter flow) {
		if(getStateValidationListener() != null)
			getStateValidationListener().onStateInvalid(flow);
		
	}

	@Override
	public void onTransitionStart(IFlowCarter flow) {
		if(getTransitionChangeListener() != null)
			getTransitionChangeListener().onTransitionStart(flow);
	}

	@Override
	public void onTransitionFinished(IFlowCarter flow) {
		if(getTransitionChangeListener() != null)
			getTransitionChangeListener().onTransitionFinished(flow);
	}

	@Override
	public void onStateEntry(IFlowCarter flow) {
		if(getStateChangeListener() != null)
			getStateChangeListener().onStateEntry(flow);
	}

	@Override
	public void onStateLeaving(IFlowCarter flow) {
		if(getStateChangeListener() != null)
			getStateChangeListener().onStateLeaving(flow);
	}

	@Override
	public IFlowState resolveState(String stateName)
			throws NoSuchStateException {
		return getStateResolver().resolveState(stateName);
	}

	@Override
	public IFlowTransition resolveTransition(IFlowCarter flow, String transitionName)
			throws NoSuchTransitionException {
		return getTransitionResolver().resolveTransition(flow, transitionName);
	}

	public IFlowStateChangeListener getStateChangeListener() {
		return stateChangeListener;
	}

	public void setStateChangeListener(
			IFlowStateChangeListener stateChangeListener) {
		this.stateChangeListener = stateChangeListener;
	}

	public IFlowTransitionChangeListener getTransitionChangeListener() {
		return transitionChangeListener;
	}

	public void setTransitionChangeListener(
			IFlowTransitionChangeListener transitionChangeListener) {
		this.transitionChangeListener = transitionChangeListener;
	}

	public IFlowStateValidationListener getStateValidationListener() {
		return stateValidationListener;
	}

	public void setStateValidationListener(
			IFlowStateValidationListener stateValidationListener) {
		this.stateValidationListener = stateValidationListener;
	}

	public IFlowStateProcessor getStateProcessor() {
		return stateProcessor;
	}

	public void setStateProcessor(IFlowStateProcessor stateProcessor) {
		this.stateProcessor = stateProcessor;
	}

	public IFlowStateValidator getStateValidator() {
		return stateValidator;
	}

	public void setStateValidator(IFlowStateValidator stateValidator) {
		this.stateValidator = stateValidator;
	}

	@Override
	public Serializable createStateData(IFlowState flowState)
			throws NoSuchStateException, StateDataException {
		return getStateDataFactory().createStateData(flowState);
	}

	public IFlowStateDataFactory getStateDataFactory() {
		return stateDataFactory;
	}

	public void setStateDataFactory(IFlowStateDataFactory stateDataFactory) {
		this.stateDataFactory = stateDataFactory;
	}

	public IFlowCarterFactory getCarterFactory() {
		return carterFactory;
	}

	public void setCarterFactory(IFlowCarterFactory carterFactory) {
		this.carterFactory = carterFactory;
	}

	public IFlowStateResolver getStateResolver() {
		return stateResolver;
	}

	public void setStateResolver(IFlowStateResolver stateResolver) {
		this.stateResolver = stateResolver;
	}

	public IFlowTransitionResolver getTransitionResolver() {
		return transitionResolver;
	}

	public void setTransitionResolver(IFlowTransitionResolver transitionResolver) {
		this.transitionResolver = transitionResolver;
	}
	
	public String getDefaultInitialStateName() {
		return getDefaultInitialState().getStateName();
	}

	public void setDefaultInitialStateName(String defaultInitialStateName) throws NoSuchStateException {
		setDefaultInitialState(getStateResolver().resolveState(defaultInitialStateName));
	}
	
	public IFlowStatePersister getFlowStatePersister() {
		return flowStatePersister;
	}

	public void setFlowStatePersister(IFlowStatePersister flowStatePersister) {
		this.flowStatePersister = flowStatePersister;
	}

	@Override
	protected void finalize() throws Throwable {
		carterFactory = null;
		defaultInitialState = null;
		stateChangeListener = null;
		stateDataFactory = null;
		stateProcessor = null;
		stateResolver = null;
		stateValidationListener = null;
		stateValidator = null;
		transitionChangeListener = null;
		transitionResolver = null;
		super.finalize();
	}

	@Override
	public int compareTo(IPriority o) {
		return Comparators.compareInts(priority, o.getPriority());
	}

	@Override
	public int getPriority() {
		return priority;
	}

	public void setPriority(int priority) {
		this.priority = priority;
	}

	public void onFlowInitialized(IFlowCarter flow) {
		
	}

	@Override
	public void persistFlowState(IFlowCarter flow) throws FlowPersistingException {
		IFlowStatePersister p = getFlowStatePersister();
		if(p != null) {
			p.persistFlowState(flow);
		}		
	}

}