ddd state pattern validation notification - validation

Question

In my DDD project I'm trying to implement the state pattern with java enum.
I have a problem when validating entity methods that have behaviour depending on the state.
For validating I use the notification pattern.
I follow the "always valid entity" approach, so that in every operation I first call a "isValidForOperation" validation method.
Here's the code, just the relevant for simplicity:
The entity:
public class Task extends AggregateRoot<TaskId> {
...
private State state;
...
// Operation with behaviour depending on the state
// It's a transition from "ASSIGNED" state to "IN_PROGRESS" state
// I apply the state pattern here
public void start () {
State next = this.state.start ( this );
this.setState ( next );
}
...
}
The java enum modeling the state:
public enum State {
ASSIGNED {
public State start ( Task task ) {
// Validation method to ensure the operation can be done
assertTaskIsValidForStart ( task );
// Business logic
...
// Return the next state
return ( State.IN_PROGRESS );
}
}
...
// more enum values for other states
...
// Default implementation of "start" operation
// It will be executed when the current state is not "ASSIGNED"
// So an error would be generated
public State start ( Task task ) {
// I can't apply notification pattern here !!!
// I would have to throw an exception
}
}
The validation method follows the notification pattern.
It collects all possible errors in a notification object.
This notification object is passed to an exception.
The exception is thrown and then the application layer catches it and return all the error messages to the client.
public void assertTaskIsValidForStart ( Task task ) {
Notification notification = new Notification();
if ( errorCondition (task) ) {
notification.addError(...);
}
...
// more errors
...
if ( notification.hasErrors() ) {
throw new TaskNotValidForStartException ( notification.errors() );
}
}
How could be the notification pattern applied (in conjuntion with the state pattern) when the error condition is about the invalid transitions between states?
Any ideas?
UPDATE:
I found a solution. I put the whole operation that depends on the state in the entity, and apply the state pattern more fine-grained, just to the code needed. This way I apply the pattern to calculate just the next state, so that I can check if the transition is allowed and apply the notification pattern too.
Code:
public class Task extends AggregateRoot<TaskId> {
...
private State state;
...
// Operation with behaviour depending on the state
// It's a transition from "ASSIGNED" state to "IN_PROGRESS" state
// I apply fine-grained state pattern here
public void start () {
// Validation method to ensure the operation can be done
// One of the validations will be if the transition is allowed
assertTaskIsValidForStart ( this );
// Business logic
// If it depends on the state, I would apply state pattern delegating to another method
...
// Set the next state
State next = this.nextStateForStart();
this.setState ( next );
}
...
public State currentState() {
return this.state;
}
...
public State nextStateForStart() {
return this.currentState().nextStateForStart();
}
...
}
public enum State {
ASSIGNED {
public State nextStateForstart() {
return ( State.IN_PROGRESS );
}
}
...
// more enum values for other states
...
// Default implementation of "start" transition
// It will be executed when the current state is not "ASSIGNED"
public State nextStateForstart() {
return null;
}
}
public void assertTaskIsValidForStart ( Task task ) {
Notification notification = new Notification();
// Validate the transition is allowed
if ( task.nextStateForStart() == null ) {
notification.addError(...);
}
...
// more errors
...
if ( notification.hasErrors() ) {
throw new TaskNotValidForStartException ( notification.errors() );
}
}

Answer 1

I think your enum does too much.
Besides having a fixed set of states which hardly can be extended, you make it hard to introduce any form of contract for each concrete state, which would also solve your notification problem.
Introduce an abstract state class which is the base class for all concrete states. A context is passed which allows setting a successor state for each state. This context can be implemented by your aggregate root.
Your notification can be managed by each state in a way you enforce using the AbstracftState, e.g. by forcing the state execution to return a notification object:
interface StateContext {
setState(AbstractState state);
}
class AbstractState {
abstract Notification execute(StateContext context);
}
class Task extends AggregateRoot implements StateContext {
AbstractState currentState;
....
public void start() {
Notification n = currentState.execute(this);
if (n.hasErrors()) {
throw new Exception(n.toErrorReport());
}
}
}
Now you can collect errors of each state before or after execution (you may want to introduce a validateStart() within each AbstractState which is called before execution) and report the collected errors to the caller.

Answer 2

I would model the TaskWorkflow as a VO inside the Task aggregate.
class Task {
private Workflow workflow;
public void start() {
workflow = workflow.followWith(Action.START, this);
}
public State currentState() {
return workflow.state();
}
public List availableActions() {
return workflow.nextActions();
}
}
The workflow is a FSM being composed of transitions between states joined by actions. Any call to a workflow method creates a new workflow representation pointing to the new state. Transitions can be modeled as direct or more complex custom involving business logic like you say.
If you use a functional language you can return a Monad to treat errors but in this case you can reify and create one or you can just throw an exception representing aggregated messages.
Hope it helps.