reorganize

Author: zcesur

lib/algora/admin/admin.ex

@@ -24,145 +24,6 @@ defmodule Algora.Admin do
 
   require Logger
 
-  defmodule JobPostingPrediction do
-    @moduledoc false
-    use Ecto.Schema
-    use Instructor.Validator
-
-    alias Algora.Organizations
-
-    @llm_doc """
-    ## Field Descriptions:
-    - tech_stack: List of technologies used in the job posting (e.g. ["Ruby", "Rails", "PostgreSQL"])
-    - countries: List of 2-letter ISO country codes (e.g. ["US", "CA"])
-    - regions: List of regions (e.g. ["EMEA", "LATAM"])
-    - location: Location of the job posting (e.g. "Remote", "San Francisco, CA", "London/Berlin")
-    - seniority: Seniority level (e.g. "Senior", "Mid-Senior", "Entry-Level")
-    - company_url: Company website URL which can be derived from email (e.g. example.com)
-    """
-    @primary_key false
-    embedded_schema do
-      embeds_many :job_postings, JobPosting, primary_key: false do
-        field(:title, :string)
-        field(:description, :string)
-        field(:tech_stack, {:array, :string})
-        field(:company_name, :string)
-        field(:company_url, :string)
-        field(:location, :string)
-        field(:countries, {:array, :string})
-        field(:regions, {:array, :string})
-        field(:compensation, :string)
-        field(:seniority, :string)
-      end
-    end
-
-    @impl true
-    def validate_changeset(changeset) do
-      changeset
-    end
-
-    def seed_jobs(jobs) do
-      jobs
-      |> Task.async_stream(&seed/1, timeout: :infinity, max_concurrency: 50)
-      |> Enum.to_list()
-    end
-
-    def seed(job) do
-      with domain when not is_nil(domain) <- Util.to_domain(job.company_url),
-           {:ok, org} <- fetch_or_create_user(domain, %{hiring: true, tech_stack: job.tech_stack}),
-           {:ok, org} <-
-             org
-             |> change(
-               Map.merge(
-                 %{
-                   domain: org.domain || domain,
-                   hiring_subscription: :trial,
-                   billing_name: org.billing_name || job.company_name,
-                   billing_address: org.billing_address || job.location,
-                   executive_name: org.executive_name || job.company_name,
-                   executive_role: org.executive_role || job.seniority
-                 },
-                 if org.handle do
-                   %{}
-                 else
-                   %{handle: Organizations.ensure_unique_org_handle(job.company_name)}
-                 end
-               )
-             )
-             |> Repo.update() do
-        Repo.insert(%JobPosting{
-          status: :processing,
-          id: Nanoid.generate(),
-          user_id: org.id,
-          company_name: org.name,
-          company_url: org.website_url,
-          title: job.title,
-          description: job.description,
-          tech_stack: job.tech_stack,
-          location: job.location,
-          compensation: job.compensation,
-          seniority: job.seniority,
-          countries: job.countries,
-          regions: job.regions
-        })
-      end
-    end
-
-    def fetch_or_create_user(domain, opts) do
-      case Repo.one(from o in User, where: o.domain == ^domain, limit: 1) do
-        %User{} = user ->
-          {:ok, user}
-
-        _ ->
-          res = Organizations.onboard_organization_from_domain(domain, opts)
-          res
-      end
-    end
-  end
-
-  def classify_jobs(jobs) do
-    batches = Enum.chunk_every(jobs, 10)
-
-    batches
-    |> Enum.with_index()
-    |> Enum.flat_map(fn {jobs, index} ->
-      case classify_batch(jobs, index) do
-        {:ok, predictions} ->
-          predictions.job_postings
-
-        {:error, error} ->
-          Logger.error("Failed to classify batch #{index}: #{inspect(error)}")
-          []
-      end
-    end)
-  end
-
-  def classify_batch(jobs, index) do
-    text = Enum.join(jobs, "\n\n")
-
-    Github.Client.run_cached("classify_jobs_#{index}", fn ->
-      Instructor.chat_completion(
-        model: "gpt-4o-mini",
-        response_model: JobPostingPrediction,
-        max_retries: 2,
-        messages: [
-          %{
-            role: "user",
-            content: """
-            Your purpose is to turn arbitrary job postings into structured data.
-
-            Return a distinct entry for each job. Some paragraphs may contain multiple jobs.
-
-            Turn following job postings into structured data:
-
-            #{text}
-            """
-          }
-        ]
-      )
-    end)
-  end
-
   def seed_job(opts \\ %{}) do
     with {:ok, user} <- Repo.fetch_by(User, handle: opts.org.handle),
          {:ok, user} <- user |> change(opts.org) |> Repo.update(),

lib/algora/settings/settings.ex

@@ -244,26 +244,4 @@ defmodule Algora.Settings do
   def set_subscription_price(price) do
     set("subscription", %{"price" => Algora.MoneyUtils.serialize(price)})
   end
-
-  def get_hn_job_ids do
-    case get("hn_job_ids") do
-      %{"ids" => ids} when is_list(ids) -> ids
-      _ -> nil
-    end
-  end
-
-  def set_hn_job_ids(ids) when is_list(ids) do
-    set("hn_job_ids", %{"ids" => ids})
-  end
-
-  def get_hn_job_seekers do
-    case get("hn_job_seekers") do
-      %{"handles" => handles} when is_list(handles) -> handles
-      _ -> nil
-    end
-  end
-
-  def set_hn_job_seekers(handles) when is_list(handles) do
-    set("hn_job_seekers", %{"handles" => handles})
-  end
 end