defmodule StepFlow.Step.Helpers do
@moduledoc """
The Helper Step context.
"""
@doc """
Retrieves a value on an Objecta and filtered by the key.
"""
def get_value_in_parameters(object, key) do
StepFlow.Map.get_by_key_or_atom(object, :parameters, [])
|> Enum.filter(fn param ->
StepFlow.Map.get_by_key_or_atom(param, :id) == key
end)
|> Enum.map(fn param ->
StepFlow.Map.get_by_key_or_atom(
param,
:value,
StepFlow.Map.get_by_key_or_atom(param, :default)
)
end)
end
@doc """
Retrieves a value on an Object and filtered by the key and type.
"""
def get_value_in_parameters_with_type(object, key, type) do
StepFlow.Map.get_by_key_or_atom(object, :parameters, [])
|> Enum.filter(fn param ->
StepFlow.Map.get_by_key_or_atom(param, :id) == key &&
StepFlow.Map.get_by_key_or_atom(param, :type) == type
end)
|> Enum.map(fn param ->
StepFlow.Map.get_by_key_or_atom(
param,
:value,
StepFlow.Map.get_by_key_or_atom(param, :default)
)
end)
end
def get_string_or_processed_template_value(
workflow,
step,
dates,
source_paths,
key,
default \\ ""
) do
get_value_in_parameters_with_type(step, key, "string")
|> List.first()
|> case do
nil ->
get_value_in_parameters_with_type(step, key, "template")
|> List.first()
|> case do
nil ->
default
template ->
template
|> template_process(workflow, step, dates, source_paths)
end
strng_value ->
strng_value
end
end
def get_jobs_destination_paths(jobs) do
jobs
|> Enum.map(fn job ->
get_job_destination_paths(job)
end)
|> List.flatten()
|> Enum.uniq()
|> Enum.filter(fn path -> !is_nil(path) end)
end
def get_job_destination_paths(job) do
destination_path = get_value_in_parameters(job, "destination_path")
destination_paths = get_value_in_parameters(job, "destination_paths")
destination_path ++ destination_paths
end
@doc """
Filter a list of paths.
## Examples
iex> StepFlow.Step.Helpers.filter_path_list(["path_1.ext1", "path2.ext2"], [%{"ends_with" => ".ext2"}])
["path2.ext2"]
iex> StepFlow.Step.Helpers.filter_path_list(["path_1.ext1", "path2.ext2"], [%{ends_with: ".ext2"}])
["path2.ext2"]
"""
def filter_path_list(source_paths, []), do: source_paths
def filter_path_list(source_paths, [filter | filters]) do
new_source_paths =
case filter do
%{ends_with: ends_with} ->
Enum.filter(source_paths, fn path -> String.ends_with?(path, ends_with) end)
%{"ends_with" => ends_with} ->
Enum.filter(source_paths, fn path -> String.ends_with?(path, ends_with) end)
end
filter_path_list(new_source_paths, filters)
end
def filter_empty(source_paths) do
source_paths
|> Enum.filter(fn path -> !blank?(path) end)
end
def filter_empty_templated(defined_parameters) do
defined_parameters
|> Enum.filter(fn {_, value} -> value != "nil" and !blank?(value) end)
end
def filter_untemplated(parameters) do
parameters
|> Enum.filter(fn value -> !String.contains?(value, ["{", "}"]) end)
end
def get_step_requirements(jobs, step) do
%{paths: get_required_paths(jobs, step)}
end
def get_required_paths(jobs, step) do
# required does not refer to anything for now
required_ids = StepFlow.Map.get_by_key_or_atom(step, :required, [])
jobs
|> Enum.filter(fn job -> job.step_id in required_ids end)
|> get_jobs_destination_paths
end
def add_required_paths(requirements, paths) when is_list(paths) do
Map.update(requirements, :paths, paths, fn cur_paths ->
Enum.concat(cur_paths, paths)
|> Enum.uniq()
end)
end
def add_required_paths(requirements, path) do
paths =
Map.get(requirements, :paths, [])
|> List.insert_at(-1, path)
add_required_paths(requirements, paths)
end
def get_dates do
now = Timex.now()
%{
date_time: Timex.format!(now, "%Y_%m_%d__%H_%M_%S", :strftime),
date: Timex.format!(now, "%Y_%m_%d", :strftime),
epoch: Timex.epoch()
}
end
def get_work_directory(step) do
StepFlow.Map.get_by_key_or_atom(step, :work_dir) ||
StepFlow.Configuration.get_var_value(StepFlow, :workers_work_directory) ||
""
end
def get_base_directory(workflow, step) do
get_work_directory(step) <> "/" <> Integer.to_string(workflow.id) <> "/"
end
def templates_process(_templates, _workflow, _step, _dates, result \\ [])
def templates_process([], _workflow, _step, _dates, result), do: result
def templates_process([template | templates], workflow, step, dates, result) do
processed = intern_template_process(template, workflow, step, dates, [])
result = List.insert_at(result, -1, processed)
templates_process(templates, workflow, step, dates, result)
end
def templates_process(template, workflow, step, dates, _result) do
intern_template_process(template, workflow, step, dates, [])
end
def template_process(template, workflow, step, dates, nil) do
intern_template_process(template, workflow, step, dates, [])
end
def template_process(template, workflow, step, dates, source_path)
when is_binary(source_path) do
filename = Path.basename(source_path)
extension = Path.extname(source_path)
name = Path.basename(source_path, extension)
source_keywords =
Keyword.new()
|> Keyword.put(:source_path, source_path)
|> Keyword.put(:filename, filename)
|> Keyword.put(:extension, extension)
|> Keyword.put(:name, name)
intern_template_process(template, workflow, step, dates, source_keywords)
end
def template_process(template, workflow, step, dates, source_paths)
when is_list(source_paths) do
source_keywords =
Keyword.new()
|> Keyword.put(:source_paths, source_paths)
intern_template_process(template, workflow, step, dates, source_keywords)
end
defp intern_template_process(template, workflow, step, dates, source_keywords) do
step_parameters =
StepFlow.Map.get_by_key_or_atom(step, :parameters, [])
|> Enum.filter(fn item ->
StepFlow.Map.get_by_key_or_atom(item, :type) in [
"string",
"integer"
]
end)
|> Enum.map(fn item ->
identifier =
StepFlow.Map.get_by_key_or_atom(item, :id)
|> String.to_atom()
value =
StepFlow.Map.get_by_key_or_atom(
item,
:value,
StepFlow.Map.get_by_key_or_atom(item, :default)
)
{identifier, value}
end)
defined_parameters =
workflow.parameters
|> Enum.filter(fn item ->
StepFlow.Map.get_by_key_or_atom(item, :type) in [
"string",
"array_of_strings",
"integer",
"array_of_integers"
]
end)
|> Enum.map(fn item ->
identifier =
StepFlow.Map.get_by_key_or_atom(item, :id)
|> String.to_atom()
value =
StepFlow.Map.get_by_key_or_atom(
item,
:value,
StepFlow.Map.get_by_key_or_atom(item, :default)
)
|> convert_to_string()
{identifier, value}
end)
|> Keyword.put(:workflow_id, workflow.id)
|> Keyword.put(:workflow_reference, workflow.reference)
|> Keyword.put(:step_name, StepFlow.Map.get_by_key_or_atom(step, :name))
|> Keyword.put(:work_directory, get_work_directory(step))
|> Keyword.put(:date_time, dates.date_time)
|> Keyword.put(:date, dates.date)
|> Keyword.merge(source_keywords)
|> Keyword.merge(step_parameters)
defined_parameters
|> filter_empty_templated()
|> Keyword.keys()
|> replace(template)
|> EEx.eval_string(defined_parameters)
|> unstringify_array()
end
defp replace([], template), do: template
defp replace([key | keys], template) do
template =
String.replace(
template,
"{" <> Atom.to_string(key) <> "}",
"<%= " <> Atom.to_string(key) <> "%>"
)
replace(keys, template)
end
defp unstringify_array(template) do
# "[131e508b-d9a0-4811-be34-1e8c9ec11af6" will crash and probably not much to do
if String.starts_with?(template, "[") do
case JSON.decode(template) do
{:ok, array_template} ->
if is_list(array_template) do
array_template
else
template
end
{_, _} ->
template
end
else
template
end
end
defp convert_to_string(value) when is_bitstring(value), do: value
defp convert_to_string(value), do: "#{inspect(value)}"
# https://stackoverflow.com/questions/52482825/how-do-you-pattern-match-for-nil-or-a-blank-string-in-elixir
defp blank?(path),
do: "" == path |> to_string() |> String.trim()
end
