Toolbox.Report behaviour (toolbox v1.1.0)
Behaviour module for notification reports.
This behaviour encapsulates notifications which behave like reports = notifications are sent periodically.
example
Example
defmodule Scenarios.Template.Reporter do
@callback Toolbox.Scenario.Template.StageBased
alias Crontab.CronExpression
alias Scenarios.Template.Reporter.DailyReport
alias Toolbox.Message
alias Toolbox.Report
alias Toolbox.Runtime.Stage.Unit
alias Toolbox.Scenario.OutputAction
import Crontab.CronExpression
@impl true
def init(init_timestamp, %Unit{} = unit) do
# report schedule defined as crontab expression
report_schedule = ~e[* * * * *]
# timezone used to display localized timestamp in notification
timezone = "Europe/Prague"
# args to init report state
init_arg = :ok
{:ok, outputs, report_state} =
Report.init(DailyReport, init_timestamp, report_schedule, timezone, init_arg)
{:ok, outputs, %Unit{unit | state: %{report_state: report_state}}}
end
@impl true
def handle_message(%Message{} = msg, %Unit{} = unit) do
{:ok, outputs, report_state} = Report.process_message(unit.state.report_state, msg)
{:reply, outputs, %Unit{unit | state: %{unit.state | report_state: report_state}}}
end
end
defmodule Scenarios.Template.Reporter.DailyReport do
@callback Toolbox.Report
alias Toolbox.Message
alias Toolbox.Scenario.OutputAction
@impl true
def init(:ok) do
{:ok, [], %{incomming_messages: []}}
end
@impl true
def handle_process_message(%{} = state, %Message{} = msg) do
{:ok, [], %{incomming_messages: [msg | state.incomming_messages]}}
end
@impl true
def handle_publish_report(%{} = state, publish_timestamp, last_publish_timestamp) do
report_notification =
OutputAction.new_notification_action(publish_timestamp, %{
type: :daily_report,
primary_asset: nil,
data: %{
"incomming_messages" => state.incomming_messages,
"publish_time" => publish_timestamp,
"last_publish_time" => last_timestamp
}
})
{:ok, [report_notification], %{incomming_messages: []}}
end
end
Link to this section Summary
Functions
Initializes report
Processes report message
Resolves date time into non-ambiguous DateTime.
Link to this section Types
Link to this type
report_state()
@type report_state() :: term()
Link to this type
timestamp()
@type timestamp() :: integer()
Link to this section Callbacks
Link to this callback
handle_process_message(report_state, t)
@callback handle_process_message(report_state(), Toolbox.Message.t()) :: {:ok, [term()], report_state()}
Link to this callback
handle_publish_report(report_state, current_report, last_report)
@callback handle_publish_report( report_state(), current_report :: timestamp(), last_report :: timestamp() ) :: {:ok, [term()], report_state()}
Link to this callback
init(term)
@callback init(term()) :: {:ok, [term()], report_state()}
Link to this section Functions
Link to this function
init(report_mod, init_timestamp, cron_expr, timezone, init_arg)
@spec init(module(), timestamp(), Crontab.CronExpression.t(), String.t(), term()) :: {:ok, [term()], Toolbox.Report.State.t()}
Initializes report
Link to this function
process_message(state, msg)
@spec process_message(Toolbox.Report.State.t(), Toolbox.Message.t()) :: {:ok, [term()], Toolbox.Report.State.t()}
Processes report message
Link to this function
resolve_ambiguous_datetime(datetime)
@spec resolve_ambiguous_datetime(Timex.AmbiguousDateTime.t() | DateTime.t()) :: DateTime.t()
Resolves date time into non-ambiguous DateTime.
If AmbiguousDateTime is given, it picks one version. If any other non-ambiguous date time is given it is returned as is.