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 to html.
 187   """
 188   def format_input(text, "text/html", options) do
 189     text
 190     |> Formatter.html_escape("text/html")
 191     |> Formatter.linkify(options)
 192   end
 193
 194   @doc """
 195   Formatting text to markdown.
 196   """
 197   def format_input(text, "text/markdown", options) do
 198     text
 199     |> Formatter.mentions_escape(options)
 200     |> Earmark.as_html!()
 201     |> Formatter.linkify(options)
 202     |> Formatter.html_escape("text/html")
 203   end
 204
 205   def make_note_data(
 206         actor,
 207         to,
 208         context,
 209         content_html,
 210         attachments,
 211         inReplyTo,
 212         tags,
 213         cw \\ nil,
 214         cc \\ []
 215       ) do
 216     object = %{
 217       "type" => "Note",
 218       "to" => to,
 219       "cc" => cc,
 220       "content" => content_html,
 221       "summary" => cw,
 222       "context" => context,
 223       "attachment" => attachments,
 224       "actor" => actor,
 225       "tag" => tags |> Enum.map(fn {_, tag} -> tag end) |> Enum.uniq()
 226     }
 227
 228     if inReplyTo do
 229       object
 230       |> Map.put("inReplyTo", inReplyTo.data["object"]["id"])
 231       |> Map.put("inReplyToStatusId", inReplyTo.id)
 232     else
 233       object
 234     end
 235   end
 236
 237   def format_naive_asctime(date) do
 238     date |> DateTime.from_naive!("Etc/UTC") |> format_asctime
 239   end
 240
 241   def format_asctime(date) do
 242     Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
 243   end
 244
 245   def date_to_asctime(date) when is_binary(date) do
 246     with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
 247       format_asctime(date)
 248     else
 249       _e ->
 250         Logger.warn("Date #{date} in wrong format, must be ISO 8601")
 251         ""
 252     end
 253   end
 254
 255   def date_to_asctime(date) do
 256     Logger.warn("Date #{date} in wrong format, must be ISO 8601")
 257     ""
 258   end
 259
 260   def to_masto_date(%NaiveDateTime{} = date) do
 261     date
 262     |> NaiveDateTime.to_iso8601()
 263     |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 264   end
 265
 266   def to_masto_date(date) do
 267     try do
 268       date
 269       |> NaiveDateTime.from_iso8601!()
 270       |> NaiveDateTime.to_iso8601()
 271       |> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
 272     rescue
 273       _e -> ""
 274     end
 275   end
 276
 277   defp shortname(name) do
 278     if String.length(name) < 30 do
 279       name
 280     else
 281       String.slice(name, 0..30) <> "…"
 282     end
 283   end
 284
 285   def confirm_current_password(user, password) do
 286     with %User{local: true} = db_user <- User.get_by_id(user.id),
 287          true <- Pbkdf2.checkpw(password, db_user.password_hash) do
 288       {:ok, db_user}
 289     else
 290       _ -> {:error, "Invalid password."}
 291     end
 292   end
 293
 294   def emoji_from_profile(%{info: _info} = user) do
 295     (Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
 296     |> Enum.map(fn {shortcode, url, _} ->
 297       %{
 298         "type" => "Emoji",
 299         "icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
 300         "name" => ":#{shortcode}:"
 301       }
 302     end)
 303   end
 304
 305   def maybe_notify_to_recipients(
 306         recipients,
 307         %Activity{data: %{"to" => to, "type" => _type}} = _activity
 308       ) do
 309     recipients ++ to
 310   end
 311
 312   def maybe_notify_mentioned_recipients(
 313         recipients,
 314         %Activity{data: %{"to" => _to, "type" => type} = data} = activity
 315       )
 316       when type == "Create" do
 317     object = Object.normalize(activity)
 318
 319     object_data =
 320       cond do
 321         !is_nil(object) ->
 322           object.data
 323
 324         is_map(data["object"]) ->
 325           data["object"]
 326
 327         true ->
 328           %{}
 329       end
 330
 331     tagged_mentions = maybe_extract_mentions(object_data)
 332
 333     recipients ++ tagged_mentions
 334   end
 335
 336   def maybe_notify_mentioned_recipients(recipients, _), do: recipients
 337
 338   def maybe_notify_subscribers(
 339         recipients,
 340         %Activity{data: %{"actor" => actor, "type" => type}} = activity
 341       )
 342       when type == "Create" do
 343     with %User{} = user <- User.get_cached_by_ap_id(actor) do
 344       subscriber_ids =
 345         user
 346         |> User.subscribers()
 347         |> Enum.filter(&Visibility.visible_for_user?(activity, &1))
 348         |> Enum.map(& &1.ap_id)
 349
 350       recipients ++ subscriber_ids
 351     end
 352   end
 353
 354   def maybe_notify_subscribers(recipients, _), do: recipients
 355
 356   def maybe_extract_mentions(%{"tag" => tag}) do
 357     tag
 358     |> Enum.filter(fn x -> is_map(x) end)
 359     |> Enum.filter(fn x -> x["type"] == "Mention" end)
 360     |> Enum.map(fn x -> x["href"] end)
 361   end
 362
 363   def maybe_extract_mentions(_), do: []
 364
 365   def make_report_content_html(nil), do: {:ok, {nil, [], []}}
 366
 367   def make_report_content_html(comment) do
 368     max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
 369
 370     if String.length(comment) <= max_size do
 371       {:ok, format_input(comment, "text/plain")}
 372     else
 373       {:error, "Comment must be up to #{max_size} characters"}
 374     end
 375   end
 376
 377   def get_report_statuses(%User{ap_id: actor}, %{"status_ids" => status_ids}) do
 378     {:ok, Activity.all_by_actor_and_id(actor, status_ids)}
 379   end
 380
 381   def get_report_statuses(_, _), do: {:ok, nil}
 382
 383   # DEPRECATED mostly, context objects are now created at insertion time.
 384   def context_to_conversation_id(context) do
 385     with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
 386       id
 387     else
 388       _e ->
 389         changeset = Object.context_mapping(context)
 390
 391         case Repo.insert(changeset) do
 392           {:ok, %{id: id}} ->
 393             id
 394
 395           # This should be solved by an upsert, but it seems ecto
 396           # has problems accessing the constraint inside the jsonb.
 397           {:error, _} ->
 398             Object.get_cached_by_ap_id(context).id
 399         end
 400     end
 401   end
 402
 403   def conversation_id_to_context(id) do
 404     with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
 405       context
 406     else
 407       _e ->
 408         {:error, "No such conversation"}
 409     end
 410   end
 411 end