init commit

lib/customer_service_web/controllers/customer.ex

@@ -1,84 +1,181 @@
-defmodule CustomerServiceWeb.Customer do
+defmodule CustomerServiceWeb.CustomerController do
   use CustomerServiceWeb, :controller
-
-  alias CustomerServiceWeb.Schemas.CreateCustomerRequest
-  alias CustomerServiceWeb.Schemas.CustomerResponse
-  alias CustomerService.Commands.CreateCustomer
-  alias CustomerService.CommandedApp
   use OpenApiSpex.ControllerSpecs
 
-  tags ["Customers"]
+  alias CustomerService.Commands.{CreateCustomer, CreateCorporateCustomer}
+  alias CustomerService.Customer.Queries, as: CustomerQueries
+  alias CustomerServiceWeb.Schemas.Customer, as: CustomerSchemas
 
-  operation :create,
-    summary: "Create customer",
-    request_body: {"Customer data", "application/json", CreateCustomerRequest},
+  operation(:index,
+    summary: "List customers",
+    parameters: [
+      "page[number]": [in: :query, type: :integer, required: false],
+      "page[size]": [in: :query, type: :integer, required: false],
+      "filters[0][field]": [in: :query, type: :string, required: false],
+      "filters[0][op]": [in: :query, type: :string, required: false],
+      "filters[0][value]": [in: :query, type: :string, required: false]
+    ],
     responses: [
-      ok: {"Customer created", "application/json", CustomerResponse}
+      ok: {"Customer list", "application/json", CustomerSchemas.CustomerListResponse}
     ]
+  )
+
+  def index(conn, params) do
+    case CustomerQueries.list_customers(params) do
+      {:ok, {customers, meta}} ->
+        conn
+        |> put_status(:ok)
+        |> json(%{
+          data: Enum.map(customers, &customer_json/1),
+          meta: %{
+            total_count: meta.total_count,
+            total_pages: meta.total_pages,
+            current_page: meta.current_page,
+            page_size: meta.page_size,
+            has_next: meta.has_next_page?,
+            has_prev: meta.has_previous_page?
+          }
+        })
+
+      {:error, _meta} ->
+        conn
+        |> put_status(:bad_request)
+        |> json(%{error: "invalid parameters"})
+    end
+  end
+
+  operation(:show,
+    summary: "Get customer",
+    parameters: [
+      id: [in: :path, type: :string, required: true, description: "Customer ID"]
+    ],
+    responses: [
+      ok: {"Customer", "application/json", CustomerSchemas.CustomerResponse},
+      not_found: {"Not found", "application/json", %OpenApiSpex.Schema{type: :object}}
+    ]
+  )
+
+  def show(conn, %{"id" => id}) do
+    case CustomerQueries.get_customer(id) do
+      {:ok, customer} ->
+        conn |> put_status(:ok) |> json(%{data: customer_json(customer)})
+
+      {:error, :not_found} ->
+        conn |> put_status(:not_found) |> json(%{error: "not found"})
+    end
+  end
+
+  operation(:create,
+    summary: "Create individual customer",
+    request_body:
+      {"Customer data", "application/json", CustomerSchemas.CreateCustomer, required: true},
+    responses: [
+      ok: {"Customer created", "application/json", CustomerSchemas.CustomerResponse}
+    ]
+  )
 
   def create(conn, params) do
     customer_id = Ecto.UUID.generate()
 
-    command =
-      %CreateCustomer{
-        id: customer_id,
-        first_name: params["first_name"],
-        last_name: params["last_name"],
-        birth_date: Date.from_iso8601!(params["birth_date"]),
-        gender: params["gender"],
-        email: params["email"],
-        phone: params["phone"]
-      }
+    command = %CreateCustomer{
+      id: customer_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"]
+    }
 
-    case CommandedApp.dispatch(command, consistency: :strong) do
+    dispatch_and_return(conn, command, customer_id)
+  end
+
+  operation(:create_corporate,
+    summary: "Create corporate customer",
+    request_body:
+      {"Corporate customer data", "application/json", CustomerSchemas.CreateCorporateCustomer,
+       required: true},
+    responses: [
+      ok: {"Corporate customer created", "application/json", CustomerSchemas.CustomerResponse}
+    ]
+  )
+
+  def create_corporate(conn, params) do
+    customer_id = Ecto.UUID.generate()
+
+    command = %CreateCorporateCustomer{
+      id: customer_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, customer_id)
+  end
+
+  # ---------------------------------------------------------------------------
+  # Private
+  # ---------------------------------------------------------------------------
+
+  defp dispatch_and_return(conn, command, customer_id) do
+    case CustomerService.CommandedApp.dispatch(command, consistency: :strong) do
       :ok ->
-        json(conn, %{id: customer_id})
+        case CustomerQueries.get_customer(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)})
+        conn |> put_status(:unprocessable_entity) |> json(%{error: inspect(reason)})
     end
   end
 
-  operation :show,
-    summary: "Get customer",
-    parameters: [
-      id: [in: :path, type: :string, description: "Customer ID"]
-    ],
-    responses: [
-      ok: {"Customer", "application/json", CustomerResponse},
-      not_found: {"Not found", "application/json", nil}
-    ]
+  defp parse_date(nil), do: nil
 
-  def show(conn, %{"id" => id}) do
-    case CustomerService.Repo.get(CustomerService.Projections.Customer, id) do
-      nil ->
-        send_resp(conn, 404, "")
-
-      customer ->
-        json(conn, customer)
+  defp parse_date(str) do
+    case Date.from_iso8601(str) do
+      {:ok, date} -> date
+      _ -> nil
     end
   end
 
-  operation :index,
-    summary: "List customers",
-    responses: [
-      ok:
-        {"Customer list", "application/json",
-         %OpenApiSpex.Schema{
-           type: :array,
-           items: CustomerResponse
-         }}
-    ]
+  defp customer_json(%{customer_type: "corporate"} = c) do
+    %{
+      id: c.id,
+      customer_type: "corporate",
+      legal_name: c.legal_name,
+      commercial_name: c.commercial_name,
+      ruc: c.ruc,
+      legal_rep_name: c.legal_rep_name,
+      legal_rep_document_id: c.legal_rep_document_id,
+      email: c.email,
+      phone: c.phone,
+      address: c.address
+    }
+  end
 
-  def index(conn, _) do
-    case CustomerService.Repo.all(CustomerService.Projections.Customer) do
-      nil ->
-        send_resp(conn, 404, "")
-
-      customer ->
-        json(conn, customer)
-    end
+  defp customer_json(c) do
+    %{
+      id: c.id,
+      customer_type: "individual",
+      first_name: c.first_name,
+      last_name: c.last_name,
+      email: c.email,
+      phone: c.phone,
+      birth_date: c.birth_date,
+      gender: c.gender,
+      document_id: c.document_id
+    }
   end
 end

lib/customer_service_web/controllers/error_json.ex

@@ -1,20 +1,16 @@
 defmodule CustomerServiceWeb.ErrorJSON do
   @moduledoc """
   This module is invoked by your endpoint in case of errors on JSON requests.
-
-  See config/config.exs.
   """
 
-  # If you want to customize a particular status code,
-  # you may add your own clauses, such as:
-  #
-  # def render("500.json", _assigns) do
-  #   %{errors: %{detail: "Internal Server Error"}}
-  # end
+  def render("404.json", _assigns) do
+    %{errors: %{detail: "Not Found"}}
+  end
+
+  def render("500.json", _assigns) do
+    %{errors: %{detail: "Internal Server Error"}}
+  end
 
-  # By default, Phoenix returns the status message from
-  # the template name. For example, "404.json" becomes
-  # "Not Found".
   def render(template, _assigns) do
     %{errors: %{detail: Phoenix.Controller.status_message_from_template(template)}}
   end

lib/customer_service_web/controllers/health_controller.ex

@@ -0,0 +1,15 @@
+defmodule CustomerServiceWeb.HealthController do
+  use CustomerServiceWeb, :controller
+
+  def health(conn, _params) do
+    conn
+    |> put_status(:ok)
+    |> json(%{status: "ok"})
+  end
+
+  def ready(conn, _params) do
+    conn
+    |> put_status(:ok)
+    |> json(%{status: "ready"})
+  end
+end