1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.MastodonAPI.StatusController do
6 use Pleroma.Web, :controller
8 import Pleroma.Web.ControllerHelper, only: [try_render: 3, add_link_headers: 2]
12 alias Pleroma.Activity
13 alias Pleroma.Bookmark
15 alias Pleroma.Plugs.OAuthScopesPlug
16 alias Pleroma.Plugs.RateLimiter
18 alias Pleroma.ScheduledActivity
20 alias Pleroma.Web.ActivityPub.ActivityPub
21 alias Pleroma.Web.ActivityPub.Visibility
22 alias Pleroma.Web.CommonAPI
23 alias Pleroma.Web.MastodonAPI.AccountView
24 alias Pleroma.Web.MastodonAPI.ScheduledActivityView
26 @unauthenticated_access %{fallback: :proceed_unauthenticated, scopes: []}
30 %{@unauthenticated_access | scopes: ["read:statuses"]}
41 %{scopes: ["write:statuses"]}
50 plug(OAuthScopesPlug, %{scopes: ["read:favourites"]} when action == :favourites)
54 %{scopes: ["write:favourites"]} when action in [:favourite, :unfavourite]
59 %{scopes: ["write:mutes"]} when action in [:mute_conversation, :unmute_conversation]
64 %{@unauthenticated_access | scopes: ["read:accounts"]}
65 when action in [:favourited_by, :reblogged_by]
68 plug(OAuthScopesPlug, %{scopes: ["write:accounts"]} when action in [:pin, :unpin])
70 # Note: scope not present in Mastodon: read:bookmarks
71 plug(OAuthScopesPlug, %{scopes: ["read:bookmarks"]} when action == :bookmarks)
73 # Note: scope not present in Mastodon: write:bookmarks
76 %{scopes: ["write:bookmarks"]} when action in [:bookmark, :unbookmark]
79 plug(Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug)
81 @rate_limited_status_actions ~w(reblog unreblog favourite unfavourite create delete)a
85 {:status_id_action, bucket_name: "status_id_action:reblog_unreblog", params: ["id"]}
86 when action in ~w(reblog unreblog)a
91 {:status_id_action, bucket_name: "status_id_action:fav_unfav", params: ["id"]}
92 when action in ~w(favourite unfavourite)a
95 plug(RateLimiter, :statuses_actions when action in @rate_limited_status_actions)
97 action_fallback(Pleroma.Web.MastodonAPI.FallbackController)
100 GET `/api/v1/statuses?ids[]=1&ids[]=2`
102 `ids` query param is required
104 def index(%{assigns: %{user: user}} = conn, %{"ids" => ids}) do
110 |> Activity.all_by_ids_with_object()
111 |> Enum.filter(&Visibility.visible_for_user?(&1, user))
113 render(conn, "index.json", activities: activities, for: user, as: :activity)
117 POST /api/v1/statuses
119 Creates a scheduled status when `scheduled_at` param is present and it's far enough
122 %{assigns: %{user: user}} = conn,
123 %{"status" => _, "scheduled_at" => scheduled_at} = params
125 params = Map.put(params, "in_reply_to_status_id", params["in_reply_to_id"])
127 if ScheduledActivity.far_enough?(scheduled_at) do
128 with {:ok, scheduled_activity} <-
129 ScheduledActivity.create(user, %{"params" => params, "scheduled_at" => scheduled_at}) do
131 |> put_view(ScheduledActivityView)
132 |> render("show.json", scheduled_activity: scheduled_activity)
135 create(conn, Map.drop(params, ["scheduled_at"]))
140 POST /api/v1/statuses
142 Creates a regular status
144 def create(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
145 params = Map.put(params, "in_reply_to_status_id", params["in_reply_to_id"])
147 with {:ok, activity} <- CommonAPI.post(user, params) do
148 try_render(conn, "show.json",
152 with_direct_conversation_id: true
157 |> put_status(:unprocessable_entity)
158 |> json(%{error: message})
162 def create(%{assigns: %{user: _user}} = conn, %{"media_ids" => _} = params) do
163 create(conn, Map.put(params, "status", ""))
166 @doc "GET /api/v1/statuses/:id"
167 def show(%{assigns: %{user: user}} = conn, %{"id" => id}) do
168 with %Activity{} = activity <- Activity.get_by_id_with_object(id),
169 true <- Visibility.visible_for_user?(activity, user) do
170 try_render(conn, "show.json", activity: activity, for: user)
174 @doc "DELETE /api/v1/statuses/:id"
175 def delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
176 with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
179 _e -> render_error(conn, :forbidden, "Can't delete this post")
183 @doc "POST /api/v1/statuses/:id/reblog"
184 def reblog(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id} = params) do
185 with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user, params),
186 %Activity{} = announce <- Activity.normalize(announce.data) do
187 try_render(conn, "show.json", %{activity: announce, for: user, as: :activity})
191 @doc "POST /api/v1/statuses/:id/unreblog"
192 def unreblog(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
193 with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
194 %Activity{} = activity <- Activity.get_create_by_object_ap_id_with_object(id) do
195 try_render(conn, "show.json", %{activity: activity, for: user, as: :activity})
199 @doc "POST /api/v1/statuses/:id/favourite"
200 def favourite(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
201 with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
202 %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
203 try_render(conn, "show.json", activity: activity, for: user, as: :activity)
207 @doc "POST /api/v1/statuses/:id/unfavourite"
208 def unfavourite(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
209 with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
210 %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
211 try_render(conn, "show.json", activity: activity, for: user, as: :activity)
215 @doc "POST /api/v1/statuses/:id/pin"
216 def pin(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
217 with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
218 try_render(conn, "show.json", activity: activity, for: user, as: :activity)
222 @doc "POST /api/v1/statuses/:id/unpin"
223 def unpin(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
224 with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
225 try_render(conn, "show.json", activity: activity, for: user, as: :activity)
229 @doc "POST /api/v1/statuses/:id/bookmark"
230 def bookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do
231 with %Activity{} = activity <- Activity.get_by_id_with_object(id),
232 %User{} = user <- User.get_cached_by_nickname(user.nickname),
233 true <- Visibility.visible_for_user?(activity, user),
234 {:ok, _bookmark} <- Bookmark.create(user.id, activity.id) do
235 try_render(conn, "show.json", activity: activity, for: user, as: :activity)
239 @doc "POST /api/v1/statuses/:id/unbookmark"
240 def unbookmark(%{assigns: %{user: user}} = conn, %{"id" => id}) do
241 with %Activity{} = activity <- Activity.get_by_id_with_object(id),
242 %User{} = user <- User.get_cached_by_nickname(user.nickname),
243 true <- Visibility.visible_for_user?(activity, user),
244 {:ok, _bookmark} <- Bookmark.destroy(user.id, activity.id) do
245 try_render(conn, "show.json", activity: activity, for: user, as: :activity)
249 @doc "POST /api/v1/statuses/:id/mute"
250 def mute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
251 with %Activity{} = activity <- Activity.get_by_id(id),
252 {:ok, activity} <- CommonAPI.add_mute(user, activity) do
253 try_render(conn, "show.json", activity: activity, for: user, as: :activity)
257 @doc "POST /api/v1/statuses/:id/unmute"
258 def unmute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
259 with %Activity{} = activity <- Activity.get_by_id(id),
260 {:ok, activity} <- CommonAPI.remove_mute(user, activity) do
261 try_render(conn, "show.json", activity: activity, for: user, as: :activity)
265 @doc "GET /api/v1/statuses/:id/card"
266 @deprecated "https://github.com/tootsuite/mastodon/pull/11213"
267 def card(%{assigns: %{user: user}} = conn, %{"id" => status_id}) do
268 with %Activity{} = activity <- Activity.get_by_id(status_id),
269 true <- Visibility.visible_for_user?(activity, user) do
270 data = Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
271 render(conn, "card.json", data)
273 _ -> render_error(conn, :not_found, "Record not found")
277 @doc "GET /api/v1/statuses/:id/favourited_by"
278 def favourited_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
279 with %Activity{} = activity <- Activity.get_by_id_with_object(id),
280 {:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
281 %Object{data: %{"likes" => likes}} <- Object.normalize(activity) do
284 |> Ecto.Query.where([u], u.ap_id in ^likes)
286 |> Enum.filter(&(not User.blocks?(user, &1)))
289 |> put_view(AccountView)
290 |> render("index.json", for: user, users: users, as: :user)
292 {:visible, false} -> {:error, :not_found}
297 @doc "GET /api/v1/statuses/:id/reblogged_by"
298 def reblogged_by(%{assigns: %{user: user}} = conn, %{"id" => id}) do
299 with %Activity{} = activity <- Activity.get_by_id_with_object(id),
300 {:visible, true} <- {:visible, Visibility.visible_for_user?(activity, user)},
301 %Object{data: %{"announcements" => announces, "id" => ap_id}} <-
302 Object.normalize(activity) do
305 |> Activity.Queries.by_type()
306 |> Ecto.Query.where([a], a.actor in ^announces)
307 # this is to use the index
308 |> Activity.Queries.by_object_id(ap_id)
310 |> Enum.filter(&Visibility.visible_for_user?(&1, user))
311 |> Enum.map(& &1.actor)
316 |> Ecto.Query.where([u], u.ap_id in ^announces)
318 |> Enum.filter(&(not User.blocks?(user, &1)))
321 |> put_view(AccountView)
322 |> render("index.json", for: user, users: users, as: :user)
324 {:visible, false} -> {:error, :not_found}
329 @doc "GET /api/v1/statuses/:id/context"
330 def context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
331 with %Activity{} = activity <- Activity.get_by_id(id) do
333 ActivityPub.fetch_activities_for_context(activity.data["context"], %{
334 "blocking_user" => user,
336 "exclude_id" => activity.id
339 render(conn, "context.json", activity: activity, activities: activities, user: user)
343 @doc "GET /api/v1/favourites"
344 def favourites(%{assigns: %{user: user}} = conn, params) do
347 |> Map.put("type", "Create")
348 |> Map.put("favorited_by", user.ap_id)
349 |> Map.put("blocking_user", user)
352 ActivityPub.fetch_activities([], params)
356 |> add_link_headers(activities)
357 |> render("index.json", activities: activities, for: user, as: :activity)
360 @doc "GET /api/v1/bookmarks"
361 def bookmarks(%{assigns: %{user: user}} = conn, params) do
362 user = User.get_cached_by_id(user.id)
366 |> Bookmark.for_user_query()
367 |> Pleroma.Pagination.fetch_paginated(params)
371 |> Enum.map(fn b -> Map.put(b.activity, :bookmark, Map.delete(b, :activity)) end)
374 |> add_link_headers(bookmarks)
375 |> render("index.json", %{activities: activities, for: user, as: :activity})