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