310 lines
9.9 KiB
Elixir
310 lines
9.9 KiB
Elixir
defmodule PolicyService.Aggregates.CarPolicyApplication do
|
|
@moduledoc """
|
|
Aggregate for managing car insurance policy applications.
|
|
|
|
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
|
|
|
|
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
|
|
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
|
|
end
|