feat: implement stargazer import functionality and UI integration

Author: zcesur

lib/algora/admin/admin.ex

@@ -20,6 +20,8 @@ defmodule Algora.Admin do
   alias Algora.Util
   alias Algora.Workspace
   alias Algora.Workspace.Installation
+  alias Algora.Workspace.Jobs.FetchTopContributions
+  alias Algora.Workspace.Jobs.ImportStargazer
   alias Algora.Workspace.Repository
   alias Algora.Workspace.Ticket
 
@@ -110,7 +112,7 @@ defmodule Algora.Admin do
           |> Repo.stream()
           |> Enum.each(fn user ->
             %{provider_login: user.provider_login}
-            |> Workspace.Jobs.FetchTopContributions.new()
+            |> FetchTopContributions.new()
             |> Oban.insert()
             |> case do
               {:ok, _job} -> IO.puts("Enqueued job for #{user.provider_login}")
@@ -1003,4 +1005,55 @@ defmodule Algora.Admin do
         {:error, :backfill_incomplete}
     end
   end
+
+  def import_stargazers(repo_url, max_pages \\ nil) when is_binary(repo_url) do
+    with {:ok, [owner: repo_owner, repo: repo_name]} <- parse_repo_url(repo_url),
+         {:ok, repo} <- Workspace.ensure_repository(token(), repo_owner, repo_name) do
+      fetch_and_import_stargazers(repo_owner, repo_name, repo.id, 1, max_pages)
+    else
+      error ->
+        Logger.error("Failed to import stargazers: #{inspect(error)}")
+        {:error, :failed_to_import_stargazers}
+    end
+  end
+
+  defp fetch_and_import_stargazers(repo_owner, repo_name, repo_id, page, max_pages) do
+    if max_pages && page > max_pages do
+      Logger.info("Reached maximum page number #{max_pages}, stopping import")
+      :ok
+    else
+      url = "/repos/#{repo_owner}/#{repo_name}/stargazers?per_page=3&page=#{page}"
+
+      case Github.Client.fetch(token(), url) do
+        {:ok, []} ->
+          Logger.info("Finished importing stargazers - no more pages")
+          :ok
+
+        {:ok, stargazers} ->
+          Enum.each(stargazers, fn user ->
+            %{provider_login: user["login"], repo_id: repo_id}
+            |> ImportStargazer.new()
+            |> Oban.insert()
+            |> case do
+              {:ok, _job} -> Logger.info("Enqueued job for #{user["login"]}")
+              {:error, error} -> Logger.error("Failed to enqueue job for #{user["login"]}: #{inspect(error)}")
+            end
+          end)
+
+          # Process next page
+          fetch_and_import_stargazers(repo_owner, repo_name, repo_id, page + 1, max_pages)
+
+        error ->
+          Logger.error("Failed to fetch stargazers page #{page}: #{inspect(error)}")
+          {:error, :failed_to_fetch_stargazers}
+      end
+    end
+  end
+
+  defp parse_repo_url(url) do
+    case Regex.run(~r{github\.com/([^/]+)/([^/]+)}, url) do
+      [_, owner, repo] -> {:ok, [owner: owner, repo: String.replace(repo, ".git", "")]}
+      _ -> {:error, :invalid_repo_url}
+    end
+  end
 end

lib/algora/workspace/jobs/import_stargazer.ex

@@ -0,0 +1,23 @@
+defmodule Algora.Workspace.Jobs.ImportStargazer do
+  @moduledoc false
+  use Oban.Worker,
+    queue: :fetch_top_contributions,
+    max_attempts: 3,
+    # 30 days
+    unique: [period: 30 * 24 * 60 * 60, fields: [:args]]
+
+  alias Algora.Github
+  alias Algora.Repo
+  alias Algora.Workspace.Stargazer
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{args: %{"provider_login" => provider_login, "repo_id" => repo_id}}) do
+    with {:ok, user} <- Algora.Workspace.fetch_top_contributions_async(Github.TokenPool.get_token(), provider_login) do
+      %Stargazer{}
+      |> Stargazer.changeset(%{user_id: user.id, repository_id: repo_id})
+      |> Repo.insert()
+    end
+  end
+
+  def timeout(_), do: :timer.seconds(30)
+end

lib/algora/workspace/schemas/stargazer.ex

@@ -0,0 +1,32 @@
+defmodule Algora.Workspace.Stargazer do
+  @moduledoc false
+  use Algora.Schema
+
+  alias Algora.Accounts.User
+  alias Algora.Workspace.Repository
+
+  typed_schema "stargazers" do
+    belongs_to :repository, Repository
+    belongs_to :user, User
+
+    timestamps()
+  end
+
+  def changeset(stargazer, params) do
+    stargazer
+    |> cast(params, [:repository_id, :user_id])
+    |> validate_required([:repository_id, :user_id])
+    |> foreign_key_constraint(:repository_id)
+    |> foreign_key_constraint(:user_id)
+    |> unique_constraint([:repository_id, :user_id])
+    |> generate_id()
+  end
+
+  def filter_by_repository_id(query, nil), do: query
+
+  def filter_by_repository_id(query, repository_id) do
+    from c in query,
+      join: r in assoc(c, :repository),
+      where: r.id == ^repository_id
+  end
+end

lib/algora/workspace/workspace.ex

@@ -14,6 +14,7 @@ defmodule Algora.Workspace do
   alias Algora.Workspace.Installation
   alias Algora.Workspace.Jobs
   alias Algora.Workspace.Repository
+  alias Algora.Workspace.Stargazer
   alias Algora.Workspace.Ticket
   alias Algora.Workspace.UserContribution
 
@@ -569,6 +570,27 @@ defmodule Algora.Workspace do
     )
   end
 
+  def list_stargazers(id) do
+    Repo.all(
+      from(s in Stargazer,
+        join: r in assoc(s, :repository),
+        where: r.provider == "github",
+        join: ro in assoc(r, :user),
+        where: ro.id == ^id,
+        join: u in assoc(s, :user),
+        where: u.type != :bot,
+        where: not ilike(u.provider_login, "%bot"),
+        left_join: m in Member,
+        on: m.user_id == u.id and m.org_id == r.user_id,
+        where: is_nil(m.id),
+        distinct: [s.user_id],
+        select_merge: %{user: u},
+        order_by: [desc: s.inserted_at, asc: s.id],
+        limit: 100
+      )
+    )
+  end
+
   def fetch_contributor(repository_id, user_id) do
     Repo.fetch_by(Contributor, repository_id: repository_id, user_id: user_id)
   end
@@ -691,7 +713,7 @@ defmodule Algora.Workspace do
     with {:ok, contributions} <- Algora.Cloud.top_contributions(provider_login),
          {:ok, user} <- ensure_user(token, provider_login),
          {:ok, _} <- add_contributions_async(token, user.id, contributions) do
-      {:ok, nil}
+      {:ok, user}
     else
       {:error, reason} ->
         Logger.error("Failed to fetch contributions for #{provider_login}: #{inspect(reason)}")

lib/algora_web/live/org/job_live.ex

@@ -242,8 +242,9 @@ defmodule AlgoraWeb.Org.JobLive do
           <%= for {tab, label, count} <- [
             {"applicants", "Applicants", length(@applicants)},
             {"imports", "Imports", length(@imports)},
+            if(length(@stargazers) > 0, do: {"stargazers", "Stargazers", length(@stargazers)}, else: nil),
             {"matches", "Matches", length(@matches)}
-          ] do %>
+          ] |> Enum.reject(& is_nil(&1)) do %>
             <label class={[
               "group relative flex cursor-pointer rounded-lg px-4 py-2 shadow-sm focus:outline-none",
               "border-2 bg-background transition-all duration-200 hover:border-primary hover:bg-primary/10",
@@ -359,7 +360,7 @@ defmodule AlgoraWeb.Org.JobLive do
                 </.card>
               <% else %>
                 <div class="grid grid-cols-1 gap-4 lg:grid-cols-3">
-                  <%= for match <- @matches |> Enum.take(if @current_org.hiring_subscription == :active, do: length(@matches), else: 15) do %>
+                  <%= for match <- @truncated_matches do %>
                     <div>
                       <.match_card
                         user={match.user}
@@ -369,20 +370,54 @@ defmodule AlgoraWeb.Org.JobLive do
                       />
                     </div>
                   <% end %>
-                  <%= if @current_org.hiring_subscription != :active do %>
+                  <%= if @current_org.hiring_subscription != :active && length(@truncated_matches) > 0 do %>
                     <div class="relative lg:col-span-3">
                       <img
                         src={~p"/images/screenshots/job-matches-more.png"}
                         class="w-full aspect-[1368/398]"
                       />
                       <div class="absolute inset-0 flex items-center font-bold text-foreground justify-center text-3xl md:text-4xl">
-                        + {length(@matches) - 15} more matches
+                        + {length(@matches) - length(@truncated_matches)} more matches
                       </div>
                     </div>
                   <% end %>
                 </div>
               <% end %>
             </.section>
+          <% "stargazers" -> %>
+            <.section title="Stargazers" subtitle="Top stargazers of your repositories">
+              <:actions>
+                <.button variant="default" phx-click="toggle_import_drawer">
+                  Import
+                </.button>
+              </:actions>
+              <%= if Enum.empty?(@stargazers) do %>
+                <.card class="rounded-lg bg-card py-12 text-center lg:rounded-[2rem]">
+                  <.card_header>
+                    <div class="mx-auto mb-2 rounded-full bg-muted p-4">
+                      <.icon name="tabler-users" class="h-8 w-8 text-muted-foreground" />
+                    </div>
+                    <.card_title>No stargazers yet</.card_title>
+                    <.card_description>
+                      Stargazers will appear here once you import your repositories
+                    </.card_description>
+                  </.card_header>
+                </.card>
+              <% else %>
+                <div class="grid grid-cols-1 gap-4 lg:grid-cols-3">
+                  <%= for stargazer <- @stargazers do %>
+                    <div>
+                      <.match_card
+                        user={stargazer.user}
+                        tech_stack={@job.tech_stack |> Enum.take(1)}
+                        contributions={Map.get(@contributions_map, stargazer.user.id, [])}
+                        contract_type="bring_your_own"
+                      />
+                    </div>
+                  <% end %>
+                </div>
+              <% end %>
+            </.section>
         <% end %>
       </div>
 
@@ -859,19 +894,32 @@ defmodule AlgoraWeb.Org.JobLive do
 
   defp assign_applicants(socket) do
     all_applicants = Jobs.list_job_applications(socket.assigns.job)
+    stargazers = Algora.Workspace.list_stargazers(socket.assigns.current_org.id)
     applicants = Enum.reject(all_applicants, & &1.imported_at)
     imports = Enum.filter(all_applicants, & &1.imported_at)
     matches = Settings.get_job_matches(socket.assigns.job)
 
-    developers = matches |> Enum.concat(all_applicants) |> Enum.map(& &1.user)
+    truncated_matches =
+      case Code.ensure_compiled(AlgoraCloud) do
+        {:module, _} -> AlgoraCloud.truncate_matches(socket.assigns.current_org, matches)
+        _ -> Enum.take(matches, 3)
+      end
+
+    developers =
+      matches
+      |> Enum.concat(all_applicants)
+      |> Enum.concat(stargazers)
+      |> Enum.map(& &1.user)
 
     contributions_map = fetch_applicants_contributions(developers, socket.assigns.job.tech_stack)
 
     socket
     |> assign(:developers, developers)
     |> assign(:applicants, sort_by_contributions(socket.assigns.job, applicants, contributions_map))
     |> assign(:imports, sort_by_contributions(socket.assigns.job, imports, contributions_map))
+    |> assign(:stargazers, sort_by_contributions(socket.assigns.job, stargazers, contributions_map))
     |> assign(:matches, matches)
+    |> assign(:truncated_matches, truncated_matches)
     |> assign(:contributions_map, contributions_map)
   end
 

priv/repo/migrations/20250518164953_create_stargazers.exs

@@ -0,0 +1,19 @@
+defmodule Algora.Repo.Migrations.CreateStargazers do
+  use Ecto.Migration
+
+  def change do
+    create table(:stargazers) do
+      add :repository_id, references(:repositories, on_delete: :delete_all), null: false
+      add :user_id, references(:users, on_delete: :delete_all), null: false
+
+      timestamps()
+    end
+
+    # Create an index for the foreign keys
+    create index(:stargazers, [:repository_id])
+    create index(:stargazers, [:user_id])
+
+    # Create a unique index to prevent duplicate stars
+    create unique_index(:stargazers, [:repository_id, :user_id])
+  end
+end