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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.CommonAPI do
   6   alias Pleroma.Activity
   7   alias Pleroma.Conversation.Participation
   8   alias Pleroma.Formatter
   9   alias Pleroma.Object
  10   alias Pleroma.ThreadMute
  11   alias Pleroma.User
  12   alias Pleroma.UserRelationship
  13   alias Pleroma.Web.ActivityPub.ActivityPub
  14   alias Pleroma.Web.ActivityPub.Builder
  15   alias Pleroma.Web.ActivityPub.Pipeline
  16   alias Pleroma.Web.ActivityPub.Utils
  17   alias Pleroma.Web.ActivityPub.Visibility
  18   alias Pleroma.Web.CommonAPI.ActivityDraft
  19
  20   import Pleroma.Web.Gettext
  21   import Pleroma.Web.CommonAPI.Utils
  22
  23   require Pleroma.Constants
  24   require Logger
  25
  26   def block(blocker, blocked) do
  27     with {:ok, block_data, _} <- Builder.block(blocker, blocked),
  28          {:ok, block, _} <- Pipeline.common_pipeline(block_data, local: true) do
  29       {:ok, block}
  30     end
  31   end
  32
  33   def post_chat_message(%User{} = user, %User{} = recipient, content, opts \\ []) do
  34     with maybe_attachment <- opts[:media_id] && Object.get_by_id(opts[:media_id]),
  35          :ok <- validate_chat_content_length(content, !!maybe_attachment),
  36          {_, {:ok, chat_message_data, _meta}} <-
  37            {:build_object,
  38             Builder.chat_message(
  39               user,
  40               recipient.ap_id,
  41               content |> format_chat_content,
  42               attachment: maybe_attachment
  43             )},
  44          {_, {:ok, create_activity_data, _meta}} <-
  45            {:build_create_activity, Builder.create(user, chat_message_data, [recipient.ap_id])},
  46          {_, {:ok, %Activity{} = activity, _meta}} <-
  47            {:common_pipeline,
  48             Pipeline.common_pipeline(create_activity_data,
  49               local: true
  50             )} do
  51       {:ok, activity}
  52     else
  53       {:common_pipeline, {:reject, _} = e} -> e
  54       e -> e
  55     end
  56   end
  57
  58   defp format_chat_content(nil), do: nil
  59
  60   defp format_chat_content(content) do
  61     {text, _, _} =
  62       content
  63       |> Formatter.html_escape("text/plain")
  64       |> Formatter.linkify()
  65       |> (fn {text, mentions, tags} ->
  66             {String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
  67           end).()
  68
  69     text
  70   end
  71
  72   defp validate_chat_content_length(_, true), do: :ok
  73   defp validate_chat_content_length(nil, false), do: {:error, :no_content}
  74
  75   defp validate_chat_content_length(content, _) do
  76     if String.length(content) <= Pleroma.Config.get([:instance, :chat_limit]) do
  77       :ok
  78     else
  79       {:error, :content_too_long}
  80     end
  81   end
  82
  83   def unblock(blocker, blocked) do
  84     with {_, %Activity{} = block} <- {:fetch_block, Utils.fetch_latest_block(blocker, blocked)},
  85          {:ok, unblock_data, _} <- Builder.undo(blocker, block),
  86          {:ok, unblock, _} <- Pipeline.common_pipeline(unblock_data, local: true) do
  87       {:ok, unblock}
  88     else
  89       {:fetch_block, nil} ->
  90         if User.blocks?(blocker, blocked) do
  91           User.unblock(blocker, blocked)
  92           {:ok, :no_activity}
  93         else
  94           {:error, :not_blocking}
  95         end
  96
  97       e ->
  98         e
  99     end
 100   end
 101
 102   def follow(follower, followed) do
 103     timeout = Pleroma.Config.get([:activitypub, :follow_handshake_timeout])
 104
 105     with {:ok, follow_data, _} <- Builder.follow(follower, followed),
 106          {:ok, activity, _} <- Pipeline.common_pipeline(follow_data, local: true),
 107          {:ok, follower, followed} <- User.wait_and_refresh(timeout, follower, followed) do
 108       if activity.data["state"] == "reject" do
 109         {:error, :rejected}
 110       else
 111         {:ok, follower, followed, activity}
 112       end
 113     end
 114   end
 115
 116   def unfollow(follower, unfollowed) do
 117     with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
 118          {:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed),
 119          {:ok, _subscription} <- User.unsubscribe(follower, unfollowed) do
 120       {:ok, follower}
 121     end
 122   end
 123
 124   def accept_follow_request(follower, followed) do
 125     with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 126          {:ok, accept_data, _} <- Builder.accept(followed, follow_activity),
 127          {:ok, _activity, _} <- Pipeline.common_pipeline(accept_data, local: true) do
 128       {:ok, follower}
 129     end
 130   end
 131
 132   def reject_follow_request(follower, followed) do
 133     with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
 134          {:ok, reject_data, _} <- Builder.reject(followed, follow_activity),
 135          {:ok, _activity, _} <- Pipeline.common_pipeline(reject_data, local: true) do
 136       {:ok, follower}
 137     end
 138   end
 139
 140   def delete(activity_id, user) do
 141     with {_, %Activity{data: %{"object" => _, "type" => "Create"}} = activity} <-
 142            {:find_activity, Activity.get_by_id(activity_id)},
 143          {_, %Object{} = object, _} <-
 144            {:find_object, Object.normalize(activity, false), activity},
 145          true <- User.superuser?(user) || user.ap_id == object.data["actor"],
 146          {:ok, delete_data, _} <- Builder.delete(user, object.data["id"]),
 147          {:ok, delete, _} <- Pipeline.common_pipeline(delete_data, local: true) do
 148       {:ok, delete}
 149     else
 150       {:find_activity, _} ->
 151         {:error, :not_found}
 152
 153       {:find_object, nil, %Activity{data: %{"actor" => actor, "object" => object}}} ->
 154         # We have the create activity, but not the object, it was probably pruned.
 155         # Insert a tombstone and try again
 156         with {:ok, tombstone_data, _} <- Builder.tombstone(actor, object),
 157              {:ok, _tombstone} <- Object.create(tombstone_data) do
 158           delete(activity_id, user)
 159         else
 160           _ ->
 161             Logger.error(
 162               "Could not insert tombstone for missing object on deletion. Object is #{object}."
 163             )
 164
 165             {:error, dgettext("errors", "Could not delete")}
 166         end
 167
 168       _ ->
 169         {:error, dgettext("errors", "Could not delete")}
 170     end
 171   end
 172
 173   def repeat(id, user, params \\ %{}) do
 174     with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id(id),
 175          object = %Object{} <- Object.normalize(activity, false),
 176          {_, nil} <- {:existing_announce, Utils.get_existing_announce(user.ap_id, object)},
 177          public = public_announce?(object, params),
 178          {:ok, announce, _} <- Builder.announce(user, object, public: public),
 179          {:ok, activity, _} <- Pipeline.common_pipeline(announce, local: true) do
 180       {:ok, activity}
 181     else
 182       {:existing_announce, %Activity{} = announce} ->
 183         {:ok, announce}
 184
 185       _ ->
 186         {:error, :not_found}
 187     end
 188   end
 189
 190   def unrepeat(id, user) do
 191     with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
 192            {:find_activity, Activity.get_by_id(id)},
 193          %Object{} = note <- Object.normalize(activity, false),
 194          %Activity{} = announce <- Utils.get_existing_announce(user.ap_id, note),
 195          {:ok, undo, _} <- Builder.undo(user, announce),
 196          {:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
 197       {:ok, activity}
 198     else
 199       {:find_activity, _} -> {:error, :not_found}
 200       _ -> {:error, dgettext("errors", "Could not unrepeat")}
 201     end
 202   end
 203
 204   @spec favorite(User.t(), binary()) :: {:ok, Activity.t() | :already_liked} | {:error, any()}
 205   def favorite(%User{} = user, id) do
 206     case favorite_helper(user, id) do
 207       {:ok, _} = res ->
 208         res
 209
 210       {:error, :not_found} = res ->
 211         res
 212
 213       {:error, e} ->
 214         Logger.error("Could not favorite #{id}. Error: #{inspect(e, pretty: true)}")
 215         {:error, dgettext("errors", "Could not favorite")}
 216     end
 217   end
 218
 219   def favorite_helper(user, id) do
 220     with {_, %Activity{object: object}} <- {:find_object, Activity.get_by_id_with_object(id)},
 221          {_, {:ok, like_object, meta}} <- {:build_object, Builder.like(user, object)},
 222          {_, {:ok, %Activity{} = activity, _meta}} <-
 223            {:common_pipeline,
 224             Pipeline.common_pipeline(like_object, Keyword.put(meta, :local, true))} do
 225       {:ok, activity}
 226     else
 227       {:find_object, _} ->
 228         {:error, :not_found}
 229
 230       {:common_pipeline,
 231        {
 232          :error,
 233          {
 234            :validate_object,
 235            {
 236              :error,
 237              changeset
 238            }
 239          }
 240        }} = e ->
 241         if {:object, {"already liked by this actor", []}} in changeset.errors do
 242           {:ok, :already_liked}
 243         else
 244           {:error, e}
 245         end
 246
 247       e ->
 248         {:error, e}
 249     end
 250   end
 251
 252   def unfavorite(id, user) do
 253     with {_, %Activity{data: %{"type" => "Create"}} = activity} <-
 254            {:find_activity, Activity.get_by_id(id)},
 255          %Object{} = note <- Object.normalize(activity, false),
 256          %Activity{} = like <- Utils.get_existing_like(user.ap_id, note),
 257          {:ok, undo, _} <- Builder.undo(user, like),
 258          {:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
 259       {:ok, activity}
 260     else
 261       {:find_activity, _} -> {:error, :not_found}
 262       _ -> {:error, dgettext("errors", "Could not unfavorite")}
 263     end
 264   end
 265
 266   def react_with_emoji(id, user, emoji) do
 267     with %Activity{} = activity <- Activity.get_by_id(id),
 268          object <- Object.normalize(activity),
 269          {:ok, emoji_react, _} <- Builder.emoji_react(user, object, emoji),
 270          {:ok, activity, _} <- Pipeline.common_pipeline(emoji_react, local: true) do
 271       {:ok, activity}
 272     else
 273       _ ->
 274         {:error, dgettext("errors", "Could not add reaction emoji")}
 275     end
 276   end
 277
 278   def unreact_with_emoji(id, user, emoji) do
 279     with %Activity{} = reaction_activity <- Utils.get_latest_reaction(id, user, emoji),
 280          {:ok, undo, _} <- Builder.undo(user, reaction_activity),
 281          {:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
 282       {:ok, activity}
 283     else
 284       _ ->
 285         {:error, dgettext("errors", "Could not remove reaction emoji")}
 286     end
 287   end
 288
 289   def vote(user, %{data: %{"type" => "Question"}} = object, choices) do
 290     with :ok <- validate_not_author(object, user),
 291          :ok <- validate_existing_votes(user, object),
 292          {:ok, options, choices} <- normalize_and_validate_choices(choices, object) do
 293       answer_activities =
 294         Enum.map(choices, fn index ->
 295           {:ok, answer_object, _meta} =
 296             Builder.answer(user, object, Enum.at(options, index)["name"])
 297
 298           {:ok, activity_data, _meta} = Builder.create(user, answer_object, [])
 299
 300           {:ok, activity, _meta} =
 301             activity_data
 302             |> Map.put("cc", answer_object["cc"])
 303             |> Map.put("context", answer_object["context"])
 304             |> Pipeline.common_pipeline(local: true)
 305
 306           # TODO: Do preload of Pleroma.Object in Pipeline
 307           Activity.normalize(activity.data)
 308         end)
 309
 310       object = Object.get_cached_by_ap_id(object.data["id"])
 311       {:ok, answer_activities, object}
 312     end
 313   end
 314
 315   defp validate_not_author(%{data: %{"actor" => ap_id}}, %{ap_id: ap_id}),
 316     do: {:error, dgettext("errors", "Poll's author can't vote")}
 317
 318   defp validate_not_author(_, _), do: :ok
 319
 320   defp validate_existing_votes(%{ap_id: ap_id}, object) do
 321     if Utils.get_existing_votes(ap_id, object) == [] do
 322       :ok
 323     else
 324       {:error, dgettext("errors", "Already voted")}
 325     end
 326   end
 327
 328   defp get_options_and_max_count(%{data: %{"anyOf" => any_of}})
 329        when is_list(any_of) and any_of != [],
 330        do: {any_of, Enum.count(any_of)}
 331
 332   defp get_options_and_max_count(%{data: %{"oneOf" => one_of}})
 333        when is_list(one_of) and one_of != [],
 334        do: {one_of, 1}
 335
 336   defp normalize_and_validate_choices(choices, object) do
 337     choices = Enum.map(choices, fn i -> if is_binary(i), do: String.to_integer(i), else: i end)
 338     {options, max_count} = get_options_and_max_count(object)
 339     count = Enum.count(options)
 340
 341     with {_, true} <- {:valid_choice, Enum.all?(choices, &(&1 < count))},
 342          {_, true} <- {:count_check, Enum.count(choices) <= max_count} do
 343       {:ok, options, choices}
 344     else
 345       {:valid_choice, _} -> {:error, dgettext("errors", "Invalid indices")}
 346       {:count_check, _} -> {:error, dgettext("errors", "Too many choices")}
 347     end
 348   end
 349
 350   def public_announce?(_, %{visibility: visibility})
 351       when visibility in ~w{public unlisted private direct},
 352       do: visibility in ~w(public unlisted)
 353
 354   def public_announce?(object, _) do
 355     Visibility.is_public?(object)
 356   end
 357
 358   def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}
 359
 360   def get_visibility(%{visibility: visibility}, in_reply_to, _)
 361       when visibility in ~w{public unlisted private direct},
 362       do: {visibility, get_replied_to_visibility(in_reply_to)}
 363
 364   def get_visibility(%{visibility: "list:" <> list_id}, in_reply_to, _) do
 365     visibility = {:list, String.to_integer(list_id)}
 366     {visibility, get_replied_to_visibility(in_reply_to)}
 367   end
 368
 369   def get_visibility(_, in_reply_to, _) when not is_nil(in_reply_to) do
 370     visibility = get_replied_to_visibility(in_reply_to)
 371     {visibility, visibility}
 372   end
 373
 374   def get_visibility(_, in_reply_to, _), do: {"public", get_replied_to_visibility(in_reply_to)}
 375
 376   def get_replied_to_visibility(nil), do: nil
 377
 378   def get_replied_to_visibility(activity) do
 379     with %Object{} = object <- Object.normalize(activity) do
 380       Visibility.get_visibility(object)
 381     end
 382   end
 383
 384   def check_expiry_date({:ok, nil} = res), do: res
 385
 386   def check_expiry_date({:ok, in_seconds}) do
 387     expiry = DateTime.add(DateTime.utc_now(), in_seconds)
 388
 389     if Pleroma.Workers.PurgeExpiredActivity.expires_late_enough?(expiry) do
 390       {:ok, expiry}
 391     else
 392       {:error, "Expiry date is too soon"}
 393     end
 394   end
 395
 396   def check_expiry_date(expiry_str) do
 397     Ecto.Type.cast(:integer, expiry_str)
 398     |> check_expiry_date()
 399   end
 400
 401   def listen(user, data) do
 402     with {:ok, draft} <- ActivityDraft.listen(user, data) do
 403       ActivityPub.listen(draft.changes)
 404     end
 405   end
 406
 407   def post(user, %{status: _} = data) do
 408     with {:ok, draft} <- ActivityDraft.create(user, data) do
 409       ActivityPub.create(draft.changes, draft.preview?)
 410     end
 411   end
 412
 413   def pin(id, %{ap_id: user_ap_id} = user) do
 414     with %Activity{
 415            actor: ^user_ap_id,
 416            data: %{"type" => "Create"},
 417            object: %Object{data: %{"type" => object_type}}
 418          } = activity <- Activity.get_by_id_with_object(id),
 419          true <- object_type in ["Note", "Article", "Question"],
 420          true <- Visibility.is_public?(activity),
 421          {:ok, _user} <- User.add_pinnned_activity(user, activity) do
 422       {:ok, activity}
 423     else
 424       {:error, %{errors: [pinned_activities: {err, _}]}} -> {:error, err}
 425       _ -> {:error, dgettext("errors", "Could not pin")}
 426     end
 427   end
 428
 429   def unpin(id, user) do
 430     with %Activity{data: %{"type" => "Create"}} = activity <- Activity.get_by_id(id),
 431          {:ok, _user} <- User.remove_pinnned_activity(user, activity) do
 432       {:ok, activity}
 433     else
 434       {:error, %{errors: [pinned_activities: {err, _}]}} -> {:error, err}
 435       _ -> {:error, dgettext("errors", "Could not unpin")}
 436     end
 437   end
 438
 439   def add_mute(user, activity) do
 440     with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]),
 441          _ <- Pleroma.Notification.mark_context_as_read(user, activity.data["context"]) do
 442       {:ok, activity}
 443     else
 444       {:error, _} -> {:error, dgettext("errors", "conversation is already muted")}
 445     end
 446   end
 447
 448   def remove_mute(user, activity) do
 449     ThreadMute.remove_mute(user.id, activity.data["context"])
 450     {:ok, activity}
 451   end
 452
 453   def thread_muted?(%User{id: user_id}, %{data: %{"context" => context}})
 454       when is_binary(context) do
 455     ThreadMute.exists?(user_id, context)
 456   end
 457
 458   def thread_muted?(_, _), do: false
 459
 460   def report(user, data) do
 461     with {:ok, account} <- get_reported_account(data.account_id),
 462          {:ok, {content_html, _, _}} <- make_report_content_html(data[:comment]),
 463          {:ok, statuses} <- get_report_statuses(account, data) do
 464       ActivityPub.flag(%{
 465         context: Utils.generate_context_id(),
 466         actor: user,
 467         account: account,
 468         statuses: statuses,
 469         content: content_html,
 470         forward: Map.get(data, :forward, false)
 471       })
 472     end
 473   end
 474
 475   defp get_reported_account(account_id) do
 476     case User.get_cached_by_id(account_id) do
 477       %User{} = account -> {:ok, account}
 478       _ -> {:error, dgettext("errors", "Account not found")}
 479     end
 480   end
 481
 482   def update_report_state(activity_ids, state) when is_list(activity_ids) do
 483     case Utils.update_report_state(activity_ids, state) do
 484       :ok -> {:ok, activity_ids}
 485       _ -> {:error, dgettext("errors", "Could not update state")}
 486     end
 487   end
 488
 489   def update_report_state(activity_id, state) do
 490     with %Activity{} = activity <- Activity.get_by_id(activity_id) do
 491       Utils.update_report_state(activity, state)
 492     else
 493       nil -> {:error, :not_found}
 494       _ -> {:error, dgettext("errors", "Could not update state")}
 495     end
 496   end
 497
 498   def update_activity_scope(activity_id, opts \\ %{}) do
 499     with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
 500          {:ok, activity} <- toggle_sensitive(activity, opts) do
 501       set_visibility(activity, opts)
 502     else
 503       nil -> {:error, :not_found}
 504       {:error, reason} -> {:error, reason}
 505     end
 506   end
 507
 508   defp toggle_sensitive(activity, %{sensitive: sensitive}) when sensitive in ~w(true false) do
 509     toggle_sensitive(activity, %{sensitive: String.to_existing_atom(sensitive)})
 510   end
 511
 512   defp toggle_sensitive(%Activity{object: object} = activity, %{sensitive: sensitive})
 513        when is_boolean(sensitive) do
 514     new_data = Map.put(object.data, "sensitive", sensitive)
 515
 516     {:ok, object} =
 517       object
 518       |> Object.change(%{data: new_data})
 519       |> Object.update_and_set_cache()
 520
 521     {:ok, Map.put(activity, :object, object)}
 522   end
 523
 524   defp toggle_sensitive(activity, _), do: {:ok, activity}
 525
 526   defp set_visibility(activity, %{visibility: visibility}) do
 527     Utils.update_activity_visibility(activity, visibility)
 528   end
 529
 530   defp set_visibility(activity, _), do: {:ok, activity}
 531
 532   def hide_reblogs(%User{} = user, %User{} = target) do
 533     UserRelationship.create_reblog_mute(user, target)
 534   end
 535
 536   def show_reblogs(%User{} = user, %User{} = target) do
 537     UserRelationship.delete_reblog_mute(user, target)
 538   end
 539
 540   def get_user(ap_id, fake_record_fallback \\ true) do
 541     cond do
 542       user = User.get_cached_by_ap_id(ap_id) ->
 543         user
 544
 545       user = User.get_by_guessed_nickname(ap_id) ->
 546         user
 547
 548       fake_record_fallback ->
 549         # TODO: refactor (fake records is never a good idea)
 550         User.error_user(ap_id)
 551
 552       true ->
 553         nil
 554     end
 555   end
 556 end