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   #### Flag-related helpers
 717   @spec make_flag_data(map(), map()) :: map()
 718   def make_flag_data(%{actor: actor, context: context, content: content} = params, additional) do
 719     %{
 720       "type" => "Flag",
 721       "actor" => actor.ap_id,
 722       "content" => content,
 723       "object" => build_flag_object(params),
 724       "context" => context,
 725       "state" => "open"
 726     }
 727     |> Map.merge(additional)
 728   end
 729
 730   def make_flag_data(_, _), do: %{}
 731
 732   defp build_flag_object(%{account: account, statuses: statuses}) do
 733     [account.ap_id | build_flag_object(%{statuses: statuses})]
 734   end
 735
 736   defp build_flag_object(%{statuses: statuses}) do
 737     Enum.map(statuses || [], &build_flag_object/1)
 738   end
 739
 740   defp build_flag_object(%Activity{data: %{"id" => id}, object: %{data: data}}) do
 741     activity_actor = User.get_by_ap_id(data["actor"])
 742
 743     %{
 744       "type" => "Note",
 745       "id" => id,
 746       "content" => data["content"],
 747       "published" => data["published"],
 748       "actor" =>
 749         AccountView.render(
 750           "show.json",
 751           %{user: activity_actor, skip_visibility_check: true}
 752         )
 753     }
 754   end
 755
 756   defp build_flag_object(act) when is_map(act) or is_binary(act) do
 757     id =
 758       case act do
 759         %Activity{} = act -> act.data["id"]
 760         act when is_map(act) -> act["id"]
 761         act when is_binary(act) -> act
 762       end
 763
 764     case Activity.get_by_ap_id_with_object(id) do
 765       %Activity{} = activity ->
 766         build_flag_object(activity)
 767
 768       nil ->
 769         if activity = Activity.get_by_object_ap_id_with_object(id) do
 770           build_flag_object(activity)
 771         else
 772           %{"id" => id, "deleted" => true}
 773         end
 774     end
 775   end
 776
 777   defp build_flag_object(_), do: []
 778
 779   #### Report-related helpers
 780   def get_reports(params, page, page_size) do
 781     params =
 782       params
 783       |> Map.put(:type, "Flag")
 784       |> Map.put(:skip_preload, true)
 785       |> Map.put(:preload_report_notes, true)
 786       |> Map.put(:total, true)
 787       |> Map.put(:limit, page_size)
 788       |> Map.put(:offset, (page - 1) * page_size)
 789
 790     ActivityPub.fetch_activities([], params, :offset)
 791   end
 792
 793   def update_report_state(%Activity{} = activity, state)
 794       when state in @strip_status_report_states do
 795     {:ok, stripped_activity} = strip_report_status_data(activity)
 796
 797     new_data =
 798       activity.data
 799       |> Map.put("state", state)
 800       |> Map.put("object", stripped_activity.data["object"])
 801
 802     activity
 803     |> Changeset.change(data: new_data)
 804     |> Repo.update()
 805   end
 806
 807   def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
 808     new_data = Map.put(activity.data, "state", state)
 809
 810     activity
 811     |> Changeset.change(data: new_data)
 812     |> Repo.update()
 813   end
 814
 815   def update_report_state(activity_ids, state) when state in @supported_report_states do
 816     activities_num = length(activity_ids)
 817
 818     from(a in Activity, where: a.id in ^activity_ids)
 819     |> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
 820     |> Repo.update_all([])
 821     |> case do
 822       {^activities_num, _} -> :ok
 823       _ -> {:error, activity_ids}
 824     end
 825   end
 826
 827   def update_report_state(_, _), do: {:error, "Unsupported state"}
 828
 829   def strip_report_status_data(activity) do
 830     [actor | reported_activities] = activity.data["object"]
 831
 832     stripped_activities =
 833       Enum.map(reported_activities, fn
 834         act when is_map(act) -> act["id"]
 835         act when is_binary(act) -> act
 836       end)
 837
 838     new_data = put_in(activity.data, ["object"], [actor | stripped_activities])
 839
 840     {:ok, %{activity | data: new_data}}
 841   end
 842
 843   def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
 844     [to, cc, recipients] =
 845       activity
 846       |> get_updated_targets(visibility)
 847       |> Enum.map(&Enum.uniq/1)
 848
 849     object_data =
 850       activity.object.data
 851       |> Map.put("to", to)
 852       |> Map.put("cc", cc)
 853
 854     {:ok, object} =
 855       activity.object
 856       |> Object.change(%{data: object_data})
 857       |> Object.update_and_set_cache()
 858
 859     activity_data =
 860       activity.data
 861       |> Map.put("to", to)
 862       |> Map.put("cc", cc)
 863
 864     activity
 865     |> Map.put(:object, object)
 866     |> Activity.change(%{data: activity_data, recipients: recipients})
 867     |> Repo.update()
 868   end
 869
 870   def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}
 871
 872   defp get_updated_targets(
 873          %Activity{data: %{"to" => to} = data, recipients: recipients},
 874          visibility
 875        ) do
 876     cc = Map.get(data, "cc", [])
 877     follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
 878     public = Pleroma.Constants.as_public()
 879
 880     case visibility do
 881       "public" ->
 882         to = [public | List.delete(to, follower_address)]
 883         cc = [follower_address | List.delete(cc, public)]
 884         recipients = [public | recipients]
 885         [to, cc, recipients]
 886
 887       "private" ->
 888         to = [follower_address | List.delete(to, public)]
 889         cc = List.delete(cc, public)
 890         recipients = List.delete(recipients, public)
 891         [to, cc, recipients]
 892
 893       "unlisted" ->
 894         to = [follower_address | List.delete(to, public)]
 895         cc = [public | List.delete(cc, follower_address)]
 896         recipients = recipients ++ [follower_address, public]
 897         [to, cc, recipients]
 898
 899       _ ->
 900         [to, cc, recipients]
 901     end
 902   end
 903
 904   def get_existing_votes(actor, %{data: %{"id" => id}}) do
 905     actor
 906     |> Activity.Queries.by_actor()
 907     |> Activity.Queries.by_type("Create")
 908     |> Activity.with_preloaded_object()
 909     |> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
 910     |> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
 911     |> Repo.all()
 912   end
 913 end