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

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()
@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()}
@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)

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.