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

   1 defmodule Pleroma.Web.ActivityPub.ActivityPub do
   2   alias Pleroma.Repo
   3   alias Pleroma.{Activity, Object, Upload, User}
   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) 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)
  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 = Ecto.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 = Ecto.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 = Ecto.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     "#{Pleroma.Web.base_url()}/#{type}/#{Ecto.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     Repo.all(query)
 177     |> Enum.reverse
 178   end
 179
 180   def announce(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, local \\ true) do
 181     data = %{
 182       "type" => "Announce",
 183       "actor" => ap_id,
 184       "object" => id,
 185       "to" => [User.ap_followers(user), object.data["actor"]],
 186       "context" => object.data["context"]
 187     }
 188
 189     {:ok, activity} = insert(data, local)
 190
 191     announcements = [ap_id | (object.data["announcements"] || [])] |> Enum.uniq
 192
 193     new_data = object.data
 194     |> Map.put("announcement_count", length(announcements))
 195     |> Map.put("announcements", announcements)
 196
 197     changeset = Ecto.Changeset.change(object, data: new_data)
 198     {:ok, object} = Repo.update(changeset)
 199
 200     update_object_in_activities(object)
 201
 202     if user.local do
 203       Pleroma.Web.Federator.enqueue(:publish, activity)
 204     end
 205
 206     {:ok, activity, object}
 207   end
 208
 209   def fetch_activities_for_context(context) do
 210     query = from activity in Activity,
 211       where: fragment("? @> ?", activity.data, ^%{ context: context })
 212     Repo.all(query)
 213   end
 214
 215   def upload(file) do
 216     data = Upload.store(file)
 217     Repo.insert(%Object{data: data})
 218   end
 219
 220   defp make_date do
 221     DateTime.utc_now() |> DateTime.to_iso8601
 222   end
 223 end