git.squeep.com Git - akkoma/blob - lib/pleroma/web/activity_pub/utils.ex

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