use OpenAgentsWeb.ConnCase

      test "GET /api/v3/repos/:owner/:repo/issues lists open issues", %{conn: conn} do

        conn = get(conn, ~p"/api/v3/repos/OpenAgents/openagents/issues")

        conn = get(conn, ~p"/api/v3/repos/OpenAgentsInc/openagents.com/issues")

        assert json_response(conn, 200)["issues"] != nil

      end

    end

Date: 2026-08-20

Status: Implemented subset with known compatibility and authorization gaps

Status: Repository-scoped subset implemented; bounded compatibility gaps remain

## Intent

surface. Project update/delete, item delete/read, field mutation, views,

ordering, draft items, and organization projects remain unimplemented.

## Known blockers

## Enforced authority contract

These are current measured behaviors, not hypothetical future concerns:

These are current measured behaviors:

- `/api/v3` public reads and authenticated writes use separate pipelines.

  Writes require an expiring digest-only `oa_pat_…` bearer with exact

  `forge:write` scope. An authenticated person creates and revokes credentials

  at `/settings/api-tokens`; plaintext is shown once.

- The route's owner/repository values are not backed by a canonical repository

  foreign key across the issue/project schema.

- Project show, item, update-item, and field actions do not consistently enforce

  the username in the route.

- The assignee read endpoints are placeholders while issue writes accept

  arbitrary login strings.

- Owner and repository path values resolve a canonical repository row. Public

  reads expose only repositories marked public; writes additionally require a

  writable membership for the PAT principal.

- Resource reads and mutations include repository ownership in their database

  query. Composite foreign keys reject cross-repository comments, label and

  assignee links, milestones, and project items.

- Issue and milestone numbers are repository-local. Project numbers are also

  repository-local for the repository-shaped LiveView surface.

- Project show, item, update-item, and field actions enforce the username in the

  route. The user-shaped Projects V2 subset is limited to the explicit initial

  repository because those compatibility URLs contain no repository segment.

- Assignee reads return active repository members with writable roles, and

  issue assignment accepts only those members.

## Remaining compatibility gaps

These are compatibility limits, not authorization fallbacks:

- Label rename does not implement GitHub's `new_name` behavior.

- Adding a nonexistent label, removing an absent label, and some label URL

  encoding cases differ from GitHub behavior.

- Error envelopes and pagination/link headers are a bounded local contract,

  not complete Octokit or `gh` parity.

Gate 6 must assign an explicit API principal and mutation policy. Gate 7 must

add repository entities, foreign keys, scoped uniqueness, one-query ownership

checks, and cross-repository isolation tests. Compatibility fixes follow those

authority boundaries rather than preceding them.

Gate 6 supplied the explicit API principal and mutation policy. Gate 7 supplied

repository entities, foreign keys, scoped uniqueness, ownership checks, and

cross-repository isolation tests. Further compatibility work must preserve

those authority boundaries.

## Evidence

- `test/openagents_web/controllers/issue_assignee_controller_test.exs`

- `test/openagents_web/controllers/milestone_controller_test.exs`

- `test/openagents_web/controllers/project_controller_test.exs`

- `test/openagents_web/controllers/repository_isolation_controller_test.exs`

- `test/openagents/repositories_test.exs`

Date: 2026-08-20

Status: Core surfaces implemented; tenant and design-system hardening pending

Status: Core surfaces and repository boundary implemented; staging UX validation pending

## Current surface

- Icons come from the vendored set through `OpenAgentsWeb.UI.icon/1`; icon-only

  controls have accessible names.

The current component inventory and transitional generated helpers are

documented in [docs/component-library.md](component-library.md).

## Blocking domain work

The route shape currently looks repository-scoped, but the durable issue and

project data model does not yet enforce that scope. Gate 7 must complete this

before the tracker is treated as a multi-repository forge:

1. Add a canonical repository entity.

2. Add repository foreign keys and scoped uniqueness to issues, labels,

   milestones, comments, assignees, and repository projects.

3. Resolve every resource through owner, repository, and resource identity in

   one authorized query.

4. Reject cross-repository identifiers in application code and PostgreSQL.

5. Replace the hardcoded assignee projection with repository membership and

   authorization.

6. Enforce project ownership instead of ignoring the username in Projects V2

   routes.

7. Separate public reads from authenticated browser and API writes.

8. Rehearse the backfill of existing rows into the initial repository.

Until this work passes cross-repository isolation tests, the URL is

presentation context rather than a proven tenancy boundary.

The current governed component inventory is documented in

[docs/component-library.md](component-library.md).

## Repository boundary

Gate 7 completed the durable repository boundary:

- `repositories` owns the stable repository ID, display and normalized path,

  visibility, and default branch. The explicit initial repository is

  `OpenAgentsInc/openagents.com`.

- Issues, labels, milestones, comments, projects, project items, issue-label

  links, and issue-assignee links carry repository ownership. Issue,

  milestone, and project numbers are unique within a repository.

- Public API reads resolve only public repositories. Authenticated LiveViews

  and PAT writes resolve a writable repository membership before loading or

  changing a resource.

- Assignees are active repository members with a writable role. Arbitrary

  login snapshots are no longer accepted.

- Projects V2 compatibility paths enforce the requested username in show,

  item, update-item, and field actions. The user-shaped API is deliberately

  bounded to the initial repository because its URL has no repository segment.

- Composite PostgreSQL foreign keys prevent a comment, label relation,

  assignee relation, milestone reference, or project item from crossing its

  repository.

- The reversible migration was run down/up, populated with pre-scope rows, run

  up, validated, then run down/up again. It reconstructed repository,

  membership, author, label, assignee, milestone, project-owner, and

  project-item relationships.

Context, controller, and LiveView tests cover same-number resources in multiple

repositories, private-repository hiding, nonmember write refusal, wrong-owner

Projects V2 paths, and database constraint failures.

## Remaining interface work

After Gate 7 establishes the domain boundary:

With the domain boundary established:

1. Reconcile every issue/project surface onto `OpenAgentsWeb.UI` and remove

   transitional generated component callers.

2. Extract repeated issue rows, comment threads, label selectors, milestone

1. Extract repeated issue rows, comment threads, label selectors, milestone

   progress, and project columns only where doing so improves behavior and test

   ownership.

3. Add bounded search, filtering, pagination, and useful empty/loading/error

2. Add bounded search, filtering, pagination, and useful empty/loading/error

   states.

4. Add PubSub invalidation and database rereads where concurrent users need

3. Add PubSub invalidation and database rereads where concurrent users need

   live updates.

5. Add repository authorization-aware actions and explicit refusal states.

6. Run accessibility, keyboard, responsive, compiled-CSS, and browser staging

4. Run accessibility, keyboard, responsive, compiled-CSS, and browser staging

   checks against the same candidate SHA.

Drag-and-drop boards, advanced project views, pull requests, review workflows,

defmodule OpenAgents.Issues do

  @moduledoc """

  The Issues context.

  """

  @moduledoc "Repository-scoped issues, comments, labels, milestones, and assignees."

  import Ecto.Query, warn: false

  alias OpenAgents.Repo

  alias OpenAgents.Issues.Comment

  alias OpenAgents.Issues.Issue

  alias OpenAgents.Accounts.User

  alias OpenAgents.Issues.{Comment, Issue}

  alias OpenAgents.Labels

  alias OpenAgents.Labels.Label

  alias OpenAgents.Milestones

  alias OpenAgents.Milestones.Milestone

  alias OpenAgents.Repo

  alias OpenAgents.Repositories

  alias OpenAgents.Repositories.Repository

  def list_issues(opts \\ []) when is_list(opts),

    do: list_issues(Repositories.initial_repository!(), opts)

  def list_issues(opts \\ []) do

  def list_issues(%Repository{id: repository_id}, opts) when is_list(opts) do

    state = Keyword.get(opts, :state, "open")

    Issue

    |> where(repository_id: ^repository_id)

    |> maybe_filter_state(state)

    |> order_by(desc: :inserted_at)

    |> Repo.all()

  end

  def get_issue!(id), do: Repo.get!(Issue, id)

  def get_issue!(id), do: get_issue!(Repositories.initial_repository!(), id)

  def get_issue!(%Repository{id: repository_id}, id) do

    Repo.get_by!(Issue, id: id, repository_id: repository_id)

  end

  def get_issue_by_number!(number) when is_integer(number),

    do: Repo.get_by!(Issue, number: number)

    do: get_issue_by_number!(Repositories.initial_repository!(), number)

  def get_issue_by_number!(%Repository{id: repository_id}, number) when is_integer(number),

    do: Repo.get_by!(Issue, repository_id: repository_id, number: number)

  def get_issue_by_path!(owner, repository_name, number) when is_integer(number) do

    Repo.one!(

      from issue in Issue,

        join: repository in Repository,

        on: repository.id == issue.repository_id,

        where:

          repository.owner_key == ^String.downcase(owner) and

            repository.name_key == ^String.downcase(repository_name) and

            repository.visibility == "public" and issue.number == ^number

    )

  end

  def create_issue(attrs \\ %{}),

    do: create_issue(Repositories.initial_repository!(), attrs, nil)

  def create_issue(attrs \\ %{}) do

    number = next_issue_number()

  def create_issue(%Repository{} = repository, attrs),

    do: create_issue(repository, attrs, nil)

  def create_issue(%Repository{} = repository, attrs, author)

      when is_nil(author) or is_struct(author, User) do

    normalized =

      attrs

      |> to_string_map()

      |> Map.put("number", number)

      |> prepare_collections()

      |> Map.put("repository_id", repository.id)

      |> put_author(author)

      |> prepare_collections(repository)

    %Issue{}

    |> Issue.changeset(normalized)

    |> Repo.insert()

    create_issue_with_number(repository, normalized, 20)

  end

  defp create_issue_with_number(repository, normalized, attempts_remaining) do

    Repo.transaction(fn ->

      number = next_issue_number(repository.id)

      normalized = Map.put(normalized, "number", number)

      with {:ok, issue} <- %Issue{} |> Issue.changeset(normalized) |> Repo.insert(),

           :ok <- sync_label_relationships(issue),

           :ok <- sync_assignee_relationships(issue) do

        issue

      else

        {:error, changeset} -> Repo.rollback(changeset)

      end

    end)

    |> case do

      {:error, changeset} when attempts_remaining > 1 ->

        if number_conflict?(changeset, "issues_repository_id_number_index") do

          create_issue_with_number(repository, normalized, attempts_remaining - 1)

        else

          {:error, changeset}

        end

      result ->

        result

    end

  end

  def update_issue(%Issue{} = issue, attrs) do

    normalized =

      issue

      |> maybe_closed_attrs(attrs)

      |> to_string_map()

      |> prepare_collections()

    repository = %Repository{id: issue.repository_id}

    issue

    |> Issue.changeset(normalized)

    |> Repo.update()

    Repo.transaction(fn ->

      normalized =

        issue

        |> maybe_closed_attrs(attrs)

        |> to_string_map()

        |> Map.drop(["number", "repository_id", "author_user_id", "user"])

        |> prepare_collections(repository)

      with {:ok, updated} <- issue |> Issue.changeset(normalized) |> Repo.update(),

           :ok <- sync_label_relationships(updated),

           :ok <- sync_assignee_relationships(updated) do

        updated

      else

        {:error, changeset} -> Repo.rollback(changeset)

      end

    end)

  end

  def change_issue(%Issue{} = issue, attrs \\ %{}) do

    attrs =

      if is_nil(issue.repository_id) do

        attrs

        |> to_string_map()

        |> Map.put("repository_id", Repositories.initial_repository!().id)

      else

        attrs

      end

    Issue.changeset(issue, attrs)

  end

  def add_labels(%Issue{} = issue, names) when is_list(names) do

    new_labels =

      names

      |> Enum.map(&Labels.get_label_by_name!/1)

      |> Enum.map(&label_json/1)

    existing = issue.labels || []

    labels = (existing ++ new_labels) |> Enum.uniq_by(& &1["name"])

      Enum.map(names, fn name ->

        issue.repository_id

        |> repository_stub()

        |> Labels.get_label_by_name!(name)

        |> label_json()

      end)

    labels = ((issue.labels || []) ++ new_labels) |> Enum.uniq_by(& &1["name"])

    update_issue(issue, %{"labels" => labels})

  end

  def remove_label(%Issue{} = issue, name) when is_binary(name) do

    name = URI.decode(name)

    labels = Enum.reject(issue.labels || [], &label_match?(&1, name))

    decoded = URI.decode(name)

    labels = Enum.reject(issue.labels || [], &label_match?(&1, decoded))

    update_issue(issue, %{"labels" => labels})

  end

  def add_assignees(%Issue{} = issue, logins) when is_list(logins) do

    new = Enum.map(logins, &%{"login" => &1})

    existing = issue.assignees || []

    assignees = (existing ++ new) |> Enum.uniq_by(& &1["login"])

    repository = repository_stub(issue.repository_id)

    new =

      Enum.map(logins, fn login ->

        repository

        |> Repositories.get_assignable_user_by_login!(login)

        |> assignee_json()

      end)

    assignees = ((issue.assignees || []) ++ new) |> Enum.uniq_by(& &1["login"])

    update_issue(issue, %{"assignees" => assignees})

  end

  def remove_assignees(%Issue{} = issue, logins) when is_list(logins) do

    logins = MapSet.new(logins)

    assignees = Enum.reject(issue.assignees || [], &(&1["login"] in logins))

    logins = logins |> Enum.map(&String.downcase/1) |> MapSet.new()

    assignees =

      Enum.reject(issue.assignees || [], fn assignee ->

        String.downcase(assignee["login"]) in logins

      end)

    update_issue(issue, %{"assignees" => assignees})

  end

  end

  def set_milestone(%Issue{} = issue, number) when is_integer(number) do

    milestone = Milestones.get_milestone_by_number!(number)

    milestone = Milestones.get_milestone_by_number!(repository_stub(issue.repository_id), number)

    update_issue(issue, %{"milestone" => milestone_json(milestone)})

  end

  def list_comments(issue_id) do

  def list_comments(%Issue{id: issue_id, repository_id: repository_id}) do

    Comment

    |> where(issue_id: ^issue_id)

    |> where(issue_id: ^issue_id, repository_id: ^repository_id)

    |> order_by(:created_at)

    |> Repo.all()

  end

  def get_comment!(id), do: Repo.get!(Comment, id)

  def list_comments(issue_id) do

    issue = get_issue!(issue_id)

    list_comments(issue)

  end

  def get_comment!(id), do: get_comment!(Repositories.initial_repository!(), id)

  def get_comment!(%Repository{id: repository_id}, id) do

    Repo.get_by!(Comment, id: id, repository_id: repository_id)

  end

  def get_comment_by_path!(owner, repository_name, id) do

    Repo.one!(

      from comment in Comment,

        join: repository in Repository,

        on: repository.id == comment.repository_id,

        where:

          repository.owner_key == ^String.downcase(owner) and

            repository.name_key == ^String.downcase(repository_name) and

            repository.visibility == "public" and comment.id == ^id

    )

  end

  def create_comment(attrs \\ %{}) do

    normalized = to_string_map(attrs)

    case Map.fetch(normalized, "issue_id") do

      {:ok, issue_id} ->

        issue = get_issue!(issue_id)

        create_comment(issue, normalized, nil)

      :error ->

        now = DateTime.utc_now() |> DateTime.truncate(:second)

        %Comment{}

        |> Comment.changeset(

          normalized

          |> Map.put("repository_id", Repositories.initial_repository!().id)

          |> Map.put_new("created_at", now)

          |> Map.put_new("updated_at", now)

        )

        |> Ecto.Changeset.apply_action(:insert)

    end

  end

  def create_comment(%Issue{} = issue, attrs, author \\ nil)

      when is_nil(author) or is_struct(author, User) do

    normalized =

      attrs

      |> to_string_map()

      |> Map.put("issue_id", issue.id)

      |> Map.put("repository_id", issue.repository_id)

      |> put_author(author)

      |> Map.put_new("created_at", DateTime.utc_now() |> DateTime.truncate(:second))

      |> Map.put_new("updated_at", DateTime.utc_now() |> DateTime.truncate(:second))

    issue_id = Map.get(normalized, "issue_id")

    Repo.transaction(fn ->

      with {:ok, %Comment{} = comment} <-

             %Comment{}

             |> Comment.changeset(normalized)

             |> Repo.insert(),

             %Comment{} |> Comment.changeset(normalized) |> Repo.insert(),

           {1, nil} <-

             from(i in Issue, where: i.id == ^issue_id, update: [inc: [comments: 1]])

             from(i in Issue,

               where: i.id == ^issue.id and i.repository_id == ^issue.repository_id,

               update: [inc: [comments: 1]]

             )

             |> Repo.update_all([]) do

        comment

      else

    normalized =

      attrs

      |> to_string_map()

      |> Map.drop(["issue_id", "repository_id", "author_user_id", "user"])

      |> Map.put("updated_at", DateTime.utc_now() |> DateTime.truncate(:second))

    comment

  def delete_comment(%Comment{} = comment) do

    Repo.transaction(fn ->

      issue_id = comment.issue_id

      with {:ok, %Comment{}} <- Repo.delete(comment),

           {1, nil} <-

             from(i in Issue, where: i.id == ^issue_id, update: [inc: [comments: -1]])

             from(i in Issue,

               where: i.id == ^comment.issue_id and i.repository_id == ^comment.repository_id,

               update: [inc: [comments: -1]]

             )

             |> Repo.update_all([]) do

        :ok

      else

    end)

  end

  defp maybe_closed_attrs(issue, %{"state" => "closed"} = attrs) do

    if issue.state == "open" do

      attrs

      |> Map.put("closed_at", DateTime.utc_now() |> DateTime.truncate(:second))

      |> Map.put_new("state_reason", "completed")

    else

      attrs

    end

  defp prepare_collections(attrs, repository) do

    attrs

    |> maybe_convert_milestone(repository)

    |> maybe_convert_labels(repository)

    |> maybe_convert_assignees(repository)

  end

  defp maybe_closed_attrs(_issue, %{"state" => "open"} = attrs) do

  defp maybe_convert_milestone(%{"milestone" => nil} = attrs, _repository) do

    attrs |> Map.put("milestone", nil) |> Map.put("milestone_id", nil)

  end

  defp maybe_convert_milestone(%{"milestone" => number} = attrs, repository)

       when is_integer(number) do

    milestone = Milestones.get_milestone_by_number!(repository, number)

    attrs

    |> Map.put("closed_at", nil)

    |> Map.put("state_reason", nil)

    |> Map.put("milestone", milestone_json(milestone))

    |> Map.put("milestone_id", milestone.id)

  end

  defp maybe_closed_attrs(_issue, %{state: "closed"} = attrs) do

    if is_nil(attrs[:closed_at]) do

      Map.put(attrs, :closed_at, DateTime.utc_now() |> DateTime.truncate(:second))

    else

      attrs

    end

    |> Map.put_new(:state_reason, "completed")

  defp maybe_convert_milestone(%{"milestone" => milestone} = attrs, repository)

       when is_map(milestone) do

    number = milestone["number"] || milestone[:number]

    maybe_convert_milestone(Map.put(attrs, "milestone", number), repository)

  end

  defp maybe_closed_attrs(_issue, %{state: "open"} = attrs) do

    attrs

    |> Map.put(:closed_at, nil)

    |> Map.put(:state_reason, nil)

  defp maybe_convert_milestone(attrs, _repository), do: attrs

  defp maybe_convert_labels(%{"labels" => labels} = attrs, repository) when is_list(labels) do

    snapshots =

      Enum.map(labels, fn label ->

        name = if is_binary(label), do: label, else: label["name"] || label[:name]

        repository |> Labels.get_label_by_name!(name) |> label_json()

      end)

    Map.put(attrs, "labels", Enum.uniq_by(snapshots, & &1["name"]))

  end

  defp maybe_closed_attrs(_issue, attrs), do: attrs

  defp maybe_convert_labels(attrs, _repository), do: attrs

  defp maybe_filter_state(query, "all"), do: query

  defp maybe_filter_state(query, state), do: where(query, state: ^state)

  defp maybe_convert_assignees(%{"assignees" => assignees} = attrs, repository)

       when is_list(assignees) do

    snapshots =

      Enum.map(assignees, fn assignee ->

        login = if is_binary(assignee), do: assignee, else: assignee["login"] || assignee[:login]

        repository |> Repositories.get_assignable_user_by_login!(login) |> assignee_json()

      end)

  defp next_issue_number do

    case Repo.aggregate(Issue, :max, :number) do

      nil -> 1

      n -> n + 1

    end

    Map.put(attrs, "assignees", Enum.uniq_by(snapshots, & &1["login"]))

  end

  defp to_string_map(attrs) do

    for {k, v} <- attrs, into: %{}, do: {to_string(k), v}

  defp maybe_convert_assignees(attrs, _repository), do: attrs

  defp sync_label_relationships(%Issue{} = issue) do

    Repo.delete_all(from row in "issue_labels", where: row.issue_id == ^issue.id)

    rows =

      Enum.map(issue.labels || [], fn snapshot ->

        label = Labels.get_label_by_name!(repository_stub(issue.repository_id), snapshot["name"])

        %{

          issue_id: issue.id,

          label_id: label.id,

          repository_id: issue.repository_id,

          inserted_at: DateTime.utc_now(),

          updated_at: DateTime.utc_now()

        }

      end)

    if rows != [], do: Repo.insert_all("issue_labels", dump_repository_ids(rows))

    :ok

  end

  defp prepare_collections(attrs) do

    attrs

    |> maybe_convert_milestone()

    |> maybe_convert_labels()

    |> maybe_convert_assignees()

  defp sync_assignee_relationships(%Issue{} = issue) do

    Repo.delete_all(from row in "issue_assignees", where: row.issue_id == ^issue.id)

    rows =

      Enum.map(issue.assignees || [], fn snapshot ->

        user =

          Repositories.get_assignable_user_by_login!(

            repository_stub(issue.repository_id),

            snapshot["login"]

          )

        %{

          issue_id: issue.id,

          user_id: user.id,

          repository_id: issue.repository_id,

          inserted_at: DateTime.utc_now(),

          updated_at: DateTime.utc_now()

        }

      end)

    if rows != [], do: Repo.insert_all("issue_assignees", dump_repository_ids(rows))

    :ok

  end

  defp maybe_convert_milestone(%{"milestone" => milestone} = attrs) when is_integer(milestone) do

    milestone = Milestones.get_milestone_by_number!(milestone)

    Map.put(attrs, "milestone", milestone_json(milestone))

  defp next_issue_number(repository_id) do

    case Repo.aggregate(from(i in Issue, where: i.repository_id == ^repository_id), :max, :number) do

      nil -> 1

      number -> number + 1

    end

  end

  defp maybe_convert_milestone(%{"milestone" => nil} = attrs) do

    Map.put(attrs, "milestone", nil)

  defp number_conflict?(%Ecto.Changeset{} = changeset, constraint_name) do

    Enum.any?(changeset.errors, fn {_field, {_message, options}} ->

      options[:constraint_name] == constraint_name

    end)

  end

  defp maybe_convert_milestone(attrs), do: attrs

  defp put_author(attrs, nil), do: attrs

  defp maybe_convert_labels(%{"labels" => labels} = attrs) when is_list(labels) do

    if Enum.all?(labels, &is_binary/1) do

      existing =

        Labels.list_labels()

        |> Enum.map(&label_json/1)

        |> Map.new(&{&1["name"], &1})

  defp put_author(attrs, %User{} = author) do

    attrs

    |> Map.put("author_user_id", author.id)

    |> Map.put("user", user_json(author))

  end

      label_maps =

        Enum.map(labels, fn name ->

          Map.get(existing, name, %{"name" => name, "color" => "ffffff"})

        end)

  defp dump_repository_ids(rows) do

    Enum.map(rows, fn row ->

      row = Map.update!(row, :repository_id, &Ecto.UUID.dump!/1)

      if Map.has_key?(row, :user_id) do

        Map.update!(row, :user_id, &Ecto.UUID.dump!/1)

      else

        row

      end

    end)

  end

      Map.put(attrs, "labels", label_maps)

  defp maybe_closed_attrs(issue, %{"state" => "closed"} = attrs) do

    if issue.state == "open" do

      attrs

      |> Map.put("closed_at", DateTime.utc_now() |> DateTime.truncate(:second))

      |> Map.put_new("state_reason", "completed")

    else

      attrs

    end

  end

  defp maybe_convert_labels(attrs), do: attrs

  defp maybe_closed_attrs(_issue, %{"state" => "open"} = attrs) do

    attrs |> Map.put("closed_at", nil) |> Map.put("state_reason", nil)

  end

  defp maybe_closed_attrs(issue, %{state: "closed"} = attrs) do

    attrs =

      if issue.state == "open" and is_nil(attrs[:closed_at]) do

        Map.put(attrs, :closed_at, DateTime.utc_now() |> DateTime.truncate(:second))

      else

        attrs

      end

  defp maybe_convert_assignees(%{"assignees" => logins} = attrs) when is_list(logins) do

    if Enum.all?(logins, &is_binary/1) do

      assignees = Enum.map(logins, &%{"login" => &1})

      Map.put(attrs, "assignees", assignees)

    else

      attrs

    end

    Map.put_new(attrs, :state_reason, "completed")

  end

  defp maybe_closed_attrs(_issue, %{state: "open"} = attrs) do

    attrs |> Map.put(:closed_at, nil) |> Map.put(:state_reason, nil)

  end

  defp maybe_closed_attrs(_issue, attrs), do: attrs

  defp maybe_filter_state(query, "all"), do: query

  defp maybe_filter_state(query, state), do: where(query, state: ^state)

  defp to_string_map(attrs) do

    for {key, value} <- attrs, into: %{}, do: {to_string(key), value}

  end

  defp maybe_convert_assignees(attrs), do: attrs

  defp repository_stub(id), do: %Repository{id: id}

  defp label_json(%OpenAgents.Labels.Label{} = label) do

  defp label_json(%Label{} = label) do

    %{

      "id" => label.id,

      "name" => label.name,

    }

  end

  defp milestone_json(%OpenAgents.Milestones.Milestone{} = milestone) do

  defp milestone_json(%Milestone{} = milestone) do

    %{

      "number" => milestone.number,

      "title" => milestone.title,

    }

  end

  defp user_json(%User{} = user) do

    %{

      "id" => user.github_id,

      "login" => user.github_login,

      "avatar_url" => user.github_avatar_url

    }

  end

  defp assignee_json(%User{} = user), do: %{"login" => user.github_login}

  defp label_match?(label, name), do: label["name"] == name

end

  import Ecto.Changeset

  alias OpenAgents.Issues.Issue

  alias OpenAgents.Repositories.Repository

  schema "comments" do

    field :body, :string

    field :updated_at, :utc_datetime

    belongs_to :issue, Issue

    belongs_to :repository, Repository, type: :binary_id

    belongs_to :author_user, OpenAgents.Accounts.User, type: :binary_id

  end

  @doc false

  def changeset(comment, attrs) do

    comment

    |> cast(attrs, [:body, :user, :issue_id, :created_at, :updated_at])

    |> validate_required([:body, :issue_id, :created_at, :updated_at])

    |> cast(attrs, [

      :body,

      :user,

      :issue_id,

      :repository_id,

      :author_user_id,

      :created_at,

      :updated_at

    ])

    |> validate_required([:body, :issue_id, :repository_id, :created_at, :updated_at])

    |> foreign_key_constraint(:repository_id)

    |> foreign_key_constraint(:issue_id)

    |> foreign_key_constraint(:author_user_id)

    |> foreign_key_constraint(:issue_id, name: :comments_issue_repository_fkey)

  end

end

  use Ecto.Schema

  import Ecto.Changeset

  alias OpenAgents.Accounts.User

  alias OpenAgents.Milestones.Milestone

  alias OpenAgents.Repositories.Repository

  schema "issues" do

    field :number, :integer

    field :title, :string

    field :assignees, {:array, :map}, default: []

    field :milestone, :map

    field :user, :map

    belongs_to :repository, Repository, type: :binary_id

    belongs_to :milestone_record, Milestone, foreign_key: :milestone_id

    belongs_to :author_user, User, type: :binary_id

    timestamps(type: :utc_datetime)

  end

      :labels,

      :assignees,

      :milestone,

      :user

      :user,

      :repository_id,

      :milestone_id,

      :author_user_id

    ])

    |> validate_required([:title, :number])

    |> validate_required([:title, :number, :repository_id])

    |> unique_constraint([:repository_id, :number])

    |> foreign_key_constraint(:repository_id)

    |> foreign_key_constraint(:milestone_id)

    |> foreign_key_constraint(:author_user_id)

  end

end

  import Ecto.Query, warn: false

  alias OpenAgents.Repo

  alias OpenAgents.Repositories

  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Labels.Label

      [%Label{}, ...]

  """

  def list_labels do

    Repo.all(Label)

  def list_labels, do: list_labels(Repositories.initial_repository!())

  def list_labels(%Repository{id: repository_id}) do

    Label

    |> where(repository_id: ^repository_id)

    |> order_by(asc: :name)

    |> Repo.all()

  end

  @doc """

      ** (Ecto.NoResultsError)

  """

  def get_label!(id), do: Repo.get!(Label, id)

  def get_label!(id), do: get_label!(Repositories.initial_repository!(), id)

  def get_label!(%Repository{id: repository_id}, id) do

    Repo.get_by!(Label, id: id, repository_id: repository_id)

  end

  def get_label_by_name!(name) when is_binary(name) do

    Repo.get_by!(Label, name: URI.decode(name))

    get_label_by_name!(Repositories.initial_repository!(), name)

  end

  def get_label_by_name!(%Repository{id: repository_id}, name) when is_binary(name) do

    Repo.get_by!(Label, repository_id: repository_id, name: URI.decode(name))

  end

  def get_label_by_path!(owner, repository_name, name) do

    Repo.one!(

      from label in Label,

        join: repository in Repository,

        on: repository.id == label.repository_id,

        where:

          repository.owner_key == ^String.downcase(owner) and

            repository.name_key == ^String.downcase(repository_name) and

            repository.visibility == "public" and label.name == ^URI.decode(name)

    )

  end

  @doc """

      {:error, %Ecto.Changeset{}}

  """

  def create_label(attrs) do

  def create_label(attrs), do: create_label(Repositories.initial_repository!(), attrs)

  def create_label(%Repository{} = repository, attrs) do

    attrs =

      attrs

      |> Enum.into(%{}, fn {key, value} -> {to_string(key), value} end)

      |> Map.put("repository_id", repository.id)

    %Label{}

    |> Label.changeset(attrs)

    |> Repo.insert()

  """

  def update_label(%Label{} = label, attrs) do

    attrs = Map.drop(attrs, [:repository_id, "repository_id"])

    label

    |> Label.changeset(attrs)

    |> Repo.update()

  use Ecto.Schema

  import Ecto.Changeset

  alias OpenAgents.Repositories.Repository

  schema "labels" do

    field :name, :string

    field :color, :string

    field :description, :string

    belongs_to :repository, Repository, type: :binary_id

    timestamps(type: :utc_datetime)

  end

  @doc false

  def changeset(label, attrs) do

    label

    |> cast(attrs, [:name, :color, :description])

    |> validate_required([:name, :color])

    |> cast(attrs, [:name, :color, :description, :repository_id])

    |> validate_required([:name, :color, :repository_id])

    |> unique_constraint([:repository_id, :name])

    |> foreign_key_constraint(:repository_id)

  end

end

  import Ecto.Query, warn: false

  alias OpenAgents.Repo

  alias OpenAgents.Repositories

  alias OpenAgents.Repositories.Repository

  alias OpenAgents.Milestones.Milestone

      [%Milestone{}, ...]

  """

  def list_milestones do

    Repo.all(Milestone)

  def list_milestones, do: list_milestones(Repositories.initial_repository!())

  def list_milestones(%Repository{id: repository_id}) do

    Milestone