partition by org_id and add auth

lib/customer_service_web/controllers/customer.ex

@@ -12,6 +12,7 @@ defmodule CustomerServiceWeb.CustomerController do
   alias CustomerService.Customer.Queries, as: CustomerQueries
   alias CustomerServiceWeb.Schemas.Customer, as: CustomerSchemas
   alias CustomerServiceWeb.QueryHelpers
+  alias CustomerService.Aggregates.CustomerId
 
   operation(:index,
     summary: "List customers",
@@ -27,7 +28,9 @@ defmodule CustomerServiceWeb.CustomerController do
   )
 
   def index(conn, params) do
-    case CustomerQueries.list_customers(params) do
+    org_id = conn.private[CustomerServiceWeb.Plugs.ExtractOrganizationId]
+
+    case CustomerQueries.list_by_org(org_id, params) do
       {:ok, {customers, meta}} ->
         conn
         |> put_status(:ok)
@@ -62,12 +65,17 @@ defmodule CustomerServiceWeb.CustomerController do
   )
 
   def show(conn, %{"id" => id}) do
-    case CustomerQueries.get_customer(id) do
-      {:ok, customer} ->
-        conn |> put_status(:ok) |> json(%{data: customer_json(customer)})
+    org_id = conn.private[CustomerServiceWeb.Plugs.ExtractOrganizationId]
 
+    with {:ok, %CustomerId{customer_id: local_id}} <- CustomerId.parse(id),
+         {:ok, customer} <- CustomerQueries.get_by_org(org_id, local_id) do
+      conn |> put_status(:ok) |> json(%{data: customer_json(customer)})
+    else
       {:error, :not_found} ->
         conn |> put_status(:not_found) |> json(%{error: "not found"})
+
+      :error ->
+        conn |> put_status(:bad_request) |> json(%{error: "invalid customer id"})
     end
   end
 
@@ -81,7 +89,10 @@ defmodule CustomerServiceWeb.CustomerController do
   )
 
   def create(conn, params) do
-    customer_id = Ecto.UUID.generate()
+    org_id = conn.private[CustomerServiceWeb.Plugs.ExtractOrganizationId]
+    customer_type = "individual"
+    customer_uuid = Ecto.UUID.generate()
+    customer_id = CustomerId.new(org_id, customer_type, customer_uuid)
 
     command = %CreateCustomer{
       id: customer_id,
@@ -108,7 +119,10 @@ defmodule CustomerServiceWeb.CustomerController do
   )
 
   def create_corporate(conn, params) do
-    customer_id = Ecto.UUID.generate()
+    org_id = conn.private[CustomerServiceWeb.Plugs.ExtractOrganizationId]
+    customer_type = "corporate"
+    customer_uuid = Ecto.UUID.generate()
+    customer_id = CustomerId.new(org_id, customer_type, customer_uuid)
 
     command = %CreateCorporateCustomer{
       id: customer_id,
@@ -138,19 +152,30 @@ defmodule CustomerServiceWeb.CustomerController do
   )
 
   def update(conn, %{"id" => id} = params) do
-    command = %UpdateCustomer{
-      id: id,
-      first_name: params["first_name"],
-      last_name: params["last_name"],
-      birth_date: parse_date(params["birth_date"]),
-      gender: params["gender"],
-      email: params["email"],
-      phone: params["phone"],
-      document_id: params["document_id"],
-      address: params["address"]
-    }
+    org_id = conn.private[CustomerServiceWeb.Plugs.ExtractOrganizationId]
 
-    dispatch_and_return(conn, command, id)
+    with {:ok, %CustomerId{customer_id: local_id}} <- CustomerId.parse(id),
+         {:ok, _customer} <- CustomerQueries.get_by_org(org_id, local_id) do
+      command = %UpdateCustomer{
+        id: CustomerId.new(org_id, "individual", local_id),
+        first_name: params["first_name"],
+        last_name: params["last_name"],
+        birth_date: parse_date(params["birth_date"]),
+        gender: params["gender"],
+        email: params["email"],
+        phone: params["phone"],
+        document_id: params["document_id"],
+        address: params["address"]
+      }
+
+      dispatch_and_return(conn, command, CustomerId.new(org_id, "individual", local_id))
+    else
+      {:error, :not_found} ->
+        conn |> put_status(:not_found) |> json(%{error: "not found"})
+
+      :error ->
+        conn |> put_status(:bad_request) |> json(%{error: "invalid customer id"})
+    end
   end
 
   operation(:update_corporate,
@@ -167,29 +192,55 @@ defmodule CustomerServiceWeb.CustomerController do
   )
 
   def update_corporate(conn, %{"id" => id} = params) do
-    command = %UpdateCorporateCustomer{
-      id: id,
-      legal_name: params["legal_name"],
-      commercial_name: params["commercial_name"],
-      ruc: params["ruc"],
-      legal_rep_name: params["legal_rep_name"],
-      legal_rep_document_id: params["legal_rep_document_id"],
-      email: params["email"],
-      phone: params["phone"],
-      address: params["address"]
-    }
+    org_id = conn.private[CustomerServiceWeb.Plugs.ExtractOrganizationId]
 
-    dispatch_and_return(conn, command, id)
+    with {:ok, %CustomerId{customer_id: local_id}} <- CustomerId.parse(id),
+         {:ok, _customer} <- CustomerQueries.get_by_org(org_id, local_id) do
+      command = %UpdateCorporateCustomer{
+        id: CustomerId.new(org_id, "corporate", local_id),
+        legal_name: params["legal_name"],
+        commercial_name: params["commercial_name"],
+        ruc: params["ruc"],
+        legal_rep_name: params["legal_rep_name"],
+        legal_rep_document_id: params["legal_rep_document_id"],
+        email: params["email"],
+        phone: params["phone"],
+        address: params["address"]
+      }
+
+      dispatch_and_return(conn, command, CustomerId.new(org_id, "corporate", local_id))
+    else
+      {:error, :not_found} ->
+        conn |> put_status(:not_found) |> json(%{error: "not found"})
+
+      :error ->
+        conn |> put_status(:bad_request) |> json(%{error: "invalid customer id"})
+    end
   end
 
-  # ---------------------------------------------------------------------------
-  # Private
-  # ---------------------------------------------------------------------------
-
-  defp dispatch_and_return(conn, command, customer_id) do
+  defp dispatch_and_return(conn, command, %CustomerId{} = customer_id) do
     case CustomerService.CommandedApp.dispatch(command, consistency: :strong) do
       :ok ->
-        case CustomerQueries.get_customer(customer_id) do
+        case CustomerQueries.get_customer(CustomerId.to_string(customer_id)) do
+          {:ok, customer} ->
+            conn |> put_status(:ok) |> json(%{data: customer_json(customer)})
+
+          {:error, :not_found} ->
+            conn
+            |> put_status(:internal_server_error)
+            |> json(%{error: "customer created but not found in projection"})
+        end
+
+      {:error, reason} ->
+        conn |> put_status(:unprocessable_entity) |> json(%{error: inspect(reason)})
+    end
+  end
+
+  defp dispatch_and_return(conn, command, customer_id_string)
+       when is_binary(customer_id_string) do
+    case CustomerService.CommandedApp.dispatch(command, consistency: :strong) do
+      :ok ->
+        case CustomerQueries.get_customer(customer_id_string) do
           {:ok, customer} ->
             conn |> put_status(:ok) |> json(%{data: customer_json(customer)})