No OneTemporary
Actions

Size

31 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/list.ex b/lib/pleroma/list.ex
	index 81b842e9c..16955b3b5 100644
	--- a/lib/pleroma/list.ex
	+++ b/lib/pleroma/list.ex
	@@ -1,160 +1,149 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.List do
	use Ecto.Schema

	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.User

	- @ap_id_regex ~r/^\/users\/(?<nickname>\w+)\/lists\/(?<list_id>\d+)/
	-
	schema "lists" do
	belongs_to(:user, User, type: Pleroma.FlakeId)
	field(:title, :string)
	field(:following, {:array, :string}, default: [])
	+ field(:ap_id, :string)

	timestamps()
	end

	def title_changeset(list, attrs \\ %{}) do
	list
	\|> cast(attrs, [:title])
	\|> validate_required([:title])
	end

	def follow_changeset(list, attrs \\ %{}) do
	list
	\|> cast(attrs, [:following])
	\|> validate_required([:following])
	end

	- def ap_id(%User{nickname: nickname}, list_id) do
	- Pleroma.Web.Endpoint.url() <> "/users/#{nickname}/lists/#{list_id}"
	- end
	-
	- def ap_id({nickname, list_id}), do: ap_id(%User{nickname: nickname}, list_id)
	-
	def for_user(user, _opts) do
	query =
	from(
	l in Pleroma.List,
	where: l.user_id == ^user.id,
	order_by: [desc: l.id],
	limit: 50
	)

	Repo.all(query)
	end

	def get(id, %{id: user_id} = _user) do
	query =
	from(
	l in Pleroma.List,
	where: l.id == ^id,
	where: l.user_id == ^user_id
	)

	Repo.one(query)
	end

	def get_by_ap_id(ap_id) do
	- host = Pleroma.Web.Endpoint.host()
	-
	- with %{host: ^host, path: path} <- URI.parse(ap_id),
	- %{"list_id" => list_id, "nickname" => nickname} <-
	- Regex.named_captures(@ap_id_regex, path),
	- %User{} = user <- User.get_cached_by_nickname(nickname) do
	- get(list_id, user)
	- else
	- _ -> nil
	- end
	+ Repo.get_by(__MODULE__, ap_id: ap_id)
	end

	def get_following(%Pleroma.List{following: following} = _list) do
	q =
	from(
	u in User,
	where: u.follower_address in ^following
	)

	{:ok, Repo.all(q)}
	end

	# Get lists the activity should be streamed to.
	def get_lists_from_activity(%Activity{actor: ap_id}) do
	actor = User.get_cached_by_ap_id(ap_id)

	query =
	from(
	l in Pleroma.List,
	where: fragment("? && ?", l.following, ^[actor.follower_address])
	)

	Repo.all(query)
	end

	# Get lists to which the account belongs.
	def get_lists_account_belongs(%User{} = owner, account_id) do
	user = User.get_cached_by_id(account_id)

	query =
	from(
	l in Pleroma.List,
	where:
	l.user_id == ^owner.id and
	fragment(
	"? = ANY(?)",
	^user.follower_address,
	l.following
	)
	)

	Repo.all(query)
	end

	def rename(%Pleroma.List{} = list, title) do
	list
	\|> title_changeset(%{title: title})
	\|> Repo.update()
	end

	def create(title, %User{} = creator) do
	list = %Pleroma.List{user_id: creator.id, title: title}
	- Repo.insert(list)
	+
	+ Repo.transaction(fn ->
	+ list = Repo.insert!(list)
	+
	+ list
	+ \|> change(ap_id: "#{creator.ap_id}/lists/#{list.id}")
	+ \|> Repo.update!()
	+ end)
	end

	def follow(%Pleroma.List{following: following} = list, %User{} = followed) do
	update_follows(list, %{following: Enum.uniq([followed.follower_address \| following])})
	end

	def unfollow(%Pleroma.List{following: following} = list, %User{} = unfollowed) do
	update_follows(list, %{following: List.delete(following, unfollowed.follower_address)})
	end

	def delete(%Pleroma.List{} = list) do
	Repo.delete(list)
	end

	def update_follows(%Pleroma.List{} = list, attrs) do
	list
	\|> follow_changeset(attrs)
	\|> Repo.update()
	end

	def memberships(%User{follower_address: follower_address}) do
	Pleroma.List
	\|> where([l], ^follower_address in l.following)
	- \|> join(:inner, [l], u in User, on: l.user_id == u.id)
	- \|> select([l, u], {u.nickname, l.id})
	+ \|> select([l], l.ap_id)
	\|> Repo.all()
	- \|> Enum.map(&ap_id/1)
	end

	def memberships(_), do: []
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index f082b77d8..ba6ed67ef 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,432 +1,433 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Utils do
	alias Calendar.Strftime
	alias Comeonin.Pbkdf2
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

	require Logger

	# This is a hack for twidere.
	def get_by_id_or_ap_id(id) do
	activity =
	Activity.get_by_id_with_object(id) \|\| Activity.get_create_by_object_ap_id_with_object(id)

	activity &&
	if activity.data["type"] == "Create" do
	activity
	else
	Activity.get_create_by_object_ap_id_with_object(activity.data["object"])
	end
	end

	def get_replied_to_activity(""), do: nil

	def get_replied_to_activity(id) when not is_nil(id) do
	Activity.get_by_id(id)
	end

	def get_replied_to_activity(_), do: nil

	def attachments_from_ids(data) do
	if Map.has_key?(data, "descriptions") do
	attachments_from_ids_descs(data["media_ids"], data["descriptions"])
	else
	attachments_from_ids_no_descs(data["media_ids"])
	end
	end

	def attachments_from_ids_no_descs(ids) do
	Enum.map(ids \|\| [], fn media_id ->
	Repo.get(Object, media_id).data
	end)
	end

	def attachments_from_ids_descs(ids, descs_str) do
	{_, descs} = Jason.decode(descs_str)

	Enum.map(ids \|\| [], fn media_id ->
	Map.put(Repo.get(Object, media_id).data, "name", descs[media_id])
	end)
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "public") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	to = ["https://www.w3.org/ns/activitystreams#Public" \| mentioned_users]
	cc = [user.follower_address]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "unlisted") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	to = [user.follower_address \| mentioned_users]
	cc = ["https://www.w3.org/ns/activitystreams#Public"]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "private") do
	{to, cc} = to_for_user_and_mentions(user, mentions, inReplyTo, "direct")
	{[user.follower_address \| to], cc}
	end

	def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| mentioned_users]), []}
	else
	{mentioned_users, []}
	end
	end

	def to_for_user_and_mentions(_user, _mentions, _inReplyTo, _), do: {[], []}

	def bcc_for_list(user, {:list, list_id}) do
	- [Pleroma.List.ap_id(user, list_id)]
	+ list = Pleroma.List.get(list_id, user)
	+ [list.ap_id]
	end

	def bcc_for_list(_, _), do: []

	def make_content_html(
	status,
	attachments,
	data,
	visibility
	) do
	no_attachment_links =
	data
	\|> Map.get("no_attachment_links", Config.get([:instance, :no_attachment_links]))
	\|> Kernel.in([true, "true"])

	content_type = get_content_type(data["content_type"])

	options =
	if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
	[safe_mention: true]
	else
	[]
	end

	status
	\|> format_input(content_type, options)
	\|> maybe_add_attachments(attachments, no_attachment_links)
	\|> maybe_add_nsfw_tag(data)
	end

	defp get_content_type(content_type) do
	if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
	content_type
	else
	"text/plain"
	end
	end

	defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
	when sensitive in [true, "True", "true", "1"] do
	{text, mentions, [{"#nsfw", "nsfw"} \| tags]}
	end

	defp maybe_add_nsfw_tag(data, _), do: data

	def make_context(%Activity{data: %{"context" => context}}), do: context
	def make_context(_), do: Utils.generate_context_id()

	def maybe_add_attachments(parsed, _attachments, true = _no_links), do: parsed

	def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
	text = add_attachments(text, attachments)
	{text, mentions, tags}
	end

	def add_attachments(text, attachments) do
	attachment_text =
	Enum.map(attachments, fn
	%{"url" => [%{"href" => href} \| _]} = attachment ->
	name = attachment["name"] \|\| URI.decode(Path.basename(href))
	href = MediaProxy.url(href)
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"

	_ ->
	""
	end)

	Enum.join([text \| attachment_text], "<br>")
	end

	def format_input(text, format, options \\ [])

	@doc """
	Formatting text to plain text.
	"""
	def format_input(text, "text/plain", options) do
	text
	\|> Formatter.html_escape("text/plain")
	\|> Formatter.linkify(options)
	\|> (fn {text, mentions, tags} ->
	{String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
	end).()
	end

	@doc """
	Formatting text as BBCode.
	"""
	def format_input(text, "text/bbcode", options) do
	text
	\|> String.replace(~r/\r/, "")
	\|> Formatter.html_escape("text/plain")
	\|> BBCode.to_html()
	\|> (fn {:ok, html} -> html end).()
	\|> Formatter.linkify(options)
	end

	@doc """
	Formatting text to html.
	"""
	def format_input(text, "text/html", options) do
	text
	\|> Formatter.html_escape("text/html")
	\|> Formatter.linkify(options)
	end

	@doc """
	Formatting text to markdown.
	"""
	def format_input(text, "text/markdown", options) do
	text
	\|> Formatter.mentions_escape(options)
	\|> Earmark.as_html!()
	\|> Formatter.linkify(options)
	\|> Formatter.html_escape("text/html")
	end

	def make_note_data(
	actor,
	to,
	context,
	content_html,
	attachments,
	in_reply_to,
	tags,
	cw \\ nil,
	cc \\ []
	) do
	object = %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => content_html,
	"summary" => cw,
	"context" => context,
	"attachment" => attachments,
	"actor" => actor,
	"tag" => tags \|> Enum.map(fn {_, tag} -> tag end) \|> Enum.uniq()
	}

	if in_reply_to do
	in_reply_to_object = Object.normalize(in_reply_to)

	object
	\|> Map.put("inReplyTo", in_reply_to_object.data["id"])
	else
	object
	end
	end

	def format_naive_asctime(date) do
	date \|> DateTime.from_naive!("Etc/UTC") \|> format_asctime
	end

	def format_asctime(date) do
	Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	end

	def date_to_asctime(date) when is_binary(date) do
	with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
	format_asctime(date)
	else
	_e ->
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end
	end

	def date_to_asctime(date) do
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end

	def to_masto_date(%NaiveDateTime{} = date) do
	date
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	end

	def to_masto_date(date) do
	try do
	date
	\|> NaiveDateTime.from_iso8601!()
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	rescue
	_e -> ""
	end
	end

	defp shortname(name) do
	if String.length(name) < 30 do
	name
	else
	String.slice(name, 0..30) <> "…"
	end
	end

	def confirm_current_password(user, password) do
	with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
	true <- Pbkdf2.checkpw(password, db_user.password_hash) do
	{:ok, db_user}
	else
	_ -> {:error, "Invalid password."}
	end
	end

	def emoji_from_profile(%{info: _info} = user) do
	(Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
	\|> Enum.map(fn {shortcode, url, _} ->
	%{
	"type" => "Emoji",
	"icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
	"name" => ":#{shortcode}:"
	}
	end)
	end

	def maybe_notify_to_recipients(
	recipients,
	%Activity{data: %{"to" => to, "type" => _type}} = _activity
	) do
	recipients ++ to
	end

	def maybe_notify_mentioned_recipients(
	recipients,
	%Activity{data: %{"to" => _to, "type" => type} = data} = activity
	)
	when type == "Create" do
	object = Object.normalize(activity)

	object_data =
	cond do
	!is_nil(object) ->
	object.data

	is_map(data["object"]) ->
	data["object"]

	true ->
	%{}
	end

	tagged_mentions = maybe_extract_mentions(object_data)

	recipients ++ tagged_mentions
	end

	def maybe_notify_mentioned_recipients(recipients, _), do: recipients

	def maybe_notify_subscribers(
	recipients,
	%Activity{data: %{"actor" => actor, "type" => type}} = activity
	)
	when type == "Create" do
	with %User{} = user <- User.get_cached_by_ap_id(actor) do
	subscriber_ids =
	user
	\|> User.subscribers()
	\|> Enum.filter(&Visibility.visible_for_user?(activity, &1))
	\|> Enum.map(& &1.ap_id)

	recipients ++ subscriber_ids
	end
	end

	def maybe_notify_subscribers(recipients, _), do: recipients

	def maybe_extract_mentions(%{"tag" => tag}) do
	tag
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	end

	def maybe_extract_mentions(_), do: []

	def make_report_content_html(nil), do: {:ok, {nil, [], []}}

	def make_report_content_html(comment) do
	max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)

	if String.length(comment) <= max_size do
	{:ok, format_input(comment, "text/plain")}
	else
	{:error, "Comment must be up to #{max_size} characters"}
	end
	end

	def get_report_statuses(%User{ap_id: actor}, %{"status_ids" => status_ids}) do
	{:ok, Activity.all_by_actor_and_id(actor, status_ids)}
	end

	def get_report_statuses(_, _), do: {:ok, nil}

	# DEPRECATED mostly, context objects are now created at insertion time.
	def context_to_conversation_id(context) do
	with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
	id
	else
	_e ->
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, %{id: id}} ->
	id

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context).id
	end
	end
	end

	def conversation_id_to_context(id) do
	with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
	context
	else
	_e ->
	{:error, "No such conversation"}
	end
	end
	end
	diff --git a/priv/repo/migrations/20190516112144_add_ap_id_to_lists.exs b/priv/repo/migrations/20190516112144_add_ap_id_to_lists.exs
	new file mode 100644
	index 000000000..3c32bc355
	--- /dev/null
	+++ b/priv/repo/migrations/20190516112144_add_ap_id_to_lists.exs
	@@ -0,0 +1,26 @@
	+defmodule Pleroma.Repo.Migrations.AddApIdToLists do
	+ use Ecto.Migration
	+
	+ def up do
	+ alter table(:lists) do
	+ add(:ap_id, :string)
	+ end
	+
	+ execute("""
	+ UPDATE lists
	+ SET ap_id = u.ap_id \|\| '/lists/' \|\| lists.id
	+ FROM users AS u
	+ WHERE lists.user_id = u.id
	+ """)
	+
	+ create(unique_index(:lists, :ap_id))
	+ end
	+
	+ def down do
	+ drop(index(:lists, [:ap_id]))
	+
	+ alter table(:lists) do
	+ remove(:ap_id)
	+ end
	+ end
	+end
	diff --git a/test/list_test.exs b/test/list_test.exs
	index 0e72b6660..6c5c6b197 100644
	--- a/test/list_test.exs
	+++ b/test/list_test.exs
	@@ -1,145 +1,131 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ListTest do
	alias Pleroma.Repo
	use Pleroma.DataCase

	import Pleroma.Factory

	test "creating a list" do
	user = insert(:user)
	{:ok, %Pleroma.List{} = list} = Pleroma.List.create("title", user)
	%Pleroma.List{title: title} = Pleroma.List.get(list.id, user)
	assert title == "title"
	end

	test "getting a list not belonging to the user" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, %Pleroma.List{} = list} = Pleroma.List.create("title", user)
	ret = Pleroma.List.get(list.id, other_user)
	assert is_nil(ret)
	end

	test "adding an user to a list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, %{following: following}} = Pleroma.List.follow(list, other_user)
	assert [other_user.follower_address] == following
	end

	test "removing an user from a list" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, %{following: _following}} = Pleroma.List.follow(list, other_user)
	{:ok, %{following: following}} = Pleroma.List.unfollow(list, other_user)
	assert [] == following
	end

	test "renaming a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, %{title: title}} = Pleroma.List.rename(list, "new")
	assert "new" == title
	end

	test "deleting a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, list} = Pleroma.List.delete(list)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end

	test "getting users in a list" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, list} = Pleroma.List.create("title", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)
	{:ok, list} = Pleroma.List.follow(list, third_user)
	{:ok, following} = Pleroma.List.get_following(list)
	assert other_user in following
	assert third_user in following
	end

	test "getting all lists by an user" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list_one} = Pleroma.List.create("title", user)
	{:ok, list_two} = Pleroma.List.create("other title", user)
	{:ok, list_three} = Pleroma.List.create("third title", other_user)
	lists = Pleroma.List.for_user(user, %{})
	assert list_one in lists
	assert list_two in lists
	refute list_three in lists
	end

	test "getting all lists the user is a member of" do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list_one} = Pleroma.List.create("title", user)
	{:ok, list_two} = Pleroma.List.create("other title", user)
	{:ok, list_three} = Pleroma.List.create("third title", other_user)
	{:ok, list_one} = Pleroma.List.follow(list_one, other_user)
	{:ok, list_two} = Pleroma.List.follow(list_two, other_user)
	{:ok, list_three} = Pleroma.List.follow(list_three, user)

	lists = Pleroma.List.get_lists_from_activity(%Pleroma.Activity{actor: other_user.ap_id})
	assert list_one in lists
	assert list_two in lists
	refute list_three in lists
	end

	test "getting own lists a given user belongs to" do
	owner = insert(:user)
	not_owner = insert(:user)
	member_1 = insert(:user)
	member_2 = insert(:user)
	{:ok, owned_list} = Pleroma.List.create("owned", owner)
	{:ok, not_owned_list} = Pleroma.List.create("not owned", not_owner)
	{:ok, owned_list} = Pleroma.List.follow(owned_list, member_1)
	{:ok, owned_list} = Pleroma.List.follow(owned_list, member_2)
	{:ok, not_owned_list} = Pleroma.List.follow(not_owned_list, member_1)
	{:ok, not_owned_list} = Pleroma.List.follow(not_owned_list, member_2)

	lists_1 = Pleroma.List.get_lists_account_belongs(owner, member_1.id)
	assert owned_list in lists_1
	refute not_owned_list in lists_1
	lists_2 = Pleroma.List.get_lists_account_belongs(owner, member_2.id)
	assert owned_list in lists_2
	refute not_owned_list in lists_2
	end

	- test "get ap_id by user nickname and list id" do
	- nickname = "foo"
	- list_id = 42
	-
	- expected = Pleroma.Web.Endpoint.url() <> "/users/#{nickname}/lists/#{list_id}"
	-
	- assert Pleroma.List.ap_id(%Pleroma.User{nickname: nickname}, list_id) == expected
	- assert Pleroma.List.ap_id({nickname, list_id}) == expected
	- end
	-
	test "get by ap_id" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	- ap_id = Pleroma.List.ap_id(user, list.id)
	-
	- assert Pleroma.List.get_by_ap_id(ap_id) == list
	+ assert Pleroma.List.get_by_ap_id(list.ap_id) == list
	end

	test "memberships" do
	user = insert(:user)
	member = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	{:ok, list} = Pleroma.List.follow(list, member)

	- list_ap_id = Pleroma.List.ap_id(user, list.id)
	-
	- assert Pleroma.List.memberships(member) == [list_ap_id]
	+ assert Pleroma.List.memberships(member) == [list.ap_id]
	end
	end
	diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
	index 23e89d685..84744e5af 100644
	--- a/test/web/common_api/common_api_test.exs
	+++ b/test/web/common_api/common_api_test.exs
	@@ -1,305 +1,303 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)
	option = Pleroma.Config.get([:instance, :safe_dm_mentions])
	Pleroma.Config.put([:instance, :safe_dm_mentions], true)

	{:ok, activity} =
	CommonAPI.post(har, %{
	"status" => "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	"visibility" => "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	Pleroma.Config.put([:instance, :safe_dm_mentions], option)
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"})

	object = Object.normalize(activity.data["object"])

	assert object.data["tag"] == ["2hu"]
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"})

	assert Object.normalize(activity).data["emoji"]["firefox"]
	end

	test "it adds emoji when updating profiles" do
	user = insert(:user, %{name: ":firefox:"})

	CommonAPI.update(user)
	user = User.get_cached_by_ap_id(user.ap_id)
	[firefox] = user.info.source_data["tag"]

	assert firefox["name"] == ":firefox:"
	end

	describe "posting" do
	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => post,
	"content_type" => "text/html"
	})

	object = Object.normalize(activity.data["object"])

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => post,
	"content_type" => "text/markdown"
	})

	object = Object.normalize(activity.data["object"])

	assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	end

	test "it does not allow replies to direct messages that are not direct messages themselves" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "suya..", "visibility" => "direct"})

	assert {:ok, _} =
	CommonAPI.post(user, %{
	"status" => "suya..",
	"visibility" => "direct",
	"in_reply_to_status_id" => activity.id
	})

	Enum.each(["public", "private", "unlisted"], fn visibility ->
	assert {:error, {:private_to_public, _}} =
	CommonAPI.post(user, %{
	"status" => "suya..",
	"visibility" => visibility,
	"in_reply_to_status_id" => activity.id
	})
	end)
	end

	test "it allows to address a list" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)

	- list_ap_id = Pleroma.List.ap_id(user, list.id)
	-
	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "foobar", "visibility" => "list:#{list.id}"})

	- assert activity.data["bcc"] == [list_ap_id]
	- assert activity.recipients == [list_ap_id, user.ap_id]
	+ assert activity.data["bcc"] == [list.ap_id]
	+ assert activity.recipients == [list.ap_id, user.ap_id]
	end
	end

	describe "reactions" do
	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{}, _} = CommonAPI.favorite(activity.id, user)
	end

	test "retweeting a status twice returns an error" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, %Activity{}, _object} = CommonAPI.repeat(activity.id, user)
	{:error, _} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns an error" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, %Activity{}, _object} = CommonAPI.favorite(activity.id, user)
	{:error, _} = CommonAPI.favorite(activity.id, user)
	end
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})

	[user: user, activity: activity]
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{info: %{pinned_activities: [^id]}} = user
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, "Could not pin"} = CommonAPI.pin(activity.id, user)
	end

	test "max pinned statuses", %{user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, "You have already pinned the maximum number of statuses"} =
	CommonAPI.pin(activity_two.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)

	user = refresh_record(user)

	assert %User{info: %{pinned_activities: []}} = user
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, _} = CommonAPI.delete(activity.id, user)

	user = refresh_record(user)

	assert %User{info: %{pinned_activities: []}} = user
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)
	assert CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user, activity)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:error, _} = CommonAPI.add_mute(user, activity)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	activity_ap_id = activity.data["id"]
	comment = "foobar"

	report_data = %{
	"account_id" => target_user.id,
	"comment" => comment,
	"status_ids" => [activity.id]
	}

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^activity_ap_id]
	}
	} = flag_activity
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, muter} = CommonAPI.hide_reblogs(muter, muted)

	assert Pleroma.User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, muter} = CommonAPI.hide_reblogs(muter, muted)
	{:ok, muter} = CommonAPI.show_reblogs(muter, muted)

	assert Pleroma.User.showing_reblogs?(muter, muted) == true
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 29, 7:58 PM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1737309
Default Alt Text: (31 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions