494 lines
12 KiB
Elixir
494 lines
12 KiB
Elixir
defmodule Hunter.Api.HTTPClient do
|
|
@moduledoc """
|
|
HTTP Client for Hunter
|
|
"""
|
|
|
|
alias Hunter.{Api.Request, Config}
|
|
|
|
@behaviour Hunter.Api
|
|
|
|
def verify_credentials(conn) do
|
|
"/api/v1/accounts/verify_credentials"
|
|
|> process_url(conn)
|
|
|> request!(:account, :get, [], conn)
|
|
end
|
|
|
|
def update_credentials(conn, data) do
|
|
"/api/v1/accounts/update_credentials"
|
|
|> process_url(conn)
|
|
|> request!(:account, :patch, data, conn)
|
|
end
|
|
|
|
def account(conn, id) do
|
|
"/api/v1/accounts/#{id}"
|
|
|> process_url(conn)
|
|
|> request!(:account, :get, [], conn)
|
|
end
|
|
|
|
def followers(conn, id, options) do
|
|
"/api/v1/accounts/#{id}/followers"
|
|
|> process_url(conn)
|
|
|> request!(:accounts, :get, options, conn)
|
|
end
|
|
|
|
def following(conn, id, options) do
|
|
"/api/v1/accounts/#{id}/following"
|
|
|> process_url(conn)
|
|
|> request!(:accounts, :get, options, conn)
|
|
end
|
|
|
|
def follow_by_uri(conn, uri) do
|
|
"/api/v1/follows"
|
|
|> process_url(conn)
|
|
|> request!(:account, :post, %{uri: uri}, conn)
|
|
end
|
|
|
|
def search_account(conn, options) do
|
|
"/api/v1/accounts/search"
|
|
|> process_url(conn)
|
|
|> request!(:accounts, :get, options, conn)
|
|
end
|
|
|
|
def blocks(conn, options) do
|
|
"/api/v1/blocks"
|
|
|> process_url(conn)
|
|
|> request!(:accounts, :get, options, conn)
|
|
end
|
|
|
|
def follow_requests(conn, options) do
|
|
"/api/v1/follow_requests"
|
|
|> process_url(conn)
|
|
|> request!(:accounts, :get, options, conn)
|
|
end
|
|
|
|
def mutes(conn, options) do
|
|
"/api/v1/mutes"
|
|
|> process_url(conn)
|
|
|> request!(:accounts, :get, options, conn)
|
|
end
|
|
|
|
def follow_request_action(conn, id, action) when action in [:authorize, :reject] do
|
|
"/api/v1/follow_requests/#{action}"
|
|
|> process_url(conn)
|
|
|> request!(nil, :post, %{id: id}, conn)
|
|
end
|
|
|
|
def create_app(name, redirect_uri, scopes, website, base_url) do
|
|
payload = %{
|
|
client_name: name,
|
|
redirect_uris: redirect_uri,
|
|
scopes: Enum.join(scopes, " "),
|
|
website: website
|
|
}
|
|
|
|
"/api/v1/apps"
|
|
|> process_url(base_url)
|
|
|> request!(:application, :post, payload)
|
|
end
|
|
|
|
def upload_media(conn, file, options) do
|
|
options =
|
|
[{:file, file, {"form-data", [name: "file", filename: Path.basename(file)]}, []}] ++
|
|
Enum.map(options, fn {key, value} -> {to_string(key), value} end)
|
|
|
|
headers =
|
|
conn
|
|
|> get_headers()
|
|
|> Keyword.put(:"Content-Type", "multipart/form-data")
|
|
|
|
"/api/v1/media"
|
|
|> process_url(conn)
|
|
|> request!(:attachment, :post, {:multipart, options}, headers)
|
|
end
|
|
|
|
def relationships(conn, ids) do
|
|
"/api/v1/accounts/relationships"
|
|
|> process_url(conn)
|
|
|> request!(:relationships, :get, %{id: ids}, conn)
|
|
end
|
|
|
|
def follow(conn, id) do
|
|
"/api/v1/accounts/#{id}/follow"
|
|
|> process_url(conn)
|
|
|> request!(:relationship, :post, [], conn)
|
|
end
|
|
|
|
def unfollow(conn, id) do
|
|
"/api/v1/accounts/#{id}/unfollow"
|
|
|> process_url(conn)
|
|
|> request!(:relationship, :post, [], conn)
|
|
end
|
|
|
|
def block(conn, id) do
|
|
"/api/v1/accounts/#{id}/block"
|
|
|> process_url(conn)
|
|
|> request!(:relationship, :post, [], conn)
|
|
end
|
|
|
|
def unblock(conn, id) do
|
|
"/api/v1/accounts/#{id}/unblock"
|
|
|> process_url(conn)
|
|
|> request!(:relationship, :post, [], conn)
|
|
end
|
|
|
|
def mute(conn, id) do
|
|
"/api/v1/accounts/#{id}/mute"
|
|
|> process_url(conn)
|
|
|> request!(:relationship, :post, [], conn)
|
|
end
|
|
|
|
def unmute(conn, id) do
|
|
"/api/v1/accounts/#{id}/unmute"
|
|
|> process_url(conn)
|
|
|> request!(:relationship, :post, [], conn)
|
|
end
|
|
|
|
def search(conn, query, options) do
|
|
options = options |> Keyword.merge(q: query) |> Map.new()
|
|
|
|
"/api/v2/search"
|
|
|> process_url(conn)
|
|
|> request!(:result, :get, options, conn)
|
|
end
|
|
|
|
def create_status(conn, status, options) do
|
|
body = options |> Keyword.put(:status, status) |> Map.new()
|
|
|
|
"/api/v1/statuses"
|
|
|> process_url(conn)
|
|
|> request!(:status, :post, body, conn)
|
|
end
|
|
|
|
def status(conn, id) do
|
|
"/api/v1/statuses/#{id}"
|
|
|> process_url(conn)
|
|
|> request!(:status, :get, [], conn)
|
|
end
|
|
|
|
def destroy_status(conn, id) do
|
|
"/api/v1/statuses/#{id}"
|
|
|> process_url(conn)
|
|
|> request!(nil, :delete, [], conn)
|
|
end
|
|
|
|
def reblog(conn, id) do
|
|
"/api/v1/statuses/#{id}/reblog"
|
|
|> process_url(conn)
|
|
|> request!(:status, :post, [], conn)
|
|
end
|
|
|
|
def unreblog(conn, id) do
|
|
"/api/v1/statuses/#{id}/unreblog"
|
|
|> process_url(conn)
|
|
|> request!(:status, :post, [], conn)
|
|
end
|
|
|
|
def reblogged_by(conn, id, options) do
|
|
"/api/v1/statuses/#{id}/reblogged_by"
|
|
|> process_url(conn)
|
|
|> request!(:accounts, :get, options, conn)
|
|
end
|
|
|
|
def favourite(conn, id) do
|
|
"/api/v1/statuses/#{id}/favourite"
|
|
|> process_url(conn)
|
|
|> request!(:status, :post, [], conn)
|
|
end
|
|
|
|
def unfavourite(conn, id) do
|
|
"/api/v1/statuses/#{id}/unfavourite"
|
|
|> process_url(conn)
|
|
|> request!(:status, :post, [], conn)
|
|
end
|
|
|
|
def favourites(conn, options) do
|
|
"/api/v1/favourites"
|
|
|> process_url(conn)
|
|
|> request!(:statuses, :get, options, conn)
|
|
end
|
|
|
|
def favourited_by(conn, id, options) do
|
|
"/api/v1/statuses/#{id}/favourited_by"
|
|
|> process_url(conn)
|
|
|> request!(:accounts, :get, options, conn)
|
|
end
|
|
|
|
def statuses(conn, account_id, options) do
|
|
"/api/v1/accounts/#{account_id}/statuses"
|
|
|> process_url(conn)
|
|
|> request!(:statuses, :get, options, conn)
|
|
end
|
|
|
|
def home_timeline(conn, options) do
|
|
retrieve_timeline(conn, "/api/v1/timelines/home", options)
|
|
end
|
|
|
|
def public_timeline(conn, options) do
|
|
retrieve_timeline(conn, "/api/v1/timelines/public", options)
|
|
end
|
|
|
|
def hashtag_timeline(conn, hashtag, options) do
|
|
retrieve_timeline(conn, "/api/v1/timelines/tag/#{hashtag}", options)
|
|
end
|
|
|
|
def list_timeline(conn, list, options) do
|
|
retrieve_timeline(conn, "/api/v1/timelines/list/#{list}", options)
|
|
end
|
|
|
|
defp retrieve_timeline(conn, endpoint, options) do
|
|
endpoint
|
|
|> process_url(conn)
|
|
|> request!(:statuses, :get, options, conn)
|
|
end
|
|
|
|
|
|
def enumerate_lists(conn) do
|
|
"/api/v1/lists"
|
|
|> process_url(conn)
|
|
|> request!(:list, :get, [], conn)
|
|
end
|
|
|
|
def enumerate_lists_by_member(conn, id) do
|
|
"/api/v1/accounts/#{id}/lists"
|
|
|> process_url(conn)
|
|
|> request!(:list, :get, [], conn)
|
|
end
|
|
|
|
def get_list(conn, id) do
|
|
"/api/v1/lists/#{id}"
|
|
|> process_url(conn)
|
|
|> request!(:list, :get, [], conn)
|
|
end
|
|
|
|
def get_list_accounts(conn, id) do
|
|
"/api/v1/lists/#{id}/accounts"
|
|
|> process_url(conn)
|
|
|> request!(:list, :get, [], conn)
|
|
end
|
|
|
|
def instance_info(conn) do
|
|
"/api/v1/instance"
|
|
|> process_url(conn)
|
|
|> request!(:instance, :get, [], conn)
|
|
end
|
|
|
|
def notifications(conn, options) do
|
|
"/api/v1/notifications"
|
|
|> process_url(conn)
|
|
|> request!(:notifications, :get, options, conn)
|
|
end
|
|
|
|
def notification(conn, id) do
|
|
"/api/v1/notifications/#{id}"
|
|
|> process_url(conn)
|
|
|> request!(:notification, :get, [], conn)
|
|
end
|
|
|
|
def clear_notifications(conn) do
|
|
"/api/v1/notifications/clear"
|
|
|> process_url(conn)
|
|
|> request!(nil, :post, [], conn)
|
|
end
|
|
|
|
def clear_notification(conn, id) do
|
|
"/api/v1/notifications/dismiss/#{id}"
|
|
|> process_url(conn)
|
|
|> request!(nil, :post, [], conn)
|
|
end
|
|
|
|
def reports(conn) do
|
|
"/api/v1/reports"
|
|
|> process_url(conn)
|
|
|> request!(:reports, :get, [], conn)
|
|
end
|
|
|
|
def report(conn, account_id, status_ids, comment) do
|
|
payload = %{
|
|
account_id: account_id,
|
|
status_ids: status_ids,
|
|
comment: comment
|
|
}
|
|
|
|
"/api/v1/reports"
|
|
|> process_url(conn)
|
|
|> request!(:report, :post, payload, conn)
|
|
end
|
|
|
|
def status_context(conn, id) do
|
|
"/api/v1/statuses/#{id}/context"
|
|
|> process_url(conn)
|
|
|> request!(:context, :get, [], conn)
|
|
end
|
|
|
|
def card_by_status(conn, id) do
|
|
"/api/v1/statuses/#{id}/card"
|
|
|> process_url(conn)
|
|
|> request!(:card, :get, [], conn)
|
|
end
|
|
|
|
def log_in(
|
|
%Hunter.Application{client_id: client_id, client_secret: client_secret},
|
|
username,
|
|
password,
|
|
base_url
|
|
) do
|
|
payload = %{
|
|
client_id: client_id,
|
|
client_secret: client_secret,
|
|
grant_type: "password",
|
|
username: username,
|
|
password: password
|
|
}
|
|
|
|
response =
|
|
"/oauth/token"
|
|
|> process_url(base_url)
|
|
|> request!(nil, :post, payload)
|
|
|
|
%Hunter.Client{base_url: base_url, bearer_token: response["access_token"]}
|
|
end
|
|
|
|
def blocked_domains(conn, options) do
|
|
"/api/v1/domain_blocks"
|
|
|> process_url(conn)
|
|
|> request!(nil, :get, options, conn)
|
|
end
|
|
|
|
def block_domain(conn, domain) do
|
|
"/api/v1/domain_blocks"
|
|
|> process_url(conn)
|
|
|> request!(nil, :post, %{domain: domain})
|
|
end
|
|
|
|
def unblock_domain(conn, domain) do
|
|
"/api/v1/domain_blocks"
|
|
|> process_url(conn)
|
|
|> request!(nil, :delete, %{domain: domain})
|
|
end
|
|
|
|
## Helpers
|
|
defp request!(url, to, method, payload, conn \\ nil) do
|
|
headers = get_headers(conn)
|
|
|
|
case Request.request(method, url, payload, headers, Config.http_options()) do
|
|
{:ok, body} ->
|
|
transform(body, to)
|
|
|
|
{:error, reason} ->
|
|
raise Hunter.Error, reason: reason
|
|
end
|
|
end
|
|
|
|
defp get_headers(nil), do: []
|
|
|
|
defp get_headers(%Hunter.Client{bearer_token: token}) do
|
|
[{:Authorization, "Bearer #{token}"}]
|
|
end
|
|
|
|
defp get_headers(headers) when is_list(headers), do: headers
|
|
|
|
defp process_url(endpoint, %Hunter.Client{base_url: base_url}) do
|
|
process_url(endpoint, base_url)
|
|
end
|
|
|
|
defp process_url(endpoint, base_url) when is_binary(base_url) do
|
|
base_url <> endpoint
|
|
end
|
|
|
|
defp transform(body, :account) do
|
|
Poison.decode!(body, as: %Hunter.Account{})
|
|
end
|
|
|
|
defp transform(body, :accounts) do
|
|
Poison.decode!(body, as: [%Hunter.Account{}])
|
|
end
|
|
|
|
defp transform(body, :application) do
|
|
Poison.decode!(body, as: %Hunter.Application{})
|
|
end
|
|
|
|
defp transform(body, :attachment) do
|
|
Poison.decode!(body, as: %Hunter.Attachment{})
|
|
end
|
|
|
|
defp transform(body, :card) do
|
|
Poison.decode!(body, as: %Hunter.Card{})
|
|
end
|
|
|
|
defp transform(body, :list) do
|
|
Poison.decode!(body)
|
|
end
|
|
|
|
defp transform(body, :context) do
|
|
Poison.decode!(
|
|
body,
|
|
as: %Hunter.Context{ancestors: [%Hunter.Status{}], descendants: [%Hunter.Status{}]}
|
|
)
|
|
end
|
|
|
|
defp transform(body, :instance) do
|
|
Poison.decode!(body, as: %Hunter.Instance{})
|
|
end
|
|
|
|
defp transform(body, :notification) do
|
|
Poison.decode!(body, as: notification_nested_struct())
|
|
end
|
|
|
|
defp transform(body, :notifications) do
|
|
Poison.decode!(body, as: [notification_nested_struct()])
|
|
end
|
|
|
|
defp transform(body, :status) do
|
|
Poison.decode!(body, as: status_nested_struct())
|
|
end
|
|
|
|
defp transform(body, :statuses) do
|
|
Poison.decode!(body, as: [status_nested_struct()])
|
|
end
|
|
|
|
defp transform(body, :relationship) do
|
|
Poison.decode!(body, as: %Hunter.Relationship{})
|
|
end
|
|
|
|
defp transform(body, :relationships) do
|
|
Poison.decode!(body, as: [%Hunter.Relationship{}])
|
|
end
|
|
|
|
defp transform(body, :report) do
|
|
Poison.decode!(body, as: %Hunter.Report{})
|
|
end
|
|
|
|
defp transform(body, :reports) do
|
|
Poison.decode!(body, as: [%Hunter.Report{}])
|
|
end
|
|
|
|
defp transform(body, :result) do
|
|
Poison.decode!(
|
|
body,
|
|
as: %Hunter.Result{accounts: [%Hunter.Account{}], statuses: [%Hunter.Status{}]}
|
|
)
|
|
end
|
|
|
|
defp transform(body, _) do
|
|
Poison.decode!(body)
|
|
end
|
|
|
|
defp status_nested_struct do
|
|
%Hunter.Status{
|
|
account: %Hunter.Account{},
|
|
reblog: %Hunter.Status{},
|
|
media_attachments: [%Hunter.Attachment{}],
|
|
mentions: [%Hunter.Mention{}],
|
|
tags: [%Hunter.Tag{}],
|
|
application: %Hunter.Application{}
|
|
}
|
|
end
|
|
|
|
defp notification_nested_struct do
|
|
%Hunter.Notification{
|
|
account: %Hunter.Account{},
|
|
status: %Hunter.Status{}
|
|
}
|
|
end
|
|
end
|