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