git.squeep.com Git - akkoma/blob - lib/pleroma/web/common_api/utils.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.CommonAPI.Utils do
   6   import Pleroma.Web.Gettext
   7
   8   alias Calendar.Strftime
   9   alias Pleroma.Activity
  10   alias Pleroma.Config
  11   alias Pleroma.Conversation.Participation
  12   alias Pleroma.Formatter
  13   alias Pleroma.Object
  14   alias Pleroma.Repo
  15   alias Pleroma.User
  16   alias Pleroma.Web.ActivityPub.Utils
  17   alias Pleroma.Web.ActivityPub.Visibility
  18   alias Pleroma.Web.CommonAPI.ActivityDraft
  19   alias Pleroma.Web.MediaProxy
  20   alias Pleroma.Web.Plugs.AuthenticationPlug
  21   alias Pleroma.Web.Utils.Params
  22
  23   require Logger
  24   require Pleroma.Constants
  25
  26   def attachments_from_ids(%{media_ids: ids, descriptions: desc}) do
  27     attachments_from_ids_descs(ids, desc)
  28   end
  29
  30   def attachments_from_ids(%{media_ids: ids}) do
  31     attachments_from_ids_no_descs(ids)
  32   end
  33
  34   def attachments_from_ids(_), do: []
  35
  36   def attachments_from_ids_no_descs([]), do: []
  37
  38   def attachments_from_ids_no_descs(ids) do
  39     Enum.map(ids, fn media_id ->
  40       case Repo.get(Object, media_id) do
  41         %Object{data: data} -> data
  42         _ -> nil
  43       end
  44     end)
  45     |> Enum.reject(&is_nil/1)
  46   end
  47
  48   def attachments_from_ids_descs([], _), do: []
  49
  50   def attachments_from_ids_descs(ids, descs_str) do
  51     {_, descs} = Jason.decode(descs_str)
  52
  53     Enum.map(ids, fn media_id ->
  54       with %Object{data: data} <- Repo.get(Object, media_id) do
  55         Map.put(data, "name", descs[media_id])
  56       end
  57     end)
  58     |> Enum.reject(&is_nil/1)
  59   end
  60
  61   @spec get_to_and_cc(ActivityDraft.t()) :: {list(String.t()), list(String.t())}
  62
  63   def get_to_and_cc(%{in_reply_to_conversation: %Participation{} = participation}) do
  64     participation = Repo.preload(participation, :recipients)
  65     {Enum.map(participation.recipients, & &1.ap_id), []}
  66   end
  67
  68   def get_to_and_cc(%{visibility: visibility} = draft) when visibility in ["public", "local"] do
  69     to =
  70       case visibility do
  71         "public" -> [Pleroma.Constants.as_public() | draft.mentions]
  72         "local" -> [Utils.as_local_public() | draft.mentions]
  73       end
  74
  75     cc = [draft.user.follower_address]
  76
  77     if draft.in_reply_to do
  78       {Enum.uniq([draft.in_reply_to.data["actor"] | to]), cc}
  79     else
  80       {to, cc}
  81     end
  82   end
  83
  84   def get_to_and_cc(%{visibility: "unlisted"} = draft) do
  85     to = [draft.user.follower_address | draft.mentions]
  86     cc = [Pleroma.Constants.as_public()]
  87
  88     if draft.in_reply_to do
  89       {Enum.uniq([draft.in_reply_to.data["actor"] | to]), cc}
  90     else
  91       {to, cc}
  92     end
  93   end
  94
  95   def get_to_and_cc(%{visibility: "private"} = draft) do
  96     {to, cc} = get_to_and_cc(struct(draft, visibility: "direct"))
  97     {[draft.user.follower_address | to], cc}
  98   end
  99
 100   def get_to_and_cc(%{visibility: "direct"} = draft) do
 101     # If the OP is a DM already, add the implicit actor.
 102     if draft.in_reply_to && Visibility.is_direct?(draft.in_reply_to) do
 103       {Enum.uniq([draft.in_reply_to.data["actor"] | draft.mentions]), []}
 104     else
 105       {draft.mentions, []}
 106     end
 107   end
 108
 109   def get_to_and_cc(%{visibility: {:list, _}, mentions: mentions}), do: {mentions, []}
 110
 111   def get_addressed_users(_, to) when is_list(to) do
 112     User.get_ap_ids_by_nicknames(to)
 113   end
 114
 115   def get_addressed_users(mentioned_users, _), do: mentioned_users
 116
 117   def maybe_add_list_data(activity_params, user, {:list, list_id}) do
 118     case Pleroma.List.get(list_id, user) do
 119       %Pleroma.List{} = list ->
 120         activity_params
 121         |> put_in([:additional, "bcc"], [list.ap_id])
 122         |> put_in([:additional, "listMessage"], list.ap_id)
 123         |> put_in([:object, "listMessage"], list.ap_id)
 124
 125       _ ->
 126         activity_params
 127     end
 128   end
 129
 130   def maybe_add_list_data(activity_params, _, _), do: activity_params
 131
 132   def make_poll_data(%{"poll" => %{"expires_in" => expires_in}} = data)
 133       when is_binary(expires_in) do
 134     # In some cases mastofe sends out strings instead of integers
 135     data
 136     |> put_in(["poll", "expires_in"], String.to_integer(expires_in))
 137     |> make_poll_data()
 138   end
 139
 140   def make_poll_data(%{poll: %{options: options, expires_in: expires_in}} = data)
 141       when is_list(options) do
 142     limits = Config.get([:instance, :poll_limits])
 143
 144     with :ok <- validate_poll_expiration(expires_in, limits),
 145          :ok <- validate_poll_options_amount(options, limits),
 146          :ok <- validate_poll_options_length(options, limits) do
 147       {option_notes, emoji} =
 148         Enum.map_reduce(options, %{}, fn option, emoji ->
 149           note = %{
 150             "name" => option,
 151             "type" => "Note",
 152             "replies" => %{"type" => "Collection", "totalItems" => 0}
 153           }
 154
 155           {note, Map.merge(emoji, Pleroma.Emoji.Formatter.get_emoji_map(option))}
 156         end)
 157
 158       end_time =
 159         DateTime.utc_now()
 160         |> DateTime.add(expires_in)
 161         |> DateTime.to_iso8601()
 162
 163       key = if Params.truthy_param?(data.poll[:multiple]), do: "anyOf", else: "oneOf"
 164       poll = %{"type" => "Question", key => option_notes, "closed" => end_time}
 165
 166       {:ok, {poll, emoji}}
 167     end
 168   end
 169
 170   def make_poll_data(%{"poll" => poll}) when is_map(poll) do
 171     {:error, "Invalid poll"}
 172   end
 173
 174   def make_poll_data(_data) do
 175     {:ok, {%{}, %{}}}
 176   end
 177
 178   defp validate_poll_options_amount(options, %{max_options: max_options}) do
 179     if Enum.count(options) > max_options do
 180       {:error, "Poll can't contain more than #{max_options} options"}
 181     else
 182       :ok
 183     end
 184   end
 185
 186   defp validate_poll_options_length(options, %{max_option_chars: max_option_chars}) do
 187     if Enum.any?(options, &(String.length(&1) > max_option_chars)) do
 188       {:error, "Poll options cannot be longer than #{max_option_chars} characters each"}
 189     else
 190       :ok
 191     end
 192   end
 193
 194   defp validate_poll_expiration(expires_in, %{min_expiration: min, max_expiration: max}) do
 195     cond do
 196       expires_in > max -> {:error, "Expiration date is too far in the future"}
 197       expires_in < min -> {:error, "Expiration date is too soon"}
 198       true -> :ok
 199     end
 200   end
 201
 202   def make_content_html(%ActivityDraft{} = draft) do
 203     attachment_links =
 204       draft.params
 205       |> Map.get("attachment_links", Config.get([:instance, :attachment_links]))
 206       |> Params.truthy_param?()
 207
 208     content_type = get_content_type(draft.params[:content_type])
 209
 210     options =
 211       if draft.visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
 212         [safe_mention: true]
 213       else
 214         []
 215       end
 216
 217     draft.status
 218     |> format_input(content_type, options)
 219     |> maybe_add_attachments(draft.attachments, attachment_links)
 220   end
 221
 222   defp get_content_type(content_type) do
 223     if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
 224       content_type
 225     else
 226       "text/plain"
 227     end
 228   end
 229
 230   def make_context(_, %Participation{} = participation) do
 231     Repo.preload(participation, :conversation).conversation.ap_id
 232   end
 233
 234   def make_context(%Activity{data: %{"context" => context}}, _), do: context
 235   def make_context(_, _), do: Utils.generate_context_id()
 236
 237   def maybe_add_attachments(parsed, _attachments, false = _no_links), do: parsed
 238
 239   def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
 240     text = add_attachments(text, attachments)
 241     {text, mentions, tags}
 242   end
 243
 244   def add_attachments(text, attachments) do
 245     attachment_text = Enum.map(attachments, &build_attachment_link/1)
 246     Enum.join([text | attachment_text], "<br>")
 247   end
 248
 249   defp build_attachment_link(%{"url" => [%{"href" => href} | _]} = attachment) do
 250     name = attachment["name"] || URI.decode(Path.basename(href))
 251     href = MediaProxy.url(href)
 252     "<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"
 253   end
 254
 255   defp build_attachment_link(_), do: ""
 256
 257   def format_input(text, format, options \\ [])
 258
 259   @doc """
 260   Formatting text to plain text, BBCode, HTML, or Markdown
 261   """
 262   def format_input(text, format, options)
 263       when format in ["text/plain", "text/x.misskeymarkdown"] do
 264     text
 265     |> Formatter.html_escape("text/plain")
 266     |> Formatter.linkify(options)
 267     |> (fn {text, mentions, tags} ->
 268           {String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
 269         end).()
 270   end
 271
 272   def format_input(text, "text/bbcode", options) do
 273     text
 274     |> String.replace(~r/\r/, "")
 275     |> Formatter.html_escape("text/plain")
 276     |> BBCode.to_html()
 277     |> (fn {:ok, html} -> html end).()
 278     |> Formatter.linkify(options)
 279   end
 280
 281   def format_input(text, "text/html", options) do
 282     text
 283     |> Formatter.html_escape("text/html")
 284     |> Formatter.linkify(options)
 285   end
 286
 287   def format_input(text, "text/markdown", options) do
 288     text
 289     |> Formatter.mentions_escape(options)
 290     |> Formatter.markdown_to_html()
 291     |> Formatter.linkify(options)
 292     |> Formatter.html_escape("text/html")
 293   end
 294
 295   def format_naive_asctime(date) do
 296     date |> DateTime.from_naive!("Etc/UTC") |> format_asctime
 297   end
 298
 299   def format_asctime(date) do
 300     Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
 301   end
 302
 303   def date_to_asctime(date) when is_binary(date) do
 304     with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
 305       format_asctime(date)
 306     else
 307       _e ->
 308         Logger.warn("Date #{date} in wrong format, must be ISO 8601")
 309         ""
 310     end
 311   end
 312
 313   def date_to_asctime(date) do
 314     Logger.warn("Date #{date} in wrong format, must be ISO 8601")
 315     ""
 316   end
 317
 318   def to_masto_date(%NaiveDateTime{} = date) do
 319     date
 320     |> NaiveDateTime.to_iso8601()
 321     |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 322   end
 323
 324   def to_masto_date(date) when is_binary(date) do
 325     with {:ok, date} <- NaiveDateTime.from_iso8601(date) do
 326       to_masto_date(date)
 327     else
 328       _ -> ""
 329     end
 330   end
 331
 332   def to_masto_date(_), do: ""
 333
 334   defp shortname(name) do
 335     with max_length when max_length > 0 <-
 336            Config.get([Pleroma.Upload, :filename_display_max_length], 30),
 337          true <- String.length(name) > max_length do
 338       String.slice(name, 0..max_length) <> "…"
 339     else
 340       _ -> name
 341     end
 342   end
 343
 344   @spec confirm_current_password(User.t(), String.t()) :: {:ok, User.t()} | {:error, String.t()}
 345   def confirm_current_password(user, password) do
 346     with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
 347          true <- AuthenticationPlug.checkpw(password, db_user.password_hash) do
 348       {:ok, db_user}
 349     else
 350       _ -> {:error, dgettext("errors", "Invalid password.")}
 351     end
 352   end
 353
 354   def maybe_notify_to_recipients(
 355         recipients,
 356         %Activity{data: %{"to" => to, "type" => _type}} = _activity
 357       ) do
 358     recipients ++ to
 359   end
 360
 361   def maybe_notify_to_recipients(recipients, _), do: recipients
 362
 363   def maybe_notify_mentioned_recipients(
 364         recipients,
 365         %Activity{data: %{"to" => _to, "type" => type} = data} = activity
 366       )
 367       when type == "Create" do
 368     object = Object.normalize(activity, fetch: false)
 369
 370     object_data =
 371       cond do
 372         not is_nil(object) ->
 373           object.data
 374
 375         is_map(data["object"]) ->
 376           data["object"]
 377
 378         true ->
 379           %{}
 380       end
 381
 382     tagged_mentions = maybe_extract_mentions(object_data)
 383
 384     recipients ++ tagged_mentions
 385   end
 386
 387   def maybe_notify_mentioned_recipients(recipients, _), do: recipients
 388
 389   def maybe_notify_subscribers(
 390         recipients,
 391         %Activity{data: %{"actor" => actor, "type" => "Create"}} = activity
 392       ) do
 393     # Do not notify subscribers if author is making a reply
 394     with %Object{data: object} <- Object.normalize(activity, fetch: false),
 395          nil <- object["inReplyTo"],
 396          %User{} = user <- User.get_cached_by_ap_id(actor) do
 397       subscriber_ids =
 398         user
 399         |> User.subscriber_users()
 400         |> Enum.filter(&Visibility.visible_for_user?(activity, &1))
 401         |> Enum.map(& &1.ap_id)
 402
 403       recipients ++ subscriber_ids
 404     else
 405       _e -> recipients
 406     end
 407   end
 408
 409   def maybe_notify_subscribers(recipients, _), do: recipients
 410
 411   def maybe_notify_followers(recipients, %Activity{data: %{"type" => "Move"}} = activity) do
 412     with %User{} = user <- User.get_cached_by_ap_id(activity.actor) do
 413       user
 414       |> User.get_followers()
 415       |> Enum.map(& &1.ap_id)
 416       |> Enum.concat(recipients)
 417     else
 418       _e -> recipients
 419     end
 420   end
 421
 422   def maybe_notify_followers(recipients, _), do: recipients
 423
 424   def maybe_extract_mentions(%{"tag" => tag}) do
 425     tag
 426     |> Enum.filter(fn x -> is_map(x) && x["type"] == "Mention" end)
 427     |> Enum.map(fn x -> x["href"] end)
 428     |> Enum.uniq()
 429   end
 430
 431   def maybe_extract_mentions(_), do: []
 432
 433   def make_report_content_html(nil), do: {:ok, {nil, [], []}}
 434
 435   def make_report_content_html(comment) do
 436     max_size = Config.get([:instance, :max_report_comment_size], 1000)
 437
 438     if String.length(comment) <= max_size do
 439       {:ok, format_input(comment, "text/plain")}
 440     else
 441       {:error,
 442        dgettext("errors", "Comment must be up to %{max_size} characters", max_size: max_size)}
 443     end
 444   end
 445
 446   def get_report_statuses(%User{ap_id: actor}, %{status_ids: status_ids})
 447       when is_list(status_ids) do
 448     {:ok, Activity.all_by_actor_and_id(actor, status_ids)}
 449   end
 450
 451   def get_report_statuses(_, _), do: {:ok, nil}
 452
 453   # DEPRECATED mostly, context objects are now created at insertion time.
 454   def context_to_conversation_id(context) do
 455     with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
 456       id
 457     else
 458       _e ->
 459         changeset = Object.context_mapping(context)
 460
 461         case Repo.insert(changeset) do
 462           {:ok, %{id: id}} ->
 463             id
 464
 465           # This should be solved by an upsert, but it seems ecto
 466           # has problems accessing the constraint inside the jsonb.
 467           {:error, _} ->
 468             Object.get_cached_by_ap_id(context).id
 469         end
 470     end
 471   end
 472
 473   def conversation_id_to_context(id) do
 474     with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
 475       context
 476     else
 477       _e ->
 478         {:error, dgettext("errors", "No such conversation")}
 479     end
 480   end
 481
 482   def validate_character_limit("" = _full_payload, [] = _attachments) do
 483     {:error, dgettext("errors", "Cannot post an empty status without attachments")}
 484   end
 485
 486   def validate_character_limit(full_payload, _attachments) do
 487     limit = Config.get([:instance, :limit])
 488     length = String.length(full_payload)
 489
 490     if length <= limit do
 491       :ok
 492     else
 493       {:error, dgettext("errors", "The status is over the character limit")}
 494     end
 495   end
 496 end