git.squeep.com Git - akkoma/blob - lib/pleroma/web/common_api/utils.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.CommonAPI.Utils do
   6   alias Calendar.Strftime
   7   alias Comeonin.Pbkdf2
   8   alias Pleroma.Activity
   9   alias Pleroma.Config
  10   alias Pleroma.Formatter
  11   alias Pleroma.Object
  12   alias Pleroma.Repo
  13   alias Pleroma.User
  14   alias Pleroma.Web.ActivityPub.Utils
  15   alias Pleroma.Web.ActivityPub.Visibility
  16   alias Pleroma.Web.Endpoint
  17   alias Pleroma.Web.MediaProxy
  18
  19   require Logger
  20
  21   # This is a hack for twidere.
  22   def get_by_id_or_ap_id(id) do
  23     activity =
  24       Activity.get_by_id_with_object(id) || Activity.get_create_by_object_ap_id_with_object(id)
  25
  26     activity &&
  27       if activity.data["type"] == "Create" do
  28         activity
  29       else
  30         Activity.get_create_by_object_ap_id_with_object(activity.data["object"])
  31       end
  32   end
  33
  34   def get_replied_to_activity(""), do: nil
  35
  36   def get_replied_to_activity(id) when not is_nil(id) do
  37     Activity.get_by_id(id)
  38   end
  39
  40   def get_replied_to_activity(_), do: nil
  41
  42   def attachments_from_ids(data) do
  43     if Map.has_key?(data, "descriptions") do
  44       attachments_from_ids_descs(data["media_ids"], data["descriptions"])
  45     else
  46       attachments_from_ids_no_descs(data["media_ids"])
  47     end
  48   end
  49
  50   def attachments_from_ids_no_descs(ids) do
  51     Enum.map(ids || [], fn media_id ->
  52       Repo.get(Object, media_id).data
  53     end)
  54   end
  55
  56   def attachments_from_ids_descs(ids, descs_str) do
  57     {_, descs} = Jason.decode(descs_str)
  58
  59     Enum.map(ids || [], fn media_id ->
  60       Map.put(Repo.get(Object, media_id).data, "name", descs[media_id])
  61     end)
  62   end
  63
  64   def to_for_user_and_mentions(user, mentions, inReplyTo, "public") do
  65     mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)
  66
  67     to = ["https://www.w3.org/ns/activitystreams#Public" | mentioned_users]
  68     cc = [user.follower_address]
  69
  70     if inReplyTo do
  71       {Enum.uniq([inReplyTo.data["actor"] | to]), cc}
  72     else
  73       {to, cc}
  74     end
  75   end
  76
  77   def to_for_user_and_mentions(user, mentions, inReplyTo, "unlisted") do
  78     mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)
  79
  80     to = [user.follower_address | mentioned_users]
  81     cc = ["https://www.w3.org/ns/activitystreams#Public"]
  82
  83     if inReplyTo do
  84       {Enum.uniq([inReplyTo.data["actor"] | to]), cc}
  85     else
  86       {to, cc}
  87     end
  88   end
  89
  90   def to_for_user_and_mentions(user, mentions, inReplyTo, "private") do
  91     {to, cc} = to_for_user_and_mentions(user, mentions, inReplyTo, "direct")
  92     {[user.follower_address | to], cc}
  93   end
  94
  95   def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
  96     mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)
  97
  98     if inReplyTo do
  99       {Enum.uniq([inReplyTo.data["actor"] | mentioned_users]), []}
 100     else
 101       {mentioned_users, []}
 102     end
 103   end
 104
 105   def make_content_html(
 106         status,
 107         attachments,
 108         data,
 109         visibility
 110       ) do
 111     no_attachment_links =
 112       data
 113       |> Map.get("no_attachment_links", Config.get([:instance, :no_attachment_links]))
 114       |> Kernel.in([true, "true"])
 115
 116     content_type = get_content_type(data["content_type"])
 117
 118     options =
 119       if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
 120         [safe_mention: true]
 121       else
 122         []
 123       end
 124
 125     status
 126     |> format_input(content_type, options)
 127     |> maybe_add_attachments(attachments, no_attachment_links)
 128     |> maybe_add_nsfw_tag(data)
 129   end
 130
 131   defp get_content_type(content_type) do
 132     if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
 133       content_type
 134     else
 135       "text/plain"
 136     end
 137   end
 138
 139   defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
 140        when sensitive in [true, "True", "true", "1"] do
 141     {text, mentions, [{"#nsfw", "nsfw"} | tags]}
 142   end
 143
 144   defp maybe_add_nsfw_tag(data, _), do: data
 145
 146   def make_context(%Activity{data: %{"context" => context}}), do: context
 147   def make_context(_), do: Utils.generate_context_id()
 148
 149   def maybe_add_attachments(parsed, _attachments, true = _no_links), do: parsed
 150
 151   def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
 152     text = add_attachments(text, attachments)
 153     {text, mentions, tags}
 154   end
 155
 156   def add_attachments(text, attachments) do
 157     attachment_text =
 158       Enum.map(attachments, fn
 159         %{"url" => [%{"href" => href} | _]} = attachment ->
 160           name = attachment["name"] || URI.decode(Path.basename(href))
 161           href = MediaProxy.url(href)
 162           "<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"
 163
 164         _ ->
 165           ""
 166       end)
 167
 168     Enum.join([text | attachment_text], "<br>")
 169   end
 170
 171   def format_input(text, format, options \\ [])
 172
 173   @doc """
 174   Formatting text to plain text.
 175   """
 176   def format_input(text, "text/plain", options) do
 177     text
 178     |> Formatter.html_escape("text/plain")
 179     |> Formatter.linkify(options)
 180     |> (fn {text, mentions, tags} ->
 181           {String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
 182         end).()
 183   end
 184
 185   @doc """
 186   Formatting text as BBCode.
 187   """
 188   def format_input(text, "text/bbcode", options) do
 189     text
 190     |> String.replace(~r/\r/, "")
 191     |> Formatter.html_escape("text/plain")
 192     |> BBCode.to_html()
 193     |> (fn {:ok, html} -> html end).()
 194     |> Formatter.linkify(options)
 195   end
 196
 197   @doc """
 198   Formatting text to html.
 199   """
 200   def format_input(text, "text/html", options) do
 201     text
 202     |> Formatter.html_escape("text/html")
 203     |> Formatter.linkify(options)
 204   end
 205
 206   @doc """
 207   Formatting text to markdown.
 208   """
 209   def format_input(text, "text/markdown", options) do
 210     text
 211     |> Formatter.mentions_escape(options)
 212     |> Earmark.as_html!()
 213     |> Formatter.linkify(options)
 214     |> Formatter.html_escape("text/html")
 215   end
 216
 217   def make_note_data(
 218         actor,
 219         to,
 220         context,
 221         content_html,
 222         attachments,
 223         in_reply_to,
 224         tags,
 225         cw \\ nil,
 226         cc \\ []
 227       ) do
 228     object = %{
 229       "type" => "Note",
 230       "to" => to,
 231       "cc" => cc,
 232       "content" => content_html,
 233       "summary" => cw,
 234       "context" => context,
 235       "attachment" => attachments,
 236       "actor" => actor,
 237       "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
 238     }
 239
 240     with false <- is_nil(in_reply_to),
 241          %Object{} = in_reply_to_object <- Object.normalize(in_reply_to) do
 242       Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
 243     else
 244       _ -> object
 245     end
 246   end
 247
 248   def format_naive_asctime(date) do
 249     date |> DateTime.from_naive!("Etc/UTC") |> format_asctime
 250   end
 251
 252   def format_asctime(date) do
 253     Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
 254   end
 255
 256   def date_to_asctime(date) when is_binary(date) do
 257     with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
 258       format_asctime(date)
 259     else
 260       _e ->
 261         Logger.warn("Date #{date} in wrong format, must be ISO 8601")
 262         ""
 263     end
 264   end
 265
 266   def date_to_asctime(date) do
 267     Logger.warn("Date #{date} in wrong format, must be ISO 8601")
 268     ""
 269   end
 270
 271   def to_masto_date(%NaiveDateTime{} = date) do
 272     date
 273     |> NaiveDateTime.to_iso8601()
 274     |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 275   end
 276
 277   def to_masto_date(date) do
 278     try do
 279       date
 280       |> NaiveDateTime.from_iso8601!()
 281       |> NaiveDateTime.to_iso8601()
 282       |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 283     rescue
 284       _e -> ""
 285     end
 286   end
 287
 288   defp shortname(name) do
 289     if String.length(name) < 30 do
 290       name
 291     else
 292       String.slice(name, 0..30) <> "…"
 293     end
 294   end
 295
 296   def confirm_current_password(user, password) do
 297     with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
 298          true <- Pbkdf2.checkpw(password, db_user.password_hash) do
 299       {:ok, db_user}
 300     else
 301       _ -> {:error, "Invalid password."}
 302     end
 303   end
 304
 305   def emoji_from_profile(%{info: _info} = user) do
 306     (Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
 307     |> Enum.map(fn {shortcode, url, _} ->
 308       %{
 309         "type" => "Emoji",
 310         "icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
 311         "name" => ":#{shortcode}:"
 312       }
 313     end)
 314   end
 315
 316   def maybe_notify_to_recipients(
 317         recipients,
 318         %Activity{data: %{"to" => to, "type" => _type}} = _activity
 319       ) do
 320     recipients ++ to
 321   end
 322
 323   def maybe_notify_mentioned_recipients(
 324         recipients,
 325         %Activity{data: %{"to" => _to, "type" => type} = data} = activity
 326       )
 327       when type == "Create" do
 328     object = Object.normalize(activity)
 329
 330     object_data =
 331       cond do
 332         !is_nil(object) ->
 333           object.data
 334
 335         is_map(data["object"]) ->
 336           data["object"]
 337
 338         true ->
 339           %{}
 340       end
 341
 342     tagged_mentions = maybe_extract_mentions(object_data)
 343
 344     recipients ++ tagged_mentions
 345   end
 346
 347   def maybe_notify_mentioned_recipients(recipients, _), do: recipients
 348
 349   def maybe_notify_subscribers(
 350         recipients,
 351         %Activity{data: %{"actor" => actor, "type" => type}} = activity
 352       )
 353       when type == "Create" do
 354     with %User{} = user <- User.get_cached_by_ap_id(actor) do
 355       subscriber_ids =
 356         user
 357         |> User.subscribers()
 358         |> Enum.filter(&Visibility.visible_for_user?(activity, &1))
 359         |> Enum.map(& &1.ap_id)
 360
 361       recipients ++ subscriber_ids
 362     end
 363   end
 364
 365   def maybe_notify_subscribers(recipients, _), do: recipients
 366
 367   def maybe_extract_mentions(%{"tag" => tag}) do
 368     tag
 369     |> Enum.filter(fn x -> is_map(x) end)
 370     |> Enum.filter(fn x -> x["type"] == "Mention" end)
 371     |> Enum.map(fn x -> x["href"] end)
 372   end
 373
 374   def maybe_extract_mentions(_), do: []
 375
 376   def make_report_content_html(nil), do: {:ok, {nil, [], []}}
 377
 378   def make_report_content_html(comment) do
 379     max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
 380
 381     if String.length(comment) <= max_size do
 382       {:ok, format_input(comment, "text/plain")}
 383     else
 384       {:error, "Comment must be up to #{max_size} characters"}
 385     end
 386   end
 387
 388   def get_report_statuses(%User{ap_id: actor}, %{"status_ids" => status_ids}) do
 389     {:ok, Activity.all_by_actor_and_id(actor, status_ids)}
 390   end
 391
 392   def get_report_statuses(_, _), do: {:ok, nil}
 393
 394   # DEPRECATED mostly, context objects are now created at insertion time.
 395   def context_to_conversation_id(context) do
 396     with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
 397       id
 398     else
 399       _e ->
 400         changeset = Object.context_mapping(context)
 401
 402         case Repo.insert(changeset) do
 403           {:ok, %{id: id}} ->
 404             id
 405
 406           # This should be solved by an upsert, but it seems ecto
 407           # has problems accessing the constraint inside the jsonb.
 408           {:error, _} ->
 409             Object.get_cached_by_ap_id(context).id
 410         end
 411     end
 412   end
 413
 414   def conversation_id_to_context(id) do
 415     with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
 416       context
 417     else
 418       _e ->
 419         {:error, "No such conversation"}
 420     end
 421   end
 422 end