defmodule Runbox.Scenario.Notification do
@moduledoc group: :internal
@moduledoc """
Module contains functions for working with scenario notifications.
"""
@notification_subfolder "notifications"
@overrides_subfolder "./settings/scenario_notification_overrides"
@template_subfolder "templates"
@type template() :: %{
notification_type: String.t(),
template_type: String.t(),
channel: String.t(),
language: String.t(),
filename: String.t(),
defined_in: :scenario | :deployment,
absolute_path: Path.t()
}
@doc """
Lists all template files defined for a particular scenario.
It returns both templates from the scenario and overrides from the deployment. The source can be
discriminated using the `:defined_in` key.
"""
@spec list_templates(String.t()) :: [template()]
def list_templates(scenario_id) do
default_subfolder = default_templates_base_folder(scenario_id)
override_subfolder = overrides_base_folder(scenario_id)
sources = [scenario: default_subfolder, deployment: override_subfolder]
for {source, base_folder} <- sources,
absolute_path <- Path.wildcard("#{base_folder}/*/*/*/*/*.eex") do
relative_path = Path.relative_to(absolute_path, base_folder)
[notification_type, template_type, channel, language, filename] = Path.split(relative_path)
%{
notification_type: notification_type,
template_type: template_type,
channel: channel,
language: language,
filename: filename,
defined_in: source,
absolute_path: absolute_path
}
end
end
@doc """
Lists all notification types for a scenario.
"""
@spec list_notification_types(String.t()) :: {:ok, [String.t()]}
def list_notification_types(scenario_id) do
default_subfolder = default_templates_base_folder(scenario_id)
override_subfolder = overrides_base_folder(scenario_id)
get(default_subfolder, override_subfolder)
end
@doc """
Lists all template types of the specified notification.
"""
@spec list_template_types(String.t(), String.t()) :: {:ok, [String.t()]}
def list_template_types(scenario_id, notification_type) do
default_subfolder =
Path.join([default_templates_base_folder(scenario_id), to_string(notification_type)])
override_subfolder =
Path.join([overrides_base_folder(scenario_id), to_string(notification_type)])
get(default_subfolder, override_subfolder)
end
@doc """
Lists all channels with templates defined for scenario, notification type and template type.
"""
@spec list_channels(String.t(), String.t(), String.t()) :: {:ok, [String.t()]}
def list_channels(scenario_id, notification_type, template_type) do
default_subfolder =
Path.join([
default_templates_base_folder(scenario_id),
to_string(notification_type),
to_string(template_type)
])
override_subfolder =
Path.join([
overrides_base_folder(scenario_id),
to_string(notification_type),
to_string(template_type)
])
get(default_subfolder, override_subfolder)
end
@doc """
Lists all template languages defined for scenario, notification type, template type and channel.
"""
@spec list_languages(String.t(), String.t(), String.t(), String.t()) :: {:ok, [String.t()]}
def list_languages(scenario_id, notification_type, template_type, channel) do
default_subfolder =
Path.join([
default_templates_base_folder(scenario_id),
to_string(notification_type),
to_string(template_type),
to_string(channel)
])
override_subfolder =
Path.join([
overrides_base_folder(scenario_id),
to_string(notification_type),
to_string(template_type),
to_string(channel)
])
get(default_subfolder, override_subfolder)
end
@doc """
Loads and evaluates templates specified by scenario, notification type, template type, channel
and language.
If language is not defined or does not exist, `fallback_language` is used.
"""
@spec load_and_eval_templates(
scenario_id :: String.t(),
notification_type :: String.t(),
template_type :: String.t(),
channel :: String.t(),
language :: String.t(),
data :: keyword(),
fallback_language :: String.t()
) :: {:ok, %{String.t() => String.t()}} | {:error, atom(), String.t()}
def load_and_eval_templates(
scenario,
notification_type,
template_type,
channel,
language,
data,
fallback_language
) do
with {:ok, templates} <-
load_templates(
scenario,
notification_type,
template_type,
channel,
language,
fallback_language
) do
{:ok, Enum.into(templates, %{}, fn {name, fun} -> {name, fun.(data)} end)}
end
end
defp load_templates(
scenario,
notification_type,
template_type,
channel,
language,
fallback_language
) do
overrides_folder =
Path.join([
overrides_base_folder(scenario),
template_subfolder(notification_type, template_type, channel, language)
])
overrides_fallback_folder =
if fallback_language do
Path.join([
overrides_base_folder(scenario),
template_subfolder(notification_type, template_type, channel, fallback_language)
])
end
default_folder =
Path.join([
default_templates_base_folder(scenario),
template_subfolder(notification_type, template_type, channel, language)
])
default_fallback_folder =
if fallback_language do
Path.join([
default_templates_base_folder(scenario),
template_subfolder(notification_type, template_type, channel, fallback_language)
])
end
[overrides_folder, overrides_fallback_folder, default_folder, default_fallback_folder]
|> Enum.reject(&is_nil/1)
|> Enum.reduce_while(
nil,
fn folder, _ ->
case compile_templates(folder) do
{:ok, _template_map} = res ->
{:halt, res}
{:error, _, _} = error ->
{:cont, error}
end
end
)
end
# finds all template files in the `folder` and compiles them.
# if any template fails then the whole compilation fails; also fails if no templates are found
defp compile_templates(folder) do
{templates, errors} =
folder
|> ls()
|> Enum.filter(&String.ends_with?(&1, ".eex"))
|> Enum.map(fn file ->
{template_name(file), compile_template(Path.join([folder, file]))}
end)
|> Enum.split_with(&match?({_, {:ok, _}}, &1))
case {templates, errors} do
{[], []} -> {:error, :no_templates_found, folder}
{_, []} -> {:ok, Enum.into(templates, %{}, fn {name, {:ok, fun}} -> {name, fun} end)}
{_, [{_name, error} | _rest]} -> error
end
end
defp compile_template(file) do
compiled = EEx.compile_file(file)
{:ok, fn bindings -> elem(Code.eval_quoted(compiled, bindings, file: file), 0) end}
rescue
_ in File.Error -> {:error, :not_found, file}
_ in EEx.SyntaxError -> {:error, :bad_syntax, file}
end
defp default_templates_base_folder(scenario_id) do
Path.join(scenario_notifications_path(scenario_id), @template_subfolder)
end
defp overrides_base_folder(scenario_id) do
path = Runbox.Utils.Path.resolve_path(@overrides_subfolder)
Path.join([path, scenario_id, @template_subfolder])
end
defp template_subfolder(notification_type, template_type, channel, language) do
Path.join([
to_string(notification_type),
to_string(template_type),
to_string(channel),
to_string(language)
])
end
defp scenario_notifications_path(scenario_id) do
scenario_app = Application.fetch_env!(:runbox, :scenario_app)
Path.join([:code.priv_dir(scenario_app), @notification_subfolder, to_string(scenario_id)])
end
# lists all files and dirs in a path
defp ls(path) do
case File.ls(path) do
{:ok, files} -> files
_ -> []
end
end
# extract template name from filename (i.e. "content.eex")
defp template_name(file) do
String.slice(file, 0..-5//1)
end
defp get(default_subfolder, override_subfolder) do
defaults = ls(default_subfolder)
overrides = ls(override_subfolder)
{:ok,
defaults
|> Enum.concat(overrides)
|> Enum.uniq()}
end
end
