Packages
mozart
0.1.9
1.0.1
1.0.0
0.9.8
0.9.7
0.9.6
0.9.5
0.9.4
0.9.3
0.9.2
0.9.1
0.9.0
0.8.9
0.8.8
0.8.7
0.8.6
0.8.5
0.8.4
0.8.3
0.8.2
0.8.1
0.8.0
0.7.8
0.7.7
0.7.6
0.7.5
0.7.4
0.7.3
0.7.2
0.7.1
0.7.0
0.6.8
0.6.7
0.6.6
0.6.5
0.6.4
0.6.3
0.6.2
0.6.1
0.6.0
0.5.8
0.5.7
0.5.6
0.5.5
0.5.4
0.5.3
0.5.2
0.5.1
0.5.0
0.4.5
0.4.4
0.4.3
0.4.2
0.4.1
0.4.0
0.3.7
0.3.6
0.3.5
0.3.4
0.3.3
0.3.2
0.3.1
0.3.0
0.2.11
0.2.10
0.2.9
0.2.8
0.2.7
0.2.6
0.2.5
0.2.4
0.2.3
0.2.2
0.2.1
0.2.0
0.1.11
0.1.10
0.1.9
0.1.8
0.1.7
0.1.6
0.1.5
0.1.4
0.1.3
0.1.2
0.1.1
0.1.0
Mozart is an Elixir based BPM platform. It provides a powerful and highly readable DSL for implementing executable business process models.
Current section
Files
Jump to
Current section
Files
lib/mozart/process_model_service.ex
defmodule Mozart.ProcessModelService do
@moduledoc """
Acts as a reposatory for storing and retreiving `Mozart.Data.ProcessModel`
"""
@doc false
use GenServer
## Client API
@doc false
def start_link(_init_arg) do
{:ok, _pid} = GenServer.start_link(__MODULE__, nil, name: __MODULE__)
end
@doc """
Loads a list of `Mozart.Data.ProcessModel`s into the state of the
ProcessModelService.
"""
def load_process_models(models) do
GenServer.call(__MODULE__, {:load_process_models, models})
end
@doc """
Retrieves a process model by name.
"""
def get_process_model(model_name) do
GenServer.call(__MODULE__, {:get_process_model, model_name})
end
@doc """
Loads a single process model in the repository.
"""
def load_process_model(model) do
GenServer.call(__MODULE__, {:load_process_model, model})
end
@doc false
def clear_then_load_process_models(models) do
GenServer.call(__MODULE__, {:clear_then_load_process_models, models})
end
@doc false
def get_state() do
GenServer.call(__MODULE__, :get_state)
end
@doc false
def clear_state() do
GenServer.call(__MODULE__, :clear_state)
end
## GenServer Callbacks
@doc false
def init(_init_arg) do
{:ok, %{process_models: %{}}}
end
@doc false
def handle_call(:get_state, _from, state) do
{:reply, state, state}
end
@doc false
def handle_call(:clear_state, _from, state) do
state = Map.put(state, :process_models, %{})
{:reply, state, state}
end
@doc false
def handle_call({:load_process_models, models}, _from, state) do
model_list = Enum.map(models, fn m -> {m.name, m} end)
model_map = Enum.into(model_list, %{}, fn {key, value} -> {key, value} end)
updated_models = Map.merge(state.process_models, model_map)
{:reply, updated_models, Map.put(state, :process_models, updated_models)}
end
@doc false
def handle_call({:get_process_model, name}, _from, state) do
{:reply, Map.get(state.process_models, name), state}
end
@doc false
def handle_call({:load_process_model, process_model}, _from, state) do
process_models = Map.put(state.process_models, process_model.name, process_model)
state = Map.put(state, :process_models, process_models)
{:reply, state, state}
end
@doc false
def handle_call({:clear_then_load_process_models, models}, _from, state) do
process_models = Enum.map(models, fn model -> {model.name, model} end)
models = Enum.into(process_models, %{}, fn {key, value} -> {key, value} end)
{:reply, models, Map.put(state, :process_models, models)}
end
end