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

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