ex_state v0.3.0 ExState.Execution View Source

t() :: %ExState.Execution{
  actions: [atom()],
  callback_mod: module(),
  chart: ExState.Definition.Chart.t(),
  context: map(),
  history: [ExState.Definition.State.t()],
  meta: map(),
  state: ExState.Definition.State.t(),
  transitions: [ExState.Definition.Transition.t()]
}

Link to this section Functions

complete(execution, step_id)

complete(t(), atom()) :: {:ok, t()} | {:error, String.t(), t()}

Completes a step and transitions the execution with {:completed, step_id} event.

complete!(execution, step_id)

complete?(execution)

continue(workflow, state_name)

continue(module(), String.t()) :: t()

Continues a workflow execution from the specified state.

continue(workflow, state_name, context)

continue(module(), String.t(), map()) :: t()

continue(chart, callback_mod, state_name, context)

continue(ExState.Definition.Chart.t(), module(), String.t(), map()) :: t()

decision(execution, step_id, decision)

decision(t(), atom(), atom()) :: {:ok, t()} | {:error, String.t(), t()}

Completes a decision and transitions the execution with {:decision, step_id, decision} event.

decision!(execution, step_id, decision)

dump(execution)

Returns serializable data representing the execution.

execute_action(execution, action)

execute_action(t(), atom()) :: {:ok, t(), any()} | {:error, any()}

Executes the provided action name through the callback module.

execute_actions(execution)

execute_actions(t()) :: {:ok, t(), map()} | {:error, t(), any()}

Executes any queued actions on the execution.

execute_actions!(execution)

get_state(execution, name)

get_subject(execution)

new(workflow)

new(module()) :: t()

Creates a new workflow execution from the initial state.

new(workflow, context)

new(module(), map()) :: t()

new(chart, callback_mod, context)

new(ExState.Definition.Chart.t(), module(), map()) :: t()

put_context(execution, context)

put_context(execution, key, value)

put_state(execution, state)

put_subject(execution, subject)

put_transition(execution, transition)

transition(execution, event)

transition(t(), ExState.Definition.Transition.event()) ::
  {:ok, t()} | {:error, String.t(), t()}

Transitions execution with the event and returns a result tuple.

transition!(execution, event)

transition_maybe(execution, event)

Transitions execution with the event and returns updated or unchanged execution.

will_transition?(execution, event)

with_completed(execution, state_name, step_name, decision \\ nil)

with_completed(t(), String.t(), String.t(), any()) :: t()

Continues a workflow execution with the completed steps. Use in conjunction with continue to resume execution.

with_meta(execution, key, value)

with_meta(t(), any(), any()) :: t()