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

   1 defmodule Pleroma.Web.ActivityPub.ActivityPub do
   2   alias Pleroma.{Activity, Repo, Object, Upload, User, Web}
   3   alias Ecto.{Changeset, UUID}
   4   import Ecto.Query
   5   import Pleroma.Web.ActivityPub.Utils
   6   require Logger
   7
   8   def insert(map, local \\ true) when is_map(map) do
   9     with nil <- Activity.get_by_ap_id(map["id"]),
  10          map <- lazy_put_activity_defaults(map),
  11          :ok <- insert_full_object(map) do
  12       Repo.insert(%Activity{data: map, local: local})
  13     else
  14       %Activity{} = activity -> {:ok, activity}
  15       error -> {:error, error}
  16     end
  17   end
  18
  19   def create(to, actor, context, object, additional \\ %{}, published \\ nil, local \\ true) do
  20     with create_data <- make_create_data(%{to: to, actor: actor, published: published, context: context, object: object}, additional),
  21          {:ok, activity} <- insert(create_data, local),
  22          :ok <- maybe_federate(activity) do
  23       {:ok, activity}
  24     end
  25   end
  26
  27   # TODO: This is weird, maybe we shouldn't check here if we can make the activity.
  28   def like(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id \\ nil, local \\ true) do
  29     with nil <- get_existing_like(ap_id, object),
  30          like_data <- make_like_data(user, object, activity_id),
  31          {:ok, activity} <- insert(like_data, local),
  32          {:ok, object} <- add_like_to_object(activity, object),
  33          :ok <- maybe_federate(activity) do
  34       {:ok, activity, object}
  35     else
  36       %Activity{} = activity -> {:ok, activity, object}
  37       error -> {:error, error}
  38     end
  39   end
  40
  41   def unlike(%User{} = actor, %Object{} = object) do
  42     with %Activity{} = activity <- get_existing_like(actor.ap_id, object),
  43          {:ok, _activity} <- Repo.delete(activity),
  44          {:ok, object} <- remove_like_from_object(activity, object) do
  45       {:ok, object}
  46       else _e -> {:ok, object}
  47     end
  48   end
  49
  50   def announce(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id \\ nil, local \\ true) do
  51     with announce_data <- make_announce_data(user, object, activity_id),
  52          {:ok, activity} <- insert(announce_data, local),
  53          {:ok, object} <- add_announce_to_object(activity, object),
  54          :ok <- maybe_federate(activity) do
  55       {:ok, activity, object}
  56     else
  57       error -> {:error, error}
  58     end
  59   end
  60
  61   def follow(follower, followed, activity_id \\ nil, local \\ true) do
  62     with data <- make_follow_data(follower, followed, activity_id),
  63          {:ok, activity} <- insert(data, local),
  64          :ok <- maybe_federate(activity) do
  65       {:ok, activity}
  66     end
  67   end
  68
  69   def unfollow(follower, followed, local \\ true) do
  70     with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
  71          unfollow_data <- make_unfollow_data(follower, followed, follow_activity),
  72          {:ok, activity} <- insert(unfollow_data, local),
  73          :ok, maybe_federate(activity) do
  74       {:ok, activity}
  75     end
  76   end
  77
  78   def fetch_activities_for_context(context) do
  79     query = from activity in Activity,
  80       where: fragment("? @> ?", activity.data, ^%{ type: "Create", context: context }),
  81       order_by: [desc: :inserted_at]
  82     Repo.all(query)
  83   end
  84
  85   def fetch_public_activities(opts \\ %{}) do
  86     public = ["https://www.w3.org/ns/activitystreams#Public"]
  87     fetch_activities(public, opts)
  88   end
  89
  90   defp restrict_since(query, %{"since_id" => since_id}) do
  91     from activity in query, where: activity.id > ^since_id
  92   end
  93   defp restrict_since(query, _), do: query
  94
  95   defp restrict_recipients(query, recipients) do
  96     Enum.reduce(recipients, query, fn (recipient, q) ->
  97       map = %{ to: [recipient] }
  98       from activity in q,
  99       or_where: fragment(~s(? @> ?), activity.data, ^map)
 100     end)
 101   end
 102
 103   defp restrict_local(query, %{"local_only" => true}) do
 104     from activity in query, where: activity.local == true
 105   end
 106   defp restrict_local(query, _), do: query
 107
 108   defp restrict_max(query, %{"max_id" => max_id}) do
 109     from activity in query, where: activity.id < ^max_id
 110   end
 111   defp restrict_max(query, _), do: query
 112
 113   defp restrict_actor(query, %{"actor_id" => actor_id}) do
 114     from activity in query,
 115       where: fragment("?->>'actor' = ?", activity.data, ^actor_id)
 116   end
 117   defp restrict_actor(query, _), do: query
 118
 119   def fetch_activities(recipients, opts \\ %{}) do
 120     base_query = from activity in Activity,
 121       limit: 20,
 122       order_by: [desc: :id]
 123
 124     base_query
 125     |> restrict_recipients(recipients)
 126     |> restrict_since(opts)
 127     |> restrict_local(opts)
 128     |> restrict_max(opts)
 129     |> restrict_actor(opts)
 130     |> Repo.all
 131     |> Enum.reverse
 132   end
 133
 134   def upload(file) do
 135     data = Upload.store(file)
 136     Repo.insert(%Object{data: data})
 137   end
 138 end