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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 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.Notification
  10   alias Pleroma.Object
  11   alias Pleroma.Repo
  12   alias Pleroma.User
  13   alias Pleroma.Web
  14   alias Pleroma.Web.ActivityPub.Visibility
  15   alias Pleroma.Web.Endpoint
  16   alias Pleroma.Web.Router.Helpers
  17
  18   import Ecto.Query
  19
  20   require Logger
  21   require Pleroma.Constants
  22
  23   @supported_object_types ["Article", "Note", "Video", "Page", "Question", "Answer", "Audio"]
  24   @supported_report_states ~w(open closed resolved)
  25   @valid_visibilities ~w(public unlisted private direct)
  26
  27   # Some implementations send the actor URI as the actor field, others send the entire actor object,
  28   # so figure out what the actor's URI is based on what we have.
  29   def get_ap_id(%{"id" => id} = _), do: id
  30   def get_ap_id(id), do: id
  31
  32   def normalize_params(params) do
  33     Map.put(params, "actor", get_ap_id(params["actor"]))
  34   end
  35
  36   @spec determine_explicit_mentions(map()) :: map()
  37   def determine_explicit_mentions(%{"tag" => tag} = _) when is_list(tag) do
  38     Enum.flat_map(tag, fn
  39       %{"type" => "Mention", "href" => href} -> [href]
  40       _ -> []
  41     end)
  42   end
  43
  44   def determine_explicit_mentions(%{"tag" => tag} = object) when is_map(tag) do
  45     object
  46     |> Map.put("tag", [tag])
  47     |> determine_explicit_mentions()
  48   end
  49
  50   def determine_explicit_mentions(_), do: []
  51
  52   @spec label_in_collection?(any(), any()) :: boolean()
  53   defp label_in_collection?(ap_id, coll) when is_binary(coll), do: ap_id == coll
  54   defp label_in_collection?(ap_id, coll) when is_list(coll), do: ap_id in coll
  55   defp label_in_collection?(_, _), do: false
  56
  57   @spec label_in_message?(String.t(), map()) :: boolean()
  58   def label_in_message?(label, params),
  59     do:
  60       [params["to"], params["cc"], params["bto"], params["bcc"]]
  61       |> Enum.any?(&label_in_collection?(label, &1))
  62
  63   @spec unaddressed_message?(map()) :: boolean()
  64   def unaddressed_message?(params),
  65     do:
  66       [params["to"], params["cc"], params["bto"], params["bcc"]]
  67       |> Enum.all?(&is_nil(&1))
  68
  69   @spec recipient_in_message(User.t(), User.t(), map()) :: boolean()
  70   def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params),
  71     do:
  72       label_in_message?(ap_id, params) || unaddressed_message?(params) ||
  73         User.following?(recipient, actor)
  74
  75   defp extract_list(target) when is_binary(target), do: [target]
  76   defp extract_list(lst) when is_list(lst), do: lst
  77   defp extract_list(_), do: []
  78
  79   def maybe_splice_recipient(ap_id, params) do
  80     need_splice? =
  81       !label_in_collection?(ap_id, params["to"]) &&
  82         !label_in_collection?(ap_id, params["cc"])
  83
  84     if need_splice? do
  85       cc_list = extract_list(params["cc"])
  86       Map.put(params, "cc", [ap_id | cc_list])
  87     else
  88       params
  89     end
  90   end
  91
  92   def make_json_ld_header do
  93     %{
  94       "@context" => [
  95         "https://www.w3.org/ns/activitystreams",
  96         "#{Web.base_url()}/schemas/litepub-0.1.jsonld",
  97         %{
  98           "@language" => "und"
  99         }
 100       ]
 101     }
 102   end
 103
 104   def make_date do
 105     DateTime.utc_now() |> DateTime.to_iso8601()
 106   end
 107
 108   def generate_activity_id do
 109     generate_id("activities")
 110   end
 111
 112   def generate_context_id do
 113     generate_id("contexts")
 114   end
 115
 116   def generate_object_id do
 117     Helpers.o_status_url(Endpoint, :object, UUID.generate())
 118   end
 119
 120   def generate_id(type) do
 121     "#{Web.base_url()}/#{type}/#{UUID.generate()}"
 122   end
 123
 124   def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
 125     fake_create_activity = %{
 126       "to" => object["to"],
 127       "cc" => object["cc"],
 128       "type" => "Create",
 129       "object" => object
 130     }
 131
 132     get_notified_from_object(fake_create_activity)
 133   end
 134
 135   def get_notified_from_object(object) do
 136     Notification.get_notified_from_activity(%Activity{data: object}, false)
 137   end
 138
 139   def create_context(context) do
 140     context = context || generate_id("contexts")
 141
 142     # Ecto has problems accessing the constraint inside the jsonb,
 143     # so we explicitly check for the existed object before insert
 144     object = Object.get_cached_by_ap_id(context)
 145
 146     with true <- is_nil(object),
 147          changeset <- Object.context_mapping(context),
 148          {:ok, inserted_object} <- Repo.insert(changeset) do
 149       inserted_object
 150     else
 151       _ ->
 152         object
 153     end
 154   end
 155
 156   @doc """
 157   Enqueues an activity for federation if it's local
 158   """
 159   @spec maybe_federate(any()) :: :ok
 160   def maybe_federate(%Activity{local: true} = activity) do
 161     if Pleroma.Config.get!([:instance, :federating]) do
 162       Pleroma.Web.Federator.publish(activity)
 163     end
 164
 165     :ok
 166   end
 167
 168   def maybe_federate(_), do: :ok
 169
 170   @doc """
 171   Adds an id and a published data if they aren't there,
 172   also adds it to an included object
 173   """
 174   @spec lazy_put_activity_defaults(map(), boolean) :: map()
 175   def lazy_put_activity_defaults(map, fake? \\ false)
 176
 177   def lazy_put_activity_defaults(map, true) do
 178     map
 179     |> Map.put_new("id", "pleroma:fakeid")
 180     |> Map.put_new_lazy("published", &make_date/0)
 181     |> Map.put_new("context", "pleroma:fakecontext")
 182     |> Map.put_new("context_id", -1)
 183     |> lazy_put_object_defaults(true)
 184   end
 185
 186   def lazy_put_activity_defaults(map, _fake?) do
 187     %{data: %{"id" => context}, id: context_id} = create_context(map["context"])
 188
 189     map
 190     |> Map.put_new_lazy("id", &generate_activity_id/0)
 191     |> Map.put_new_lazy("published", &make_date/0)
 192     |> Map.put_new("context", context)
 193     |> Map.put_new("context_id", context_id)
 194     |> lazy_put_object_defaults(false)
 195   end
 196
 197   # Adds an id and published date if they aren't there.
 198   #
 199   @spec lazy_put_object_defaults(map(), boolean()) :: map()
 200   defp lazy_put_object_defaults(%{"object" => map} = activity, true)
 201        when is_map(map) do
 202     object =
 203       map
 204       |> Map.put_new("id", "pleroma:fake_object_id")
 205       |> Map.put_new_lazy("published", &make_date/0)
 206       |> Map.put_new("context", activity["context"])
 207       |> Map.put_new("context_id", activity["context_id"])
 208       |> Map.put_new("fake", true)
 209
 210     %{activity | "object" => object}
 211   end
 212
 213   defp lazy_put_object_defaults(%{"object" => map} = activity, _)
 214        when is_map(map) do
 215     object =
 216       map
 217       |> Map.put_new_lazy("id", &generate_object_id/0)
 218       |> Map.put_new_lazy("published", &make_date/0)
 219       |> Map.put_new("context", activity["context"])
 220       |> Map.put_new("context_id", activity["context_id"])
 221
 222     %{activity | "object" => object}
 223   end
 224
 225   defp lazy_put_object_defaults(activity, _), do: activity
 226
 227   @doc """
 228   Inserts a full object if it is contained in an activity.
 229   """
 230   def insert_full_object(%{"object" => %{"type" => type} = object_data} = map)
 231       when is_map(object_data) and type in @supported_object_types do
 232     with {:ok, object} <- Object.create(object_data) do
 233       map = Map.put(map, "object", object.data["id"])
 234
 235       {:ok, map, object}
 236     end
 237   end
 238
 239   def insert_full_object(map), do: {:ok, map, nil}
 240
 241   #### Like-related helpers
 242
 243   @doc """
 244   Returns an existing like if a user already liked an object
 245   """
 246   @spec get_existing_like(String.t(), map()) :: Activity.t() | nil
 247   def get_existing_like(actor, %{data: %{"id" => id}}) do
 248     actor
 249     |> Activity.Queries.by_actor()
 250     |> Activity.Queries.by_object_id(id)
 251     |> Activity.Queries.by_type("Like")
 252     |> limit(1)
 253     |> Repo.one()
 254   end
 255
 256   @spec make_like_data(User.t(), map(), String.t()) :: map()
 257   def make_like_data(
 258         %User{ap_id: ap_id} = actor,
 259         %{data: %{"actor" => object_actor_id, "id" => id}} = object,
 260         activity_id
 261       ) do
 262     object_actor = User.get_cached_by_ap_id(object_actor_id)
 263
 264     to =
 265       if Visibility.is_public?(object) do
 266         [actor.follower_address, object.data["actor"]]
 267       else
 268         [object.data["actor"]]
 269       end
 270
 271     cc =
 272       (object.data["to"] ++ (object.data["cc"] || []))
 273       |> List.delete(actor.ap_id)
 274       |> List.delete(object_actor.follower_address)
 275
 276     %{
 277       "type" => "Like",
 278       "actor" => ap_id,
 279       "object" => id,
 280       "to" => to,
 281       "cc" => cc,
 282       "context" => object.data["context"]
 283     }
 284     |> maybe_put("id", activity_id)
 285   end
 286
 287   @spec update_element_in_object(String.t(), list(any), Object.t()) ::
 288           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 289   def update_element_in_object(property, element, object) do
 290     data =
 291       Map.merge(
 292         object.data,
 293         %{"#{property}_count" => length(element), "#{property}s" => element}
 294       )
 295
 296     object
 297     |> Changeset.change(data: data)
 298     |> Object.update_and_set_cache()
 299   end
 300
 301   @spec add_like_to_object(Activity.t(), Object.t()) ::
 302           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 303   def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
 304     [actor | fetch_likes(object)]
 305     |> Enum.uniq()
 306     |> update_likes_in_object(object)
 307   end
 308
 309   @spec remove_like_from_object(Activity.t(), Object.t()) ::
 310           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 311   def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
 312     object
 313     |> fetch_likes()
 314     |> List.delete(actor)
 315     |> update_likes_in_object(object)
 316   end
 317
 318   defp update_likes_in_object(likes, object) do
 319     update_element_in_object("like", likes, object)
 320   end
 321
 322   defp fetch_likes(object) do
 323     if is_list(object.data["likes"]) do
 324       object.data["likes"]
 325     else
 326       []
 327     end
 328   end
 329
 330   #### Follow-related helpers
 331
 332   @doc """
 333   Updates a follow activity's state (for locked accounts).
 334   """
 335   @spec update_follow_state_for_all(Activity.t(), String.t()) :: {:ok, Activity} | {:error, any()}
 336   def update_follow_state_for_all(
 337         %Activity{data: %{"actor" => actor, "object" => object}} = activity,
 338         state
 339       ) do
 340     "Follow"
 341     |> Activity.Queries.by_type()
 342     |> Activity.Queries.by_actor(actor)
 343     |> Activity.Queries.by_object_id(object)
 344     |> where(fragment("data->>'state' = 'pending'"))
 345     |> update(set: [data: fragment("jsonb_set(data, '{state}', ?)", ^state)])
 346     |> Repo.update_all([])
 347
 348     User.set_follow_state_cache(actor, object, state)
 349
 350     activity = Activity.get_by_id(activity.id)
 351
 352     {:ok, activity}
 353   end
 354
 355   def update_follow_state(
 356         %Activity{data: %{"actor" => actor, "object" => object}} = activity,
 357         state
 358       ) do
 359     new_data = Map.put(activity.data, "state", state)
 360     changeset = Changeset.change(activity, data: new_data)
 361
 362     with {:ok, activity} <- Repo.update(changeset) do
 363       User.set_follow_state_cache(actor, object, state)
 364       {:ok, activity}
 365     end
 366   end
 367
 368   @doc """
 369   Makes a follow activity data for the given follower and followed
 370   """
 371   def make_follow_data(
 372         %User{ap_id: follower_id},
 373         %User{ap_id: followed_id} = _followed,
 374         activity_id
 375       ) do
 376     %{
 377       "type" => "Follow",
 378       "actor" => follower_id,
 379       "to" => [followed_id],
 380       "cc" => [Pleroma.Constants.as_public()],
 381       "object" => followed_id,
 382       "state" => "pending"
 383     }
 384     |> maybe_put("id", activity_id)
 385   end
 386
 387   def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
 388     "Follow"
 389     |> Activity.Queries.by_type()
 390     |> where(actor: ^follower_id)
 391     # this is to use the index
 392     |> Activity.Queries.by_object_id(followed_id)
 393     |> order_by([activity], fragment("? desc nulls last", activity.id))
 394     |> limit(1)
 395     |> Repo.one()
 396   end
 397
 398   #### Announce-related helpers
 399
 400   @doc """
 401   Retruns an existing announce activity if the notice has already been announced
 402   """
 403   @spec get_existing_announce(String.t(), map()) :: Activity.t() | nil
 404   def get_existing_announce(actor, %{data: %{"id" => ap_id}}) do
 405     "Announce"
 406     |> Activity.Queries.by_type()
 407     |> where(actor: ^actor)
 408     # this is to use the index
 409     |> Activity.Queries.by_object_id(ap_id)
 410     |> Repo.one()
 411   end
 412
 413   @doc """
 414   Make announce activity data for the given actor and object
 415   """
 416   # for relayed messages, we only want to send to subscribers
 417   def make_announce_data(
 418         %User{ap_id: ap_id} = user,
 419         %Object{data: %{"id" => id}} = object,
 420         activity_id,
 421         false
 422       ) do
 423     %{
 424       "type" => "Announce",
 425       "actor" => ap_id,
 426       "object" => id,
 427       "to" => [user.follower_address],
 428       "cc" => [],
 429       "context" => object.data["context"]
 430     }
 431     |> maybe_put("id", activity_id)
 432   end
 433
 434   def make_announce_data(
 435         %User{ap_id: ap_id} = user,
 436         %Object{data: %{"id" => id}} = object,
 437         activity_id,
 438         true
 439       ) do
 440     %{
 441       "type" => "Announce",
 442       "actor" => ap_id,
 443       "object" => id,
 444       "to" => [user.follower_address, object.data["actor"]],
 445       "cc" => [Pleroma.Constants.as_public()],
 446       "context" => object.data["context"]
 447     }
 448     |> maybe_put("id", activity_id)
 449   end
 450
 451   @doc """
 452   Make unannounce activity data for the given actor and object
 453   """
 454   def make_unannounce_data(
 455         %User{ap_id: ap_id} = user,
 456         %Activity{data: %{"context" => context, "object" => object}} = activity,
 457         activity_id
 458       ) do
 459     object = Object.normalize(object)
 460
 461     %{
 462       "type" => "Undo",
 463       "actor" => ap_id,
 464       "object" => activity.data,
 465       "to" => [user.follower_address, object.data["actor"]],
 466       "cc" => [Pleroma.Constants.as_public()],
 467       "context" => context
 468     }
 469     |> maybe_put("id", activity_id)
 470   end
 471
 472   def make_unlike_data(
 473         %User{ap_id: ap_id} = user,
 474         %Activity{data: %{"context" => context, "object" => object}} = activity,
 475         activity_id
 476       ) do
 477     object = Object.normalize(object)
 478
 479     %{
 480       "type" => "Undo",
 481       "actor" => ap_id,
 482       "object" => activity.data,
 483       "to" => [user.follower_address, object.data["actor"]],
 484       "cc" => [Pleroma.Constants.as_public()],
 485       "context" => context
 486     }
 487     |> maybe_put("id", activity_id)
 488   end
 489
 490   @spec add_announce_to_object(Activity.t(), Object.t()) ::
 491           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 492   def add_announce_to_object(
 493         %Activity{data: %{"actor" => actor}},
 494         object
 495       ) do
 496     unless actor |> User.get_cached_by_ap_id() |> User.invisible?() do
 497       announcements = take_announcements(object)
 498
 499       with announcements <- Enum.uniq([actor | announcements]) do
 500         update_element_in_object("announcement", announcements, object)
 501       end
 502     else
 503       {:ok, object}
 504     end
 505   end
 506
 507   def add_announce_to_object(_, object), do: {:ok, object}
 508
 509   @spec remove_announce_from_object(Activity.t(), Object.t()) ::
 510           {:ok, Object.t()} | {:error, Ecto.Changeset.t()}
 511   def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
 512     with announcements <- List.delete(take_announcements(object), actor) do
 513       update_element_in_object("announcement", announcements, object)
 514     end
 515   end
 516
 517   defp take_announcements(%{data: %{"announcements" => announcements}} = _)
 518        when is_list(announcements),
 519        do: announcements
 520
 521   defp take_announcements(_), do: []
 522
 523   #### Unfollow-related helpers
 524
 525   def make_unfollow_data(follower, followed, follow_activity, activity_id) do
 526     %{
 527       "type" => "Undo",
 528       "actor" => follower.ap_id,
 529       "to" => [followed.ap_id],
 530       "object" => follow_activity.data
 531     }
 532     |> maybe_put("id", activity_id)
 533   end
 534
 535   #### Block-related helpers
 536   @spec fetch_latest_block(User.t(), User.t()) :: Activity.t() | nil
 537   def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
 538     "Block"
 539     |> Activity.Queries.by_type()
 540     |> where(actor: ^blocker_id)
 541     # this is to use the index
 542     |> Activity.Queries.by_object_id(blocked_id)
 543     |> order_by([activity], fragment("? desc nulls last", activity.id))
 544     |> limit(1)
 545     |> Repo.one()
 546   end
 547
 548   def make_block_data(blocker, blocked, activity_id) do
 549     %{
 550       "type" => "Block",
 551       "actor" => blocker.ap_id,
 552       "to" => [blocked.ap_id],
 553       "object" => blocked.ap_id
 554     }
 555     |> maybe_put("id", activity_id)
 556   end
 557
 558   def make_unblock_data(blocker, blocked, block_activity, activity_id) do
 559     %{
 560       "type" => "Undo",
 561       "actor" => blocker.ap_id,
 562       "to" => [blocked.ap_id],
 563       "object" => block_activity.data
 564     }
 565     |> maybe_put("id", activity_id)
 566   end
 567
 568   #### Create-related helpers
 569
 570   def make_create_data(params, additional) do
 571     published = params.published || make_date()
 572
 573     %{
 574       "type" => "Create",
 575       "to" => params.to |> Enum.uniq(),
 576       "actor" => params.actor.ap_id,
 577       "object" => params.object,
 578       "published" => published,
 579       "context" => params.context
 580     }
 581     |> Map.merge(additional)
 582   end
 583
 584   #### Listen-related helpers
 585   def make_listen_data(params, additional) do
 586     published = params.published || make_date()
 587
 588     %{
 589       "type" => "Listen",
 590       "to" => params.to |> Enum.uniq(),
 591       "actor" => params.actor.ap_id,
 592       "object" => params.object,
 593       "published" => published,
 594       "context" => params.context
 595     }
 596     |> Map.merge(additional)
 597   end
 598
 599   #### Flag-related helpers
 600   @spec make_flag_data(map(), map()) :: map()
 601   def make_flag_data(%{actor: actor, context: context, content: content} = params, additional) do
 602     %{
 603       "type" => "Flag",
 604       "actor" => actor.ap_id,
 605       "content" => content,
 606       "object" => build_flag_object(params),
 607       "context" => context,
 608       "state" => "open"
 609     }
 610     |> Map.merge(additional)
 611   end
 612
 613   def make_flag_data(_, _), do: %{}
 614
 615   defp build_flag_object(%{account: account, statuses: statuses} = _) do
 616     [account.ap_id] ++
 617       Enum.map(statuses || [], fn
 618         %Activity{} = act -> act.data["id"]
 619         act when is_map(act) -> act["id"]
 620         act when is_binary(act) -> act
 621       end)
 622   end
 623
 624   defp build_flag_object(_), do: []
 625
 626   @doc """
 627   Fetches the OrderedCollection/OrderedCollectionPage from `from`, limiting the amount of pages fetched after
 628   the first one to `pages_left` pages.
 629   If the amount of pages is higher than the collection has, it returns whatever was there.
 630   """
 631   def fetch_ordered_collection(from, pages_left, acc \\ []) do
 632     with {:ok, response} <- Tesla.get(from),
 633          {:ok, collection} <- Jason.decode(response.body) do
 634       case collection["type"] do
 635         "OrderedCollection" ->
 636           # If we've encountered the OrderedCollection and not the page,
 637           # just call the same function on the page address
 638           fetch_ordered_collection(collection["first"], pages_left)
 639
 640         "OrderedCollectionPage" ->
 641           if pages_left > 0 do
 642             # There are still more pages
 643             if Map.has_key?(collection, "next") do
 644               # There are still more pages, go deeper saving what we have into the accumulator
 645               fetch_ordered_collection(
 646                 collection["next"],
 647                 pages_left - 1,
 648                 acc ++ collection["orderedItems"]
 649               )
 650             else
 651               # No more pages left, just return whatever we already have
 652               acc ++ collection["orderedItems"]
 653             end
 654           else
 655             # Got the amount of pages needed, add them all to the accumulator
 656             acc ++ collection["orderedItems"]
 657           end
 658
 659         _ ->
 660           {:error, "Not an OrderedCollection or OrderedCollectionPage"}
 661       end
 662     end
 663   end
 664
 665   #### Report-related helpers
 666
 667   def update_report_state(%Activity{} = activity, state) when state in @supported_report_states do
 668     new_data = Map.put(activity.data, "state", state)
 669
 670     activity
 671     |> Changeset.change(data: new_data)
 672     |> Repo.update()
 673   end
 674
 675   def update_report_state(_, _), do: {:error, "Unsupported state"}
 676
 677   def update_activity_visibility(activity, visibility) when visibility in @valid_visibilities do
 678     [to, cc, recipients] =
 679       activity
 680       |> get_updated_targets(visibility)
 681       |> Enum.map(&Enum.uniq/1)
 682
 683     object_data =
 684       activity.object.data
 685       |> Map.put("to", to)
 686       |> Map.put("cc", cc)
 687
 688     {:ok, object} =
 689       activity.object
 690       |> Object.change(%{data: object_data})
 691       |> Object.update_and_set_cache()
 692
 693     activity_data =
 694       activity.data
 695       |> Map.put("to", to)
 696       |> Map.put("cc", cc)
 697
 698     activity
 699     |> Map.put(:object, object)
 700     |> Activity.change(%{data: activity_data, recipients: recipients})
 701     |> Repo.update()
 702   end
 703
 704   def update_activity_visibility(_, _), do: {:error, "Unsupported visibility"}
 705
 706   defp get_updated_targets(
 707          %Activity{data: %{"to" => to} = data, recipients: recipients},
 708          visibility
 709        ) do
 710     cc = Map.get(data, "cc", [])
 711     follower_address = User.get_cached_by_ap_id(data["actor"]).follower_address
 712     public = Pleroma.Constants.as_public()
 713
 714     case visibility do
 715       "public" ->
 716         to = [public | List.delete(to, follower_address)]
 717         cc = [follower_address | List.delete(cc, public)]
 718         recipients = [public | recipients]
 719         [to, cc, recipients]
 720
 721       "private" ->
 722         to = [follower_address | List.delete(to, public)]
 723         cc = List.delete(cc, public)
 724         recipients = List.delete(recipients, public)
 725         [to, cc, recipients]
 726
 727       "unlisted" ->
 728         to = [follower_address | List.delete(to, public)]
 729         cc = [public | List.delete(cc, follower_address)]
 730         recipients = recipients ++ [follower_address, public]
 731         [to, cc, recipients]
 732
 733       _ ->
 734         [to, cc, recipients]
 735     end
 736   end
 737
 738   def get_existing_votes(actor, %{data: %{"id" => id}}) do
 739     actor
 740     |> Activity.Queries.by_actor()
 741     |> Activity.Queries.by_type("Create")
 742     |> Activity.with_preloaded_object()
 743     |> where([a, object: o], fragment("(?)->>'inReplyTo' = ?", o.data, ^to_string(id)))
 744     |> where([a, object: o], fragment("(?)->>'type' = 'Answer'", o.data))
 745     |> Repo.all()
 746   end
 747
 748   def maybe_put(map, _key, nil), do: map
 749   def maybe_put(map, key, value), do: Map.put(map, key, value)
 750 end