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     %{data: %{"object" => object_ap_id}} = Activity.get_by_id(internal_activity_id)
 547
 548     emoji = Pleroma.Emoji.maybe_quote(emoji)
 549
 550     "EmojiReact"
 551     |> Activity.Queries.by_type()
 552     |> where(actor: ^ap_id)
 553     |> where([activity], fragment("?->>'content' = ?", activity.data, ^emoji))
 554     |> Activity.Queries.by_object_id(object_ap_id)
 555     |> order_by([activity], fragment("? desc nulls last", activity.id))
 556     |> limit(1)
 557     |> Repo.one()
 558   end
 559
 560   #### Announce-related helpers
 561
 562   @doc """
 563   Returns an existing announce activity if the notice has already been announced
 564   """
 565   @spec get_existing_announce(String.t(), map()) :: Activity.t() | nil
 566   def get_existing_announce(actor, %{data: %{"id" => ap_id}}) do
 567     "Announce"
 568     |> Activity.Queries.by_type()
 569     |> where(actor: ^actor)
 570     # this is to use the index
 571     |> Activity.Queries.by_object_id(ap_id)
 572     |> Repo.one()
 573   end
 574
 575   @doc """
 576   Make announce activity data for the given actor and object
 577   """
 578   # for relayed messages, we only want to send to subscribers
 579   def make_announce_data(
 580         %User{ap_id: ap_id} = user,
 581         %Object{data: %{"id" => id}} = object,
 582         activity_id,
 583         false
 584       ) do
 585     %{
 586       "type" => "Announce",
 587       "actor" => ap_id,
 588       "object" => id,
 589       "to" => [user.follower_address],
 590       "cc" => [],
 591       "context" => object.data["context"]
 592     }
 593     |> Maps.put_if_present("id", activity_id)
 594   end
 595
 596   def make_announce_data(
 597         %User{ap_id: ap_id} = user,
 598         %Object{data: %{"id" => id}} = object,
 599         activity_id,
 600         true
 601       ) do
 602     %{
 603       "type" => "Announce",
 604       "actor" => ap_id,
 605       "object" => id,
 606       "to" => [user.follower_address, object.data["actor"]],
 607       "cc" => [Pleroma.Constants.as_public()],
 608       "context" => object.data["context"]
 609     }
 610     |> Maps.put_if_present("id", activity_id)
 611   end
 612
 613   def make_undo_data(
 614         %User{ap_id: actor, follower_address: follower_address},
 615         %Activity{
 616           data: %{"id" => undone_activity_id, "context" => context},
 617           actor: undone_activity_actor
 618         },
 619         activity_id \\ nil
 620       ) do
 621     %{
 622       "type" => "Undo",
 623       "actor" => actor,
 624       "object" => undone_activity_id,
 625       "to" => [follower_address, undone_activity_actor],
 626       "cc" => [Pleroma.Constants.as_public()],
 627       "context" => context
 628     }
 629     |> Maps.put_if_present("id", activity_id)
 630   end
 631
 632   @spec add_announce_to_object(Activity.t(), Object.t()) ::
 633           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 634   def add_announce_to_object(
 635         %Activity{data: %{"actor" => actor}},
 636         object
 637       ) do
 638     unless actor |> User.get_cached_by_ap_id() |> User.invisible?() do
 639       announcements = take_announcements(object)
 640
 641       with announcements <- Enum.uniq([actor | announcements]) do
 642         update_element_in_object("announcement", announcements, object)
 643       end
 644     else
 645       {:ok, object}
 646     end
 647   end
 648
 649   def add_announce_to_object(_, object), do: {:ok, object}
 650
 651   @spec remove_announce_from_object(Activity.t(), Object.t()) ::
 652           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 653   def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
 654     with announcements <- List.delete(take_announcements(object), actor) do
 655       update_element_in_object("announcement", announcements, object)
 656     end
 657   end
 658
 659   defp take_announcements(%{data: %{"announcements" => announcements}} = _)
 660        when is_list(announcements),
 661        do: announcements
 662
 663   defp take_announcements(_), do: []
 664
 665   #### Unfollow-related helpers
 666
 667   def make_unfollow_data(follower, followed, follow_activity, activity_id) do
 668     %{
 669       "type" => "Undo",
 670       "actor" => follower.ap_id,
 671       "to" => [followed.ap_id],
 672       "object" => follow_activity.data
 673     }
 674     |> Maps.put_if_present("id", activity_id)
 675   end
 676
 677   #### Block-related helpers
 678   @spec fetch_latest_block(User.t(), User.t()) :: Activity.t() | nil
 679   def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
 680     "Block"
 681     |> Activity.Queries.by_type()
 682     |> where(actor: ^blocker_id)
 683     # this is to use the index
 684     |> Activity.Queries.by_object_id(blocked_id)
 685     |> order_by([activity], fragment("? desc nulls last", activity.id))
 686     |> limit(1)
 687     |> Repo.one()
 688   end
 689
 690   def make_block_data(blocker, blocked, activity_id) do
 691     %{
 692       "type" => "Block",
 693       "actor" => blocker.ap_id,
 694       "to" => [blocked.ap_id],
 695       "object" => blocked.ap_id
 696     }
 697     |> Maps.put_if_present("id", activity_id)
 698   end
 699
 700   #### Create-related helpers
 701
 702   def make_create_data(params, additional) do
 703     published = params.published || make_date()
 704
 705     %{
 706       "type" => "Create",
 707       "to" => params.to |> Enum.uniq(),
 708       "actor" => params.actor.ap_id,
 709       "object" => params.object,
 710       "published" => published,
 711       "context" => params.context
 712     }
 713     |> Map.merge(additional)
 714   end
 715
 716   #### Listen-related helpers
 717   def make_listen_data(params, additional) do
 718     published = params.published || make_date()
 719
 720     %{
 721       "type" => "Listen",
 722       "to" => params.to |> Enum.uniq(),
 723       "actor" => params.actor.ap_id,
 724       "object" => params.object,
 725       "published" => published,
 726       "context" => params.context
 727     }
 728     |> Map.merge(additional)
 729   end
 730
 731   #### Flag-related helpers
 732   @spec make_flag_data(map(), map()) :: map()
 733   def make_flag_data(%{actor: actor, context: context, content: content} = params, additional) do
 734     %{
 735       "type" => "Flag",
 736       "actor" => actor.ap_id,
 737       "content" => content,
 738       "object" => build_flag_object(params),
 739       "context" => context,
 740       "state" => "open"
 741     }
 742     |> Map.merge(additional)
 743   end
 744
 745   def make_flag_data(_, _), do: %{}
 746
 747   defp build_flag_object(%{account: account, statuses: statuses}) do
 748     [account.ap_id | build_flag_object(%{statuses: statuses})]
 749   end
 750
 751   defp build_flag_object(%{statuses: statuses}) do
 752     Enum.map(statuses || [], &build_flag_object/1)
 753   end
 754
 755   defp build_flag_object(%Activity{data: %{"id" => id}, object: %{data: data}}) do
 756     activity_actor = User.get_by_ap_id(data["actor"])
 757
 758     %{
 759       "type" => "Note",
 760       "id" => id,
 761       "content" => data["content"],
 762       "published" => data["published"],
 763       "actor" =>
 764         AccountView.render(
 765           "show.json",
 766           %{user: activity_actor, skip_visibility_check: true}
 767         )
 768     }
 769   end
 770
 771   defp build_flag_object(act) when is_map(act) or is_binary(act) do
 772     id =
 773       case act do
 774         %Activity{} = act -> act.data["id"]
 775         act when is_map(act) -> act["id"]
 776         act when is_binary(act) -> act
 777       end
 778
 779     case Activity.get_by_ap_id_with_object(id) do
 780       %Activity{} = activity ->
 781         build_flag_object(activity)
 782
 783       nil ->
 784         if activity = Activity.get_by_object_ap_id_with_object(id) do
 785           build_flag_object(activity)
 786         else
 787           %{"id" => id, "deleted" => true}
 788         end
 789     end
 790   end
 791
 792   defp build_flag_object(_), do: []
 793
 794   #### Report-related helpers
 795   def get_reports(params, page, page_size) do
 796     params =
 797       params
 798       |> Map.put(:type, "Flag")
 799       |> Map.put(:skip_preload, true)
 800       |> Map.put(:preload_report_notes, true)
 801       |> Map.put(:total, true)
 802       |> Map.put(:limit, page_size)
 803       |> Map.put(:offset, (page - 1) * page_size)
 804
 805     ActivityPub.fetch_activities([], params, :offset)
 806   end
 807
 808   def update_report_state(%Activity{} = activity, state)
 809       when state in @strip_status_report_states do
 810     {:ok, stripped_activity} = strip_report_status_data(activity)
 811
 812     new_data =
 813       activity.data
 814       |> Map.put("state", state)
 815       |> Map.put("object", stripped_activity.data["object"])
 816
 817     activity
 818     |> Changeset.change(data: new_data)
 819     |> Repo.update()
 820   end
 821
 822   def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
 823     new_data = Map.put(activity.data, "state", state)
 824
 825     activity
 826     |> Changeset.change(data: new_data)
 827     |> Repo.update()
 828   end
 829
 830   def update_report_state(activity_ids, state) when state in @supported_report_states do
 831     activities_num = length(activity_ids)
 832
 833     from(a in Activity, where: a.id in ^activity_ids)
 834     |> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
 835     |> Repo.update_all([])
 836     |> case do
 837       {^activities_num, _} -> :ok
 838       _ -> {:error, activity_ids}
 839     end
 840   end
 841
 842   def update_report_state(_, _), do: {:error, "Unsupported state"}
 843
 844   def strip_report_status_data(activity) do
 845     [actor | reported_activities] = activity.data["object"]
 846
 847     stripped_activities =
 848       Enum.map(reported_activities, fn
 849         act when is_map(act) -> act["id"]
 850         act when is_binary(act) -> act
 851       end)
 852
 853     new_data = put_in(activity.data, ["object"], [actor | stripped_activities])
 854
 855     {:ok, %{activity | data: new_data}}
 856   end
 857
 858   def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
 859     [to, cc, recipients] =
 860       activity
 861       |> get_updated_targets(visibility)
 862       |> Enum.map(&Enum.uniq/1)
 863
 864     object_data =
 865       activity.object.data
 866       |> Map.put("to", to)
 867       |> Map.put("cc", cc)
 868
 869     {:ok, object} =
 870       activity.object
 871       |> Object.change(%{data: object_data})
 872       |> Object.update_and_set_cache()
 873
 874     activity_data =
 875       activity.data
 876       |> Map.put("to", to)
 877       |> Map.put("cc", cc)
 878
 879     activity
 880     |> Map.put(:object, object)
 881     |> Activity.change(%{data: activity_data, recipients: recipients})
 882     |> Repo.update()
 883   end
 884
 885   def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}
 886
 887   defp get_updated_targets(
 888          %Activity{data: %{"to" => to} = data, recipients: recipients},
 889          visibility
 890        ) do
 891     cc = Map.get(data, "cc", [])
 892     follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
 893     public = Pleroma.Constants.as_public()
 894
 895     case visibility do
 896       "public" ->
 897         to = [public | List.delete(to, follower_address)]
 898         cc = [follower_address | List.delete(cc, public)]
 899         recipients = [public | recipients]
 900         [to, cc, recipients]
 901
 902       "private" ->
 903         to = [follower_address | List.delete(to, public)]
 904         cc = List.delete(cc, public)
 905         recipients = List.delete(recipients, public)
 906         [to, cc, recipients]
 907
 908       "unlisted" ->
 909         to = [follower_address | List.delete(to, public)]
 910         cc = [public | List.delete(cc, follower_address)]
 911         recipients = recipients ++ [follower_address, public]
 912         [to, cc, recipients]
 913
 914       _ ->
 915         [to, cc, recipients]
 916     end
 917   end
 918
 919   def get_existing_votes(actor, %{data: %{"id" => id}}) do
 920     actor
 921     |> Activity.Queries.by_actor()
 922     |> Activity.Queries.by_type("Create")
 923     |> Activity.with_preloaded_object()
 924     |> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
 925     |> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
 926     |> Repo.all()
 927   end
 928 end