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       _ ->
 265         {:error, dgettext("errors", "Could not add reaction emoji")}
 266     end
 267   end
 268
 269   def unreact_with_emoji(id, user, emoji) do
 270     with %Activity{} = reaction_activity <- Utils.get_latest_reaction(id, user, emoji),
 271          {:ok, undo, _} <- Builder.undo(user, reaction_activity),
 272          {:ok, activity, _} <- Pipeline.common_pipeline(undo, local: true) do
 273       {:ok, activity}
 274     else
 275       _ ->
 276         {:error, dgettext("errors", "Could not remove reaction emoji")}
 277     end
 278   end
 279
 280   def vote(user, %{data: %{"type" => "Question"}} = object, choices) do
 281     with :ok <- validate_not_author(object, user),
 282          :ok <- validate_existing_votes(user, object),
 283          {:ok, options, choices} <- normalize_and_validate_choices(choices, object) do
 284       answer_activities =
 285         Enum.map(choices, fn index ->
 286           {:ok, answer_object, _meta} =
 287             Builder.answer(user, object, Enum.at(options, index)["name"])
 288
 289           {:ok, activity_data, _meta} = Builder.create(user, answer_object, [])
 290
 291           {:ok, activity, _meta} =
 292             activity_data
 293             |> Map.put("cc", answer_object["cc"])
 294             |> Map.put("context", answer_object["context"])
 295             |> Pipeline.common_pipeline(local: true)
 296
 297           # TODO: Do preload of Pleroma.Object in Pipeline
 298           Activity.normalize(activity.data)
 299         end)
 300
 301       object = Object.get_cached_by_ap_id(object.data["id"])
 302       {:ok, answer_activities, object}
 303     end
 304   end
 305
 306   defp validate_not_author(%{data: %{"actor" => ap_id}}, %{ap_id: ap_id}),
 307     do: {:error, dgettext("errors", "Poll's author can't vote")}
 308
 309   defp validate_not_author(_, _), do: :ok
 310
 311   defp validate_existing_votes(%{ap_id: ap_id}, object) do
 312     if Utils.get_existing_votes(ap_id, object) == [] do
 313       :ok
 314     else
 315       {:error, dgettext("errors", "Already voted")}
 316     end
 317   end
 318
 319   defp get_options_and_max_count(%{data: %{"anyOf" => any_of}})
 320        when is_list(any_of) and any_of != [],
 321        do: {any_of, Enum.count(any_of)}
 322
 323   defp get_options_and_max_count(%{data: %{"oneOf" => one_of}})
 324        when is_list(one_of) and one_of != [],
 325        do: {one_of, 1}
 326
 327   defp normalize_and_validate_choices(choices, object) do
 328     choices = Enum.map(choices, fn i -> if is_binary(i), do: String.to_integer(i), else: i end)
 329     {options, max_count} = get_options_and_max_count(object)
 330     count = Enum.count(options)
 331
 332     with {_, true} <- {:valid_choice, Enum.all?(choices, &(&1 < count))},
 333          {_, true} <- {:count_check, Enum.count(choices) <= max_count} do
 334       {:ok, options, choices}
 335     else
 336       {:valid_choice, _} -> {:error, dgettext("errors", "Invalid indices")}
 337       {:count_check, _} -> {:error, dgettext("errors", "Too many choices")}
 338     end
 339   end
 340
 341   def public_announce?(_, %{visibility: visibility})
 342       when visibility in ~w{public unlisted private direct},
 343       do: visibility in ~w(public unlisted)
 344
 345   def public_announce?(object, _) do
 346     Visibility.is_public?(object)
 347   end
 348
 349   def get_visibility(_, _, %Participation{}), do: {"direct", "direct"}
 350
 351   def get_visibility(%{visibility: visibility}, in_reply_to, _)
 352       when visibility in ~w{public local unlisted private direct},
 353       do: {visibility, get_replied_to_visibility(in_reply_to)}
 354
 355   def get_visibility(%{visibility: "list:" <> list_id}, in_reply_to, _) do
 356     visibility = {:list, String.to_integer(list_id)}
 357     {visibility, get_replied_to_visibility(in_reply_to)}
 358   end
 359
 360   def get_visibility(_, in_reply_to, _) when not is_nil(in_reply_to) do
 361     visibility = get_replied_to_visibility(in_reply_to)
 362     {visibility, visibility}
 363   end
 364
 365   def get_visibility(_, in_reply_to, _), do: {"public", get_replied_to_visibility(in_reply_to)}
 366
 367   def get_replied_to_visibility(nil), do: nil
 368
 369   def get_replied_to_visibility(activity) do
 370     with %Object{} = object <- Object.normalize(activity, fetch: false) do
 371       Visibility.get_visibility(object)
 372     end
 373   end
 374
 375   def check_expiry_date({:ok, nil} = res), do: res
 376
 377   def check_expiry_date({:ok, in_seconds}) do
 378     expiry = DateTime.add(DateTime.utc_now(), in_seconds)
 379
 380     if Pleroma.Workers.PurgeExpiredActivity.expires_late_enough?(expiry) do
 381       {:ok, expiry}
 382     else
 383       {:error, "Expiry date is too soon"}
 384     end
 385   end
 386
 387   def check_expiry_date(expiry_str) do
 388     Ecto.Type.cast(:integer, expiry_str)
 389     |> check_expiry_date()
 390   end
 391
 392   def listen(user, data) do
 393     with {:ok, draft} <- ActivityDraft.listen(user, data) do
 394       ActivityPub.listen(draft.changes)
 395     end
 396   end
 397
 398   def post(user, %{status: _} = data) do
 399     with {:ok, draft} <- ActivityDraft.create(user, data) do
 400       activity = ActivityPub.create(draft.changes, draft.preview?)
 401       unless draft.preview? do
 402         Pleroma.Elasticsearch.maybe_put_into_elasticsearch(activity)
 403       end
 404       activity
 405     end
 406   end
 407
 408   @spec pin(String.t(), User.t()) :: {:ok, Activity.t()} | {:error, term()}
 409   def pin(id, %User{} = user) do
 410     with %Activity{} = activity <- create_activity_by_id(id),
 411          true <- activity_belongs_to_actor(activity, user.ap_id),
 412          true <- object_type_is_allowed_for_pin(activity.object),
 413          true <- activity_is_public(activity),
 414          {:ok, pin_data, _} <- Builder.pin(user, activity.object),
 415          {:ok, _pin, _} <-
 416            Pipeline.common_pipeline(pin_data,
 417              local: true,
 418              activity_id: id
 419            ) do
 420       {:ok, activity}
 421     else
 422       {:error, {:side_effects, error}} -> error
 423       error -> error
 424     end
 425   end
 426
 427   defp create_activity_by_id(id) do
 428     with nil <- Activity.create_by_id_with_object(id) do
 429       {:error, :not_found}
 430     end
 431   end
 432
 433   defp activity_belongs_to_actor(%{actor: actor}, actor), do: true
 434   defp activity_belongs_to_actor(_, _), do: {:error, :ownership_error}
 435
 436   defp object_type_is_allowed_for_pin(%{data: %{"type" => type}}) do
 437     with false <- type in ["Note", "Article", "Question"] do
 438       {:error, :not_allowed}
 439     end
 440   end
 441
 442   defp activity_is_public(activity) do
 443     with false <- Visibility.is_public?(activity) do
 444       {:error, :visibility_error}
 445     end
 446   end
 447
 448   @spec unpin(String.t(), User.t()) :: {:ok, User.t()} | {:error, term()}
 449   def unpin(id, user) do
 450     with %Activity{} = activity <- create_activity_by_id(id),
 451          {:ok, unpin_data, _} <- Builder.unpin(user, activity.object),
 452          {:ok, _unpin, _} <-
 453            Pipeline.common_pipeline(unpin_data,
 454              local: true,
 455              activity_id: activity.id,
 456              expires_at: activity.data["expires_at"],
 457              featured_address: user.featured_address
 458            ) do
 459       {:ok, activity}
 460     end
 461   end
 462
 463   def add_mute(user, activity, params \\ %{}) do
 464     expires_in = Map.get(params, :expires_in, 0)
 465
 466     with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]),
 467          _ <- Pleroma.Notification.mark_context_as_read(user, activity.data["context"]) do
 468       if expires_in > 0 do
 469         Pleroma.Workers.MuteExpireWorker.enqueue(
 470           "unmute_conversation",
 471           %{"user_id" => user.id, "activity_id" => activity.id},
 472           schedule_in: expires_in
 473         )
 474       end
 475
 476       {:ok, activity}
 477     else
 478       {:error, _} -> {:error, dgettext("errors", "conversation is already muted")}
 479     end
 480   end
 481
 482   def remove_mute(%User{} = user, %Activity{} = activity) do
 483     ThreadMute.remove_mute(user.id, activity.data["context"])
 484     {:ok, activity}
 485   end
 486
 487   def remove_mute(user_id, activity_id) do
 488     with {:user, %User{} = user} <- {:user, User.get_by_id(user_id)},
 489          {:activity, %Activity{} = activity} <- {:activity, Activity.get_by_id(activity_id)} do
 490       remove_mute(user, activity)
 491     else
 492       {what, result} = error ->
 493         Logger.warn(
 494           "CommonAPI.remove_mute/2 failed. #{what}: #{result}, user_id: #{user_id}, activity_id: #{activity_id}"
 495         )
 496
 497         {:error, error}
 498     end
 499   end
 500
 501   def thread_muted?(%User{id: user_id}, %{data: %{"context" => context}})
 502       when is_binary(context) do
 503     ThreadMute.exists?(user_id, context)
 504   end
 505
 506   def thread_muted?(_, _), do: false
 507
 508   def report(user, data) do
 509     with {:ok, account} <- get_reported_account(data.account_id),
 510          {:ok, {content_html, _, _}} <- make_report_content_html(data[:comment]),
 511          {:ok, statuses} <- get_report_statuses(account, data) do
 512       ActivityPub.flag(%{
 513         context: Utils.generate_context_id(),
 514         actor: user,
 515         account: account,
 516         statuses: statuses,
 517         content: content_html,
 518         forward: Map.get(data, :forward, false)
 519       })
 520     end
 521   end
 522
 523   defp get_reported_account(account_id) do
 524     case User.get_cached_by_id(account_id) do
 525       %User{} = account -> {:ok, account}
 526       _ -> {:error, dgettext("errors", "Account not found")}
 527     end
 528   end
 529
 530   def update_report_state(activity_ids, state) when is_list(activity_ids) do
 531     case Utils.update_report_state(activity_ids, state) do
 532       :ok -> {:ok, activity_ids}
 533       _ -> {:error, dgettext("errors", "Could not update state")}
 534     end
 535   end
 536
 537   def update_report_state(activity_id, state) do
 538     with %Activity{} = activity <- Activity.get_by_id(activity_id) do
 539       Utils.update_report_state(activity, state)
 540     else
 541       nil -> {:error, :not_found}
 542       _ -> {:error, dgettext("errors", "Could not update state")}
 543     end
 544   end
 545
 546   def update_activity_scope(activity_id, opts \\ %{}) do
 547     with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
 548          {:ok, activity} <- toggle_sensitive(activity, opts) do
 549       set_visibility(activity, opts)
 550     else
 551       nil -> {:error, :not_found}
 552       {:error, reason} -> {:error, reason}
 553     end
 554   end
 555
 556   defp toggle_sensitive(activity, %{sensitive: sensitive}) when sensitive in ~w(true false) do
 557     toggle_sensitive(activity, %{sensitive: String.to_existing_atom(sensitive)})
 558   end
 559
 560   defp toggle_sensitive(%Activity{object: object} = activity, %{sensitive: sensitive})
 561        when is_boolean(sensitive) do
 562     new_data = Map.put(object.data, "sensitive", sensitive)
 563
 564     {:ok, object} =
 565       object
 566       |> Object.change(%{data: new_data})
 567       |> Object.update_and_set_cache()
 568
 569     {:ok, Map.put(activity, :object, object)}
 570   end
 571
 572   defp toggle_sensitive(activity, _), do: {:ok, activity}
 573
 574   defp set_visibility(activity, %{visibility: visibility}) do
 575     Utils.update_activity_visibility(activity, visibility)
 576   end
 577
 578   defp set_visibility(activity, _), do: {:ok, activity}
 579
 580   def hide_reblogs(%User{} = user, %User{} = target) do
 581     UserRelationship.create_reblog_mute(user, target)
 582   end
 583
 584   def show_reblogs(%User{} = user, %User{} = target) do
 585     UserRelationship.delete_reblog_mute(user, target)
 586   end
 587
 588   def get_user(ap_id, fake_record_fallback \\ true) do
 589     cond do
 590       user = User.get_cached_by_ap_id(ap_id) ->
 591         user
 592
 593       user = User.get_by_guessed_nickname(ap_id) ->
 594         user
 595
 596       fake_record_fallback ->
 597         # TODO: refactor (fake records is never a good idea)
 598         User.error_user(ap_id)
 599
 600       true ->
 601         nil
 602     end
 603   end
 604 end