git.squeep.com Git - akkoma/blob - lib/pleroma/web/pleroma_api/controllers/pleroma_api_controller.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.PleromaAPI.PleromaAPIController do
   6   use Pleroma.Web, :controller
   7
   8   import Pleroma.Web.ControllerHelper, only: [add_link_headers: 2]
   9
  10   alias Pleroma.Activity
  11   alias Pleroma.Conversation.Participation
  12   alias Pleroma.Notification
  13   alias Pleroma.Object
  14   alias Pleroma.Plugs.OAuthScopesPlug
  15   alias Pleroma.User
  16   alias Pleroma.Web.ActivityPub.ActivityPub
  17   alias Pleroma.Web.CommonAPI
  18   alias Pleroma.Web.MastodonAPI.AccountView
  19   alias Pleroma.Web.MastodonAPI.ConversationView
  20   alias Pleroma.Web.MastodonAPI.NotificationView
  21   alias Pleroma.Web.MastodonAPI.StatusView
  22
  23   plug(
  24     OAuthScopesPlug,
  25     %{scopes: ["read:statuses"]} when action in [:conversation, :conversation_statuses]
  26   )
  27
  28   plug(
  29     OAuthScopesPlug,
  30     %{scopes: ["write:conversations"]} when action == :update_conversation
  31   )
  32
  33   plug(OAuthScopesPlug, %{scopes: ["write:notifications"]} when action == :read_notification)
  34
  35   plug(Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug)
  36
  37   def emoji_reactions_by(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
  38     with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
  39          %Object{data: %{"reactions" => emoji_reactions}} <- Object.normalize(activity) do
  40       reactions =
  41         emoji_reactions
  42         |> Enum.map(fn {emoji, users} ->
  43           users = Enum.map(users, &User.get_cached_by_ap_id/1)
  44           {emoji, AccountView.render("index.json", %{users: users, for: user, as: :user})}
  45         end)
  46         |> Enum.into(%{})
  47
  48       conn
  49       |> json(reactions)
  50     else
  51       _e ->
  52         conn
  53         |> json(%{})
  54     end
  55   end
  56
  57   def react_with_emoji(%{assigns: %{user: user}} = conn, %{"id" => activity_id, "emoji" => emoji}) do
  58     with {:ok, _activity, _object} <- CommonAPI.react_with_emoji(activity_id, user, emoji),
  59          activity <- Activity.get_by_id(activity_id) do
  60       conn
  61       |> put_view(StatusView)
  62       |> render("show.json", %{activity: activity, for: user, as: :activity})
  63     end
  64   end
  65
  66   def unreact_with_emoji(%{assigns: %{user: user}} = conn, %{
  67         "id" => activity_id,
  68         "emoji" => emoji
  69       }) do
  70     with {:ok, _activity, _object} <- CommonAPI.unreact_with_emoji(activity_id, user, emoji),
  71          activity <- Activity.get_by_id(activity_id) do
  72       conn
  73       |> put_view(StatusView)
  74       |> render("show.json", %{activity: activity, for: user, as: :activity})
  75     end
  76   end
  77
  78   def conversation(%{assigns: %{user: user}} = conn, %{"id" => participation_id}) do
  79     with %Participation{} = participation <- Participation.get(participation_id),
  80          true <- user.id == participation.user_id do
  81       conn
  82       |> put_view(ConversationView)
  83       |> render("participation.json", %{participation: participation, for: user})
  84     end
  85   end
  86
  87   def conversation_statuses(
  88         %{assigns: %{user: user}} = conn,
  89         %{"id" => participation_id} = params
  90       ) do
  91     participation = Participation.get(participation_id, preload: [:conversation])
  92
  93     if user.id == participation.user_id do
  94       params =
  95         params
  96         |> Map.put("blocking_user", user)
  97         |> Map.put("muting_user", user)
  98         |> Map.put("user", user)
  99
 100       activities =
 101         participation.conversation.ap_id
 102         |> ActivityPub.fetch_activities_for_context(params)
 103         |> Enum.reverse()
 104
 105       conn
 106       |> add_link_headers(activities)
 107       |> put_view(StatusView)
 108       |> render("index.json", %{activities: activities, for: user, as: :activity})
 109     end
 110   end
 111
 112   def update_conversation(
 113         %{assigns: %{user: user}} = conn,
 114         %{"id" => participation_id, "recipients" => recipients}
 115       ) do
 116     participation =
 117       participation_id
 118       |> Participation.get()
 119
 120     with true <- user.id == participation.user_id,
 121          {:ok, participation} <- Participation.set_recipients(participation, recipients) do
 122       conn
 123       |> put_view(ConversationView)
 124       |> render("participation.json", %{participation: participation, for: user})
 125     end
 126   end
 127
 128   def read_notification(%{assigns: %{user: user}} = conn, %{"id" => notification_id}) do
 129     with {:ok, notification} <- Notification.read_one(user, notification_id) do
 130       conn
 131       |> put_view(NotificationView)
 132       |> render("show.json", %{notification: notification, for: user})
 133     else
 134       {:error, message} ->
 135         conn
 136         |> put_status(:bad_request)
 137         |> json(%{"error" => message})
 138     end
 139   end
 140
 141   def read_notification(%{assigns: %{user: user}} = conn, %{"max_id" => max_id}) do
 142     with notifications <- Notification.set_read_up_to(user, max_id) do
 143       notifications = Enum.take(notifications, 80)
 144
 145       conn
 146       |> put_view(NotificationView)
 147       |> render("index.json", %{notifications: notifications, for: user})
 148     end
 149   end
 150 end