# Generated by `mix github.gen` from docs/github-api/api.github.com.json.
# Do not edit by hand; re-run the task instead.

defmodule Noizu.Github.Api.Issues do
  @moduledoc """
  GitHub `issues` API.
  """
  import Noizu.Github

  @doc """
  Add assignees to an issue

  @see https://docs.github.com/rest/issues/assignees#add-assignees-to-an-issue
  """
  def add_assignees(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/assignees"
    body = body
    api_call(:post, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Add a dependency an issue is blocked by

  @see https://docs.github.com/rest/issues/issue-dependencies#add-a-dependency-an-issue-is-blocked-by
  """
  def add_blocked_by_dependency(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/dependencies/blocked_by"

    body = body
    api_call(:post, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Add issue field values to an issue

  @see https://docs.github.com/rest/issues/issue-field-values#add-issue-field-values-to-an-issue
  """
  def add_issue_field_values(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/issue-field-values"
    body = body
    api_call(:post, url, body, Noizu.Github.Collection.IssueFieldValue, options)
  end

  @doc """
  Add labels to an issue

  @see https://docs.github.com/rest/issues/labels#add-labels-to-an-issue
  """
  def add_labels(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/labels"
    body = body
    api_call(:post, url, body, Noizu.Github.Collection.Label, options)
  end

  @doc """
  Add sub-issue

  @see https://docs.github.com/rest/issues/sub-issues#add-sub-issue
  """
  def add_sub_issue(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/sub_issues"
    body = body
    api_call(:post, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Check if a user can be assigned

  @see https://docs.github.com/rest/issues/assignees#check-if-a-user-can-be-assigned
  """
  def check_user_can_be_assigned(assignee, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/assignees/#{assignee}"
    body = %{}
    api_call(:get, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Check if a user can be assigned to a issue

  @see https://docs.github.com/rest/issues/assignees#check-if-a-user-can-be-assigned-to-a-issue
  """
  def check_user_can_be_assigned_to_issue(issue_number, assignee, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/assignees/#{assignee}"
    body = %{}
    api_call(:get, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Create an issue

  @see https://docs.github.com/rest/issues/issues#create-an-issue
  """
  def create(body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues"
    body = body
    api_call(:post, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Create an issue comment

  @see https://docs.github.com/rest/issues/comments#create-an-issue-comment
  """
  def create_comment(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/comments"
    body = body
    api_call(:post, url, body, Noizu.Github.IssueComment, options)
  end

  @doc """
  Create a label

  @see https://docs.github.com/rest/issues/labels#create-a-label
  """
  def create_label(body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/labels"
    body = body
    api_call(:post, url, body, Noizu.Github.Label, options)
  end

  @doc """
  Create a milestone

  @see https://docs.github.com/rest/issues/milestones#create-a-milestone
  """
  def create_milestone(body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/milestones"
    body = body
    api_call(:post, url, body, Noizu.Github.Milestone, options)
  end

  @doc """
  Delete an issue comment

  @see https://docs.github.com/rest/issues/comments#delete-an-issue-comment
  """
  def delete_comment(comment_id, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/comments/#{comment_id}"
    body = %{}
    api_call(:delete, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Delete an issue field value from an issue

  @see https://docs.github.com/rest/issues/issue-field-values#delete-an-issue-field-value-from-an-issue
  """
  def delete_issue_field_value(issue_number, issue_field_id, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      github_base() <>
        "/repos/#{owner}/#{repo}/issues/#{issue_number}/issue-field-values/#{issue_field_id}"

    body = %{}
    api_call(:delete, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Delete a label

  @see https://docs.github.com/rest/issues/labels#delete-a-label
  """
  def delete_label(name, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/labels/#{name}"
    body = %{}
    api_call(:delete, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Delete a milestone

  @see https://docs.github.com/rest/issues/milestones#delete-a-milestone
  """
  def delete_milestone(milestone_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/milestones/#{milestone_number}"
    body = %{}
    api_call(:delete, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Get an issue

  @see https://docs.github.com/rest/issues/issues#get-an-issue
  """
  def get(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}"
    body = %{}
    api_call(:get, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Get an issue comment

  @see https://docs.github.com/rest/issues/comments#get-an-issue-comment
  """
  def get_comment(comment_id, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/comments/#{comment_id}"
    body = %{}
    api_call(:get, url, body, Noizu.Github.IssueComment, options)
  end

  @doc """
  Get an issue event

  @see https://docs.github.com/rest/issues/events#get-an-issue-event
  """
  def get_event(event_id, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/events/#{event_id}"
    body = %{}
    api_call(:get, url, body, Noizu.Github.IssueEvent, options)
  end

  @doc """
  Get a label

  @see https://docs.github.com/rest/issues/labels#get-a-label
  """
  def get_label(name, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/labels/#{name}"
    body = %{}
    api_call(:get, url, body, Noizu.Github.Label, options)
  end

  @doc """
  Get a milestone

  @see https://docs.github.com/rest/issues/milestones#get-a-milestone
  """
  def get_milestone(milestone_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/milestones/#{milestone_number}"
    body = %{}
    api_call(:get, url, body, Noizu.Github.Milestone, options)
  end

  @doc """
  Get parent issue

  @see https://docs.github.com/rest/issues/sub-issues#get-parent-issue
  """
  def get_parent(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/parent"
    body = %{}
    api_call(:get, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  List issues assigned to the authenticated user

  @see https://docs.github.com/rest/issues/issues#list-issues-assigned-to-the-authenticated-user
  """
  def list(options \\ nil) do
    url =
      (
        query =
          [
            get_field(:filter, options, nil),
            get_field(:state, options, nil),
            get_field(:labels, options, nil),
            get_field(:sort, options, nil),
            get_field(:direction, options, nil),
            get_field(:since, options, nil),
            get_field(:collab, options, nil),
            get_field(:orgs, options, nil),
            get_field(:owned, options, nil),
            get_field(:pulls, options, nil),
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/issues" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Issue, options)
  end

  @doc """
  List assignees

  @see https://docs.github.com/rest/issues/assignees#list-assignees
  """
  def list_assignees(options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/assignees" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.SimpleUser, options)
  end

  @doc """
  List issue comments

  @see https://docs.github.com/rest/issues/comments#list-issue-comments
  """
  def list_comments(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:since, options, nil),
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/comments" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.IssueComment, options)
  end

  @doc """
  List issue comments for a repository

  @see https://docs.github.com/rest/issues/comments#list-issue-comments-for-a-repository
  """
  def list_comments_for_repo(options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:sort, options, nil),
            get_field(:direction, options, nil),
            get_field(:since, options, nil),
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues/comments" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.IssueComment, options)
  end

  @doc """
  List dependencies an issue is blocked by

  @see https://docs.github.com/rest/issues/issue-dependencies#list-dependencies-an-issue-is-blocked-by
  """
  def list_dependencies_blocked_by(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")

        github_base() <>
          "/repos/#{owner}/#{repo}/issues/#{issue_number}/dependencies/blocked_by" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Issue, options)
  end

  @doc """
  List dependencies an issue is blocking

  @see https://docs.github.com/rest/issues/issue-dependencies#list-dependencies-an-issue-is-blocking
  """
  def list_dependencies_blocking(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")

        github_base() <>
          "/repos/#{owner}/#{repo}/issues/#{issue_number}/dependencies/blocking" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Issue, options)
  end

  @doc """
  List issue events

  @see https://docs.github.com/rest/issues/events#list-issue-events
  """
  def list_events(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/events" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection, options)
  end

  @doc """
  List issue events for a repository

  @see https://docs.github.com/rest/issues/events#list-issue-events-for-a-repository
  """
  def list_events_for_repo(options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues/events" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.IssueEvent, options)
  end

  @doc """
  List timeline events for an issue

  @see https://docs.github.com/rest/issues/timeline#list-timeline-events-for-an-issue
  """
  def list_events_for_timeline(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/timeline" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection, options)
  end

  @doc """
  List user account issues assigned to the authenticated user

  @see https://docs.github.com/rest/issues/issues#list-user-account-issues-assigned-to-the-authenticated-user
  """
  def list_for_authenticated_user(options \\ nil) do
    url =
      (
        query =
          [
            get_field(:filter, options, nil),
            get_field(:state, options, nil),
            get_field(:labels, options, nil),
            get_field(:sort, options, nil),
            get_field(:direction, options, nil),
            get_field(:since, options, nil),
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/user/issues" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Issue, options)
  end

  @doc """
  List organization issues assigned to the authenticated user

  @see https://docs.github.com/rest/issues/issues#list-organization-issues-assigned-to-the-authenticated-user
  """
  def list_for_org(org, options \\ nil) do
    url =
      (
        query =
          [
            get_field(:filter, options, nil),
            get_field(:state, options, nil),
            get_field(:labels, options, nil),
            get_field(:type, options, nil),
            get_field(:sort, options, nil),
            get_field(:direction, options, nil),
            get_field(:since, options, nil),
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/orgs/#{org}/issues" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Issue, options)
  end

  @doc """
  List repository issues

  @see https://docs.github.com/rest/issues/issues#list-repository-issues
  """
  def list_for_repo(options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:milestone, options, nil),
            get_field(:state, options, nil),
            get_field(:assignee, options, nil),
            get_field(:type, options, nil),
            get_field(:creator, options, nil),
            get_field(:mentioned, options, nil),
            get_field(:issue_field_values, options, nil),
            get_field(:labels, options, nil),
            get_field(:sort, options, nil),
            get_field(:direction, options, nil),
            get_field(:since, options, nil),
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Issue, options)
  end

  @doc """
  List issue field values for an issue

  @see https://docs.github.com/rest/issues/issue-field-values#list-issue-field-values-for-an-issue
  """
  def list_issue_field_values_for_issue(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/issue-field-values" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.IssueFieldValue, options)
  end

  @doc """
  List labels for issues in a milestone

  @see https://docs.github.com/rest/issues/labels#list-labels-for-issues-in-a-milestone
  """
  def list_labels_for_milestone(milestone_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/milestones/#{milestone_number}/labels" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Label, options)
  end

  @doc """
  List labels for a repository

  @see https://docs.github.com/rest/issues/labels#list-labels-for-a-repository
  """
  def list_labels_for_repo(options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/labels" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Label, options)
  end

  @doc """
  List labels for an issue

  @see https://docs.github.com/rest/issues/labels#list-labels-for-an-issue
  """
  def list_labels_on_issue(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/labels" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Label, options)
  end

  @doc """
  List milestones

  @see https://docs.github.com/rest/issues/milestones#list-milestones
  """
  def list_milestones(options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:state, options, nil),
            get_field(:sort, options, nil),
            get_field(:direction, options, nil),
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/milestones" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Milestone, options)
  end

  @doc """
  List sub-issues

  @see https://docs.github.com/rest/issues/sub-issues#list-sub-issues
  """
  def list_sub_issues(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      (
        query =
          [
            get_field(:per_page, options, nil),
            get_field(:page, options, nil)
          ]
          |> Enum.filter(& &1)

        qs = if query == [], do: "", else: "?" <> Enum.join(query, "&")
        github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/sub_issues" <> qs
      )

    body = %{}
    api_call(:get, url, body, Noizu.Github.Collection.Issue, options)
  end

  @doc """
  Lock an issue

  @see https://docs.github.com/rest/issues/issues#lock-an-issue
  """
  def lock(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/lock"
    body = body
    api_call(:put, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Pin an issue comment

  @see https://docs.github.com/rest/issues/comments#pin-an-issue-comment
  """
  def pin_comment(comment_id, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/comments/#{comment_id}/pin"
    body = body
    api_call(:put, url, body, Noizu.Github.IssueComment, options)
  end

  @doc """
  Remove all labels from an issue

  @see https://docs.github.com/rest/issues/labels#remove-all-labels-from-an-issue
  """
  def remove_all_labels(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/labels"
    body = %{}
    api_call(:delete, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Remove assignees from an issue

  @see https://docs.github.com/rest/issues/assignees#remove-assignees-from-an-issue
  """
  def remove_assignees(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/assignees"
    body = body
    api_call(:delete, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Remove dependency an issue is blocked by

  @see https://docs.github.com/rest/issues/issue-dependencies#remove-dependency-an-issue-is-blocked-by
  """
  def remove_dependency_blocked_by(issue_number, issue_id, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)

    url =
      github_base() <>
        "/repos/#{owner}/#{repo}/issues/#{issue_number}/dependencies/blocked_by/#{issue_id}"

    body = %{}
    api_call(:delete, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Remove a label from an issue

  @see https://docs.github.com/rest/issues/labels#remove-a-label-from-an-issue
  """
  def remove_label(issue_number, name, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/labels/#{name}"
    body = %{}
    api_call(:delete, url, body, Noizu.Github.Collection.Label, options)
  end

  @doc """
  Remove sub-issue

  @see https://docs.github.com/rest/issues/sub-issues#remove-sub-issue
  """
  def remove_sub_issue(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/sub_issue"
    body = body
    api_call(:delete, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Reprioritize sub-issue

  @see https://docs.github.com/rest/issues/sub-issues#reprioritize-sub-issue
  """
  def reprioritize_sub_issue(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/sub_issues/priority"
    body = body
    api_call(:patch, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Set issue field values for an issue

  @see https://docs.github.com/rest/issues/issue-field-values#set-issue-field-values-for-an-issue
  """
  def set_issue_field_values(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/issue-field-values"
    body = body
    api_call(:put, url, body, Noizu.Github.Collection.IssueFieldValue, options)
  end

  @doc """
  Set labels for an issue

  @see https://docs.github.com/rest/issues/labels#set-labels-for-an-issue
  """
  def set_labels(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/labels"
    body = body
    api_call(:put, url, body, Noizu.Github.Collection.Label, options)
  end

  @doc """
  Unlock an issue

  @see https://docs.github.com/rest/issues/issues#unlock-an-issue
  """
  def unlock(issue_number, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}/lock"
    body = %{}
    api_call(:delete, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Unpin an issue comment

  @see https://docs.github.com/rest/issues/comments#unpin-an-issue-comment
  """
  def unpin_comment(comment_id, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/comments/#{comment_id}/pin"
    body = %{}
    api_call(:delete, url, body, Noizu.Github.Raw, options)
  end

  @doc """
  Update an issue

  @see https://docs.github.com/rest/issues/issues#update-an-issue
  """
  def update(issue_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/#{issue_number}"
    body = body
    api_call(:patch, url, body, Noizu.Github.Issue, options)
  end

  @doc """
  Update an issue comment

  @see https://docs.github.com/rest/issues/comments#update-an-issue-comment
  """
  def update_comment(comment_id, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/issues/comments/#{comment_id}"
    body = body
    api_call(:patch, url, body, Noizu.Github.IssueComment, options)
  end

  @doc """
  Update a label

  @see https://docs.github.com/rest/issues/labels#update-a-label
  """
  def update_label(name, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/labels/#{name}"
    body = body
    api_call(:patch, url, body, Noizu.Github.Label, options)
  end

  @doc """
  Update a milestone

  @see https://docs.github.com/rest/issues/milestones#update-a-milestone
  """
  def update_milestone(milestone_number, body, options \\ nil) do
    owner = repo_owner(options)
    repo = repo_name(options)
    url = github_base() <> "/repos/#{owner}/#{repo}/milestones/#{milestone_number}"
    body = body
    api_call(:patch, url, body, Noizu.Github.Milestone, options)
  end
end