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) 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 create(to, actor, context, object, additional \\ %{}, published \\ nil) do
  23     published = published || make_date()
  24
  25     activity = %{
  26       "type" => "Create",
  27       "to" => to,
  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) do
  36       {:ok, activity} = add_conversation_id(activity)
  37
  38       if actor.local do
  39         Pleroma.Web.Websub.publish(Pleroma.Web.OStatus.feed_path(actor), actor, activity)
  40        end
  41
  42       {:ok, activity}
  43     end
  44   end
  45
  46   defp add_conversation_id(activity) do
  47     if is_integer(activity.data["statusnetConversationId"]) do
  48       {:ok, activity}
  49     else
  50       data = activity.data
  51       |> put_in(["object", "statusnetConversationId"], activity.id)
  52       |> put_in(["statusnetConversationId"], activity.id)
  53
  54       object = Object.get_by_ap_id(activity.data["object"]["id"])
  55
  56       changeset = Ecto.Changeset.change(object, data: data["object"])
  57       Repo.update(changeset)
  58
  59       changeset = Ecto.Changeset.change(activity, data: data)
  60       Repo.update(changeset)
  61     end
  62   end
  63
  64   def like(%User{ap_id: ap_id} = user, %Object{data: %{ "id" => id}} = object) do
  65     cond do
  66       # There's already a like here, so return the original activity.
  67       ap_id in (object.data["likes"] || []) ->
  68         query = from activity in Activity,
  69           where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})
  70
  71         activity = Repo.one(query)
  72         {:ok, activity, object}
  73       true ->
  74         data = %{
  75           "type" => "Like",
  76           "actor" => ap_id,
  77           "object" => id,
  78           "to" => [User.ap_followers(user), object.data["actor"]]
  79         }
  80
  81         {:ok, activity} = insert(data)
  82
  83         likes = [ap_id | (object.data["likes"] || [])] |> Enum.uniq
  84
  85         new_data = object.data
  86         |> Map.put("like_count", length(likes))
  87         |> Map.put("likes", likes)
  88
  89         changeset = Ecto.Changeset.change(object, data: new_data)
  90         {:ok, object} = Repo.update(changeset)
  91
  92         update_object_in_activities(object)
  93
  94         {:ok, activity, object}
  95     end
  96   end
  97
  98   defp update_object_in_activities(%{data: %{"id" => id}} = object) do
  99     # Update activities that already had this. Could be done in a seperate process.
 100     relevant_activities = Activity.all_by_object_ap_id(id)
 101     Enum.map(relevant_activities, fn (activity) ->
 102       new_activity_data = activity.data |> Map.put("object", object.data)
 103       changeset = Ecto.Changeset.change(activity, data: new_activity_data)
 104       Repo.update(changeset)
 105     end)
 106   end
 107
 108   def unlike(%User{ap_id: ap_id}, %Object{data: %{ "id" => id}} = object) do
 109     query = from activity in Activity,
 110       where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})
 111
 112     activity = Repo.one(query)
 113
 114     if activity do
 115       # just delete for now...
 116       {:ok, _activity} = Repo.delete(activity)
 117
 118       likes = (object.data["likes"] || []) |> List.delete(ap_id)
 119
 120       new_data = object.data
 121       |> Map.put("like_count", length(likes))
 122       |> Map.put("likes", likes)
 123
 124       changeset = Ecto.Changeset.change(object, data: new_data)
 125       {:ok, object} = Repo.update(changeset)
 126
 127       update_object_in_activities(object)
 128
 129       {:ok, object}
 130     else
 131       {:ok, object}
 132     end
 133   end
 134
 135   def generate_activity_id do
 136     generate_id("activities")
 137   end
 138
 139   def generate_context_id do
 140     generate_id("contexts")
 141   end
 142
 143   def generate_object_id do
 144     generate_id("objects")
 145   end
 146
 147   def generate_id(type) do
 148     "#{Pleroma.Web.base_url()}/#{type}/#{Ecto.UUID.generate}"
 149   end
 150
 151   def fetch_public_activities(opts \\ %{}) do
 152     public = ["https://www.w3.org/ns/activitystreams#Public"]
 153     fetch_activities(public, opts)
 154   end
 155
 156   def fetch_activities(recipients, opts \\ %{}) do
 157     since_id = opts["since_id"] || 0
 158
 159     query = from activity in Activity,
 160       limit: 20,
 161       order_by: [desc: :inserted_at]
 162
 163     query = Enum.reduce(recipients, query, fn (recipient, q) ->
 164       map = %{ to: [recipient] }
 165       from activity in q,
 166       or_where: fragment(~s(? @> ?), activity.data, ^map)
 167     end)
 168
 169     query = from activity in query,
 170       where: activity.id > ^since_id
 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     Repo.all(query)
 186     |> Enum.reverse
 187   end
 188
 189   def announce(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object) do
 190     data = %{
 191       "type" => "Announce",
 192       "actor" => ap_id,
 193       "object" => id,
 194       "to" => [User.ap_followers(user), object.data["actor"]]
 195     }
 196
 197     {:ok, activity} = insert(data)
 198
 199     announcements = [ap_id | (object.data["announcements"] || [])] |> Enum.uniq
 200
 201     new_data = object.data
 202     |> Map.put("announcement_count", length(announcements))
 203     |> Map.put("announcements", announcements)
 204
 205     changeset = Ecto.Changeset.change(object, data: new_data)
 206     {:ok, object} = Repo.update(changeset)
 207
 208     update_object_in_activities(object)
 209
 210     {:ok, activity, object}
 211   end
 212
 213   def fetch_activities_for_context(context) do
 214     query = from activity in Activity,
 215       where: fragment("? @> ?", activity.data, ^%{ context: context })
 216     Repo.all(query)
 217   end
 218
 219   def upload(file) do
 220     data = Upload.store(file)
 221     Repo.insert(%Object{data: data})
 222   end
 223
 224   defp make_date do
 225     DateTime.utc_now() |> DateTime.to_iso8601
 226   end
 227 end