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