feat: add contexts for job interviews and matches

Author: zcesur

lib/algora/interviews/interviews.ex

@@ -0,0 +1,161 @@
+defmodule Algora.Interviews do
+  @moduledoc """
+  The Interviews context.
+  """
+
+  import Ecto.Query, warn: false
+
+  alias Algora.Interviews.JobInterview
+  alias Algora.Repo
+
+  @doc """
+  Returns the list of job interviews.
+
+  ## Examples
+
+      iex> list_job_interviews()
+      [%JobInterview{}, ...]
+
+  """
+  def list_job_interviews do
+    Repo.all(JobInterview)
+  end
+
+  @doc """
+  Returns the list of job interviews grouped by organization.
+  Groups by the job posting's user (which represents the organization).
+
+  ## Examples
+
+      iex> list_job_interviews_by_org()
+      %{org_id => [%JobInterview{}, ...]}
+
+  """
+  def list_job_interviews_by_org do
+    JobInterview
+    |> join(:inner, [ji], jp in assoc(ji, :job_posting))
+    |> join(:inner, [ji, jp], org in assoc(jp, :user))
+    |> preload([ji, jp, org], job_posting: {jp, user: org})
+    |> preload(:user)
+    |> Repo.all()
+    |> Enum.group_by(fn interview -> interview.job_posting.user_id end)
+  end
+
+  @doc """
+  Gets a single job interview.
+
+  Raises `Ecto.NoResultsError` if the Job interview does not exist.
+
+  ## Examples
+
+      iex> get_job_interview!(123)
+      %JobInterview{}
+
+      iex> get_job_interview!(456)
+      ** (Ecto.NoResultsError)
+
+  """
+  def get_job_interview!(id), do: Repo.get!(JobInterview, id)
+
+  @doc """
+  Creates a job interview.
+
+  ## Examples
+
+      iex> create_job_interview(%{field: value})
+      {:ok, %JobInterview{}}
+
+      iex> create_job_interview(%{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def create_job_interview(attrs \\ %{}) do
+    %JobInterview{}
+    |> JobInterview.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  @doc """
+  Updates a job interview.
+
+  ## Examples
+
+      iex> update_job_interview(job_interview, %{field: new_value})
+      {:ok, %JobInterview{}}
+
+      iex> update_job_interview(job_interview, %{field: bad_value})
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def update_job_interview(%JobInterview{} = job_interview, attrs) do
+    job_interview
+    |> JobInterview.changeset(attrs)
+    |> Repo.update()
+  end
+
+  @doc """
+  Deletes a job interview.
+
+  ## Examples
+
+      iex> delete_job_interview(job_interview)
+      {:ok, %JobInterview{}}
+
+      iex> delete_job_interview(job_interview)
+      {:error, %Ecto.Changeset{}}
+
+  """
+  def delete_job_interview(%JobInterview{} = job_interview) do
+    Repo.delete(job_interview)
+  end
+
+  @doc """
+  Returns an `%Ecto.Changeset{}` for tracking job interview changes.
+
+  ## Examples
+
+      iex> change_job_interview(job_interview)
+      %Ecto.Changeset{data: %JobInterview{}}
+
+  """
+  def change_job_interview(%JobInterview{} = job_interview, attrs \\ %{}) do
+    JobInterview.changeset(job_interview, attrs)
+  end
+
+  @doc """
+  Creates a job interview with the given status.
+
+  ## Examples
+
+      iex> create_interview_with_status(user_id, job_posting_id, :scheduled)
+      {:ok, %JobInterview{}}
+
+      iex> create_interview_with_status(user_id, job_posting_id, :completed, "Great candidate!")
+      {:ok, %JobInterview{}}
+
+  """
+  def create_interview_with_status(user_id, job_posting_id, status, notes \\ nil) do
+    attrs = %{
+      user_id: user_id,
+      job_posting_id: job_posting_id,
+      status: status,
+      notes: notes
+    }
+
+    attrs =
+      case status do
+        :scheduled ->
+          Map.put(attrs, :scheduled_at, DateTime.utc_now())
+
+        :completed ->
+          attrs
+          |> Map.put(:scheduled_at, DateTime.utc_now())
+          |> Map.put(:completed_at, DateTime.utc_now())
+
+        _ ->
+          attrs
+      end
+
+    create_job_interview(attrs)
+  end
+end

lib/algora/interviews/schemas/job_interview.ex

@@ -0,0 +1,28 @@
+defmodule Algora.Interviews.JobInterview do
+  @moduledoc false
+  use Algora.Schema
+
+  import Ecto.Changeset
+
+  typed_schema "job_interviews" do
+    field :status, Ecto.Enum, values: [:scheduled, :completed, :cancelled, :no_show]
+    field :notes, :string
+    field :scheduled_at, :utc_datetime_usec
+    field :completed_at, :utc_datetime_usec
+
+    belongs_to :user, Algora.Accounts.User
+    belongs_to :job_posting, Algora.Jobs.JobPosting
+
+    timestamps()
+  end
+
+  def changeset(job_interview, attrs) do
+    job_interview
+    |> cast(attrs, [:user_id, :job_posting_id, :status, :notes, :scheduled_at, :completed_at])
+    |> validate_required([:user_id, :job_posting_id, :status])
+    |> validate_inclusion(:status, [:scheduled, :completed, :cancelled, :no_show])
+    |> foreign_key_constraint(:user_id)
+    |> foreign_key_constraint(:job_posting_id)
+    |> generate_id()
+  end
+end

lib/algora/jobs/jobs.ex

@@ -6,14 +6,14 @@ defmodule Algora.Jobs do
 
   alias Algora.Accounts.User
   alias Algora.Bounties.LineItem
+  alias Algora.Interviews.JobInterview
   alias Algora.Jobs.JobApplication
   alias Algora.Jobs.JobPosting
+  alias Algora.Matches.JobMatch
   alias Algora.Payments
   alias Algora.Payments.Transaction
   alias Algora.Repo
   alias Algora.Util
-  alias AlgoraCloud.Interviews.JobInterview
-  alias AlgoraCloud.Matches.JobMatch
 
   require Logger
 

lib/algora/jobs/schemas/job_posting.ex

@@ -25,8 +25,8 @@ defmodule Algora.Jobs.JobPosting do
     field :system_tags, {:array, :string}, default: []
 
     belongs_to :user, User, null: false
-    has_many :interviews, AlgoraCloud.Interviews.JobInterview, foreign_key: :job_posting_id
-    has_many :matches, AlgoraCloud.Matches.JobMatch, foreign_key: :job_posting_id
+    has_many :interviews, Algora.Interviews.JobInterview, foreign_key: :job_posting_id
+    has_many :matches, Algora.Matches.JobMatch, foreign_key: :job_posting_id
 
     timestamps()
   end

lib/algora/matches/matches.ex

@@ -0,0 +1,130 @@
+defmodule Algora.Matches do
+  @moduledoc false
+
+  import Ecto.Query, warn: false
+
+  alias Algora.Jobs.JobPosting
+  alias Algora.Matches.JobMatch
+  alias Algora.Repo
+
+  def list_job_matches(opts \\ []) do
+    order_by_clause = opts[:order_by] || [desc: :inserted_at]
+
+    JobMatch
+    |> filter_by_job_posting_id(opts[:job_posting_id])
+    |> filter_by_user_id(opts[:user_id])
+    |> filter_by_status(opts[:status])
+    |> order_by(^order_by_clause)
+    |> maybe_preload(opts[:preload])
+    |> Repo.all()
+  end
+
+  def get_job_match!(id) do
+    JobMatch
+    |> preload([:user, :job_posting])
+    |> Repo.get!(id)
+  end
+
+  def get_job_match(user_id, job_posting_id) do
+    JobMatch
+    |> where([m], m.user_id == ^user_id and m.job_posting_id == ^job_posting_id)
+    |> preload([:user, :job_posting])
+    |> Repo.one()
+  end
+
+  def create_job_match(attrs \\ %{}) do
+    %JobMatch{}
+    |> JobMatch.changeset(attrs)
+    |> Repo.insert()
+  end
+
+  def fetch_job_matches(job_posting_id) do
+    job = Repo.get!(JobPosting, job_posting_id)
+
+    job_countries =
+      job.regions
+      |> Enum.flat_map(&Algora.PSP.ConnectCountries.get_countries/1)
+      |> Enum.concat(job.countries)
+      |> Enum.uniq()
+
+    [
+      limit: 3,
+      tech_stack: job.tech_stack,
+      has_min_compensation: true,
+      system_tags: job.system_tags,
+      sort_by: [{"countries", job_countries}]
+    ]
+    |> Algora.Cloud.list_top_matches()
+    |> Algora.Settings.load_matches_2()
+  end
+
+  def create_job_matches(job_posting_id) do
+    job_posting_id
+    |> fetch_job_matches()
+    |> Enum.map(fn match -> match.user.id end)
+    |> then(&create_job_matches(job_posting_id, &1))
+  end
+
+  def create_job_matches(job_posting_id, user_ids) do
+    matches =
+      Enum.map(user_ids, fn user_id ->
+        %{
+          id: Nanoid.generate(),
+          user_id: user_id,
+          job_posting_id: job_posting_id,
+          inserted_at: DateTime.truncate(DateTime.utc_now(), :microsecond),
+          updated_at: DateTime.truncate(DateTime.utc_now(), :microsecond)
+        }
+      end)
+
+    Repo.transaction(fn ->
+      # Delete existing matches for this job posting
+      Repo.delete_all(from(m in JobMatch, where: m.job_posting_id == ^job_posting_id))
+
+      # Insert new matches
+      case Repo.insert_all(JobMatch, matches, on_conflict: :nothing) do
+        {count, _} -> count
+        error -> Repo.rollback(error)
+      end
+    end)
+  end
+
+  def update_job_match(%JobMatch{} = job_match, attrs) do
+    job_match
+    |> JobMatch.changeset(attrs)
+    |> Repo.update()
+  end
+
+  def delete_job_match(%JobMatch{} = job_match) do
+    Repo.delete(job_match)
+  end
+
+  def change_job_match(%JobMatch{} = job_match, attrs \\ %{}) do
+    JobMatch.changeset(job_match, attrs)
+  end
+
+  # Private helper functions
+  defp filter_by_job_posting_id(query, nil), do: query
+
+  defp filter_by_job_posting_id(query, job_posting_id) do
+    where(query, [m], m.job_posting_id == ^job_posting_id)
+  end
+
+  defp filter_by_user_id(query, nil), do: query
+
+  defp filter_by_user_id(query, user_id) do
+    where(query, [m], m.user_id == ^user_id)
+  end
+
+  defp filter_by_status(query, nil), do: query
+
+  defp filter_by_status(query, status) do
+    where(query, [m], m.status == ^status)
+  end
+
+  defp maybe_preload(query, nil), do: query
+
+  defp maybe_preload(query, preload_list) do
+    preload(query, ^preload_list)
+  end
+end

lib/algora/matches/schemas/job_match.ex

@@ -0,0 +1,28 @@
+defmodule Algora.Matches.JobMatch do
+  @moduledoc false
+  use Algora.Schema
+
+  import Ecto.Changeset
+
+  typed_schema "job_matches" do
+    field :status, Ecto.Enum, values: [:pending, :accepted, :rejected], default: :pending
+    field :score, :decimal
+    field :notes, :string
+
+    belongs_to :user, Algora.Accounts.User
+    belongs_to :job_posting, Algora.Jobs.JobPosting
+
+    timestamps()
+  end
+
+  def changeset(job_match, attrs) do
+    job_match
+    |> cast(attrs, [:user_id, :job_posting_id, :status, :score, :notes])
+    |> validate_required([:user_id, :job_posting_id])
+    |> validate_inclusion(:status, [:pending, :accepted, :rejected])
+    |> foreign_key_constraint(:user_id)
+    |> foreign_key_constraint(:job_posting_id)
+    |> unique_constraint([:user_id, :job_posting_id])
+    |> generate_id()
+  end
+end