git.squeep.com Git - akkoma/blob - lib/pleroma/web/pleroma_api/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: 7]
   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     params =
  70       params
  71       |> Map.put("blocking_user", user)
  72       |> Map.put("muting_user", user)
  73       |> Map.put("user", user)
  74
  75     participation =
  76       participation_id
  77       |> Participation.get(preload: [:conversation])
  78
  79     if user.id == participation.user_id do
  80       activities =
  81         participation.conversation.ap_id
  82         |> ActivityPub.fetch_activities_for_context(params)
  83         |> Enum.reverse()
  84
  85       conn
  86       |> add_link_headers(
  87         :conversation_statuses,
  88         activities,
  89         participation_id,
  90         params,
  91         nil,
  92         &pleroma_api_url/4
  93       )
  94       |> put_view(StatusView)
  95       |> render("index.json", %{activities: activities, for: user, as: :activity})
  96     end
  97   end
  98
  99   def update_conversation(
 100         %{assigns: %{user: user}} = conn,
 101         %{"id" => participation_id, "recipients" => recipients}
 102       ) do
 103     participation =
 104       participation_id
 105       |> Participation.get()
 106
 107     with true <- user.id == participation.user_id,
 108          {:ok, participation} <- Participation.set_recipients(participation, recipients) do
 109       conn
 110       |> put_view(ConversationView)
 111       |> render("participation.json", %{participation: participation, for: user})
 112     end
 113   end
 114
 115   def read_notification(%{assigns: %{user: user}} = conn, %{"id" => notification_id}) do
 116     with {:ok, notification} <- Notification.read_one(user, notification_id) do
 117       conn
 118       |> put_view(NotificationView)
 119       |> render("show.json", %{notification: notification, for: user})
 120     else
 121       {:error, message} ->
 122         conn
 123         |> put_status(:bad_request)
 124         |> json(%{"error" => message})
 125     end
 126   end
 127
 128   def read_notification(%{assigns: %{user: user}} = conn, %{"max_id" => max_id}) do
 129     with notifications <- Notification.set_read_up_to(user, max_id) do
 130       notifications = Enum.take(notifications, 80)
 131
 132       conn
 133       |> put_view(NotificationView)
 134       |> render("index.json", %{notifications: notifications, for: user})
 135     end
 136   end
 137 end