wip

lib/policy_service/aggregates/policy_application.ex

@@ -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