akkoma/lib/pleroma/web/activity_pub/activity_pub.ex

282 lines
7.8 KiB
Elixir
Raw Normal View History

2017-03-21 08:21:52 +00:00
defmodule Pleroma.Web.ActivityPub.ActivityPub do
alias Pleroma.{Activity, Repo, Object, Upload, User, Web}
alias Ecto.{Changeset, UUID}
2017-03-21 16:53:20 +00:00
import Ecto.Query
2017-03-21 08:21:52 +00:00
2017-05-02 08:47:04 +00:00
def insert(map, local \\ true) when is_map(map) do
2017-04-13 13:50:05 +00:00
map = map
|> Map.put_new_lazy("id", &generate_activity_id/0)
|> Map.put_new_lazy("published", &make_date/0)
2017-03-23 16:56:49 +00:00
2017-05-07 18:13:10 +00:00
with %Activity{} = activity <- Activity.get_by_ap_id(map["id"]) do
{:ok, activity}
else _e ->
map = if is_map(map["object"]) do
object = Map.put_new_lazy(map["object"], "id", &generate_object_id/0)
Repo.insert!(%Object{data: object})
Map.put(map, "object", object)
else
map
end
2017-03-23 20:22:49 +00:00
2017-05-07 18:13:10 +00:00
Repo.insert(%Activity{data: map, local: local})
end
2017-03-21 08:21:52 +00:00
end
2017-03-21 16:53:20 +00:00
2017-05-02 08:47:04 +00:00
def create(to, actor, context, object, additional \\ %{}, published \\ nil, local \\ true) do
published = published || make_date()
activity = %{
"type" => "Create",
2017-05-03 14:08:24 +00:00
"to" => to |> Enum.uniq,
"actor" => actor.ap_id,
"object" => object,
"published" => published,
"context" => context
}
|> Map.merge(additional)
2017-05-02 08:47:04 +00:00
with {:ok, activity} <- insert(activity, local) do
if actor.local do
Pleroma.Web.Federator.enqueue(:publish, activity)
end
{:ok, activity}
end
2017-03-21 08:21:52 +00:00
end
2017-03-21 16:53:20 +00:00
2017-05-07 18:05:03 +00:00
def like(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id \\ nil, local \\ true) do
cond do
# There's already a like here, so return the original activity.
ap_id in (object.data["likes"] || []) ->
query = from activity in Activity,
2017-04-14 16:08:47 +00:00
where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})
2017-04-13 13:50:05 +00:00
activity = Repo.one(query)
{:ok, activity, object}
true ->
data = %{
"type" => "Like",
"actor" => ap_id,
"object" => id,
2017-05-02 13:54:14 +00:00
"to" => [User.ap_followers(user), object.data["actor"]],
"context" => object.data["context"]
}
2017-04-13 13:50:05 +00:00
2017-05-07 18:05:03 +00:00
data = if activity_id, do: Map.put(data, "id", activity_id), else: data
{:ok, activity} = insert(data, local)
2017-04-13 13:50:05 +00:00
likes = [ap_id | (object.data["likes"] || [])] |> Enum.uniq
new_data = object.data
|> Map.put("like_count", length(likes))
|> Map.put("likes", likes)
changeset = Changeset.change(object, data: new_data)
{:ok, object} = Repo.update(changeset)
2017-04-14 16:08:47 +00:00
update_object_in_activities(object)
2017-05-02 14:45:54 +00:00
if user.local do
Pleroma.Web.Federator.enqueue(:publish, activity)
end
{:ok, activity, object}
end
2017-04-13 13:50:05 +00:00
end
2017-04-14 16:08:47 +00:00
defp update_object_in_activities(%{data: %{"id" => id}} = object) do
2017-05-07 18:05:03 +00:00
# TODO
2017-04-14 16:08:47 +00:00
# Update activities that already had this. Could be done in a seperate process.
2017-05-07 18:05:03 +00:00
# Alternatively, just don't do this and fetch the current object each time. Most
# could probably be taken from cache.
2017-04-14 16:08:47 +00:00
relevant_activities = Activity.all_by_object_ap_id(id)
Enum.map(relevant_activities, fn (activity) ->
new_activity_data = activity.data |> Map.put("object", object.data)
changeset = Changeset.change(activity, data: new_activity_data)
2017-04-14 16:08:47 +00:00
Repo.update(changeset)
end)
end
2017-04-15 11:54:46 +00:00
def unlike(%User{ap_id: ap_id}, %Object{data: %{ "id" => id}} = object) do
2017-04-14 16:08:47 +00:00
query = from activity in Activity,
where: fragment("? @> ?", activity.data, ^%{actor: ap_id, object: id, type: "Like"})
activity = Repo.one(query)
if activity do
# just delete for now...
{:ok, _activity} = Repo.delete(activity)
likes = (object.data["likes"] || []) |> List.delete(ap_id)
new_data = object.data
|> Map.put("like_count", length(likes))
|> Map.put("likes", likes)
changeset = Changeset.change(object, data: new_data)
2017-04-14 16:08:47 +00:00
{:ok, object} = Repo.update(changeset)
update_object_in_activities(object)
{:ok, object}
else
{:ok, object}
end
end
2017-03-23 16:56:49 +00:00
def generate_activity_id do
2017-03-23 22:34:10 +00:00
generate_id("activities")
end
def generate_context_id do
generate_id("contexts")
2017-03-23 16:56:49 +00:00
end
2017-03-23 20:22:49 +00:00
def generate_object_id do
Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :object, Ecto.UUID.generate)
2017-03-23 22:34:10 +00:00
end
def generate_id(type) do
"#{Web.base_url()}/#{type}/#{UUID.generate}"
2017-03-23 20:22:49 +00:00
end
2017-03-21 19:31:48 +00:00
def fetch_public_activities(opts \\ %{}) do
2017-03-22 13:45:17 +00:00
public = ["https://www.w3.org/ns/activitystreams#Public"]
fetch_activities(public, opts)
end
def fetch_activities(recipients, opts \\ %{}) do
2017-03-21 20:09:20 +00:00
since_id = opts["since_id"] || 0
2017-03-21 19:31:48 +00:00
2017-03-21 16:53:20 +00:00
query = from activity in Activity,
2017-03-21 19:22:05 +00:00
limit: 20,
order_by: [desc: :inserted_at]
2017-03-21 16:53:20 +00:00
2017-03-22 13:45:17 +00:00
query = Enum.reduce(recipients, query, fn (recipient, q) ->
map = %{ to: [recipient] }
from activity in q,
or_where: fragment(~s(? @> ?), activity.data, ^map)
end)
query = from activity in query,
where: activity.id > ^since_id
2017-05-02 12:12:43 +00:00
query = if opts["local_only"] do
from activity in query, where: activity.local == true
else
query
end
query = if opts["max_id"] do
from activity in query, where: activity.id < ^opts["max_id"]
else
query
end
2017-04-14 13:09:13 +00:00
query = if opts["actor_id"] do
from activity in query,
where: fragment("? @> ?", activity.data, ^%{actor: opts["actor_id"]})
else
query
end
Enum.reverse(Repo.all(query))
2017-03-21 16:53:20 +00:00
end
2017-03-23 23:09:08 +00:00
2017-05-07 18:05:03 +00:00
def announce(%User{ap_id: ap_id} = user, %Object{data: %{"id" => id}} = object, activity_id \\ nil, local \\ true) do
2017-04-15 10:11:20 +00:00
data = %{
"type" => "Announce",
"actor" => ap_id,
"object" => id,
2017-05-02 13:54:14 +00:00
"to" => [User.ap_followers(user), object.data["actor"]],
"context" => object.data["context"]
2017-04-15 10:11:20 +00:00
}
2017-05-07 18:05:03 +00:00
data = if activity_id, do: Map.put(data, "id", activity_id), else: data
2017-05-04 16:42:29 +00:00
{:ok, activity} = insert(data, local)
2017-04-15 10:11:20 +00:00
announcements = [ap_id | (object.data["announcements"] || [])] |> Enum.uniq
new_data = object.data
|> Map.put("announcement_count", length(announcements))
|> Map.put("announcements", announcements)
changeset = Changeset.change(object, data: new_data)
2017-04-15 10:11:20 +00:00
{:ok, object} = Repo.update(changeset)
update_object_in_activities(object)
2017-05-03 15:41:55 +00:00
if user.local do
Pleroma.Web.Federator.enqueue(:publish, activity)
end
2017-04-15 10:11:20 +00:00
{:ok, activity, object}
end
def follow(%User{ap_id: follower_id, local: actor_local}, %User{ap_id: followed_id}, local \\ true) do
data = %{
"type" => "Follow",
"actor" => follower_id,
"to" => [followed_id],
"object" => followed_id,
"published" => make_date()
}
with {:ok, activity} <- insert(data, local) do
if actor_local do
Pleroma.Web.Federator.enqueue(:publish, activity)
end
{:ok, activity}
end
end
def unfollow(follower, followed, local \\ true) do
with follow_activity when not is_nil(follow_activity) <- fetch_latest_follow(follower, followed) do
data = %{
"type" => "Undo",
"actor" => follower.ap_id,
"to" => [followed.ap_id],
"object" => follow_activity.data["id"],
"published" => make_date()
}
with {:ok, activity} <- insert(data, local) do
if follower.local do
Pleroma.Web.Federator.enqueue(:publish, activity)
end
{:ok, activity}
end
end
end
2017-03-23 23:09:08 +00:00
def fetch_activities_for_context(context) do
query = from activity in Activity,
where: fragment("? @> ?", activity.data, ^%{ context: context })
Repo.all(query)
end
2017-03-29 00:05:51 +00:00
2017-04-21 16:54:21 +00:00
def fetch_latest_follow(%User{ap_id: follower_id},
%User{ap_id: followed_id}) do
query = from activity in Activity,
where: fragment("? @> ?", activity.data, ^%{type: "Follow", actor: follower_id,
object: followed_id}),
order_by: [desc: :inserted_at],
limit: 1
Repo.one(query)
end
2017-04-16 12:23:30 +00:00
def upload(file) do
2017-03-29 00:05:51 +00:00
data = Upload.store(file)
Repo.insert(%Object{data: data})
end
2017-04-13 13:50:05 +00:00
defp make_date do
DateTime.utc_now() |> DateTime.to_iso8601
end
2017-03-21 08:21:52 +00:00
end