MastoAPI: Add notification endpoints get, clear and dismiss.
Closes #42
See merge request pleroma/pleroma!13
ttl_interval: 1000,
limit: 2500
]]),
- worker(Pleroma.Web.Federator, [])
+ worker(Pleroma.Web.Federator, []),
+ worker(Pleroma.Web.Streamer, [])
]
# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
result_file = Path.join(upload_folder, file.filename)
File.cp!(file.path, result_file)
+ # fix content type on some image uploads
+ content_type = if file.content_type == "application/octet-stream" do
+ get_content_type(file.path)
+ else
+ file.content_type
+ end
+
%{
"type" => "Image",
"url" => [%{
"type" => "Link",
- "mediaType" => file.content_type,
+ "mediaType" => content_type,
"href" => url_for(Path.join(uuid, :cow_uri.urlencode(file.filename)))
}],
"name" => file.filename,
defp url_for(file) do
"#{Web.base_url()}/media/#{file}"
end
+
+ def get_content_type(file) do
+ match = File.open(file, [:read], fn(f) ->
+ case IO.binread(f, 8) do
+ <<0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a>> ->
+ "image/png"
+ <<0x47, 0x49, 0x46, 0x38, _, 0x61, _, _>> ->
+ "image/gif"
+ <<0xff, 0xd8, 0xff, _, _, _, _, _>> ->
+ "image/jpeg"
+ <<0x1a, 0x45, 0xdf, 0xa3, _, _, _, _>> ->
+ "video/webm"
+ <<0x00, 0x00, 0x00, _, 0x66, 0x74, 0x79, 0x70>> ->
+ "video/mp4"
+ <<0x49, 0x44, 0x33, _, _, _, _, _>> ->
+ "audio/mpeg"
+ <<0x4f, 0x67, 0x67, 0x53, 0x00, 0x02, 0x00, 0x00>> ->
+ "audio/ogg"
+ <<0x52, 0x49, 0x46, 0x46, _, _, _, _>> ->
+ "audio/wav"
+ _ ->
+ "application/octet-stream"
+ end
+ end)
+
+ case match do
+ {:ok, type} -> type
+ _e -> "application/octet-stream"
+ end
+ end
end
with create_data <- make_create_data(%{to: to, actor: actor, published: published, context: context, object: object}, additional),
{:ok, activity} <- insert(create_data, local),
:ok <- maybe_federate(activity) do
+ if activity.data["type"] == "Create" and Enum.member?(activity.data["to"], "https://www.w3.org/ns/activitystreams#Public") do
+ Pleroma.Web.Streamer.stream("public", activity)
+ end
{:ok, activity}
end
end
use Phoenix.Endpoint, otp_app: :pleroma
socket "/socket", Pleroma.Web.UserSocket
+ socket "/api/v1", Pleroma.Web.MastodonAPI.MastodonSocket
# Serve at "/" the static files from "priv/static" directory.
#
alias Pleroma.Web.MastodonAPI.{StatusView, AccountView}
alias Pleroma.Web.ActivityPub.ActivityPub
alias Pleroma.Web.TwitterAPI.TwitterAPI
- alias Pleroma.Web.CommonAPI
+ alias Pleroma.Web.{CommonAPI, OStatus}
import Ecto.Query
import Logger
end
end
+ def update_credentials(%{assigns: %{user: user}} = conn, params) do
+ params = if bio = params["note"] do
+ Map.put(params, "bio", bio)
+ else
+ params
+ end
+
+ params = if name = params["display_name"] do
+ Map.put(params, "name", name)
+ else
+ params
+ end
+
+ user = if avatar = params["avatar"] do
+ with %Plug.Upload{} <- avatar,
+ {:ok, object} <- ActivityPub.upload(avatar),
+ change = Ecto.Changeset.change(user, %{avatar: object.data}),
+ {:ok, user} = Repo.update(change) do
+ user
+ else
+ _e -> user
+ end
+ else
+ user
+ end
+
+ user = if banner = params["header"] do
+ with %Plug.Upload{} <- banner,
+ {:ok, object} <- ActivityPub.upload(banner),
+ new_info <- Map.put(user.info, "banner", object.data),
+ change <- User.info_changeset(user, %{info: new_info}),
+ {:ok, user} <- Repo.update(change) do
+ user
+ else
+ _e -> user
+ end
+ else
+ user
+ end
+
+ with changeset <- User.update_changeset(user, params),
+ {:ok, user} <- Repo.update(changeset) do
+ json conn, AccountView.render("account.json", %{user: user})
+ else
+ _e ->
+ conn
+ |> put_status(403)
+ |> json(%{error: "Invalid request"})
+ end
+ end
+
def verify_credentials(%{assigns: %{user: user}} = conn, params) do
account = AccountView.render("account.json", %{user: user})
json(conn, account)
def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
accounts = User.search(query, params["resolve"] == "true")
+ fetched = if Regex.match?(~r/https?:/, query) do
+ with {:ok, activities} <- OStatus.fetch_activity_from_url(query) do
+ activities
+ else
+ _e -> []
+ end
+ end || []
+
q = from a in Activity,
where: fragment("?->>'type' = 'Create'", a.data),
where: fragment("to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)", a.data, ^query),
limit: 20
- statuses = Repo.all(q)
+ statuses = Repo.all(q) ++ fetched
res = %{
"accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
--- /dev/null
+defmodule Pleroma.Web.MastodonAPI.MastodonSocket do
+ use Phoenix.Socket
+
+ transport :streaming, Phoenix.Transports.WebSocket.Raw,
+ timeout: :infinity # We never receive data.
+
+ def connect(params, socket) do
+ if params["stream"] == "public" do
+ socket = socket
+ |> assign(:topic, params["stream"])
+ Pleroma.Web.Streamer.add_socket(params["stream"], socket)
+ {:ok, socket}
+ else
+ :error
+ end
+ end
+
+ def id(socket), do: nil
+
+ def handle(:text, message, state) do
+ IO.inspect message
+ #| :ok
+ #| state
+ #| {:text, message}
+ #| {:text, message, state}
+ #| {:close, "Goodbye!"}
+ {:text, message}
+ end
+
+ def handle(:closed, reason, %{socket: socket}) do
+ topic = socket.assigns[:topic]
+ Pleroma.Web.Streamer.remove_socket(topic, socket)
+ end
+end
header = image_url(user.info["banner"]) || "https://placehold.it/700x335"
%{
- id: user.id,
+ id: to_string(user.id),
username: hd(String.split(user.nickname, "@")),
acct: user.nickname,
display_name: user.name,
def render("mention.json", %{user: user}) do
%{
- id: user.id,
+ id: to_string(user.id),
acct: user.nickname,
username: hd(String.split(user.nickname, "@")),
url: user.ap_id
def render("relationship.json", %{user: user, target: target}) do
%{
- id: target.id,
+ id: to_string(target.id),
following: User.following?(user, target),
followed_by: User.following?(target, user),
blocking: User.blocks?(user, target),
name: "Web",
website: nil
},
- language: nil
+ language: nil,
+ emojis: []
}
end
auth: auth
}
else
- url = "#{redirect_uri}?code=#{auth.token}"
+ connector = if String.contains?(redirect_uri, "?"), do: "&", else: "?"
+ url = "#{redirect_uri}#{connector}code=#{auth.token}"
url = if params["state"] do
url <> "&state=#{params["state"]}"
else
scope "/api/v1", Pleroma.Web.MastodonAPI do
pipe_through :authenticated_api
+ patch "/accounts/update_credentials", MastodonAPIController, :update_credentials
get "/accounts/verify_credentials", MastodonAPIController, :verify_credentials
get "/accounts/relationships", MastodonAPIController, :relationships
get "/accounts/search", MastodonAPIController, :account_search
--- /dev/null
+defmodule Pleroma.Web.Streamer do
+ use GenServer
+ require Logger
+ import Plug.Conn
+
+ def start_link do
+ spawn(fn ->
+ Process.sleep(1000 * 30) # 30 seconds
+ GenServer.cast(__MODULE__, %{action: :ping})
+ end)
+ GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
+ end
+
+ def add_socket(topic, socket) do
+ GenServer.cast(__MODULE__, %{action: :add, socket: socket, topic: topic})
+ end
+
+ def remove_socket(topic, socket) do
+ GenServer.cast(__MODULE__, %{action: :remove, socket: socket, topic: topic})
+ end
+
+ def stream(topic, item) do
+ GenServer.cast(__MODULE__, %{action: :stream, topic: topic, item: item})
+ end
+
+ def handle_cast(%{action: :ping}, topics) do
+ Map.values(topics)
+ |> List.flatten
+ |> Enum.each(fn (socket) ->
+ Logger.debug("Sending keepalive ping")
+ send socket.transport_pid, {:text, ""}
+ end)
+ spawn(fn ->
+ Process.sleep(1000 * 30) # 30 seconds
+ GenServer.cast(__MODULE__, %{action: :ping})
+ end)
+ {:noreply, topics}
+ end
+
+ def handle_cast(%{action: :stream, topic: topic, item: item}, topics) do
+ Logger.debug("Trying to push to #{topic}")
+ Logger.debug("Pushing item to #{topic}")
+ Enum.each(topics[topic] || [], fn (socket) ->
+ json = %{
+ event: "update",
+ payload: Pleroma.Web.MastodonAPI.StatusView.render("status.json", activity: item) |> Poison.encode!
+ } |> Poison.encode!
+
+ send socket.transport_pid, {:text, json}
+ end)
+ {:noreply, topics}
+ end
+
+ def handle_cast(%{action: :add, topic: topic, socket: socket}, sockets) do
+ sockets_for_topic = sockets[topic] || []
+ sockets_for_topic = Enum.uniq([socket | sockets_for_topic])
+ sockets = Map.put(sockets, topic, sockets_for_topic)
+ Logger.debug("Got new conn for #{topic}")
+ IO.inspect(sockets)
+ {:noreply, sockets}
+ end
+
+ def handle_cast(%{action: :remove, topic: topic, socket: socket}, sockets) do
+ sockets_for_topic = sockets[topic] || []
+ sockets_for_topic = List.delete(sockets_for_topic, socket)
+ sockets = Map.put(sockets, topic, sockets_for_topic)
+ Logger.debug("Removed conn for #{topic}")
+ IO.inspect(sockets)
+ {:noreply, sockets}
+ end
+
+ def handle_cast(m, state) do
+ IO.inspect("Unknown: #{inspect(m)}, #{inspect(state)}")
+ {:noreply, state}
+ end
+end
--- /dev/null
+defmodule Phoenix.Transports.WebSocket.Raw do
+ import Plug.Conn, only: [
+ fetch_query_params: 1,
+ send_resp: 3
+ ]
+ alias Phoenix.Socket.Transport
+
+ def default_config do
+ [
+ timeout: 60_000,
+ transport_log: false,
+ cowboy: Phoenix.Endpoint.CowboyWebSocket
+ ]
+ end
+
+ def init(%Plug.Conn{method: "GET"} = conn, {endpoint, handler, transport}) do
+ {_, opts} = handler.__transport__(transport)
+
+ conn = conn
+ |> fetch_query_params
+ |> Transport.transport_log(opts[:transport_log])
+ |> Transport.force_ssl(handler, endpoint, opts)
+ |> Transport.check_origin(handler, endpoint, opts)
+
+ case conn do
+ %{halted: false} = conn ->
+ case Transport.connect(endpoint, handler, transport, __MODULE__, nil, conn.params) do
+ {:ok, socket} ->
+ {:ok, conn, {__MODULE__, {socket, opts}}}
+ :error ->
+ send_resp(conn, :forbidden, "")
+ {:error, conn}
+ end
+ _ ->
+ {:error, conn}
+ end
+ end
+
+ def init(conn, _) do
+ send_resp(conn, :bad_request, "")
+ {:error, conn}
+ end
+
+ def ws_init({socket, config}) do
+ Process.flag(:trap_exit, true)
+ {:ok, %{socket: socket}, config[:timeout]}
+ end
+
+ def ws_handle(op, data, state) do
+ state.socket.handler
+ |> apply(:handle, [op, data, state])
+ |> case do
+ {op, data} ->
+ {:reply, {op, data}, state}
+ {op, data, state} ->
+ {:reply, {op, data}, state}
+ %{} = state ->
+ {:ok, state}
+ _ ->
+ {:ok, state}
+ end
+ end
+
+ def ws_info({op, data} = tuple, state) do
+ {:reply, tuple, state}
+ end
+
+ def ws_info(_tuple, state), do: {:ok, state}
+
+ def ws_close(state) do
+ ws_handle(:closed, :normal, state)
+ end
+
+ def ws_terminate(reason, state) do
+ ws_handle(:closed, reason, state)
+ end
+end
assert data["name"] == "an [image.jpg"
assert List.first(data["url"])["href"] == "http://localhost:4001/media/#{data["uuid"]}/an%20%5Bimage.jpg"
end
+
+ test "fixes an incorrect content type" do
+ file = %Plug.Upload{content_type: "application/octet-stream", path: Path.absname("test/fixtures/image.jpg"), filename: "an [image.jpg"}
+ data = Upload.store(file)
+ assert hd(data["url"])["mediaType"] == "image/jpeg"
+ end
+
+ test "does not modify a valid content type" do
+ file = %Plug.Upload{content_type: "image/png", path: Path.absname("test/fixtures/image.jpg"), filename: "an [image.jpg"}
+ data = Upload.store(file)
+ assert hd(data["url"])["mediaType"] == "image/png"
+ end
end
end
user = insert(:user, %{info: %{"note_count" => 5, "follower_count" => 3}, nickname: "shp@shitposter.club", inserted_at: ~N[2017-08-15 15:47:06.597036]})
expected = %{
- id: user.id,
+ id: to_string(user.id),
username: "shp",
acct: user.nickname,
display_name: user.name,
user = insert(:user)
expected = %{
- id: user.id,
+ id: to_string(user.id),
acct: user.nickname,
username: user.nickname,
url: user.ap_id
{:ok, user} = User.block(user, other_user)
expected = %{
- id: other_user.id,
+ id: to_string(other_user.id),
following: true,
followed_by: false,
blocking: true,
|> get("/api/v1/accounts/verify_credentials")
assert %{"id" => id} = json_response(conn, 200)
- assert id == user.id
+ assert id == to_string(user.id)
end
test "get a status", %{conn: conn} do
assert [relationship] = json_response(conn, 200)
- assert other_user.id == relationship["id"]
+ assert to_string(other_user.id) == relationship["id"]
end
end
|> get("/api/v1/accounts/#{user.id}")
assert %{"id" => id} = json_response(conn, 200)
- assert id == user.id
+ assert id == to_string(user.id)
conn = build_conn()
|> get("/api/v1/accounts/-1")
|> get("/api/v1/accounts/#{other_user.id}/followers")
assert [%{"id" => id}] = json_response(conn, 200)
- assert id = user.id
+ assert id == to_string(user.id)
end
test "getting following", %{conn: conn} do
|> get("/api/v1/accounts/#{user.id}/following")
assert [%{"id" => id}] = json_response(conn, 200)
- assert id = other_user.id
+ assert id == to_string(other_user.id)
end
test "following / unfollowing a user", %{conn: conn} do
|> post("/api/v1/follows", %{"uri" => other_user.nickname})
assert %{"id" => id} = json_response(conn, 200)
- assert id == other_user.id
+ assert id == to_string(other_user.id)
end
test "blocking / unblocking a user", %{conn: conn} do
|> assign(:user, user)
|> get("/api/v1/blocks")
- other_user_id = other_user.id
+ other_user_id = to_string(other_user.id)
assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
end
|> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")
assert %{"id" => id} = json_response(conn, 200)
- assert id == other_user.id
+ assert id == to_string(other_user.id)
end)
end
|> get("/api/v1/accounts/search", %{"q" => "2hu"})
assert [account] = json_response(conn, 200)
- assert account["id"] == user_three.id
+ assert account["id"] == to_string(user_three.id)
end
test "search", %{conn: conn} do
assert results = json_response(conn, 200)
[account] = results["accounts"]
- assert account["id"] == user_three.id
+ assert account["id"] == to_string(user_three.id)
assert results["hashtags"] == []
assert status["id"] == to_string(activity.id)
end
+ test "search fetches remote statuses", %{conn: conn} do
+ conn = conn
+ |> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})
+ assert results = json_response(conn, 200)
+
+ [status] = results["statuses"]
+ assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
+ end
+
test "search fetches remote accounts", %{conn: conn} do
conn = conn
|> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})
assert [status] = json_response(conn, 200)
assert status["id"] == to_string(activity.id)
end
+
+ describe "updating credentials" do
+ test "updates the user's bio" do
+ user = insert(:user)
+
+ conn = conn
+ |> assign(:user, user)
+ |> patch("/api/v1/accounts/update_credentials", %{"note" => "I drink #cofe"})
+
+ assert user = json_response(conn, 200)
+ assert user["note"] == "I drink #cofe"
+ end
+
+ test "updates the user's name" do
+ user = insert(:user)
+
+ conn = conn
+ |> assign(:user, user)
+ |> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})
+
+ assert user = json_response(conn, 200)
+ assert user["display_name"] == "markorepairs"
+ end
+
+ test "updates the user's avatar" do
+ user = insert(:user)
+
+ new_avatar = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
+
+ conn = conn
+ |> assign(:user, user)
+ |> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})
+
+ assert user = json_response(conn, 200)
+ assert user["avatar"] != "https://placehold.it/48x48"
+ end
+
+ test "updates the user's banner" do
+ user = insert(:user)
+
+ new_header = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}
+
+ conn = conn
+ |> assign(:user, user)
+ |> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})
+
+ assert user = json_response(conn, 200)
+ assert user["header"] != "https://placehold.it/700x335"
+ end
+ end
end
assert represented[:id] == to_string(reblog.id)
assert represented[:reblog][:id] == to_string(activity.id)
+ assert represented[:emojis] == []
end
end
projects / akkoma / commitdiff