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   require Logger
   6
   7   def insert(map, local \\ true) when is_map(map) do
   8     map = map
   9     |> Map.put_new_lazy("id", &generate_activity_id/0)
  10     |> Map.put_new_lazy("published", &make_date/0)
  11
  12     with %Activity{} = activity <- Activity.get_by_ap_id(map["id"]) do
  13       Logger.debug(fn -> "Already have activity, #{activity.id}, not inserting." end)
  14       {:ok, activity}
  15     else _e ->
  16       map = if is_map(map["object"]) do
  17         object = Map.put_new_lazy(map["object"], "id", &generate_object_id/0)
  18         Repo.insert!(%Object{data: object})
  19         Map.put(map, "object", object)
  20       else
  21         map
  22       end
  23
  24       Repo.insert(%Activity{data: map, local: local})
  25     end
  26   end
  27
  28   def create(to, actor, context, object, additional \\ %{}, published \\ nil, local \\ true) do
  29     published = published || make_date()
  30
  31     activity = %{
  32       "type" => "Create",
  33       "to" => to |> Enum.uniq,
  34       "actor" => actor.ap_id,
  35       "object" => object,
  36       "published" => published,
  37       "context" => context
  38     }
  39     |> Map.merge(additional)
  40
  41     with {:ok, activity} <- insert(activity, local) do
  42       if actor.local do
  43         Pleroma.Web.Federator.enqueue(:publish, activity)
  44        end
  45
  46       {:ok, activity}
  47     end
  48   end
  49
  50   def like(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id \\ nil, local \\ true) do
  51     cond do
  52       # There's already a like here, so return the original activity.
  53       ap_id in (object.data["likes"] || []) ->
  54         query = from activity in Activity,
  55           where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})
  56
  57         activity = Repo.one(query)
  58         {:ok, activity, object}
  59       true ->
  60         data = %{
  61           "type" => "Like",
  62           "actor" => ap_id,
  63           "object" => id,
  64           "to" => [User.ap_followers(user), object.data["actor"]],
  65           "context" => object.data["context"]
  66         }
  67
  68         data = if activity_id, do: Map.put(data, "id", activity_id), else: data
  69
  70         {:ok, activity} = insert(data, local)
  71
  72         likes = [ap_id | (object.data["likes"] || [])] |> Enum.uniq
  73
  74         new_data = object.data
  75         |> Map.put("like_count", length(likes))
  76         |> Map.put("likes", likes)
  77
  78         changeset = Changeset.change(object, data: new_data)
  79         {:ok, object} = Repo.update(changeset)
  80
  81         update_object_in_activities(object)
  82
  83         if user.local do
  84           Pleroma.Web.Federator.enqueue(:publish, activity)
  85         end
  86
  87         {:ok, activity, object}
  88     end
  89   end
  90
  91   defp update_object_in_activities(%{data: %{"id" => id}} = object) do
  92     # TODO
  93     # Update activities that already had this. Could be done in a seperate process.
  94     # Alternatively, just don't do this and fetch the current object each time. Most
  95     # could probably be taken from cache.
  96     relevant_activities = Activity.all_by_object_ap_id(id)
  97     Enum.map(relevant_activities, fn (activity) ->
  98       new_activity_data = activity.data |> Map.put("object", object.data)
  99       changeset = Changeset.change(activity, data: new_activity_data)
 100       Repo.update(changeset)
 101     end)
 102   end
 103
 104   def unlike(%User{ap_id: ap_id}, %Object{data: %{ "id" => id}} = object) do
 105     query = from activity in Activity,
 106       where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})
 107
 108     activity = Repo.one(query)
 109
 110     if activity do
 111       # just delete for now...
 112       {:ok, _activity} = Repo.delete(activity)
 113
 114       likes = (object.data["likes"] || []) |> List.delete(ap_id)
 115
 116       new_data = object.data
 117       |> Map.put("like_count", length(likes))
 118       |> Map.put("likes", likes)
 119
 120       changeset = Changeset.change(object, data: new_data)
 121       {:ok, object} = Repo.update(changeset)
 122
 123       update_object_in_activities(object)
 124
 125       {:ok, object}
 126     else
 127       {:ok, object}
 128     end
 129   end
 130
 131   def generate_activity_id do
 132     generate_id("activities")
 133   end
 134
 135   def generate_context_id do
 136     generate_id("contexts")
 137   end
 138
 139   def generate_object_id do
 140     Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :object, Ecto.UUID.generate)
 141   end
 142
 143   def generate_id(type) do
 144     "#{Web.base_url()}/#{type}/#{UUID.generate}"
 145   end
 146
 147   def fetch_public_activities(opts \\ %{}) do
 148     public = ["https://www.w3.org/ns/activitystreams#Public"]
 149     fetch_activities(public, opts)
 150   end
 151
 152   def fetch_activities(recipients, opts \\ %{}) do
 153     since_id = opts["since_id"] || 0
 154
 155     query = from activity in Activity,
 156       limit: 20,
 157       order_by: [desc: :inserted_at]
 158
 159     query = Enum.reduce(recipients, query, fn (recipient, q) ->
 160       map = %{ to: [recipient] }
 161       from activity in q,
 162       or_where: fragment(~s(? @> ?), activity.data, ^map)
 163     end)
 164
 165     query = from activity in query,
 166       where: activity.id > ^since_id
 167
 168     query = if opts["local_only"] do
 169       from activity in query, where: activity.local == true
 170     else
 171       query
 172     end
 173
 174     query = if opts["max_id"] do
 175       from activity in query, where: activity.id < ^opts["max_id"]
 176     else
 177       query
 178     end
 179
 180     query = if opts["actor_id"] do
 181       from activity in query,
 182         where: fragment("? @> ?", activity.data, ^%{actor: opts["actor_id"]})
 183     else
 184       query
 185     end
 186
 187     Enum.reverse(Repo.all(query))
 188   end
 189
 190   def announce(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id \\ nil, local \\ true) do
 191     data = %{
 192       "type" => "Announce",
 193       "actor" => ap_id,
 194       "object" => id,
 195       "to" => [User.ap_followers(user), object.data["actor"]],
 196       "context" => object.data["context"]
 197     }
 198
 199     data = if activity_id, do: Map.put(data, "id", activity_id), else: data
 200
 201     {:ok, activity} = insert(data, local)
 202
 203     announcements = [ap_id | (object.data["announcements"] || [])] |> Enum.uniq
 204
 205     new_data = object.data
 206     |> Map.put("announcement_count", length(announcements))
 207     |> Map.put("announcements", announcements)
 208
 209     changeset = Changeset.change(object, data: new_data)
 210     {:ok, object} = Repo.update(changeset)
 211
 212     update_object_in_activities(object)
 213
 214     if user.local do
 215       Pleroma.Web.Federator.enqueue(:publish, activity)
 216     end
 217
 218     {:ok, activity, object}
 219   end
 220
 221   def follow(%User{ap_id: follower_id, local: actor_local}, %User{ap_id: followed_id}, activity_id \\ nil, local \\ true) do
 222     data = %{
 223       "type" => "Follow",
 224       "actor" => follower_id,
 225       "to" => [followed_id],
 226       "object" => followed_id,
 227       "published" => make_date()
 228     }
 229
 230     data = if activity_id, do: Map.put(data, "id", activity_id), else: data
 231
 232     with {:ok, activity} <- insert(data, local) do
 233       if actor_local do
 234         Pleroma.Web.Federator.enqueue(:publish, activity)
 235        end
 236
 237       {:ok, activity}
 238     end
 239   end
 240
 241   def unfollow(follower, followed, local \\ true) do
 242     with follow_activity when not is_nil(follow_activity) <- fetch_latest_follow(follower, followed) do
 243       data = %{
 244         "type" => "Undo",
 245         "actor" => follower.ap_id,
 246         "to" => [followed.ap_id],
 247         "object" => follow_activity.data["id"],
 248         "published" => make_date()
 249       }
 250
 251       with {:ok, activity} <- insert(data, local) do
 252         if follower.local do
 253           Pleroma.Web.Federator.enqueue(:publish, activity)
 254         end
 255
 256         {:ok, activity}
 257       end
 258     end
 259   end
 260
 261   def fetch_activities_for_context(context) do
 262     query = from activity in Activity,
 263       where: fragment("? @> ?", activity.data, ^%{ context: context })
 264     Repo.all(query)
 265   end
 266
 267   def fetch_latest_follow(%User{ap_id: follower_id},
 268                           %User{ap_id: followed_id}) do
 269     query = from activity in Activity,
 270       where: fragment("? @> ?", activity.data, ^%{type: "Follow", actor: follower_id,
 271                                                   object: followed_id}),
 272       order_by: [desc: :inserted_at],
 273       limit: 1
 274     Repo.one(query)
 275   end
 276
 277   def upload(file) do
 278     data = Upload.store(file)
 279     Repo.insert(%Object{data: data})
 280   end
 281
 282   defp make_date do
 283     DateTime.utc_now() |> DateTime.to_iso8601
 284   end
 285 end