git.squeep.com Git - akkoma/blob - lib/pleroma/web/activity_pub/utils.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.ActivityPub.Utils do
   6   alias Ecto.Changeset
   7   alias Ecto.UUID
   8   alias Pleroma.Activity
   9   alias Pleroma.Config
  10   alias Pleroma.Maps
  11   alias Pleroma.Notification
  12   alias Pleroma.Object
  13   alias Pleroma.Repo
  14   alias Pleroma.User
  15   alias Pleroma.Web.ActivityPub.ActivityPub
  16   alias Pleroma.Web.ActivityPub.Visibility
  17   alias Pleroma.Web.AdminAPI.AccountView
  18   alias Pleroma.Web.Endpoint
  19   alias Pleroma.Web.Router.Helpers
  20
  21   import Ecto.Query
  22
  23   require Logger
  24   require Pleroma.Constants
  25
  26   @supported_object_types [
  27     "Article",
  28     "Note",
  29     "Event",
  30     "Video",
  31     "Page",
  32     "Question",
  33     "Answer",
  34     "Audio"
  35   ]
  36   @strip_status_report_states ~w(closed resolved)
  37   @supported_report_states ~w(open closed resolved)
  38   @valid_visibilities ~w(public unlisted private direct)
  39
  40   def as_local_public, do: Endpoint.url() <> "/#Public"
  41
  42   # Some implementations send the actor URI as the actor field, others send the entire actor object,
  43   # so figure out what the actor's URI is based on what we have.
  44   def get_ap_id(%{"id" => id} = _), do: id
  45   def get_ap_id(id), do: id
  46
  47   def normalize_params(params) do
  48     Map.put(params, "actor", get_ap_id(params["actor"]))
  49   end
  50
  51   @spec determine_explicit_mentions(map()) :: [any]
  52   def determine_explicit_mentions(%{"tag" => tag}) when is_list(tag) do
  53     Enum.flat_map(tag, fn
  54       %{"type" => "Mention", "href" => href} -> [href]
  55       _ -> []
  56     end)
  57   end
  58
  59   def determine_explicit_mentions(%{"tag" => tag} = object) when is_map(tag) do
  60     object
  61     |> Map.put("tag", [tag])
  62     |> determine_explicit_mentions()
  63   end
  64
  65   def determine_explicit_mentions(_), do: []
  66
  67   @spec label_in_collection?(any(), any()) :: boolean()
  68   defp label_in_collection?(ap_id, coll) when is_binary(coll), do: ap_id == coll
  69   defp label_in_collection?(ap_id, coll) when is_list(coll), do: ap_id in coll
  70   defp label_in_collection?(_, _), do: false
  71
  72   @spec label_in_message?(String.t(), map()) :: boolean()
  73   def label_in_message?(label, params),
  74     do:
  75       [params["to"], params["cc"], params["bto"], params["bcc"]]
  76       |> Enum.any?(&label_in_collection?(label, &1))
  77
  78   @spec unaddressed_message?(map()) :: boolean()
  79   def unaddressed_message?(params),
  80     do:
  81       [params["to"], params["cc"], params["bto"], params["bcc"]]
  82       |> Enum.all?(&is_nil(&1))
  83
  84   @spec recipient_in_message(User.t(), User.t(), map()) :: boolean()
  85   def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params),
  86     do:
  87       label_in_message?(ap_id, params) || unaddressed_message?(params) ||
  88         User.following?(recipient, actor)
  89
  90   defp extract_list(target) when is_binary(target), do: [target]
  91   defp extract_list(lst) when is_list(lst), do: lst
  92   defp extract_list(_), do: []
  93
  94   def maybe_splice_recipient(ap_id, params) do
  95     need_splice? =
  96       !label_in_collection?(ap_id, params["to"]) &&
  97         !label_in_collection?(ap_id, params["cc"])
  98
  99     if need_splice? do
 100       cc = [ap_id | extract_list(params["cc"])]
 101
 102       params
 103       |> Map.put("cc", cc)
 104       |> Maps.safe_put_in(["object", "cc"], cc)
 105     else
 106       params
 107     end
 108   end
 109
 110   def make_json_ld_header do
 111     %{
 112       "@context" => [
 113         "https://www.w3.org/ns/activitystreams",
 114         "#{Endpoint.url()}/schemas/litepub-0.1.jsonld",
 115         %{
 116           "@language" => "und"
 117         }
 118       ]
 119     }
 120   end
 121
 122   def make_date do
 123     DateTime.utc_now() |> DateTime.to_iso8601()
 124   end
 125
 126   def generate_activity_id do
 127     generate_id("activities")
 128   end
 129
 130   def generate_context_id do
 131     generate_id("contexts")
 132   end
 133
 134   def generate_object_id do
 135     Helpers.o_status_url(Endpoint, :object, UUID.generate())
 136   end
 137
 138   def generate_id(type) do
 139     "#{Endpoint.url()}/#{type}/#{UUID.generate()}"
 140   end
 141
 142   def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
 143     fake_create_activity = %{
 144       "to" => object["to"],
 145       "cc" => object["cc"],
 146       "type" => "Create",
 147       "object" => object
 148     }
 149
 150     get_notified_from_object(fake_create_activity)
 151   end
 152
 153   def get_notified_from_object(object) do
 154     Notification.get_notified_from_activity(%Activity{data: object}, false)
 155   end
 156
 157   def create_context(context) do
 158     context = context || generate_id("contexts")
 159
 160     # Ecto has problems accessing the constraint inside the jsonb,
 161     # so we explicitly check for the existed object before insert
 162     object = Object.get_cached_by_ap_id(context)
 163
 164     with true <- is_nil(object),
 165          changeset <- Object.context_mapping(context),
 166          {:ok, inserted_object} <- Repo.insert(changeset) do
 167       inserted_object
 168     else
 169       _ ->
 170         object
 171     end
 172   end
 173
 174   @doc """
 175   Enqueues an activity for federation if it's local
 176   """
 177   @spec maybe_federate(any()) :: :ok
 178   def maybe_federate(%Activity{local: true, data: %{"type" => type}} = activity) do
 179     outgoing_blocks = Config.get([:activitypub, :outgoing_blocks])
 180
 181     with true <- Config.get!([:instance, :federating]),
 182          true <- type != "Block" || outgoing_blocks,
 183          false <- Visibility.is_local_public?(activity) do
 184       Pleroma.Web.Federator.publish(activity)
 185     end
 186
 187     :ok
 188   end
 189
 190   def maybe_federate(_), do: :ok
 191
 192   @doc """
 193   Adds an id and a published data if they aren't there,
 194   also adds it to an included object
 195   """
 196   @spec lazy_put_activity_defaults(map(), boolean) :: map()
 197   def lazy_put_activity_defaults(map, fake? \\ false)
 198
 199   def lazy_put_activity_defaults(map, true) do
 200     map
 201     |> Map.put_new("id", "pleroma:fakeid")
 202     |> Map.put_new_lazy("published", &make_date/0)
 203     |> Map.put_new("context", "pleroma:fakecontext")
 204     |> Map.put_new("context_id", -1)
 205     |> lazy_put_object_defaults(true)
 206   end
 207
 208   def lazy_put_activity_defaults(map, _fake?) do
 209     %{data: %{"id" => context}, id: context_id} = create_context(map["context"])
 210
 211     map
 212     |> Map.put_new_lazy("id", &generate_activity_id/0)
 213     |> Map.put_new_lazy("published", &make_date/0)
 214     |> Map.put_new("context", context)
 215     |> Map.put_new("context_id", context_id)
 216     |> lazy_put_object_defaults(false)
 217   end
 218
 219   # Adds an id and published date if they aren't there.
 220   #
 221   @spec lazy_put_object_defaults(map(), boolean()) :: map()
 222   defp lazy_put_object_defaults(%{"object" => map} = activity, true)
 223        when is_map(map) do
 224     object =
 225       map
 226       |> Map.put_new("id", "pleroma:fake_object_id")
 227       |> Map.put_new_lazy("published", &make_date/0)
 228       |> Map.put_new("context", activity["context"])
 229       |> Map.put_new("context_id", activity["context_id"])
 230       |> Map.put_new("fake", true)
 231
 232     %{activity | "object" => object}
 233   end
 234
 235   defp lazy_put_object_defaults(%{"object" => map} = activity, _)
 236        when is_map(map) do
 237     object =
 238       map
 239       |> Map.put_new_lazy("id", &generate_object_id/0)
 240       |> Map.put_new_lazy("published", &make_date/0)
 241       |> Map.put_new("context", activity["context"])
 242       |> Map.put_new("context_id", activity["context_id"])
 243
 244     %{activity | "object" => object}
 245   end
 246
 247   defp lazy_put_object_defaults(activity, _), do: activity
 248
 249   @doc """
 250   Inserts a full object if it is contained in an activity.
 251   """
 252   def insert_full_object(%{"object" => %{"type" => type} = object_data} = map)
 253       when type in @supported_object_types do
 254     with {:ok, object} <- Object.create(object_data) do
 255       map = Map.put(map, "object", object.data["id"])
 256
 257       {:ok, map, object}
 258     end
 259   end
 260
 261   def insert_full_object(map), do: {:ok, map, nil}
 262
 263   #### Like-related helpers
 264
 265   @doc """
 266   Returns an existing like if a user already liked an object
 267   """
 268   @spec get_existing_like(String.t(), map()) :: Activity.t() | nil
 269   def get_existing_like(actor, %{data: %{"id" => id}}) do
 270     actor
 271     |> Activity.Queries.by_actor()
 272     |> Activity.Queries.by_object_id(id)
 273     |> Activity.Queries.by_type("Like")
 274     |> limit(1)
 275     |> Repo.one()
 276   end
 277
 278   @doc """
 279   Returns like activities targeting an object
 280   """
 281   def get_object_likes(%{data: %{"id" => id}}) do
 282     id
 283     |> Activity.Queries.by_object_id()
 284     |> Activity.Queries.by_type("Like")
 285     |> Repo.all()
 286   end
 287
 288   @spec make_like_data(User.t(), map(), String.t()) :: map()
 289   def make_like_data(
 290         %User{ap_id: ap_id} = actor,
 291         %{data: %{"actor" => object_actor_id, "id" => id}} = object,
 292         activity_id
 293       ) do
 294     object_actor = User.get_cached_by_ap_id(object_actor_id)
 295
 296     to =
 297       if Visibility.is_public?(object) do
 298         [actor.follower_address, object.data["actor"]]
 299       else
 300         [object.data["actor"]]
 301       end
 302
 303     cc =
 304       (object.data["to"] ++ (object.data["cc"] || []))
 305       |> List.delete(actor.ap_id)
 306       |> List.delete(object_actor.follower_address)
 307
 308     %{
 309       "type" => "Like",
 310       "actor" => ap_id,
 311       "object" => id,
 312       "to" => to,
 313       "cc" => cc,
 314       "context" => object.data["context"]
 315     }
 316     |> Maps.put_if_present("id", activity_id)
 317   end
 318
 319   def make_emoji_reaction_data(user, object, emoji, activity_id) do
 320     make_like_data(user, object, activity_id)
 321     |> Map.put("type", "EmojiReact")
 322     |> Map.put("content", emoji)
 323   end
 324
 325   @spec update_element_in_object(String.t(), list(any), Object.t(), integer() | nil) ::
 326           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 327   def update_element_in_object(property, element, object, count \\ nil) do
 328     length =
 329       count ||
 330         length(element)
 331
 332     data =
 333       Map.merge(
 334         object.data,
 335         %{"#{property}_count" => length, "#{property}s" => element}
 336       )
 337
 338     object
 339     |> Changeset.change(data: data)
 340     |> Object.update_and_set_cache()
 341   end
 342
 343   @spec add_emoji_reaction_to_object(Activity.t(), Object.t()) ::
 344           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 345
 346   def add_emoji_reaction_to_object(
 347         %Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
 348         object
 349       ) do
 350     reactions = get_cached_emoji_reactions(object)
 351     emoji = stripped_emoji_name(emoji)
 352     url = emoji_url(emoji, activity)
 353
 354     new_reactions =
 355       case Enum.find_index(reactions, fn [candidate, _, candidate_url] ->
 356              if is_nil(candidate_url) do
 357                emoji == candidate
 358              else
 359                url == candidate_url
 360              end
 361            end) do
 362         nil ->
 363           reactions ++ [[emoji, [actor], url]]
 364
 365         index ->
 366           List.update_at(
 367             reactions,
 368             index,
 369             fn [emoji, users, url] -> [emoji, Enum.uniq([actor | users]), url] end
 370           )
 371       end
 372
 373     count = emoji_count(new_reactions)
 374
 375     update_element_in_object("reaction", new_reactions, object, count)
 376   end
 377
 378   defp stripped_emoji_name(name) do
 379     name
 380     |> String.replace_leading(":", "")
 381     |> String.replace_trailing(":", "")
 382   end
 383
 384   defp emoji_url(
 385          name,
 386          %Activity{
 387            data: %{
 388              "tag" => [
 389                %{"type" => "Emoji", "name" => name, "icon" => %{"url" => url}}
 390              ]
 391            }
 392          }
 393        ),
 394        do: url
 395
 396   defp emoji_url(_, _), do: nil
 397
 398   def emoji_count(reactions_list) do
 399     Enum.reduce(reactions_list, 0, fn [_, users, _], acc -> acc + length(users) end)
 400   end
 401
 402   def remove_emoji_reaction_from_object(
 403         %Activity{data: %{"content" => emoji, "actor" => actor}} = activity,
 404         object
 405       ) do
 406     emoji = stripped_emoji_name(emoji)
 407     reactions = get_cached_emoji_reactions(object)
 408     url = emoji_url(emoji, activity)
 409
 410     new_reactions =
 411       case Enum.find_index(reactions, fn [candidate, _, candidate_url] ->
 412              if is_nil(candidate_url) do
 413                emoji == candidate
 414              else
 415                url == candidate_url
 416              end
 417            end) do
 418         nil ->
 419           reactions
 420
 421         index ->
 422           List.update_at(
 423             reactions,
 424             index,
 425             fn [emoji, users, url] -> [emoji, List.delete(users, actor), url] end
 426           )
 427           |> Enum.reject(fn [_, users, _] -> Enum.empty?(users) end)
 428       end
 429
 430     count = emoji_count(new_reactions)
 431     update_element_in_object("reaction", new_reactions, object, count)
 432   end
 433
 434   def get_cached_emoji_reactions(object) do
 435     if is_list(object.data["reactions"]) do
 436       object.data["reactions"]
 437     else
 438       []
 439     end
 440   end
 441
 442   @spec add_like_to_object(Activity.t(), Object.t()) ::
 443           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 444   def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
 445     [actor | fetch_likes(object)]
 446     |> Enum.uniq()
 447     |> update_likes_in_object(object)
 448   end
 449
 450   @spec remove_like_from_object(Activity.t(), Object.t()) ::
 451           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 452   def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
 453     object
 454     |> fetch_likes()
 455     |> List.delete(actor)
 456     |> update_likes_in_object(object)
 457   end
 458
 459   defp update_likes_in_object(likes, object) do
 460     update_element_in_object("like", likes, object)
 461   end
 462
 463   defp fetch_likes(object) do
 464     if is_list(object.data["likes"]) do
 465       object.data["likes"]
 466     else
 467       []
 468     end
 469   end
 470
 471   #### Follow-related helpers
 472
 473   @doc """
 474   Updates a follow activity's state (for locked accounts).
 475   """
 476   @spec update_follow_state_for_all(Activity.t(), String.t()) :: {:ok, Activity | nil}
 477   def update_follow_state_for_all(
 478         %Activity{data: %{"actor" => actor, "object" => object}} = activity,
 479         state
 480       ) do
 481     "Follow"
 482     |> Activity.Queries.by_type()
 483     |> Activity.Queries.by_actor(actor)
 484     |> Activity.Queries.by_object_id(object)
 485     |> where(fragment("data->>'state' = 'pending'") or fragment("data->>'state' = 'accept'"))
 486     |> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
 487     |> Repo.update_all([])
 488
 489     activity = Activity.get_by_id(activity.id)
 490
 491     {:ok, activity}
 492   end
 493
 494   def update_follow_state(
 495         %Activity{} = activity,
 496         state
 497       ) do
 498     new_data = Map.put(activity.data, "state", state)
 499     changeset = Changeset.change(activity, data: new_data)
 500
 501     with {:ok, activity} <- Repo.update(changeset) do
 502       {:ok, activity}
 503     end
 504   end
 505
 506   @doc """
 507   Makes a follow activity data for the given follower and followed
 508   """
 509   def make_follow_data(
 510         %User{ap_id: follower_id},
 511         %User{ap_id: followed_id} = _followed,
 512         activity_id
 513       ) do
 514     %{
 515       "type" => "Follow",
 516       "actor" => follower_id,
 517       "to" => [followed_id],
 518       "cc" => [Pleroma.Constants.as_public()],
 519       "object" => followed_id,
 520       "state" => "pending"
 521     }
 522     |> Maps.put_if_present("id", activity_id)
 523   end
 524
 525   def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
 526     "Follow"
 527     |> Activity.Queries.by_type()
 528     |> where(actor: ^follower_id)
 529     # this is to use the index
 530     |> Activity.Queries.by_object_id(followed_id)
 531     |> order_by([activity], fragment("? desc nulls last", activity.id))
 532     |> limit(1)
 533     |> Repo.one()
 534   end
 535
 536   def fetch_latest_undo(%User{ap_id: ap_id}) do
 537     "Undo"
 538     |> Activity.Queries.by_type()
 539     |> where(actor: ^ap_id)
 540     |> order_by([activity], fragment("? desc nulls last", activity.id))
 541     |> limit(1)
 542     |> Repo.one()
 543   end
 544
 545   def get_latest_reaction(internal_activity_id, %{ap_id: ap_id}, emoji) do
 546     IO.inspect(emoji)
 547     %{data: %{"object" => object_ap_id}} = Activity.get_by_id(internal_activity_id)
 548
 549     emoji = Pleroma.Emoji.maybe_quote(emoji)
 550
 551     "EmojiReact"
 552     |> Activity.Queries.by_type()
 553     |> where(actor: ^ap_id)
 554     |> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
 555     |> Activity.Queries.by_object_id(object_ap_id)
 556     |> order_by([activity], fragment("? desc nulls last", activity.id))
 557     |> limit(1)
 558     |> Repo.one()
 559   end
 560
 561   #### Announce-related helpers
 562
 563   @doc """
 564   Returns an existing announce activity if the notice has already been announced
 565   """
 566   @spec get_existing_announce(String.t(), map()) :: Activity.t() | nil
 567   def get_existing_announce(actor, %{data: %{"id" => ap_id}}) do
 568     "Announce"
 569     |> Activity.Queries.by_type()
 570     |> where(actor: ^actor)
 571     # this is to use the index
 572     |> Activity.Queries.by_object_id(ap_id)
 573     |> Repo.one()
 574   end
 575
 576   @doc """
 577   Make announce activity data for the given actor and object
 578   """
 579   # for relayed messages, we only want to send to subscribers
 580   def make_announce_data(
 581         %User{ap_id: ap_id} = user,
 582         %Object{data: %{"id" => id}} = object,
 583         activity_id,
 584         false
 585       ) do
 586     %{
 587       "type" => "Announce",
 588       "actor" => ap_id,
 589       "object" => id,
 590       "to" => [user.follower_address],
 591       "cc" => [],
 592       "context" => object.data["context"]
 593     }
 594     |> Maps.put_if_present("id", activity_id)
 595   end
 596
 597   def make_announce_data(
 598         %User{ap_id: ap_id} = user,
 599         %Object{data: %{"id" => id}} = object,
 600         activity_id,
 601         true
 602       ) do
 603     %{
 604       "type" => "Announce",
 605       "actor" => ap_id,
 606       "object" => id,
 607       "to" => [user.follower_address, object.data["actor"]],
 608       "cc" => [Pleroma.Constants.as_public()],
 609       "context" => object.data["context"]
 610     }
 611     |> Maps.put_if_present("id", activity_id)
 612   end
 613
 614   def make_undo_data(
 615         %User{ap_id: actor, follower_address: follower_address},
 616         %Activity{
 617           data: %{"id" => undone_activity_id, "context" => context},
 618           actor: undone_activity_actor
 619         },
 620         activity_id \\ nil
 621       ) do
 622     %{
 623       "type" => "Undo",
 624       "actor" => actor,
 625       "object" => undone_activity_id,
 626       "to" => [follower_address, undone_activity_actor],
 627       "cc" => [Pleroma.Constants.as_public()],
 628       "context" => context
 629     }
 630     |> Maps.put_if_present("id", activity_id)
 631   end
 632
 633   @spec add_announce_to_object(Activity.t(), Object.t()) ::
 634           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 635   def add_announce_to_object(
 636         %Activity{data: %{"actor" => actor}},
 637         object
 638       ) do
 639     unless actor |> User.get_cached_by_ap_id() |> User.invisible?() do
 640       announcements = take_announcements(object)
 641
 642       with announcements <- Enum.uniq([actor | announcements]) do
 643         update_element_in_object("announcement", announcements, object)
 644       end
 645     else
 646       {:ok, object}
 647     end
 648   end
 649
 650   def add_announce_to_object(_, object), do: {:ok, object}
 651
 652   @spec remove_announce_from_object(Activity.t(), Object.t()) ::
 653           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 654   def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
 655     with announcements <- List.delete(take_announcements(object), actor) do
 656       update_element_in_object("announcement", announcements, object)
 657     end
 658   end
 659
 660   defp take_announcements(%{data: %{"announcements" => announcements}} = _)
 661        when is_list(announcements),
 662        do: announcements
 663
 664   defp take_announcements(_), do: []
 665
 666   #### Unfollow-related helpers
 667
 668   def make_unfollow_data(follower, followed, follow_activity, activity_id) do
 669     %{
 670       "type" => "Undo",
 671       "actor" => follower.ap_id,
 672       "to" => [followed.ap_id],
 673       "object" => follow_activity.data
 674     }
 675     |> Maps.put_if_present("id", activity_id)
 676   end
 677
 678   #### Block-related helpers
 679   @spec fetch_latest_block(User.t(), User.t()) :: Activity.t() | nil
 680   def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
 681     "Block"
 682     |> Activity.Queries.by_type()
 683     |> where(actor: ^blocker_id)
 684     # this is to use the index
 685     |> Activity.Queries.by_object_id(blocked_id)
 686     |> order_by([activity], fragment("? desc nulls last", activity.id))
 687     |> limit(1)
 688     |> Repo.one()
 689   end
 690
 691   def make_block_data(blocker, blocked, activity_id) do
 692     %{
 693       "type" => "Block",
 694       "actor" => blocker.ap_id,
 695       "to" => [blocked.ap_id],
 696       "object" => blocked.ap_id
 697     }
 698     |> Maps.put_if_present("id", activity_id)
 699   end
 700
 701   #### Create-related helpers
 702
 703   def make_create_data(params, additional) do
 704     published = params.published || make_date()
 705
 706     %{
 707       "type" => "Create",
 708       "to" => params.to |> Enum.uniq(),
 709       "actor" => params.actor.ap_id,
 710       "object" => params.object,
 711       "published" => published,
 712       "context" => params.context
 713     }
 714     |> Map.merge(additional)
 715   end
 716
 717   #### Listen-related helpers
 718   def make_listen_data(params, additional) do
 719     published = params.published || make_date()
 720
 721     %{
 722       "type" => "Listen",
 723       "to" => params.to |> Enum.uniq(),
 724       "actor" => params.actor.ap_id,
 725       "object" => params.object,
 726       "published" => published,
 727       "context" => params.context
 728     }
 729     |> Map.merge(additional)
 730   end
 731
 732   #### Flag-related helpers
 733   @spec make_flag_data(map(), map()) :: map()
 734   def make_flag_data(%{actor: actor, context: context, content: content} = params, additional) do
 735     %{
 736       "type" => "Flag",
 737       "actor" => actor.ap_id,
 738       "content" => content,
 739       "object" => build_flag_object(params),
 740       "context" => context,
 741       "state" => "open"
 742     }
 743     |> Map.merge(additional)
 744   end
 745
 746   def make_flag_data(_, _), do: %{}
 747
 748   defp build_flag_object(%{account: account, statuses: statuses}) do
 749     [account.ap_id | build_flag_object(%{statuses: statuses})]
 750   end
 751
 752   defp build_flag_object(%{statuses: statuses}) do
 753     Enum.map(statuses || [], &build_flag_object/1)
 754   end
 755
 756   defp build_flag_object(%Activity{data: %{"id" => id}, object: %{data: data}}) do
 757     activity_actor = User.get_by_ap_id(data["actor"])
 758
 759     %{
 760       "type" => "Note",
 761       "id" => id,
 762       "content" => data["content"],
 763       "published" => data["published"],
 764       "actor" =>
 765         AccountView.render(
 766           "show.json",
 767           %{user: activity_actor, skip_visibility_check: true}
 768         )
 769     }
 770   end
 771
 772   defp build_flag_object(act) when is_map(act) or is_binary(act) do
 773     id =
 774       case act do
 775         %Activity{} = act -> act.data["id"]
 776         act when is_map(act) -> act["id"]
 777         act when is_binary(act) -> act
 778       end
 779
 780     case Activity.get_by_ap_id_with_object(id) do
 781       %Activity{} = activity ->
 782         build_flag_object(activity)
 783
 784       nil ->
 785         if activity = Activity.get_by_object_ap_id_with_object(id) do
 786           build_flag_object(activity)
 787         else
 788           %{"id" => id, "deleted" => true}
 789         end
 790     end
 791   end
 792
 793   defp build_flag_object(_), do: []
 794
 795   #### Report-related helpers
 796   def get_reports(params, page, page_size) do
 797     params =
 798       params
 799       |> Map.put(:type, "Flag")
 800       |> Map.put(:skip_preload, true)
 801       |> Map.put(:preload_report_notes, true)
 802       |> Map.put(:total, true)
 803       |> Map.put(:limit, page_size)
 804       |> Map.put(:offset, (page - 1) * page_size)
 805
 806     ActivityPub.fetch_activities([], params, :offset)
 807   end
 808
 809   def update_report_state(%Activity{} = activity, state)
 810       when state in @strip_status_report_states do
 811     {:ok, stripped_activity} = strip_report_status_data(activity)
 812
 813     new_data =
 814       activity.data
 815       |> Map.put("state", state)
 816       |> Map.put("object", stripped_activity.data["object"])
 817
 818     activity
 819     |> Changeset.change(data: new_data)
 820     |> Repo.update()
 821   end
 822
 823   def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
 824     new_data = Map.put(activity.data, "state", state)
 825
 826     activity
 827     |> Changeset.change(data: new_data)
 828     |> Repo.update()
 829   end
 830
 831   def update_report_state(activity_ids, state) when state in @supported_report_states do
 832     activities_num = length(activity_ids)
 833
 834     from(a in Activity, where: a.id in ^activity_ids)
 835     |> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
 836     |> Repo.update_all([])
 837     |> case do
 838       {^activities_num, _} -> :ok
 839       _ -> {:error, activity_ids}
 840     end
 841   end
 842
 843   def update_report_state(_, _), do: {:error, "Unsupported state"}
 844
 845   def strip_report_status_data(activity) do
 846     [actor | reported_activities] = activity.data["object"]
 847
 848     stripped_activities =
 849       Enum.map(reported_activities, fn
 850         act when is_map(act) -> act["id"]
 851         act when is_binary(act) -> act
 852       end)
 853
 854     new_data = put_in(activity.data, ["object"], [actor | stripped_activities])
 855
 856     {:ok, %{activity | data: new_data}}
 857   end
 858
 859   def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
 860     [to, cc, recipients] =
 861       activity
 862       |> get_updated_targets(visibility)
 863       |> Enum.map(&Enum.uniq/1)
 864
 865     object_data =
 866       activity.object.data
 867       |> Map.put("to", to)
 868       |> Map.put("cc", cc)
 869
 870     {:ok, object} =
 871       activity.object
 872       |> Object.change(%{data: object_data})
 873       |> Object.update_and_set_cache()
 874
 875     activity_data =
 876       activity.data
 877       |> Map.put("to", to)
 878       |> Map.put("cc", cc)
 879
 880     activity
 881     |> Map.put(:object, object)
 882     |> Activity.change(%{data: activity_data, recipients: recipients})
 883     |> Repo.update()
 884   end
 885
 886   def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}
 887
 888   defp get_updated_targets(
 889          %Activity{data: %{"to" => to} = data, recipients: recipients},
 890          visibility
 891        ) do
 892     cc = Map.get(data, "cc", [])
 893     follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
 894     public = Pleroma.Constants.as_public()
 895
 896     case visibility do
 897       "public" ->
 898         to = [public | List.delete(to, follower_address)]
 899         cc = [follower_address | List.delete(cc, public)]
 900         recipients = [public | recipients]
 901         [to, cc, recipients]
 902
 903       "private" ->
 904         to = [follower_address | List.delete(to, public)]
 905         cc = List.delete(cc, public)
 906         recipients = List.delete(recipients, public)
 907         [to, cc, recipients]
 908
 909       "unlisted" ->
 910         to = [follower_address | List.delete(to, public)]
 911         cc = [public | List.delete(cc, follower_address)]
 912         recipients = recipients ++ [follower_address, public]
 913         [to, cc, recipients]
 914
 915       _ ->
 916         [to, cc, recipients]
 917     end
 918   end
 919
 920   def get_existing_votes(actor, %{data: %{"id" => id}}) do
 921     actor
 922     |> Activity.Queries.by_actor()
 923     |> Activity.Queries.by_type("Create")
 924     |> Activity.with_preloaded_object()
 925     |> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
 926     |> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
 927     |> Repo.all()
 928   end
 929 end