add quick leads

lib/customer_service/aggregates/corporate_customer.ex

@@ -33,6 +33,21 @@ defmodule CustomerService.Aggregates.CorporateCustomer do
     }
   end
 
+  @impl Aggregate
+  def execute(%CorporateCustomer{id: _id}, %Commands.UpdateCorporateCustomer{} = cmd) do
+    %Events.CorporateCustomerUpdated{
+      id: cmd.id,
+      legal_name: cmd.legal_name,
+      commercial_name: cmd.commercial_name,
+      ruc: cmd.ruc,
+      legal_rep_name: cmd.legal_rep_name,
+      legal_rep_document_id: cmd.legal_rep_document_id,
+      email: cmd.email,
+      phone: cmd.phone,
+      address: cmd.address
+    }
+  end
+
   @impl Aggregate
   def apply(%CorporateCustomer{} = c, %Events.CorporateCustomerCreated{} = e) do
     %CorporateCustomer{
@@ -48,4 +63,19 @@ defmodule CustomerService.Aggregates.CorporateCustomer do
         address: e.address
     }
   end
+
+  @impl Aggregate
+  def apply(%CorporateCustomer{} = c, %Events.CorporateCustomerUpdated{} = e) do
+    %CorporateCustomer{
+      c
+      | legal_name: e.legal_name || c.legal_name,
+        commercial_name: e.commercial_name || c.commercial_name,
+        ruc: e.ruc || c.ruc,
+        legal_rep_name: e.legal_rep_name || c.legal_rep_name,
+        legal_rep_document_id: e.legal_rep_document_id || c.legal_rep_document_id,
+        email: e.email || c.email,
+        phone: e.phone || c.phone,
+        address: e.address || c.address
+    }
+  end
 end

lib/customer_service/aggregates/customer.ex

@@ -32,6 +32,21 @@ defmodule CustomerService.Aggregates.Customer do
     }
   end
 
+  @impl Aggregate
+  def execute(%Customer{id: _id}, %Commands.UpdateCustomer{} = cmd) do
+    %Events.CustomerUpdated{
+      id: cmd.id,
+      first_name: cmd.first_name,
+      last_name: cmd.last_name,
+      birth_date: cmd.birth_date,
+      gender: cmd.gender,
+      email: cmd.email,
+      phone: cmd.phone,
+      document_id: cmd.document_id,
+      address: cmd.address
+    }
+  end
+
   @impl Aggregate
   def apply(%Customer{} = c, %Events.CustomerCreated{} = e) do
     %__MODULE__{
@@ -47,4 +62,19 @@ defmodule CustomerService.Aggregates.Customer do
         document_id: e.document_id
     }
   end
+
+  @impl Aggregate
+  def apply(%Customer{} = c, %Events.CustomerUpdated{} = e) do
+    %__MODULE__{
+      c
+      | first_name: e.first_name || c.first_name,
+        last_name: e.last_name || c.last_name,
+        birth_date: e.birth_date || c.birth_date,
+        gender: e.gender || c.gender,
+        email: e.email || c.email,
+        phone: e.phone || c.phone,
+        address: e.address || c.address,
+        document_id: e.document_id || c.document_id
+    }
+  end
 end

lib/customer_service/aggregates/quick_lead.ex

@@ -0,0 +1,140 @@
+defmodule CustomerService.Aggregates.QuickLead do
+  defstruct [
+    :id,
+    :name,
+    :email,
+    :phone,
+    :company_name,
+    :status,
+    :priority,
+    :source,
+    :notes,
+    :assigned_to,
+    :estimated_value,
+    :expected_close_date,
+    :status_history
+  ]
+
+  alias __MODULE__
+  alias Commanded.Aggregates.Aggregate
+  alias CustomerService.Commands
+  alias CustomerService.Events
+
+  @behaviour Aggregate
+
+  @valid_statuses ~w(new contacted qualified proposal negotiation converted lost)a
+
+  @impl Aggregate
+  def execute(%QuickLead{id: nil}, %Commands.CreateQuickLead{} = cmd) do
+    status = cmd.status || :new
+    priority = cmd.priority || :medium
+    source = cmd.source || :other
+
+    %Events.QuickLeadCreated{
+      id: cmd.id,
+      name: cmd.name,
+      email: cmd.email,
+      phone: cmd.phone,
+      company_name: cmd.company_name,
+      status: status,
+      priority: priority,
+      source: source,
+      notes: cmd.notes,
+      assigned_to: cmd.assigned_to,
+      estimated_value: cmd.estimated_value,
+      expected_close_date: cmd.expected_close_date
+    }
+  end
+
+  @impl Aggregate
+  def execute(%QuickLead{id: _id}, %Commands.UpdateQuickLead{} = cmd) do
+    %Events.QuickLeadUpdated{
+      id: cmd.id,
+      name: cmd.name,
+      email: cmd.email,
+      phone: cmd.phone,
+      company_name: cmd.company_name,
+      notes: cmd.notes,
+      assigned_to: cmd.assigned_to,
+      estimated_value: cmd.estimated_value,
+      expected_close_date: cmd.expected_close_date
+    }
+  end
+
+  @impl Aggregate
+  def execute(%QuickLead{id: _id, status: current_status}, %Commands.UpdateLeadStatus{} = cmd) do
+    new_status = cmd.status
+
+    if valid_status_transition?(current_status, new_status) do
+      %Events.LeadStatusUpdated{
+        id: cmd.id,
+        status: new_status,
+        previous_status: current_status,
+        updated_at: DateTime.utc_now()
+      }
+    else
+      {:error, :invalid_status_transition}
+    end
+  end
+
+  @impl Aggregate
+  def apply(%QuickLead{id: nil}, %Events.QuickLeadCreated{} = e) do
+    %__MODULE__{
+      id: e.id,
+      name: e.name,
+      email: e.email,
+      phone: e.phone,
+      company_name: e.company_name,
+      status: e.status,
+      priority: e.priority,
+      source: e.source,
+      notes: e.notes,
+      assigned_to: e.assigned_to,
+      estimated_value: e.estimated_value,
+      expected_close_date: e.expected_close_date,
+      status_history: [
+        %{
+          status: e.status,
+          updated_at: DateTime.utc_now(),
+          notes: "Lead created"
+        }
+      ]
+    }
+  end
+
+  @impl Aggregate
+  def apply(%QuickLead{} = lead, %Events.QuickLeadUpdated{} = e) do
+    %__MODULE__{
+      lead
+      | name: e.name || lead.name,
+        email: e.email || lead.email,
+        phone: e.phone || lead.phone,
+        company_name: e.company_name || lead.company_name,
+        notes: e.notes || lead.notes,
+        assigned_to: e.assigned_to || lead.assigned_to,
+        estimated_value: e.estimated_value || lead.estimated_value,
+        expected_close_date: e.expected_close_date || lead.expected_close_date
+    }
+  end
+
+  @impl Aggregate
+  def apply(%QuickLead{} = lead, %Events.LeadStatusUpdated{} = e) do
+    %__MODULE__{
+      lead
+      | status: e.status,
+        status_history: [
+          %{
+            status: e.status,
+            previous_status: e.previous_status,
+            updated_at: e.updated_at
+          }
+          | lead.status_history
+        ]
+    }
+  end
+
+  defp valid_status_transition?(current_status, new_status) do
+    current_status in @valid_statuses and new_status in @valid_statuses and
+      current_status != new_status
+  end
+end

lib/customer_service/application.ex

@@ -11,6 +11,7 @@ defmodule CustomerService.Application do
       CustomerService.CommandedApp,
       CustomerService.Repo,
       CustomerService.Projectors.Customer,
+      CustomerService.Projectors.QuickLead,
       CustomerServiceWeb.Telemetry,
       {DNSCluster, query: Application.get_env(:customer_service, :dns_cluster_query) || :ignore},
       {Phoenix.PubSub, name: CustomerService.PubSub},

lib/customer_service/commanded_app.ex

@@ -4,12 +4,20 @@ defmodule CustomerService.Router do
   alias CustomerService.Aggregates
 
   identify(Aggregates.Customer, by: :id)
-  dispatch([Commands.CreateCustomer], to: Aggregates.Customer)
+  dispatch([Commands.CreateCustomer, Commands.UpdateCustomer], to: Aggregates.Customer)
 
-  dispatch(Commands.CreateCorporateCustomer,
+  dispatch(
+    [Commands.CreateCorporateCustomer, Commands.UpdateCorporateCustomer],
     to: Aggregates.CorporateCustomer,
     identity: :id
   )
+
+  identify(Aggregates.QuickLead, by: :id)
+
+  dispatch(
+    [Commands.CreateQuickLead, Commands.UpdateQuickLead, Commands.UpdateLeadStatus],
+    to: Aggregates.QuickLead
+  )
 end
 
 defmodule CustomerService.CommandedApp do

lib/customer_service/commands.ex

@@ -25,3 +25,66 @@ defmodule CustomerService.Commands.CreateCorporateCustomer do
     :address
   ]
 end
+
+defmodule CustomerService.Commands.UpdateCustomer do
+  defstruct [
+    :id,
+    :first_name,
+    :last_name,
+    :birth_date,
+    :gender,
+    :email,
+    :phone,
+    :address,
+    :document_id
+  ]
+end
+
+defmodule CustomerService.Commands.UpdateCorporateCustomer do
+  defstruct [
+    :id,
+    :legal_name,
+    :commercial_name,
+    :ruc,
+    :legal_rep_name,
+    :legal_rep_document_id,
+    :email,
+    :phone,
+    :address
+  ]
+end
+
+defmodule CustomerService.Commands.CreateQuickLead do
+  defstruct [
+    :id,
+    :name,
+    :email,
+    :phone,
+    :company_name,
+    :status,
+    :priority,
+    :source,
+    :notes,
+    :assigned_to,
+    :estimated_value,
+    :expected_close_date
+  ]
+end
+
+defmodule CustomerService.Commands.UpdateQuickLead do
+  defstruct [
+    :id,
+    :name,
+    :email,
+    :phone,
+    :company_name,
+    :notes,
+    :assigned_to,
+    :estimated_value,
+    :expected_close_date
+  ]
+end
+
+defmodule CustomerService.Commands.UpdateLeadStatus do
+  defstruct [:id, :status]
+end

lib/customer_service/events.ex

@@ -27,3 +27,71 @@ defmodule CustomerService.Events.CorporateCustomerCreated do
     :address
   ]
 end
+
+defmodule CustomerService.Events.CustomerUpdated do
+  @derive Jason.Encoder
+  defstruct [
+    :id,
+    :first_name,
+    :last_name,
+    :birth_date,
+    :gender,
+    :email,
+    :phone,
+    :address,
+    :document_id
+  ]
+end
+
+defmodule CustomerService.Events.CorporateCustomerUpdated do
+  @derive Jason.Encoder
+  defstruct [
+    :id,
+    :legal_name,
+    :commercial_name,
+    :ruc,
+    :legal_rep_name,
+    :legal_rep_document_id,
+    :email,
+    :phone,
+    :address
+  ]
+end
+
+defmodule CustomerService.Events.QuickLeadCreated do
+  @derive Jason.Encoder
+  defstruct [
+    :id,
+    :name,
+    :email,
+    :phone,
+    :company_name,
+    :status,
+    :priority,
+    :source,
+    :notes,
+    :assigned_to,
+    :estimated_value,
+    :expected_close_date
+  ]
+end
+
+defmodule CustomerService.Events.QuickLeadUpdated do
+  @derive Jason.Encoder
+  defstruct [
+    :id,
+    :name,
+    :email,
+    :phone,
+    :company_name,
+    :notes,
+    :assigned_to,
+    :estimated_value,
+    :expected_close_date
+  ]
+end
+
+defmodule CustomerService.Events.LeadStatusUpdated do
+  @derive Jason.Encoder
+  defstruct [:id, :status, :previous_status, :updated_at]
+end

lib/customer_service/lead/filters.ex

@@ -0,0 +1,17 @@
+defmodule CustomerService.Lead.Filters do
+  import Ecto.Query
+
+  def search(query, %Flop.Filter{value: value}, _opts) do
+    term = "%#{value}%"
+
+    where(
+      query,
+      [l],
+      ilike(l.name, ^term) or
+        ilike(l.email, ^term) or
+        ilike(l.phone, ^term) or
+        ilike(l.company_name, ^term) or
+        ilike(l.assigned_to, ^term)
+    )
+  end
+end

lib/customer_service/lead/queries.ex

@@ -0,0 +1,15 @@
+defmodule CustomerService.Lead.Queries do
+  alias CustomerService.Projections.QuickLead
+  alias CustomerService.Repo
+
+  def list_leads(params \\ %{}) do
+    Flop.validate_and_run(QuickLead, params, for: QuickLead)
+  end
+
+  def get_lead(id) do
+    case Repo.get(QuickLead, id) do
+      nil -> {:error, :not_found}
+      lead -> {:ok, lead}
+    end
+  end
+end

lib/customer_service/projections/quick_lead.ex

@@ -0,0 +1,57 @@
+defmodule CustomerService.Projections.QuickLead do
+  use Ecto.Schema
+
+  @derive {Jason.Encoder,
+           only: [
+             :id,
+             :name,
+             :email,
+             :phone,
+             :company_name,
+             :status,
+             :priority,
+             :source,
+             :notes,
+             :assigned_to,
+             :estimated_value,
+             :expected_close_date,
+             :status_history,
+             :inserted_at,
+             :updated_at
+           ]}
+
+  @derive {
+    Flop.Schema,
+    filterable: [:status, :priority, :source, :assigned_to, :search],
+    sortable: [:name, :company_name, :status, :priority, :inserted_at],
+    default_limit: 20,
+    max_limit: 100,
+    custom_fields: [
+      search: [
+        filter: {CustomerService.Lead.Filters, :search, []},
+        ecto_type: :string,
+        operators: [:==]
+      ]
+    ]
+  }
+
+  @primary_key {:id, :binary_id, autogenerate: false}
+  @timestamps_opts [type: :utc_datetime_usec]
+
+  schema "quick_leads" do
+    field :name, :string
+    field :email, :string
+    field :phone, :string
+    field :company_name, :string
+    field :status, :string
+    field :priority, :string
+    field :source, :string
+    field :notes, :string
+    field :assigned_to, :string
+    field :estimated_value, :decimal
+    field :expected_close_date, :date
+    field :status_history, :map
+
+    timestamps()
+  end
+end

lib/customer_service/projectors/customer.ex

@@ -47,4 +47,34 @@ defmodule CustomerService.Projectors.Customer do
       address: e.address
     })
   end)
+
+  project(%Events.CustomerUpdated{} = e, _meta, fn multi ->
+    Ecto.Multi.update_all(multi, :customer, from(c in Customer, where: c.id == ^e.id),
+      set: [
+        first_name: e.first_name,
+        last_name: e.last_name,
+        birth_date: parse_date(e.birth_date),
+        gender: e.gender,
+        email: e.email,
+        phone: e.phone,
+        address: e.address,
+        document_id: e.document_id
+      ]
+    )
+  end)
+
+  project(%Events.CorporateCustomerUpdated{} = e, _meta, fn multi ->
+    Ecto.Multi.update_all(multi, :customer, from(c in Customer, where: c.id == ^e.id),
+      set: [
+        legal_name: e.legal_name,
+        commercial_name: e.commercial_name,
+        ruc: e.ruc,
+        legal_rep_name: e.legal_rep_name,
+        legal_rep_document_id: e.legal_rep_document_id,
+        email: e.email,
+        phone: e.phone,
+        address: e.address
+      ]
+    )
+  end)
 end

lib/customer_service/projectors/quick_lead.ex

@@ -0,0 +1,67 @@
+defmodule CustomerService.Projectors.QuickLead do
+  use Commanded.Projections.Ecto,
+    application: CustomerService.CommandedApp,
+    repo: CustomerService.Repo,
+    name: "CustomerService.Projectors.QuickLead",
+    consistency: :strong
+
+  alias CustomerService.Events
+  alias CustomerService.Projections.QuickLead
+
+  project(%Events.QuickLeadCreated{} = event, fn multi ->
+    Ecto.Multi.insert(multi, :quick_lead, %QuickLead{
+      id: event.id,
+      name: event.name,
+      email: event.email,
+      phone: event.phone,
+      company_name: event.company_name,
+      status: to_string(event.status),
+      priority: to_string(event.priority),
+      source: to_string(event.source),
+      notes: event.notes,
+      assigned_to: event.assigned_to,
+      estimated_value: event.estimated_value,
+      expected_close_date: parse_date(event.expected_close_date),
+      status_history: [
+        %{
+          status: to_string(event.status),
+          updated_at: DateTime.utc_now(),
+          notes: "Lead created"
+        }
+      ]
+    })
+  end)
+
+  project(%Events.QuickLeadUpdated{} = event, _meta, fn multi ->
+    Ecto.Multi.update_all(multi, :quick_lead, from(q in QuickLead, where: q.id == ^event.id),
+      set: [
+        name: event.name,
+        email: event.email,
+        phone: event.phone,
+        company_name: event.company_name,
+        notes: event.notes,
+        assigned_to: event.assigned_to,
+        estimated_value: event.estimated_value,
+        expected_close_date: parse_date(event.expected_close_date)
+      ]
+    )
+  end)
+
+  project(%Events.LeadStatusUpdated{} = event, _meta, fn multi ->
+    Ecto.Multi.update_all(multi, :quick_lead, from(q in QuickLead, where: q.id == ^event.id),
+      set: [
+        status: to_string(event.status)
+      ]
+    )
+  end)
+
+  defp parse_date(nil), do: nil
+  defp parse_date(%Date{} = d), do: d
+
+  defp parse_date(str) when is_binary(str) do
+    case Date.from_iso8601(str) do
+      {:ok, d} -> d
+      _ -> nil
+    end
+  end
+end