refactor buyer and insured and add more policy types

lib/policy_service/aggregates/car_policy_application.ex

@@ -11,21 +11,52 @@ defmodule PolicyService.Aggregates.CarPolicyApplication do
         "make" => make,
         "model" => model,
         "year" => year,
-        "car_value" => car_value,
+        "use_type" => use_type,
+        "car_type" => car_type,
+        "rc_limits" => _rc_limits,
+        "market_value" => market_value,
+        "requested_value" => requested_value
+      })
+      when is_binary(plate) and is_binary(make) and is_binary(model) and
+             is_integer(year) and
+             is_number(market_value) and market_value > 0 and
+             is_number(requested_value) and requested_value > 0 and
+             is_binary(use_type) and byte_size(use_type) > 0 and
+             is_binary(car_type) and byte_size(car_type) > 0 do
+    cond do
+      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(plate) == 0 -> {:error, :missing_plate}
+      true -> :ok
+    end
+  end
+
+  def validate_details(%{
+        "plate" => plate,
+        "make" => make,
+        "model" => model,
+        "year" => year,
         "use_type" => use_type,
         "car_type" => car_type,
         "chassis_number" => chassis,
-        "engine_number" => engine
+        "engine_number" => engine,
+        "rc_limits" => _rc_limits,
+        "market_value" => market_value,
+        "requested_value" => requested_value
       })
       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_integer(year) and
+             is_number(market_value) and market_value > 0 and
+             is_number(requested_value) and requested_value > 0 and
+             is_binary(use_type) and byte_size(use_type) > 0 and
+             is_binary(car_type) and byte_size(car_type) > 0 and
              is_binary(chassis) and is_binary(engine) do
     cond do
       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}
+      byte_size(plate) == 0 -> {:error, :missing_plate}
       true -> :ok
     end
   end

lib/policy_service/aggregates/fire_contents_policy_application.ex

@@ -0,0 +1,22 @@
+defmodule PolicyService.Aggregates.FireContentsPolicyApplication do
+  use PolicyService.Aggregates.PolicyApplication,
+    policy_type: "fire_contents",
+    commands: PolicyService.Commands.FireContentsPolicy
+
+  def validate_details(%{
+        "location" => location,
+        "contents_value" => value,
+        "property_use" => use_type,
+        "security_measures" => measures,
+        "high_value_items" => items
+      })
+      when is_binary(location) and byte_size(location) > 0 and
+             is_number(value) and value > 0 and
+             is_binary(use_type) and byte_size(use_type) > 0 and
+             is_list(measures) and
+             is_list(items) do
+    :ok
+  end
+
+  def validate_details(_), do: {:error, :invalid_fire_contents_details}
+end

lib/policy_service/aggregates/fire_structure_policy_application.ex

@@ -0,0 +1,22 @@
+defmodule PolicyService.Aggregates.FireStructurePolicyApplication do
+  use PolicyService.Aggregates.PolicyApplication,
+    policy_type: "fire_structure",
+    commands: PolicyService.Commands.FireStructurePolicy
+
+  def validate_details(%{
+        "location" => location,
+        "property_value" => value,
+        "property_use" => use_type,
+        "security_measures" => measures,
+        "market_value" => market_value
+      })
+      when is_binary(location) and byte_size(location) > 0 and
+             is_number(value) and value > 0 and
+             is_binary(use_type) and byte_size(use_type) > 0 and
+             is_list(measures) and
+             is_number(market_value) and market_value > 0 do
+    :ok
+  end
+
+  def validate_details(_), do: {:error, :invalid_fire_structure_details}
+end

lib/policy_service/aggregates/policy_application.ex

@@ -39,7 +39,8 @@ defmodule PolicyService.Aggregates.PolicyApplication do
       defstruct [
         :id,
         :submitted_by,
-        :applicant_info,
+        :insured,
+        :buyer,
         :policy_details,
         :selected_providers,
         :accepted_plan_id,
@@ -52,13 +53,15 @@ defmodule PolicyService.Aggregates.PolicyApplication do
         endorsements: %{}
       ]
 
-      # ── Execute ────────────────────────────────────────────────────────────
+      # ── 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),
+               PolicyService.Aggregates.PolicyApplication.validate_insured(cmd.insured),
+             :ok <-
+               PolicyService.Aggregates.PolicyApplication.validate_buyer(cmd.buyer),
              :ok <- validate_details(cmd.policy_details),
              :ok <-
                PolicyService.Aggregates.PolicyApplication.validate_providers(
@@ -70,7 +73,8 @@ defmodule PolicyService.Aggregates.PolicyApplication do
                 id: cmd.id,
                 provider_id: provider.provider_id,
                 provider_email: provider.email,
-                applicant_info: cmd.applicant_info,
+                insured: cmd.insured,
+                buyer: cmd.buyer,
                 policy_details: cmd.policy_details,
                 requested_at: DateTime.utc_now()
               }
@@ -80,7 +84,8 @@ defmodule PolicyService.Aggregates.PolicyApplication do
             %PolicyApplicationSubmitted{
               id: cmd.id,
               submitted_by: cmd.submitted_by,
-              applicant_info: cmd.applicant_info,
+              insured: cmd.insured,
+              buyer: cmd.buyer,
               policy_details: cmd.policy_details,
               selected_providers: cmd.selected_providers,
               submitted_at: DateTime.utc_now()
@@ -178,7 +183,7 @@ defmodule PolicyService.Aggregates.PolicyApplication do
         }
       end
 
-      # ── Apply ──────────────────────────────────────────────────────────────
+      # ── Apply ──────────────────────────────────────────────────────
 
       @impl Commanded.Aggregates.Aggregate
       def apply(%__MODULE__{} = agg, %PolicyApplicationSubmitted{} = e) do
@@ -186,7 +191,8 @@ defmodule PolicyService.Aggregates.PolicyApplication do
           agg
           | id: e.id,
             submitted_by: e.submitted_by,
-            applicant_info: e.applicant_info,
+            insured: e.insured,
+            buyer: e.buyer,
             policy_details: e.policy_details,
             selected_providers: e.selected_providers,
             quotes: %{},
@@ -247,12 +253,17 @@ defmodule PolicyService.Aggregates.PolicyApplication do
   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})
+  def validate_insured(%{
+        "type" => "individual",
+        "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(%{
+  def validate_insured(%{
+        "type" => "corporate",
         "company_name" => c,
         "ruc" => r,
         "legal_rep_name" => rep,
@@ -262,7 +273,29 @@ defmodule PolicyService.Aggregates.PolicyApplication do
              byte_size(c) > 0 and byte_size(r) > 0,
       do: :ok
 
-  def validate_applicant(_), do: {:error, :invalid_applicant_info}
+  def validate_insured(_), do: {:error, :invalid_insured_info}
+
+  def validate_buyer(%{
+        "type" => "individual",
+        "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
+
+  def validate_buyer(%{
+        "type" => "corporate",
+        "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_buyer(_), do: {:error, :invalid_buyer_info}
 
   def validate_providers(p) when is_list(p) and length(p) > 0, do: :ok
   def validate_providers(_), do: {:error, :no_providers_selected}

lib/policy_service/aggregates/policy_id.ex

@@ -1,9 +1,9 @@
 defmodule PolicyService.Aggregates.PolicyId do
   @type t :: %__MODULE__{
-        org_id: String.t(),
-        policy_type: String.t(),
-        application_id: String.t()
-      }
+          org_id: String.t(),
+          policy_type: String.t(),
+          application_id: String.t()
+        }
   @derive Jason.Encoder
   defstruct [:org_id, :policy_type, :application_id]