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       ActivityPub.create(draft.changes, draft.preview?)
 401     end
 402   end
 403
 404   @spec pin(String.t(), User.t()) :: {:ok, Activity.t()} | {:error, term()}
 405   def pin(id, %User{} = user) do
 406     with %Activity{} = activity <- create_activity_by_id(id),
 407          true <- activity_belongs_to_actor(activity, user.ap_id),
 408          true <- object_type_is_allowed_for_pin(activity.object),
 409          true <- activity_is_public(activity),
 410          {:ok, pin_data, _} <- Builder.pin(user, activity.object),
 411          {:ok, _pin, _} <-
 412            Pipeline.common_pipeline(pin_data,
 413              local: true,
 414              activity_id: id
 415            ) do
 416       {:ok, activity}
 417     else
 418       {:error, {:side_effects, error}} -> error
 419       error -> error
 420     end
 421   end
 422
 423   defp create_activity_by_id(id) do
 424     with nil <- Activity.create_by_id_with_object(id) do
 425       {:error, :not_found}
 426     end
 427   end
 428
 429   defp activity_belongs_to_actor(%{actor: actor}, actor), do: true
 430   defp activity_belongs_to_actor(_, _), do: {:error, :ownership_error}
 431
 432   defp object_type_is_allowed_for_pin(%{data: %{"type" => type}}) do
 433     with false <- type in ["Note", "Article", "Question"] do
 434       {:error, :not_allowed}
 435     end
 436   end
 437
 438   defp activity_is_public(activity) do
 439     with false <- Visibility.is_public?(activity) do
 440       {:error, :visibility_error}
 441     end
 442   end
 443
 444   @spec unpin(String.t(), User.t()) :: {:ok, User.t()} | {:error, term()}
 445   def unpin(id, user) do
 446     with %Activity{} = activity <- create_activity_by_id(id),
 447          {:ok, unpin_data, _} <- Builder.unpin(user, activity.object),
 448          {:ok, _unpin, _} <-
 449            Pipeline.common_pipeline(unpin_data,
 450              local: true,
 451              activity_id: activity.id,
 452              expires_at: activity.data["expires_at"],
 453              featured_address: user.featured_address
 454            ) do
 455       {:ok, activity}
 456     end
 457   end
 458
 459   def add_mute(user, activity, params \\ %{}) do
 460     expires_in = Map.get(params, :expires_in, 0)
 461
 462     with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]),
 463          _ <- Pleroma.Notification.mark_context_as_read(user, activity.data["context"]) do
 464       if expires_in > 0 do
 465         Pleroma.Workers.MuteExpireWorker.enqueue(
 466           "unmute_conversation",
 467           %{"user_id" => user.id, "activity_id" => activity.id},
 468           schedule_in: expires_in
 469         )
 470       end
 471
 472       {:ok, activity}
 473     else
 474       {:error, _} -> {:error, dgettext("errors", "conversation is already muted")}
 475     end
 476   end
 477
 478   def remove_mute(%User{} = user, %Activity{} = activity) do
 479     ThreadMute.remove_mute(user.id, activity.data["context"])
 480     {:ok, activity}
 481   end
 482
 483   def remove_mute(user_id, activity_id) do
 484     with {:user, %User{} = user} <- {:user, User.get_by_id(user_id)},
 485          {:activity, %Activity{} = activity} <- {:activity, Activity.get_by_id(activity_id)} do
 486       remove_mute(user, activity)
 487     else
 488       {what, result} = error ->
 489         Logger.warn(
 490           "CommonAPI.remove_mute/2 failed. #{what}: #{result}, user_id: #{user_id}, activity_id: #{activity_id}"
 491         )
 492
 493         {:error, error}
 494     end
 495   end
 496
 497   def thread_muted?(%User{id: user_id}, %{data: %{"context" => context}})
 498       when is_binary(context) do
 499     ThreadMute.exists?(user_id, context)
 500   end
 501
 502   def thread_muted?(_, _), do: false
 503
 504   def report(user, data) do
 505     with {:ok, account} <- get_reported_account(data.account_id),
 506          {:ok, {content_html, _, _}} <- make_report_content_html(data[:comment]),
 507          {:ok, statuses} <- get_report_statuses(account, data) do
 508       ActivityPub.flag(%{
 509         context: Utils.generate_context_id(),
 510         actor: user,
 511         account: account,
 512         statuses: statuses,
 513         content: content_html,
 514         forward: Map.get(data, :forward, false)
 515       })
 516     end
 517   end
 518
 519   defp get_reported_account(account_id) do
 520     case User.get_cached_by_id(account_id) do
 521       %User{} = account -> {:ok, account}
 522       _ -> {:error, dgettext("errors", "Account not found")}
 523     end
 524   end
 525
 526   def update_report_state(activity_ids, state) when is_list(activity_ids) do
 527     case Utils.update_report_state(activity_ids, state) do
 528       :ok -> {:ok, activity_ids}
 529       _ -> {:error, dgettext("errors", "Could not update state")}
 530     end
 531   end
 532
 533   def update_report_state(activity_id, state) do
 534     with %Activity{} = activity <- Activity.get_by_id(activity_id) do
 535       Utils.update_report_state(activity, state)
 536     else
 537       nil -> {:error, :not_found}
 538       _ -> {:error, dgettext("errors", "Could not update state")}
 539     end
 540   end
 541
 542   def update_activity_scope(activity_id, opts \\ %{}) do
 543     with %Activity{} = activity <- Activity.get_by_id_with_object(activity_id),
 544          {:ok, activity} <- toggle_sensitive(activity, opts) do
 545       set_visibility(activity, opts)
 546     else
 547       nil -> {:error, :not_found}
 548       {:error, reason} -> {:error, reason}
 549     end
 550   end
 551
 552   defp toggle_sensitive(activity, %{sensitive: sensitive}) when sensitive in ~w(true false) do
 553     toggle_sensitive(activity, %{sensitive: String.to_existing_atom(sensitive)})
 554   end
 555
 556   defp toggle_sensitive(%Activity{object: object} = activity, %{sensitive: sensitive})
 557        when is_boolean(sensitive) do
 558     new_data = Map.put(object.data, "sensitive", sensitive)
 559
 560     {:ok, object} =
 561       object
 562       |> Object.change(%{data: new_data})
 563       |> Object.update_and_set_cache()
 564
 565     {:ok, Map.put(activity, :object, object)}
 566   end
 567
 568   defp toggle_sensitive(activity, _), do: {:ok, activity}
 569
 570   defp set_visibility(activity, %{visibility: visibility}) do
 571     Utils.update_activity_visibility(activity, visibility)
 572   end
 573
 574   defp set_visibility(activity, _), do: {:ok, activity}
 575
 576   def hide_reblogs(%User{} = user, %User{} = target) do
 577     UserRelationship.create_reblog_mute(user, target)
 578   end
 579
 580   def show_reblogs(%User{} = user, %User{} = target) do
 581     UserRelationship.delete_reblog_mute(user, target)
 582   end
 583
 584   def get_user(ap_id, fake_record_fallback \\ true) do
 585     cond do
 586       user = User.get_cached_by_ap_id(ap_id) ->
 587         user
 588
 589       user = User.get_by_guessed_nickname(ap_id) ->
 590         user
 591
 592       fake_record_fallback ->
 593         # TODO: refactor (fake records is never a good idea)
 594         User.error_user(ap_id)
 595
 596       true ->
 597         nil
 598     end
 599   end
 600 end