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 to_for_user_and_mentions(_user, _mentions, _inReplyTo, _), do: {[], []}
 106
 107   def bcc_for_list(user, {:list, list_id}) do
 108     list = Pleroma.List.get(list_id, user)
 109     [list.ap_id]
 110   end
 111
 112   def bcc_for_list(_, _), do: []
 113
 114   def make_content_html(
 115         status,
 116         attachments,
 117         data,
 118         visibility
 119       ) do
 120     no_attachment_links =
 121       data
 122       |> Map.get("no_attachment_links", Config.get([:instance, :no_attachment_links]))
 123       |> Kernel.in([true, "true"])
 124
 125     content_type = get_content_type(data["content_type"])
 126
 127     options =
 128       if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
 129         [safe_mention: true]
 130       else
 131         []
 132       end
 133
 134     status
 135     |> format_input(content_type, options)
 136     |> maybe_add_attachments(attachments, no_attachment_links)
 137     |> maybe_add_nsfw_tag(data)
 138   end
 139
 140   defp get_content_type(content_type) do
 141     if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
 142       content_type
 143     else
 144       "text/plain"
 145     end
 146   end
 147
 148   defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
 149        when sensitive in [true, "True", "true", "1"] do
 150     {text, mentions, [{"#nsfw", "nsfw"} | tags]}
 151   end
 152
 153   defp maybe_add_nsfw_tag(data, _), do: data
 154
 155   def make_context(%Activity{data: %{"context" => context}}), do: context
 156   def make_context(_), do: Utils.generate_context_id()
 157
 158   def maybe_add_attachments(parsed, _attachments, true = _no_links), do: parsed
 159
 160   def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
 161     text = add_attachments(text, attachments)
 162     {text, mentions, tags}
 163   end
 164
 165   def add_attachments(text, attachments) do
 166     attachment_text =
 167       Enum.map(attachments, fn
 168         %{"url" => [%{"href" => href} | _]} = attachment ->
 169           name = attachment["name"] || URI.decode(Path.basename(href))
 170           href = MediaProxy.url(href)
 171           "<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"
 172
 173         _ ->
 174           ""
 175       end)
 176
 177     Enum.join([text | attachment_text], "<br>")
 178   end
 179
 180   def format_input(text, format, options \\ [])
 181
 182   @doc """
 183   Formatting text to plain text.
 184   """
 185   def format_input(text, "text/plain", options) do
 186     text
 187     |> Formatter.html_escape("text/plain")
 188     |> Formatter.linkify(options)
 189     |> (fn {text, mentions, tags} ->
 190           {String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
 191         end).()
 192   end
 193
 194   @doc """
 195   Formatting text as BBCode.
 196   """
 197   def format_input(text, "text/bbcode", options) do
 198     text
 199     |> String.replace(~r/\r/, "")
 200     |> Formatter.html_escape("text/plain")
 201     |> BBCode.to_html()
 202     |> (fn {:ok, html} -> html end).()
 203     |> Formatter.linkify(options)
 204   end
 205
 206   @doc """
 207   Formatting text to html.
 208   """
 209   def format_input(text, "text/html", options) do
 210     text
 211     |> Formatter.html_escape("text/html")
 212     |> Formatter.linkify(options)
 213   end
 214
 215   @doc """
 216   Formatting text to markdown.
 217   """
 218   def format_input(text, "text/markdown", options) do
 219     text
 220     |> Formatter.mentions_escape(options)
 221     |> Earmark.as_html!()
 222     |> Formatter.linkify(options)
 223     |> Formatter.html_escape("text/html")
 224   end
 225
 226   def make_note_data(
 227         actor,
 228         to,
 229         context,
 230         content_html,
 231         attachments,
 232         in_reply_to,
 233         tags,
 234         cw \\ nil,
 235         cc \\ []
 236       ) do
 237     object = %{
 238       "type" => "Note",
 239       "to" => to,
 240       "cc" => cc,
 241       "content" => content_html,
 242       "summary" => cw,
 243       "context" => context,
 244       "attachment" => attachments,
 245       "actor" => actor,
 246       "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
 247     }
 248
 249     with false <- is_nil(in_reply_to),
 250          %Object{} = in_reply_to_object <- Object.normalize(in_reply_to) do
 251       Map.put(object, "inReplyTo", in_reply_to_object.data["id"])
 252     else
 253       _ -> object
 254     end
 255   end
 256
 257   def format_naive_asctime(date) do
 258     date |> DateTime.from_naive!("Etc/UTC") |> format_asctime
 259   end
 260
 261   def format_asctime(date) do
 262     Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
 263   end
 264
 265   def date_to_asctime(date) when is_binary(date) do
 266     with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
 267       format_asctime(date)
 268     else
 269       _e ->
 270         Logger.warn("Date #{date} in wrong format, must be ISO 8601")
 271         ""
 272     end
 273   end
 274
 275   def date_to_asctime(date) do
 276     Logger.warn("Date #{date} in wrong format, must be ISO 8601")
 277     ""
 278   end
 279
 280   def to_masto_date(%NaiveDateTime{} = date) do
 281     date
 282     |> NaiveDateTime.to_iso8601()
 283     |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 284   end
 285
 286   def to_masto_date(date) do
 287     try do
 288       date
 289       |> NaiveDateTime.from_iso8601!()
 290       |> NaiveDateTime.to_iso8601()
 291       |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 292     rescue
 293       _e -> ""
 294     end
 295   end
 296
 297   defp shortname(name) do
 298     if String.length(name) < 30 do
 299       name
 300     else
 301       String.slice(name, 0..30) <> "…"
 302     end
 303   end
 304
 305   def confirm_current_password(user, password) do
 306     with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
 307          true <- Pbkdf2.checkpw(password, db_user.password_hash) do
 308       {:ok, db_user}
 309     else
 310       _ -> {:error, "Invalid password."}
 311     end
 312   end
 313
 314   def emoji_from_profile(%{info: _info} = user) do
 315     (Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
 316     |> Enum.map(fn {shortcode, url, _} ->
 317       %{
 318         "type" => "Emoji",
 319         "icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
 320         "name" => ":#{shortcode}:"
 321       }
 322     end)
 323   end
 324
 325   def maybe_notify_to_recipients(
 326         recipients,
 327         %Activity{data: %{"to" => to, "type" => _type}} = _activity
 328       ) do
 329     recipients ++ to
 330   end
 331
 332   def maybe_notify_mentioned_recipients(
 333         recipients,
 334         %Activity{data: %{"to" => _to, "type" => type} = data} = activity
 335       )
 336       when type == "Create" do
 337     object = Object.normalize(activity)
 338
 339     object_data =
 340       cond do
 341         !is_nil(object) ->
 342           object.data
 343
 344         is_map(data["object"]) ->
 345           data["object"]
 346
 347         true ->
 348           %{}
 349       end
 350
 351     tagged_mentions = maybe_extract_mentions(object_data)
 352
 353     recipients ++ tagged_mentions
 354   end
 355
 356   def maybe_notify_mentioned_recipients(recipients, _), do: recipients
 357
 358   def maybe_notify_subscribers(
 359         recipients,
 360         %Activity{data: %{"actor" => actor, "type" => type}} = activity
 361       )
 362       when type == "Create" do
 363     with %User{} = user <- User.get_cached_by_ap_id(actor) do
 364       subscriber_ids =
 365         user
 366         |> User.subscribers()
 367         |> Enum.filter(&Visibility.visible_for_user?(activity, &1))
 368         |> Enum.map(& &1.ap_id)
 369
 370       recipients ++ subscriber_ids
 371     end
 372   end
 373
 374   def maybe_notify_subscribers(recipients, _), do: recipients
 375
 376   def maybe_extract_mentions(%{"tag" => tag}) do
 377     tag
 378     |> Enum.filter(fn x -> is_map(x) end)
 379     |> Enum.filter(fn x -> x["type"] == "Mention" end)
 380     |> Enum.map(fn x -> x["href"] end)
 381   end
 382
 383   def maybe_extract_mentions(_), do: []
 384
 385   def make_report_content_html(nil), do: {:ok, {nil, [], []}}
 386
 387   def make_report_content_html(comment) do
 388     max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
 389
 390     if String.length(comment) <= max_size do
 391       {:ok, format_input(comment, "text/plain")}
 392     else
 393       {:error, "Comment must be up to #{max_size} characters"}
 394     end
 395   end
 396
 397   def get_report_statuses(%User{ap_id: actor}, %{"status_ids" => status_ids}) do
 398     {:ok, Activity.all_by_actor_and_id(actor, status_ids)}
 399   end
 400
 401   def get_report_statuses(_, _), do: {:ok, nil}
 402
 403   # DEPRECATED mostly, context objects are now created at insertion time.
 404   def context_to_conversation_id(context) do
 405     with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
 406       id
 407     else
 408       _e ->
 409         changeset = Object.context_mapping(context)
 410
 411         case Repo.insert(changeset) do
 412           {:ok, %{id: id}} ->
 413             id
 414
 415           # This should be solved by an upsert, but it seems ecto
 416           # has problems accessing the constraint inside the jsonb.
 417           {:error, _} ->
 418             Object.get_cached_by_ap_id(context).id
 419         end
 420     end
 421   end
 422
 423   def conversation_id_to_context(id) do
 424     with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
 425       context
 426     else
 427       _e ->
 428         {:error, "No such conversation"}
 429     end
 430   end
 431 end