This commit is contained in:
@@ -1,309 +1,34 @@
|
||||
defmodule PolicyService.Aggregates.CarPolicyApplication do
|
||||
@moduledoc """
|
||||
Aggregate for managing car insurance policy applications.
|
||||
use PolicyService.Aggregates.PolicyApplication,
|
||||
policy_type: "car",
|
||||
commands: PolicyService.Commands.CarPolicy
|
||||
|
||||
Lifecycle:
|
||||
nil → :awaiting_quotes → :solicitation_sent → :issued
|
||||
"""
|
||||
|
||||
defstruct [
|
||||
:application_id,
|
||||
:org_id,
|
||||
:submitted_by,
|
||||
:applicant_info,
|
||||
:car_details,
|
||||
:selected_providers,
|
||||
:quotes,
|
||||
:accepted_quote_id,
|
||||
:accepted_provider_id,
|
||||
:policy_number,
|
||||
:state
|
||||
]
|
||||
|
||||
alias PolicyService.Commands.Car.{
|
||||
SubmitCarPolicyApplication,
|
||||
RecordCarProviderQuote,
|
||||
AcceptCarQuoteAndSolicit,
|
||||
RecordCarPolicyIssued
|
||||
}
|
||||
|
||||
alias PolicyService.Events.Car.{
|
||||
CarPolicyApplicationSubmitted,
|
||||
CarProviderQuoteReceived,
|
||||
AllCarQuotesReceived,
|
||||
CarQuoteAccepted,
|
||||
CarSolicitationSent,
|
||||
CarPolicyIssued,
|
||||
CarQuoteRequestSent
|
||||
}
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Submit — establishes org ownership
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def execute(%__MODULE__{state: nil}, %SubmitCarPolicyApplication{} = cmd) do
|
||||
with :ok <- validate_org(cmd.org_id),
|
||||
:ok <- validate_user(cmd.submitted_by),
|
||||
:ok <- validate_applicant(cmd.applicant_info),
|
||||
:ok <- validate_car_details(cmd.car_details),
|
||||
:ok <- validate_providers(cmd.selected_providers) do
|
||||
quote_requests =
|
||||
Enum.map(cmd.selected_providers, fn provider ->
|
||||
%CarQuoteRequestSent{
|
||||
application_id: cmd.application_id,
|
||||
org_id: cmd.org_id,
|
||||
provider_id: provider.id,
|
||||
provider_email: provider.email,
|
||||
applicant_info: cmd.applicant_info,
|
||||
car_details: cmd.car_details,
|
||||
requested_at: DateTime.utc_now()
|
||||
}
|
||||
end)
|
||||
|
||||
[
|
||||
%CarPolicyApplicationSubmitted{
|
||||
application_id: cmd.application_id,
|
||||
org_id: cmd.org_id,
|
||||
submitted_by: cmd.submitted_by,
|
||||
applicant_info: cmd.applicant_info,
|
||||
car_details: cmd.car_details,
|
||||
selected_providers: cmd.selected_providers,
|
||||
submitted_at: DateTime.utc_now()
|
||||
}
|
||||
| quote_requests
|
||||
]
|
||||
end
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: state}, %SubmitCarPolicyApplication{}) do
|
||||
{:error, {:invalid_state, "cannot submit in state: #{state}"}}
|
||||
end
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Record provider quote — external webhook, verify org
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def execute(%__MODULE__{state: :awaiting_quotes} = agg, %RecordCarProviderQuote{} = cmd) do
|
||||
with :ok <- verify_org(agg, cmd) do
|
||||
if Map.has_key?(agg.quotes, cmd.provider_id) do
|
||||
{:error, {:duplicate_quote, "quote from provider #{cmd.provider_id} already received"}}
|
||||
else
|
||||
quote_event = %CarProviderQuoteReceived{
|
||||
application_id: cmd.application_id,
|
||||
org_id: agg.org_id,
|
||||
recorded_by: cmd.recorded_by,
|
||||
provider_id: cmd.provider_id,
|
||||
quote_id: cmd.quote_id,
|
||||
premium: cmd.premium,
|
||||
coverage_details: cmd.coverage_details,
|
||||
valid_until: cmd.valid_until,
|
||||
received_at: DateTime.utc_now()
|
||||
}
|
||||
|
||||
new_quote_count = map_size(agg.quotes) + 1
|
||||
|
||||
if new_quote_count == length(agg.selected_providers) do
|
||||
[
|
||||
quote_event,
|
||||
%AllCarQuotesReceived{
|
||||
application_id: cmd.application_id,
|
||||
org_id: agg.org_id,
|
||||
quote_count: new_quote_count
|
||||
}
|
||||
]
|
||||
else
|
||||
quote_event
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: state}, %RecordCarProviderQuote{}) do
|
||||
{:error, {:invalid_state, "cannot record quote in state: #{state}"}}
|
||||
end
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Accept quote and solicit — internal user action, verify org
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def execute(%__MODULE__{state: :awaiting_quotes} = agg, %AcceptCarQuoteAndSolicit{} = cmd) do
|
||||
with :ok <- verify_org(agg, cmd) do
|
||||
case find_quote(agg.quotes, cmd.quote_id) do
|
||||
nil ->
|
||||
{:error, {:quote_not_found, "quote #{cmd.quote_id} not found"}}
|
||||
|
||||
{provider_id, _quote} ->
|
||||
[
|
||||
%CarQuoteAccepted{
|
||||
application_id: cmd.application_id,
|
||||
org_id: agg.org_id,
|
||||
accepted_by: cmd.accepted_by,
|
||||
quote_id: cmd.quote_id,
|
||||
provider_id: provider_id,
|
||||
accepted_at: DateTime.utc_now()
|
||||
},
|
||||
%CarSolicitationSent{
|
||||
application_id: cmd.application_id,
|
||||
org_id: agg.org_id,
|
||||
provider_id: provider_id,
|
||||
quote_id: cmd.quote_id,
|
||||
sent_at: DateTime.utc_now()
|
||||
}
|
||||
]
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: state}, %AcceptCarQuoteAndSolicit{}) do
|
||||
{:error, {:invalid_state, "cannot accept quote in state: #{state}"}}
|
||||
end
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Record policy issued — external or internal, verify org
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def execute(%__MODULE__{state: :solicitation_sent} = agg, %RecordCarPolicyIssued{} = cmd) do
|
||||
with :ok <- verify_org(agg, cmd) do
|
||||
if cmd.provider_id != agg.accepted_provider_id do
|
||||
{:error, {:provider_mismatch, "policy issued by unexpected provider"}}
|
||||
else
|
||||
%CarPolicyIssued{
|
||||
application_id: cmd.application_id,
|
||||
org_id: agg.org_id,
|
||||
recorded_by: cmd.recorded_by,
|
||||
policy_number: cmd.policy_number,
|
||||
provider_id: cmd.provider_id,
|
||||
effective_date: cmd.effective_date,
|
||||
expiry_date: cmd.expiry_date,
|
||||
issued_at: DateTime.utc_now()
|
||||
}
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: state}, %RecordCarPolicyIssued{}) do
|
||||
{:error, {:invalid_state, "cannot record policy in state: #{state}"}}
|
||||
end
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Apply events
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
def apply(%__MODULE__{} = agg, %CarPolicyApplicationSubmitted{} = e) do
|
||||
%__MODULE__{
|
||||
agg
|
||||
| application_id: e.application_id,
|
||||
org_id: e.org_id,
|
||||
submitted_by: e.submitted_by,
|
||||
applicant_info: e.applicant_info,
|
||||
car_details: e.car_details,
|
||||
selected_providers: e.selected_providers,
|
||||
quotes: %{},
|
||||
state: :awaiting_quotes
|
||||
}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %CarQuoteRequestSent{}), do: agg
|
||||
|
||||
def apply(%__MODULE__{} = agg, %CarProviderQuoteReceived{} = e) do
|
||||
quote_data = %{
|
||||
quote_id: e.quote_id,
|
||||
premium: e.premium,
|
||||
coverage_details: e.coverage_details,
|
||||
valid_until: e.valid_until
|
||||
}
|
||||
|
||||
%__MODULE__{agg | quotes: Map.put(agg.quotes, e.provider_id, quote_data)}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %AllCarQuotesReceived{}), do: agg
|
||||
|
||||
def apply(%__MODULE__{} = agg, %CarQuoteAccepted{} = e) do
|
||||
%__MODULE__{agg | accepted_quote_id: e.quote_id, accepted_provider_id: e.provider_id}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %CarSolicitationSent{}) do
|
||||
%__MODULE__{agg | state: :solicitation_sent}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %CarPolicyIssued{} = e) do
|
||||
%__MODULE__{agg | policy_number: e.policy_number, state: :issued}
|
||||
end
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Private helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
defp verify_org(%__MODULE__{org_id: org_id}, %{org_id: cmd_org_id}) do
|
||||
if org_id == cmd_org_id,
|
||||
do: :ok,
|
||||
else: {:error, :org_mismatch}
|
||||
end
|
||||
|
||||
defp validate_org(org_id) when is_binary(org_id) and byte_size(org_id) > 0, do: :ok
|
||||
defp validate_org(_), do: {:error, :missing_org_id}
|
||||
|
||||
defp validate_user(user_id) when is_binary(user_id) and byte_size(user_id) > 0, do: :ok
|
||||
defp validate_user(_), do: {:error, :missing_user_id}
|
||||
|
||||
defp validate_applicant(%{name: name, date_of_birth: dob, document_id: doc})
|
||||
when is_binary(name) and is_binary(doc),
|
||||
do: :ok
|
||||
|
||||
defp validate_applicant(_), do: {:error, :invalid_applicant_info}
|
||||
|
||||
@valid_use_types ~w(private commercial bus taxi school)a
|
||||
@valid_car_types ~w(sedan suv hatchback coupe convertible pickup van minivan truck)a
|
||||
|
||||
defp validate_car_details(%{
|
||||
plate: plate,
|
||||
make: make,
|
||||
model: model,
|
||||
year: year,
|
||||
car_value: car_value,
|
||||
use_type: use_type,
|
||||
car_type: car_type,
|
||||
chassis_number: chassis_number,
|
||||
engine_number: engine_number
|
||||
})
|
||||
when is_binary(plate) and is_binary(make) and is_binary(model) and
|
||||
is_integer(year) and is_number(car_value) and car_value > 0 and
|
||||
is_binary(chassis_number) and is_binary(engine_number) do
|
||||
current_year = Date.utc_today().year
|
||||
@valid_use_types ~w(private commercial bus taxi school)
|
||||
@valid_car_types ~w(sedan suv hatchback coupe convertible pickup van minivan truck)
|
||||
|
||||
def validate_details(%{
|
||||
"plate" => plate,
|
||||
"make" => make,
|
||||
"model" => model,
|
||||
"year" => year,
|
||||
"car_value" => car_value,
|
||||
"use_type" => use_type,
|
||||
"car_type" => car_type,
|
||||
"chassis_number" => chassis,
|
||||
"engine_number" => engine
|
||||
})
|
||||
when is_binary(plate) and is_binary(make) and is_binary(model) and
|
||||
is_integer(year) and is_number(car_value) and car_value > 0 and
|
||||
is_binary(chassis) and is_binary(engine) do
|
||||
cond do
|
||||
year < 1886 ->
|
||||
{:error, :invalid_car_year}
|
||||
|
||||
year > current_year + 1 ->
|
||||
{:error, :invalid_car_year}
|
||||
|
||||
use_type not in @valid_use_types ->
|
||||
{:error, {:invalid_use_type, "must be one of: #{inspect(@valid_use_types)}"}}
|
||||
|
||||
car_type not in @valid_car_types ->
|
||||
{:error, {:invalid_car_type, "must be one of: #{inspect(@valid_car_types)}"}}
|
||||
|
||||
byte_size(chassis_number) == 0 ->
|
||||
{:error, :missing_chassis_number}
|
||||
|
||||
byte_size(engine_number) == 0 ->
|
||||
{:error, :missing_engine_number}
|
||||
|
||||
true ->
|
||||
:ok
|
||||
year < 1886 or year > Date.utc_today().year + 1 -> {:error, :invalid_car_year}
|
||||
use_type not in @valid_use_types -> {:error, :invalid_use_type}
|
||||
car_type not in @valid_car_types -> {:error, :invalid_car_type}
|
||||
byte_size(chassis) == 0 -> {:error, :missing_chassis_number}
|
||||
byte_size(engine) == 0 -> {:error, :missing_engine_number}
|
||||
true -> :ok
|
||||
end
|
||||
end
|
||||
|
||||
defp validate_car_details(_), do: {:error, :invalid_car_details}
|
||||
|
||||
defp validate_providers(providers)
|
||||
when is_list(providers) and length(providers) > 0,
|
||||
do: :ok
|
||||
|
||||
defp validate_providers(_), do: {:error, :no_providers_selected}
|
||||
|
||||
defp find_quote(quotes, quote_id) do
|
||||
Enum.find(quotes, fn {_provider_id, q} -> q.quote_id == quote_id end)
|
||||
end
|
||||
def validate_details(_), do: {:error, :invalid_car_details}
|
||||
end
|
||||
|
||||
11
lib/policy_service/aggregates/fire_policy_application.ex
Normal file
11
lib/policy_service/aggregates/fire_policy_application.ex
Normal file
@@ -0,0 +1,11 @@
|
||||
defmodule PolicyService.Aggregates.FirePolicyApplication do
|
||||
use PolicyService.Aggregates.PolicyApplication,
|
||||
policy_type: "fire",
|
||||
commands: PolicyService.Commands.FirePolicy
|
||||
|
||||
def validate_details(%{property_address: addr, property_value: val})
|
||||
when is_binary(addr) and byte_size(addr) > 0 and is_number(val) and val > 0,
|
||||
do: :ok
|
||||
|
||||
def validate_details(_), do: {:error, :invalid_fire_details}
|
||||
end
|
||||
284
lib/policy_service/aggregates/policy_application.ex
Normal file
284
lib/policy_service/aggregates/policy_application.ex
Normal file
@@ -0,0 +1,284 @@
|
||||
defmodule PolicyService.Aggregates.PolicyApplication do
|
||||
@moduledoc """
|
||||
Behaviour and __using__ macro for policy application aggregates.
|
||||
Each policy type implements validate_details/1 and declares its detail fields.
|
||||
|
||||
Usage:
|
||||
defmodule PolicyService.Aggregates.CarPolicyApplication do
|
||||
use PolicyService.Aggregates.PolicyApplication,
|
||||
policy_type: "car"
|
||||
end
|
||||
"""
|
||||
|
||||
@callback validate_details(map()) :: :ok | {:error, term()}
|
||||
|
||||
defmacro __using__(opts) do
|
||||
policy_type = Keyword.fetch!(opts, :policy_type)
|
||||
commands_module = Keyword.get(opts, :commands, PolicyService.Commands.Policy)
|
||||
|
||||
quote do
|
||||
@behaviour Commanded.Aggregates.Aggregate
|
||||
|
||||
alias unquote(commands_module).SubmitPolicyApplication
|
||||
alias unquote(commands_module).RecordProviderQuote
|
||||
alias unquote(commands_module).AcceptQuoteAndSolicit
|
||||
alias unquote(commands_module).RecordPolicyIssued
|
||||
|
||||
alias PolicyService.Events.Policy.{
|
||||
PolicyApplicationSubmitted,
|
||||
QuoteRequestSent,
|
||||
ProviderQuoteReceived,
|
||||
AllQuotesReceived,
|
||||
QuoteAccepted,
|
||||
SolicitationSent,
|
||||
PolicyIssued
|
||||
}
|
||||
|
||||
@policy_type unquote(policy_type)
|
||||
|
||||
defstruct [
|
||||
:id,
|
||||
:submitted_by,
|
||||
:applicant_info,
|
||||
:policy_details,
|
||||
:selected_providers,
|
||||
:accepted_quote_id,
|
||||
:accepted_plan_id,
|
||||
:accepted_provider_id,
|
||||
:solicitation_id,
|
||||
:policy_number,
|
||||
:effective_date,
|
||||
:expiry_date,
|
||||
:state,
|
||||
quotes: %{},
|
||||
pending_endorsements: %{}
|
||||
]
|
||||
|
||||
# ── Execute ────────────────────────────────────────────────────────────
|
||||
|
||||
@impl Commanded.Aggregates.Aggregate
|
||||
def execute(%__MODULE__{state: nil}, %SubmitPolicyApplication{} = cmd) do
|
||||
with :ok <- PolicyService.Aggregates.PolicyApplication.validate_policy_id(cmd.id),
|
||||
:ok <-
|
||||
PolicyService.Aggregates.PolicyApplication.validate_applicant(cmd.applicant_info),
|
||||
:ok <- validate_details(cmd.policy_details),
|
||||
:ok <-
|
||||
PolicyService.Aggregates.PolicyApplication.validate_providers(
|
||||
cmd.selected_providers
|
||||
) do
|
||||
quote_requests =
|
||||
Enum.map(cmd.selected_providers, fn provider ->
|
||||
%QuoteRequestSent{
|
||||
id: cmd.id,
|
||||
provider_id: provider.provider_id,
|
||||
provider_email: provider.email,
|
||||
applicant_info: cmd.applicant_info,
|
||||
policy_details: cmd.policy_details,
|
||||
requested_at: DateTime.utc_now()
|
||||
}
|
||||
end)
|
||||
|
||||
[
|
||||
%PolicyApplicationSubmitted{
|
||||
id: cmd.id,
|
||||
submitted_by: cmd.submitted_by,
|
||||
applicant_info: cmd.applicant_info,
|
||||
policy_details: cmd.policy_details,
|
||||
selected_providers: cmd.selected_providers,
|
||||
submitted_at: DateTime.utc_now()
|
||||
}
|
||||
| quote_requests
|
||||
]
|
||||
end
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: state}, %SubmitPolicyApplication{}) do
|
||||
{:error, {:invalid_state, "cannot submit in state: #{state}"}}
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: :awaiting_quotes} = agg, %RecordProviderQuote{} = cmd) do
|
||||
if Map.has_key?(agg.quotes, cmd.provider_id) do
|
||||
{:error, {:duplicate_quote, "quote from #{cmd.provider_id} already received"}}
|
||||
else
|
||||
quote_event = %ProviderQuoteReceived{
|
||||
id: cmd.id,
|
||||
recorded_by: cmd.recorded_by,
|
||||
provider_id: cmd.provider_id,
|
||||
quote_id: cmd.quote_id,
|
||||
valid_until: cmd.valid_until,
|
||||
plans: cmd.plans,
|
||||
received_at: DateTime.utc_now()
|
||||
}
|
||||
|
||||
new_quote_count = map_size(agg.quotes) + 1
|
||||
|
||||
if new_quote_count == length(agg.selected_providers) do
|
||||
[
|
||||
quote_event,
|
||||
%AllQuotesReceived{
|
||||
id: cmd.id,
|
||||
quote_count: new_quote_count
|
||||
}
|
||||
]
|
||||
else
|
||||
quote_event
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: state}, %RecordProviderQuote{}) do
|
||||
{:error, {:invalid_state, "cannot record quote in state: #{state}"}}
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: :awaiting_quotes}, %AcceptQuoteAndSolicit{}) do
|
||||
{:error, :no_quotes_received}
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: state}, %AcceptQuoteAndSolicit{})
|
||||
when state not in [:quotes_received] do
|
||||
{:error, :invalid_state}
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{} = agg, %AcceptQuoteAndSolicit{} = cmd) do
|
||||
with {:ok, quote} <-
|
||||
PolicyService.Aggregates.PolicyApplication.find_quote(agg, cmd.quote_id),
|
||||
{:ok, provider} <-
|
||||
PolicyService.Aggregates.PolicyApplication.find_provider(agg, quote.provider_id),
|
||||
{:ok, plan} <-
|
||||
PolicyService.Aggregates.PolicyApplication.find_plan(quote, cmd.plan_id) do
|
||||
%QuoteAccepted{
|
||||
id: agg.id,
|
||||
quote: quote,
|
||||
plan: plan,
|
||||
provider: provider,
|
||||
accepted_at: DateTime.utc_now()
|
||||
}
|
||||
end
|
||||
end
|
||||
|
||||
def execute(%__MODULE__{state: :issued}, %RecordPolicyIssued{}),
|
||||
do: {:error, :already_issued}
|
||||
|
||||
def execute(%__MODULE__{} = agg, %RecordPolicyIssued{} = cmd) do
|
||||
%PolicyIssued{
|
||||
id: agg.id,
|
||||
policy_number: cmd.policy_number,
|
||||
effective_date: cmd.effective_date,
|
||||
expiry_date: cmd.expiry_date,
|
||||
issued_at: cmd.issued_at || DateTime.utc_now()
|
||||
}
|
||||
end
|
||||
|
||||
# ── Apply ──────────────────────────────────────────────────────────────
|
||||
|
||||
@impl Commanded.Aggregates.Aggregate
|
||||
def apply(%__MODULE__{} = agg, %PolicyApplicationSubmitted{} = e) do
|
||||
%__MODULE__{
|
||||
agg
|
||||
| id: e.id,
|
||||
submitted_by: e.submitted_by,
|
||||
applicant_info: e.applicant_info,
|
||||
policy_details: e.policy_details,
|
||||
selected_providers: e.selected_providers,
|
||||
quotes: %{},
|
||||
state: :awaiting_quotes
|
||||
}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %QuoteRequestSent{}), do: agg
|
||||
|
||||
def apply(%__MODULE__{} = agg, %ProviderQuoteReceived{} = e) do
|
||||
quote_data = %{
|
||||
quote_id: e.quote_id,
|
||||
provider_id: e.provider_id,
|
||||
valid_until: e.valid_until,
|
||||
plans: e.plans || []
|
||||
}
|
||||
|
||||
%__MODULE__{agg | quotes: Map.put(agg.quotes, e.provider_id, quote_data)}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %AllQuotesReceived{}) do
|
||||
%__MODULE__{agg | state: :quotes_received}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %QuoteAccepted{} = e) do
|
||||
%__MODULE__{
|
||||
agg
|
||||
| accepted_quote_id: e.quote.quote_id,
|
||||
accepted_plan_id: e.plan.plan_id,
|
||||
accepted_provider_id: e.provider.provider_id,
|
||||
state: :solicitation_sent
|
||||
}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %SolicitationSent{} = e) do
|
||||
%__MODULE__{agg | solicitation_id: e.solicitation_id}
|
||||
end
|
||||
|
||||
def apply(%__MODULE__{} = agg, %PolicyIssued{} = e) do
|
||||
%__MODULE__{
|
||||
agg
|
||||
| policy_number: e.policy_number,
|
||||
effective_date: e.effective_date,
|
||||
expiry_date: e.expiry_date,
|
||||
state: :issued
|
||||
}
|
||||
end
|
||||
|
||||
# allow each aggregate to override any callback
|
||||
defoverridable execute: 2, apply: 2
|
||||
end
|
||||
end
|
||||
|
||||
def validate_policy_id(%PolicyService.Aggregates.PolicyId{policy_type: _}), do: :ok
|
||||
def validate_policy_id(_), do: {:error, :invalid_policy_id_format}
|
||||
|
||||
def validate_user(id) when is_binary(id) and byte_size(id) > 0, do: :ok
|
||||
def validate_user(_), do: {:error, :missing_user_id}
|
||||
|
||||
def validate_applicant(%{"name" => n, "date_of_birth" => _, "document_id" => d})
|
||||
when is_binary(n) and is_binary(d) and byte_size(n) > 0 and byte_size(d) > 0,
|
||||
do: :ok
|
||||
|
||||
# Match on string keys for Company
|
||||
def validate_applicant(%{
|
||||
"company_name" => c,
|
||||
"ruc" => r,
|
||||
"legal_rep_name" => rep,
|
||||
"legal_rep_document" => rd
|
||||
})
|
||||
when is_binary(c) and is_binary(r) and is_binary(rep) and is_binary(rd) and
|
||||
byte_size(c) > 0 and byte_size(r) > 0,
|
||||
do: :ok
|
||||
|
||||
def validate_applicant(_), do: {:error, :invalid_applicant_info}
|
||||
|
||||
def validate_providers(p) when is_list(p) and length(p) > 0, do: :ok
|
||||
def validate_providers(_), do: {:error, :no_providers_selected}
|
||||
|
||||
def find_quote(agg, quote_id) do
|
||||
case Enum.find(agg.quotes, fn {_, q} -> q.quote_id == quote_id end) do
|
||||
nil -> {:error, :quote_not_found}
|
||||
{_, quote} -> {:ok, quote}
|
||||
end
|
||||
end
|
||||
|
||||
def find_plan(quote, plan_id) do
|
||||
case Enum.find(quote.plans || [], fn p ->
|
||||
Map.get(p, :plan_id) == plan_id or Map.get(p, "plan_id") == plan_id
|
||||
end) do
|
||||
nil -> {:error, :plan_not_found}
|
||||
plan -> {:ok, plan}
|
||||
end
|
||||
end
|
||||
|
||||
def find_provider(agg, provider_id) do
|
||||
case Enum.find(agg.selected_providers || [], fn p ->
|
||||
Map.get(p, :provider_id) == provider_id
|
||||
end) do
|
||||
nil -> {:error, :provider_not_found}
|
||||
provider -> {:ok, provider}
|
||||
end
|
||||
end
|
||||
end
|
||||
48
lib/policy_service/aggregates/policy_id.ex
Normal file
48
lib/policy_service/aggregates/policy_id.ex
Normal file
@@ -0,0 +1,48 @@
|
||||
defmodule PolicyService.Aggregates.PolicyId do
|
||||
@derive Jason.Encoder
|
||||
defstruct [:org_id, :policy_type, :application_id]
|
||||
|
||||
def new(org_id, policy_type, application_id) do
|
||||
%__MODULE__{
|
||||
org_id: org_id,
|
||||
policy_type: policy_type,
|
||||
application_id: application_id
|
||||
}
|
||||
end
|
||||
|
||||
def parse(string) when is_binary(string) do
|
||||
case String.split(string, ":", parts: 3) do
|
||||
[org_id, policy_type, application_id] ->
|
||||
{:ok,
|
||||
%__MODULE__{
|
||||
org_id: org_id,
|
||||
policy_type: policy_type,
|
||||
application_id: application_id
|
||||
}}
|
||||
|
||||
_ ->
|
||||
{:error, :invalid_policy_id}
|
||||
end
|
||||
end
|
||||
|
||||
def parse!(string) do
|
||||
case parse(string) do
|
||||
{:ok, id} -> id
|
||||
{:error, reason} -> raise ArgumentError, "invalid policy id #{inspect(string)}: #{reason}"
|
||||
end
|
||||
end
|
||||
|
||||
defimpl String.Chars do
|
||||
def to_string(%PolicyService.Aggregates.PolicyId{
|
||||
org_id: org_id,
|
||||
policy_type: policy_type,
|
||||
application_id: application_id
|
||||
}) do
|
||||
org_id <> ":" <> policy_type <> ":" <> application_id
|
||||
end
|
||||
end
|
||||
|
||||
defimpl Commanded.Serialization.JsonDecoder do
|
||||
def decode(id), do: id
|
||||
end
|
||||
end
|
||||
Reference in New Issue
Block a user