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.User
  15   alias Pleroma.Web.ActivityPub.ActivityPub
  16   alias Pleroma.Web.CommonAPI
  17   alias Pleroma.Web.MastodonAPI.AccountView
  18   alias Pleroma.Web.MastodonAPI.ConversationView
  19   alias Pleroma.Web.MastodonAPI.NotificationView
  20   alias Pleroma.Web.MastodonAPI.StatusView
  21
  22   def emoji_reactions_by(%{assigns: %{user: user}} = conn, %{"id" => activity_id}) do
  23     with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
  24          %Object{data: %{"reactions" => emoji_reactions}} <- Object.normalize(activity) do
  25       reactions =
  26         Enum.reduce(emoji_reactions, %{}, fn {emoji, users}, res ->
  27           users =
  28             users
  29             |> Enum.map(&User.get_cached_by_ap_id/1)
  30
  31           res
  32           |> Map.put(
  33             emoji,
  34             AccountView.render("accounts.json", %{users: users, for: user, as: :user})
  35           )
  36         end)
  37
  38       conn
  39       |> json(reactions)
  40     else
  41       _e ->
  42         conn
  43         |> json(%{})
  44     end
  45   end
  46
  47   def react_with_emoji(%{assigns: %{user: user}} = conn, %{"id" => activity_id, "emoji" => emoji}) do
  48     with {:ok, _activity, _object} <- CommonAPI.react_with_emoji(activity_id, user, emoji),
  49          activity = Activity.get_by_id(activity_id) do
  50       conn
  51       |> put_view(StatusView)
  52       |> render("status.json", %{activity: activity, for: user, as: :activity})
  53     end
  54   end
  55
  56   def conversation(%{assigns: %{user: user}} = conn, %{"id" => participation_id}) do
  57     with %Participation{} = participation <- Participation.get(participation_id),
  58          true <- user.id == participation.user_id do
  59       conn
  60       |> put_view(ConversationView)
  61       |> render("participation.json", %{participation: participation, for: user})
  62     end
  63   end
  64
  65   def conversation_statuses(
  66         %{assigns: %{user: user}} = conn,
  67         %{"id" => participation_id} = params
  68       ) do
  69     participation = Participation.get(participation_id, preload: [:conversation])
  70
  71     if user.id == participation.user_id do
  72       params =
  73         params
  74         |> Map.put("blocking_user", user)
  75         |> Map.put("muting_user", user)
  76         |> Map.put("user", user)
  77
  78       activities =
  79         participation.conversation.ap_id
  80         |> ActivityPub.fetch_activities_for_context(params)
  81         |> Enum.reverse()
  82
  83       conn
  84       |> add_link_headers(activities)
  85       |> put_view(StatusView)
  86       |> render("index.json", %{activities: activities, for: user, as: :activity})
  87     end
  88   end
  89
  90   def update_conversation(
  91         %{assigns: %{user: user}} = conn,
  92         %{"id" => participation_id, "recipients" => recipients}
  93       ) do
  94     participation =
  95       participation_id
  96       |> Participation.get()
  97
  98     with true <- user.id == participation.user_id,
  99          {:ok, participation} <- Participation.set_recipients(participation, recipients) do
 100       conn
 101       |> put_view(ConversationView)
 102       |> render("participation.json", %{participation: participation, for: user})
 103     end
 104   end
 105
 106   def read_notification(%{assigns: %{user: user}} = conn, %{"id" => notification_id}) do
 107     with {:ok, notification} <- Notification.read_one(user, notification_id) do
 108       conn
 109       |> put_view(NotificationView)
 110       |> render("show.json", %{notification: notification, for: user})
 111     else
 112       {:error, message} ->
 113         conn
 114         |> put_status(:bad_request)
 115         |> json(%{"error" => message})
 116     end
 117   end
 118
 119   def read_notification(%{assigns: %{user: user}} = conn, %{"max_id" => max_id}) do
 120     with notifications <- Notification.set_read_up_to(user, max_id) do
 121       notifications = Enum.take(notifications, 80)
 122
 123       conn
 124       |> put_view(NotificationView)
 125       |> render("index.json", %{notifications: notifications, for: user})
 126     end
 127   end
 128 end