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-2020 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.Conversation.Participation
  11   alias Pleroma.Notification
  12   alias Pleroma.Plugs.OAuthScopesPlug
  13   alias Pleroma.Web.ActivityPub.ActivityPub
  14   alias Pleroma.Web.MastodonAPI.ConversationView
  15   alias Pleroma.Web.MastodonAPI.NotificationView
  16   alias Pleroma.Web.MastodonAPI.StatusView
  17
  18   plug(Pleroma.Web.ApiSpec.CastAndValidate)
  19
  20   plug(
  21     OAuthScopesPlug,
  22     %{scopes: ["read:statuses"]}
  23     when action in [:conversation, :conversation_statuses]
  24   )
  25
  26   plug(
  27     OAuthScopesPlug,
  28     %{scopes: ["write:conversations"]}
  29     when action in [:update_conversation, :mark_conversations_as_read]
  30   )
  31
  32   plug(
  33     OAuthScopesPlug,
  34     %{scopes: ["write:notifications"]} when action == :mark_notifications_as_read
  35   )
  36
  37   defdelegate open_api_operation(action), to: Pleroma.Web.ApiSpec.PleromaOperation
  38
  39   def conversation(%{assigns: %{user: user}} = conn, %{id: participation_id}) do
  40     with %Participation{} = participation <- Participation.get(participation_id),
  41          true <- user.id == participation.user_id do
  42       conn
  43       |> put_view(ConversationView)
  44       |> render("participation.json", %{participation: participation, for: user})
  45     else
  46       _error ->
  47         conn
  48         |> put_status(404)
  49         |> json(%{"error" => "Unknown conversation id"})
  50     end
  51   end
  52
  53   def conversation_statuses(
  54         %{assigns: %{user: %{id: user_id} = user}} = conn,
  55         %{id: participation_id} = params
  56       ) do
  57     with %Participation{user_id: ^user_id} = participation <-
  58            Participation.get(participation_id, preload: [:conversation]) do
  59       params =
  60         params
  61         |> Map.new(fn {key, value} -> {to_string(key), value} end)
  62         |> Map.put("blocking_user", user)
  63         |> Map.put("muting_user", user)
  64         |> Map.put("user", user)
  65
  66       activities =
  67         participation.conversation.ap_id
  68         |> ActivityPub.fetch_activities_for_context_query(params)
  69         |> Pleroma.Pagination.fetch_paginated(Map.put(params, "total", false))
  70         |> Enum.reverse()
  71
  72       conn
  73       |> add_link_headers(activities)
  74       |> put_view(StatusView)
  75       |> render("index.json",
  76         activities: activities,
  77         for: user,
  78         as: :activity
  79       )
  80     else
  81       _error ->
  82         conn
  83         |> put_status(404)
  84         |> json(%{"error" => "Unknown conversation id"})
  85     end
  86   end
  87
  88   def update_conversation(
  89         %{assigns: %{user: user}} = conn,
  90         %{id: participation_id, recipients: recipients}
  91       ) do
  92     with %Participation{} = participation <- Participation.get(participation_id),
  93          true <- user.id == participation.user_id,
  94          {:ok, participation} <- Participation.set_recipients(participation, recipients) do
  95       conn
  96       |> put_view(ConversationView)
  97       |> render("participation.json", %{participation: participation, for: user})
  98     else
  99       {:error, message} ->
 100         conn
 101         |> put_status(:bad_request)
 102         |> json(%{"error" => message})
 103
 104       _error ->
 105         conn
 106         |> put_status(404)
 107         |> json(%{"error" => "Unknown conversation id"})
 108     end
 109   end
 110
 111   def mark_conversations_as_read(%{assigns: %{user: user}} = conn, _params) do
 112     with {:ok, _, participations} <- Participation.mark_all_as_read(user) do
 113       conn
 114       |> add_link_headers(participations)
 115       |> put_view(ConversationView)
 116       |> render("participations.json", participations: participations, for: user)
 117     end
 118   end
 119
 120   def mark_notifications_as_read(%{assigns: %{user: user}} = conn, %{id: notification_id}) do
 121     with {:ok, notification} <- Notification.read_one(user, notification_id) do
 122       conn
 123       |> put_view(NotificationView)
 124       |> render("show.json", %{notification: notification, for: user})
 125     else
 126       {:error, message} ->
 127         conn
 128         |> put_status(:bad_request)
 129         |> json(%{"error" => message})
 130     end
 131   end
 132
 133   def mark_notifications_as_read(%{assigns: %{user: user}} = conn, %{max_id: max_id}) do
 134     with notifications <- Notification.set_read_up_to(user, max_id) do
 135       notifications = Enum.take(notifications, 80)
 136
 137       conn
 138       |> put_view(NotificationView)
 139       |> render("index.json",
 140         notifications: notifications,
 141         for: user
 142       )
 143     end
 144   end
 145 end