No OneTemporary
Actions

Size

13 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index 0217b28d6..a195301ee 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,191 +1,192 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.{User, Activity, Repo, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter

	import Ecto.Query

	def create_status(user = %User{}, data = %{}) do
	attachments = Enum.map(data["media_ids"] \|\| [], fn (media_id) ->
	Repo.get(Object, media_id).data
	end)

	context = ActivityPub.generate_context_id

	content = HtmlSanitizeEx.strip_tags(data["status"])

	mentions = parse_mentions(content)

	default_to = [
	User.ap_followers(user),
	"https://www.w3.org/ns/activitystreams#Public"
	]

	to = default_to ++ Enum.map(mentions, fn ({_, %{ap_id: ap_id}}) -> ap_id end)

	content_html = add_user_links(content, mentions)

	date = make_date()

	activity = %{
	"type" => "Create",
	"to" => to,
	"actor" => user.ap_id,
	"object" => %{
	"type" => "Note",
	"to" => to,
	"content" => content_html,
	"published" => date,
	"context" => context,
	- "attachment" => attachments
	+ "attachment" => attachments,
	+ "actor" => user.ap_id
	},
	"published" => date,
	"context" => context
	}

	# Wire up reply info.
	activity = with inReplyToId when not is_nil(inReplyToId) <- data["in_reply_to_status_id"],
	inReplyTo <- Repo.get(Activity, inReplyToId),
	context <- inReplyTo.data["context"]
	do

	to = activity["to"] ++ [inReplyTo.data["actor"]]

	activity
	\|> put_in(["to"], to)
	\|> put_in(["context"], context)
	\|> put_in(["object", "context"], context)
	\|> put_in(["object", "inReplyTo"], inReplyTo.data["object"]["id"])
	\|> put_in(["object", "inReplyToStatusId"], inReplyToId)
	\|> put_in(["statusnetConversationId"], inReplyTo.data["statusnetConversationId"])
	\|> put_in(["object", "statusnetConversationId"], inReplyTo.data["statusnetConversationId"])
	else _e ->
	activity
	end

	with {:ok, activity} <- ActivityPub.insert(activity) do
	add_conversation_id(activity)
	end
	end

	def fetch_friend_statuses(user, opts \\ %{}) do
	ActivityPub.fetch_activities([user.ap_id \| user.following], opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_public_statuses(user, opts \\ %{}) do
	ActivityPub.fetch_public_activities(opts)
	\|> activities_to_statuses(%{for: user})
	end

	def fetch_conversation(user, id) do
	query = from activity in Activity,
	where: fragment("? @> ?", activity.data, ^%{ statusnetConversationId: id}),
	limit: 1

	with %Activity{} = activity <- Repo.one(query),
	context <- activity.data["context"],
	activities <- ActivityPub.fetch_activities_for_context(context),
	statuses <- activities \|> activities_to_statuses(%{for: user})
	do
	statuses
	else e ->
	IO.inspect(e)
	[]
	end
	end

	def fetch_status(user, id) do
	with %Activity{} = activity <- Repo.get(Activity, id) do
	activity_to_status(activity, %{for: user})
	end
	end

	def follow(%User{} = follower, followed_id) do
	with %User{} = followed <- Repo.get(User, followed_id),
	{ :ok, follower } <- User.follow(follower, followed),
	{ :ok, activity } <- ActivityPub.insert(%{
	"type" => "Follow",
	"actor" => follower.ap_id,
	"object" => followed.ap_id,
	"published" => make_date()
	})
	do
	{ :ok, follower, followed, activity }
	end
	end

	def unfollow(%User{} = follower, followed_id) do
	with %User{} = followed <- Repo.get(User, followed_id),
	{ :ok, follower } <- User.unfollow(follower, followed)
	do
	{ :ok, follower, followed }
	end
	end

	def upload(%Plug.Upload{} = file) do
	{:ok, object} = ActivityPub.upload(file)

	url = List.first(object.data["url"])
	href = url["href"]
	type = url["mediaType"]

	# Fake this as good as possible...
	"""
	<?xml version="1.0" encoding="UTF-8"?>
	<rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
	<mediaid>#{object.id}</mediaid>
	<media_id>#{object.id}</media_id>
	<media_id_string>#{object.id}</media_id_string>
	<media_url>#{href}</media_url>
	<mediaurl>#{href}</mediaurl>
	<atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
	</rsp>
	"""
	end

	def parse_mentions(text) do
	# Modified from https://www.w3.org/TR/html5/forms.html#valid-e-mail-address
	regex = ~r/@[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@?[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)/

	Regex.scan(regex, text)
	\|> List.flatten
	\|> Enum.uniq
	\|> Enum.map(fn ("@" <> match = full_match) -> {full_match, Repo.get_by(User, nickname: match)} end)
	\|> Enum.filter(fn ({_match, user}) -> user end)
	end

	def add_user_links(text, mentions) do
	Enum.reduce(mentions, text, fn ({match, %User{ap_id: ap_id}}, text) -> String.replace(text, match, "<a href='#{ap_id}'>#{match}</a>") end)
	end

	defp add_conversation_id(activity) do
	if is_integer(activity.data["statusnetConversationId"]) do
	{:ok, activity}
	else
	data = activity.data
	\|> put_in(["object", "statusnetConversationId"], activity.id)
	\|> put_in(["statusnetConversationId"], activity.id)

	changeset = Ecto.Changeset.change(activity, data: data)
	Repo.update(changeset)
	end
	end

	defp activities_to_statuses(activities, opts) do
	Enum.map(activities, fn(activity) ->
	activity_to_status(activity, opts)
	end)
	end

	defp activity_to_status(activity, opts) do
	actor = get_in(activity.data, ["actor"])
	user = Repo.get_by!(User, ap_id: actor)
	mentioned_users = Repo.all(from user in User, where: user.ap_id in ^activity.data["to"])
	ActivityRepresenter.to_map(activity, Map.merge(opts, %{user: user, mentioned: mentioned_users}))
	end

	defp make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index e8853a910..a4c9bd7e7 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,179 +1,180 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Builders.{UserBuilder, ActivityBuilder}
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.{Activity, User, Object, Repo}
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter

	test "create a status" do
	user = UserBuilder.build(%{ap_id: "142344"})
	_mentioned_user = UserBuilder.insert(%{nickname: "shp", ap_id: "shp"})

	object_data = %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}

	object = Repo.insert!(%Object{data: object_data})

	input = %{
	"status" => "Hello again, @shp.<script></script>",
	"media_ids" => [object.id]
	}

	{ :ok, activity = %Activity{} } = TwitterAPI.create_status(user, input)

	assert get_in(activity.data, ["object", "content"]) == "Hello again, <a href='shp'>@shp</a>."
	assert get_in(activity.data, ["object", "type"]) == "Note"
	+ assert get_in(activity.data, ["object", "actor"]) == user.ap_id
	assert get_in(activity.data, ["actor"]) == user.ap_id
	assert Enum.member?(get_in(activity.data, ["to"]), User.ap_followers(user))
	assert Enum.member?(get_in(activity.data, ["to"]), "https://www.w3.org/ns/activitystreams#Public")
	assert Enum.member?(get_in(activity.data, ["to"]), "shp")

	# Add a context + 'statusnet_conversation_id'
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(activity.data, ["object", "context"]))
	assert get_in(activity.data, ["object", "statusnetConversationId"]) == activity.id
	assert get_in(activity.data, ["statusnetConversationId"]) == activity.id

	assert is_list(activity.data["object"]["attachment"])
	end

	test "create a status that is a reply" do
	user = UserBuilder.build(%{ap_id: "some_cool_id"})
	input = %{
	"status" => "Hello again."
	}

	{ :ok, activity = %Activity{} } = TwitterAPI.create_status(user, input)

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{ :ok, reply = %Activity{} } = TwitterAPI.create_status(user, input)

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])
	assert get_in(reply.data, ["object", "context"]) == get_in(activity.data, ["object", "context"])
	assert get_in(reply.data, ["statusnetConversationId"]) == get_in(activity.data, ["statusnetConversationId"])
	assert get_in(reply.data, ["object", "statusnetConversationId"]) == get_in(activity.data, ["object", "statusnetConversationId"])
	assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
	assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
	assert Enum.member?(get_in(reply.data, ["to"]), "some_cool_id")
	end

	test "fetch public statuses" do
	%{ public: activity, user: user } = ActivityBuilder.public_and_non_public
	{:ok, follower } = UserBuilder.insert(%{name: "dude", ap_id: "idididid", following: [User.ap_followers(user)]})

	statuses = TwitterAPI.fetch_public_statuses(follower)

	assert length(statuses) == 1
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: user, for: follower})
	end

	test "fetch friends' statuses" do
	ActivityBuilder.public_and_non_public

	{:ok, activity} = ActivityBuilder.insert(%{"to" => ["someguy/followers"]})
	{:ok, direct_activity} = ActivityBuilder.insert(%{"to" => ["some other id"]})
	{:ok, user} = UserBuilder.insert(%{ap_id: "some other id", following: ["someguy/followers"]})

	statuses = TwitterAPI.fetch_friend_statuses(user)

	activity_user = Repo.get_by(User, ap_id: activity.data["actor"])

	assert length(statuses) == 2
	assert Enum.at(statuses, 0) == ActivityRepresenter.to_map(activity, %{user: activity_user})
	assert Enum.at(statuses, 1) == ActivityRepresenter.to_map(direct_activity, %{user: activity_user, mentioned: [user]})
	end

	test "fetch a single status" do
	{:ok, activity} = ActivityBuilder.insert()
	{:ok, user} = UserBuilder.insert()
	actor = Repo.get_by!(User, ap_id: activity.data["actor"])

	status = TwitterAPI.fetch_status(user, activity.id)

	assert status == ActivityRepresenter.to_map(activity, %{for: user, user: actor})
	end

	test "Follow another user" do
	{ :ok, user } = UserBuilder.insert
	{ :ok, following } = UserBuilder.insert(%{nickname: "guy"})

	{:ok, user, following, activity } = TwitterAPI.follow(user, following.id)

	user = Repo.get(User, user.id)
	follow = Repo.get(Activity, activity.id)

	assert user.following == [User.ap_followers(following)]
	assert follow == activity
	end

	test "Unfollow another user" do
	{ :ok, following } = UserBuilder.insert(%{nickname: "guy"})
	{ :ok, user } = UserBuilder.insert(%{following: [User.ap_followers(following)]})

	{:ok, user, _following } = TwitterAPI.unfollow(user, following.id)

	user = Repo.get(User, user.id)

	assert user.following == []
	end

	test "fetch statuses in a context using the conversation id" do
	{:ok, user} = UserBuilder.insert()
	{:ok, activity} = ActivityBuilder.insert(%{"statusnetConversationId" => 1, "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"statusnetConversationId" => 1,"context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"context" => "3hu"})

	statuses = TwitterAPI.fetch_conversation(user, 1)

	assert length(statuses) == 2
	assert Enum.at(statuses, 0)["id"] == activity.id
	assert Enum.at(statuses, 1)["id"] == activity_two.id
	end

	test "upload a file" do
	file = %Plug.Upload{content_type: "image/jpg", path: Path.absname("test/fixtures/image.jpg"), filename: "an_image.jpg"}

	response = TwitterAPI.upload(file)

	assert is_binary(response)
	end

	test "it can parse mentions and return the relevant users" do
	text = "@gsimg According to @archaeme , that is @daggsy."

	{:ok, gsimg} = UserBuilder.insert(%{nickname: "gsimg"})
	{:ok, archaeme} = UserBuilder.insert(%{nickname: "archaeme"})

	expected_result = [
	{"@gsimg", gsimg},
	{"@archaeme", archaeme}
	]

	assert TwitterAPI.parse_mentions(text) == expected_result
	end

	test "it adds user links to an existing text" do
	text = "@gsimg According to @archaeme , that is @daggsy."

	{:ok, _gsimg} = UserBuilder.insert(%{nickname: "gsimg", ap_id: "first_link" })
	{:ok, _archaeme} = UserBuilder.insert(%{nickname: "archaeme", ap_id: "second_link"})

	mentions = TwitterAPI.parse_mentions(text)
	expected_text = "<a href='first_link'>@gsimg</a> According to <a href='second_link'>@archaeme</a> , that is @daggsy."

	assert TwitterAPI.add_user_links(text, mentions) == expected_text
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 1:16 AM (11 h, 6 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768585
Default Alt Text: (13 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions