Git of dcc - anni/blob - lib/pleroma/web/common_api/activity_draft.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.CommonAPI.ActivityDraft do
   6   alias Pleroma.Activity
   7   alias Pleroma.Conversation.Participation
   8   alias Pleroma.Object
   9   alias Pleroma.Web.ActivityPub.Builder
  10   alias Pleroma.Web.ActivityPub.Visibility
  11   alias Pleroma.Web.CommonAPI
  12   alias Pleroma.Web.CommonAPI.Utils
  13
  14   import Pleroma.Web.Gettext
  15   import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]
  16
  17   @type t :: %__MODULE__{}
  18
  19   defstruct valid?: true,
  20             errors: [],
  21             user: nil,
  22             params: %{},
  23             status: nil,
  24             summary: nil,
  25             full_payload: nil,
  26             attachments: [],
  27             in_reply_to: nil,
  28             in_reply_to_conversation: nil,
  29             quote_post: nil,
  30             visibility: nil,
  31             expires_at: nil,
  32             extra: nil,
  33             emoji: %{},
  34             content_html: nil,
  35             mentions: [],
  36             tags: [],
  37             to: [],
  38             cc: [],
  39             context: nil,
  40             sensitive: false,
  41             object: nil,
  42             preview?: false,
  43             changes: %{}
  44
  45   def new(user, params) do
  46     %__MODULE__{user: user}
  47     |> put_params(params)
  48   end
  49
  50   def create(user, params) do
  51     user
  52     |> new(params)
  53     |> status()
  54     |> summary()
  55     |> with_valid(&attachments/1)
  56     |> full_payload()
  57     |> expires_at()
  58     |> poll()
  59     |> with_valid(&in_reply_to/1)
  60     |> with_valid(&in_reply_to_conversation/1)
  61     |> with_valid(&quote_post/1)
  62     |> with_valid(&visibility/1)
  63     |> with_valid(&quoting_visibility/1)
  64     |> content()
  65     |> with_valid(&to_and_cc/1)
  66     |> with_valid(&context/1)
  67     |> sensitive()
  68     |> with_valid(&object/1)
  69     |> preview?()
  70     |> with_valid(&changes/1)
  71     |> validate()
  72   end
  73
  74   def listen(user, params) do
  75     user
  76     |> new(params)
  77     |> visibility()
  78     |> to_and_cc()
  79     |> context()
  80     |> listen_object()
  81     |> with_valid(&changes/1)
  82     |> validate()
  83   end
  84
  85   defp listen_object(draft) do
  86     object =
  87       draft.params
  88       |> Map.take([:album, :artist, :title, :length, :externalLink])
  89       |> Map.new(fn {key, value} -> {to_string(key), value} end)
  90       |> Map.put("type", "Audio")
  91       |> Map.put("to", draft.to)
  92       |> Map.put("cc", draft.cc)
  93       |> Map.put("actor", draft.user.ap_id)
  94
  95     %__MODULE__{draft | object: object}
  96   end
  97
  98   defp put_params(draft, params) do
  99     params = Map.put_new(params, :in_reply_to_status_id, params[:in_reply_to_id])
 100     %__MODULE__{draft | params: params}
 101   end
 102
 103   defp status(%{params: %{status: status}} = draft) do
 104     %__MODULE__{draft | status: String.trim(status)}
 105   end
 106
 107   defp summary(%{params: params} = draft) do
 108     %__MODULE__{draft | summary: Map.get(params, :spoiler_text, "")}
 109   end
 110
 111   defp full_payload(%{status: status, summary: summary} = draft) do
 112     full_payload = String.trim(status <> summary)
 113
 114     case Utils.validate_character_limit(full_payload, draft.attachments) do
 115       :ok -> %__MODULE__{draft | full_payload: full_payload}
 116       {:error, message} -> add_error(draft, message)
 117     end
 118   end
 119
 120   defp attachments(%{params: params} = draft) do
 121     attachments = Utils.attachments_from_ids(params, draft.user)
 122     draft = %__MODULE__{draft | attachments: attachments}
 123
 124     case Utils.validate_attachments_count(attachments) do
 125       :ok -> draft
 126       {:error, message} -> add_error(draft, message)
 127     end
 128   end
 129
 130   defp in_reply_to(%{params: %{in_reply_to_status_id: ""}} = draft), do: draft
 131
 132   defp in_reply_to(%{params: %{in_reply_to_status_id: id}} = draft) when is_binary(id) do
 133     %__MODULE__{draft | in_reply_to: Activity.get_by_id(id)}
 134   end
 135
 136   defp in_reply_to(%{params: %{in_reply_to_status_id: %Activity{} = in_reply_to}} = draft) do
 137     %__MODULE__{draft | in_reply_to: in_reply_to}
 138   end
 139
 140   defp in_reply_to(draft), do: draft
 141
 142   defp quote_post(%{params: %{quote_id: id}} = draft) when not_empty_string(id) do
 143     case Activity.get_by_id_with_object(id) do
 144       %Activity{} = activity ->
 145         %__MODULE__{draft | quote_post: activity}
 146
 147       _ ->
 148         draft
 149     end
 150   end
 151
 152   defp quote_post(draft), do: draft
 153
 154   defp in_reply_to_conversation(draft) do
 155     in_reply_to_conversation = Participation.get(draft.params[:in_reply_to_conversation_id])
 156     %__MODULE__{draft | in_reply_to_conversation: in_reply_to_conversation}
 157   end
 158
 159   defp visibility(%{params: params} = draft) do
 160     case CommonAPI.get_visibility(params, draft.in_reply_to, draft.in_reply_to_conversation) do
 161       {visibility, "direct"} when visibility != "direct" ->
 162         add_error(draft, dgettext("errors", "The message visibility must be direct"))
 163
 164       {visibility, _} ->
 165         %__MODULE__{draft | visibility: visibility}
 166     end
 167   end
 168
 169   defp can_quote?(_draft, _object, visibility) when visibility in ~w(public unlisted local) do
 170     true
 171   end
 172
 173   defp can_quote?(draft, object, "private") do
 174     draft.user.ap_id == object.data["actor"]
 175   end
 176
 177   defp can_quote?(_, _, _) do
 178     false
 179   end
 180
 181   defp quoting_visibility(%{quote_post: %Activity{}} = draft) do
 182     with %Object{} = object <- Object.normalize(draft.quote_post, fetch: false),
 183          true <- can_quote?(draft, object, Visibility.get_visibility(object)) do
 184       draft
 185     else
 186       _ -> add_error(draft, dgettext("errors", "Cannot quote private message"))
 187     end
 188   end
 189
 190   defp quoting_visibility(draft), do: draft
 191
 192   defp expires_at(draft) do
 193     case CommonAPI.check_expiry_date(draft.params[:expires_in]) do
 194       {:ok, expires_at} -> %__MODULE__{draft | expires_at: expires_at}
 195       {:error, message} -> add_error(draft, message)
 196     end
 197   end
 198
 199   defp poll(draft) do
 200     case Utils.make_poll_data(draft.params) do
 201       {:ok, {poll, poll_emoji}} ->
 202         %__MODULE__{draft | extra: poll, emoji: Map.merge(draft.emoji, poll_emoji)}
 203
 204       {:error, message} ->
 205         add_error(draft, message)
 206     end
 207   end
 208
 209   defp content(%{mentions: mentions} = draft) do
 210     {content_html, mentioned_users, tags} = Utils.make_content_html(draft)
 211
 212     mentioned_ap_ids =
 213       Enum.map(mentioned_users, fn {_, mentioned_user} -> mentioned_user.ap_id end)
 214
 215     mentions =
 216       mentions
 217       |> Kernel.++(mentioned_ap_ids)
 218       |> Utils.get_addressed_users(draft.params[:to])
 219
 220     %__MODULE__{draft | content_html: content_html, mentions: mentions, tags: tags}
 221   end
 222
 223   defp to_and_cc(draft) do
 224     {to, cc} = Utils.get_to_and_cc(draft)
 225     %__MODULE__{draft | to: to, cc: cc}
 226   end
 227
 228   defp context(draft) do
 229     context = Utils.make_context(draft.in_reply_to, draft.in_reply_to_conversation)
 230     %__MODULE__{draft | context: context}
 231   end
 232
 233   defp sensitive(draft) do
 234     sensitive = draft.params[:sensitive]
 235     %__MODULE__{draft | sensitive: sensitive}
 236   end
 237
 238   defp object(draft) do
 239     emoji = Map.merge(Pleroma.Emoji.Formatter.get_emoji_map(draft.full_payload), draft.emoji)
 240
 241     # Sometimes people create posts with subject containing emoji,
 242     # since subjects are usually copied this will result in a broken
 243     # subject when someone replies from an instance that does not have
 244     # the emoji or has it under different shortcode. This is an attempt
 245     # to mitigate this by copying emoji from inReplyTo if they are present
 246     # in the subject.
 247     summary_emoji =
 248       with %Activity{} <- draft.in_reply_to,
 249            %Object{data: %{"tag" => [_ | _] = tag}} <- Object.normalize(draft.in_reply_to) do
 250         Enum.reduce(tag, %{}, fn
 251           %{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}, acc ->
 252             if String.contains?(draft.summary, name) do
 253               Map.put(acc, name, url)
 254             else
 255               acc
 256             end
 257
 258           _, acc ->
 259             acc
 260         end)
 261       else
 262         _ -> %{}
 263       end
 264
 265     emoji = Map.merge(emoji, summary_emoji)
 266
 267     {:ok, note_data, _meta} = Builder.note(draft)
 268
 269     object =
 270       note_data
 271       |> Map.put("emoji", emoji)
 272       |> Map.put("source", %{
 273         "content" => draft.status,
 274         "mediaType" => Utils.get_content_type(draft.params[:content_type])
 275       })
 276       |> Map.put("generator", draft.params[:generator])
 277
 278     %__MODULE__{draft | object: object}
 279   end
 280
 281   defp preview?(draft) do
 282     preview? = Pleroma.Web.Utils.Params.truthy_param?(draft.params[:preview])
 283     %__MODULE__{draft | preview?: preview?}
 284   end
 285
 286   defp changes(draft) do
 287     direct? = draft.visibility == "direct"
 288     additional = %{"cc" => draft.cc, "directMessage" => direct?}
 289
 290     additional =
 291       case draft.expires_at do
 292         %DateTime{} = expires_at -> Map.put(additional, "expires_at", expires_at)
 293         _ -> additional
 294       end
 295
 296     changes =
 297       %{
 298         to: draft.to,
 299         actor: draft.user,
 300         context: draft.context,
 301         object: draft.object,
 302         additional: additional
 303       }
 304       |> Utils.maybe_add_list_data(draft.user, draft.visibility)
 305
 306     %__MODULE__{draft | changes: changes}
 307   end
 308
 309   defp with_valid(%{valid?: true} = draft, func), do: func.(draft)
 310   defp with_valid(draft, _func), do: draft
 311
 312   defp add_error(draft, message) do
 313     %__MODULE__{draft | valid?: false, errors: [message | draft.errors]}
 314   end
 315
 316   defp validate(%{valid?: true} = draft), do: {:ok, draft}
 317   defp validate(%{errors: [message | _]}), do: {:error, message}
 318 end