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) 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})
  20   end
  21
  22   def like(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object) do
  23     cond do
  24       # There's already a like here, so return the original activity.
  25       ap_id in (object.data["likes"] || []) ->
  26         query = from activity in Activity,
  27           where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})
  28
  29         activity = Repo.one(query)
  30         {:ok, activity, object}
  31       true ->
  32         data = %{
  33           "type" => "Like",
  34           "actor" => ap_id,
  35           "object" => id,
  36           "to" => [User.ap_followers(user), object.data["actor"]]
  37         }
  38
  39         {:ok, activity} = insert(data)
  40
  41         likes = [ap_id | (object.data["likes"] || [])] |> Enum.uniq
  42
  43         new_data = object.data
  44         |> Map.put("like_count", length(likes))
  45         |> Map.put("likes", likes)
  46
  47         changeset = Changeset.change(object, data: new_data)
  48         {:ok, object} = Repo.update(changeset)
  49
  50         update_object_in_activities(object)
  51
  52         {:ok, activity, object}
  53     end
  54   end
  55
  56   defp update_object_in_activities(%{data: %{"id" => id}} = object) do
  57     # Update activities that already had this. Could be done in a seperate process.
  58     relevant_activities = Activity.all_by_object_ap_id(id)
  59     Enum.map(relevant_activities, fn (activity) ->
  60       new_activity_data = activity.data |> Map.put("object", object.data)
  61       changeset = Changeset.change(activity, data: new_activity_data)
  62       Repo.update(changeset)
  63     end)
  64   end
  65
  66   def unlike(%User{ap_id: ap_id}, %Object{data: %{ "id" => id}} = object) do
  67     query = from activity in Activity,
  68       where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})
  69
  70     activity = Repo.one(query)
  71
  72     if activity do
  73       # just delete for now...
  74       {:ok, _activity} = Repo.delete(activity)
  75
  76       likes = (object.data["likes"] || []) |> List.delete(ap_id)
  77
  78       new_data = object.data
  79       |> Map.put("like_count", length(likes))
  80       |> Map.put("likes", likes)
  81
  82       changeset = Changeset.change(object, data: new_data)
  83       {:ok, object} = Repo.update(changeset)
  84
  85       update_object_in_activities(object)
  86
  87       {:ok, object}
  88     else
  89       {:ok, object}
  90     end
  91   end
  92
  93   def generate_activity_id do
  94     generate_id("activities")
  95   end
  96
  97   def generate_context_id do
  98     generate_id("contexts")
  99   end
 100
 101   def generate_object_id do
 102     generate_id("objects")
 103   end
 104
 105   def generate_id(type) do
 106     "#{Web.base_url()}/#{type}/#{UUID.generate}"
 107   end
 108
 109   def fetch_public_activities(opts \\ %{}) do
 110     public = ["https://www.w3.org/ns/activitystreams#Public"]
 111     fetch_activities(public, opts)
 112   end
 113
 114   def fetch_activities(recipients, opts \\ %{}) do
 115     since_id = opts["since_id"] || 0
 116
 117     query = from activity in Activity,
 118       limit: 20,
 119       order_by: [desc: :inserted_at]
 120
 121     query = Enum.reduce(recipients, query, fn (recipient, q) ->
 122       map = %{ to: [recipient] }
 123       from activity in q,
 124       or_where: fragment(~s(? @> ?), activity.data, ^map)
 125     end)
 126
 127     query = from activity in query,
 128       where: activity.id > ^since_id
 129
 130     query = if opts["max_id"] do
 131       from activity in query, where: activity.id < ^opts["max_id"]
 132     else
 133       query
 134     end
 135
 136     query = if opts["actor_id"] do
 137       from activity in query,
 138         where: fragment("? @> ?", activity.data, ^%{actor: opts["actor_id"]})
 139     else
 140       query
 141     end
 142
 143     Enum.reverse(Repo.all(query))
 144   end
 145
 146   def announce(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object) do
 147     data = %{
 148       "type" => "Announce",
 149       "actor" => ap_id,
 150       "object" => id,
 151       "to" => [User.ap_followers(user), object.data["actor"]]
 152     }
 153
 154     {:ok, activity} = insert(data)
 155
 156     announcements = [ap_id | (object.data["announcements"] || [])] |> Enum.uniq
 157
 158     new_data = object.data
 159     |> Map.put("announcement_count", length(announcements))
 160     |> Map.put("announcements", announcements)
 161
 162     changeset = Changeset.change(object, data: new_data)
 163     {:ok, object} = Repo.update(changeset)
 164
 165     update_object_in_activities(object)
 166
 167     {:ok, activity, object}
 168   end
 169
 170   def fetch_activities_for_context(context) do
 171     query = from activity in Activity,
 172       where: fragment("? @> ?", activity.data, ^%{ context: context })
 173     Repo.all(query)
 174   end
 175
 176   def upload(file) do
 177     data = Upload.store(file)
 178     Repo.insert(%Object{data: data})
 179   end
 180
 181   defp make_date do
 182     DateTime.utc_now() |> DateTime.to_iso8601
 183   end
 184 end