No OneTemporary
Actions

Size

19 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/list.ex b/lib/pleroma/list.ex
	index 16955b3b5..1d320206e 100644
	--- a/lib/pleroma/list.ex
	+++ b/lib/pleroma/list.ex
	@@ -1,149 +1,155 @@
	# 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

	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 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
	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.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)
	\|> select([l], l.ap_id)
	\|> Repo.all()
	end

	def memberships(_), do: []
	+
	+ def member?(%Pleroma.List{following: following}, %User{follower_address: follower_address}) do
	+ Enum.member?(following, follower_address)
	+ end
	+
	+ def member?(_, _), do: false
	end
	diff --git a/lib/pleroma/web/activity_pub/visibility.ex b/lib/pleroma/web/activity_pub/visibility.ex
	index 9908a2e75..e0282d758 100644
	--- a/lib/pleroma/web/activity_pub/visibility.ex
	+++ b/lib/pleroma/web/activity_pub/visibility.ex
	@@ -1,83 +1,99 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Visibility do
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User

	def is_public?(%Object{data: %{"type" => "Tombstone"}}), do: false
	def is_public?(%Object{data: data}), do: is_public?(data)
	def is_public?(%Activity{data: data}), do: is_public?(data)
	def is_public?(%{"directMessage" => true}), do: false

	def is_public?(data) do
	"https://www.w3.org/ns/activitystreams#Public" in (data["to"] ++ (data["cc"] \|\| []))
	end

	def is_private?(activity) do
	with false <- is_public?(activity),
	%User{follower_address: follower_address} <-
	User.get_cached_by_ap_id(activity.data["actor"]) do
	follower_address in activity.data["to"]
	else
	_ -> false
	end
	end

	def is_direct?(%Activity{data: %{"directMessage" => true}}), do: true
	def is_direct?(%Object{data: %{"directMessage" => true}}), do: true

	def is_direct?(activity) do
	!is_public?(activity) && !is_private?(activity)
	end

	+ def is_list?(%{data: %{"listMessage" => _}}), do: true
	+ def is_list?(_), do: false
	+
	+ def visible_for_user?(%{actor: ap_id}, %User{ap_id: ap_id}), do: true
	+
	+ def visible_for_user?(%{data: %{"listMessage" => list_ap_id}}, %User{} = user) do
	+ list_ap_id
	+ \|> Pleroma.List.get_by_ap_id()
	+ \|> Pleroma.List.member?(user)
	+ end
	+
	+ def visible_for_user?(%{data: %{"listMessage" => _}}, nil), do: false
	+
	def visible_for_user?(activity, nil) do
	is_public?(activity)
	end

	def visible_for_user?(activity, user) do
	x = [user.ap_id \| user.following]
	y = [activity.actor] ++ activity.data["to"] ++ (activity.data["cc"] \|\| [])
	visible_for_user?(activity, nil) \|\| Enum.any?(x, &(&1 in y))
	end

	def entire_thread_visible_for_user?(%Activity{} = activity, %User{} = user) do
	{:ok, %{rows: [[result]]}} =
	Ecto.Adapters.SQL.query(Repo, "SELECT thread_visibility($1, $2)", [
	user.ap_id,
	activity.data["id"]
	])

	result
	end

	def get_visibility(object) do
	public = "https://www.w3.org/ns/activitystreams#Public"
	to = object.data["to"] \|\| []
	cc = object.data["cc"] \|\| []

	cond do
	public in to ->
	"public"

	public in cc ->
	"unlisted"

	# this should use the sql for the object's activity
	Enum.any?(to, &String.contains?(&1, "/followers")) ->
	"private"

	object.data["directMessage"] == true ->
	"direct"

	+ is_binary(object.data["listMessage"]) ->
	+ "list"
	+
	length(cc) > 0 ->
	"private"

	true ->
	"direct"
	end
	end
	end
	diff --git a/test/list_test.exs b/test/list_test.exs
	index 6c5c6b197..f39033d02 100644
	--- a/test/list_test.exs
	+++ b/test/list_test.exs
	@@ -1,131 +1,142 @@
	# 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 by ap_id" do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("foo", user)
	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)

	assert Pleroma.List.memberships(member) == [list.ap_id]
	end
	+
	+ test "member?" do
	+ user = insert(:user)
	+ member = insert(:user)
	+
	+ {:ok, list} = Pleroma.List.create("foo", user)
	+ {:ok, list} = Pleroma.List.follow(list, member)
	+
	+ assert Pleroma.List.member?(list, member)
	+ refute Pleroma.List.member?(list, user)
	+ end
	end
	diff --git a/test/web/activity_pub/visibilty_test.exs b/test/web/activity_pub/visibilty_test.exs
	index 4d5c07da4..2ce6928c4 100644
	--- a/test/web/activity_pub/visibilty_test.exs
	+++ b/test/web/activity_pub/visibilty_test.exs
	@@ -1,171 +1,229 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.VisibilityTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	import Pleroma.Factory

	setup do
	user = insert(:user)
	mentioned = insert(:user)
	following = insert(:user)
	unrelated = insert(:user)
	{:ok, following} = Pleroma.User.follow(following, user)
	+ {:ok, list} = Pleroma.List.create("foo", user)
	+
	+ Pleroma.List.follow(list, unrelated)

	{:ok, public} =
	CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "public"})

	{:ok, private} =
	CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "private"})

	{:ok, direct} =
	CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "direct"})

	{:ok, unlisted} =
	CommonAPI.post(user, %{"status" => "@#{mentioned.nickname}", "visibility" => "unlisted"})

	+ {:ok, list} =
	+ CommonAPI.post(user, %{
	+ "status" => "@#{mentioned.nickname}",
	+ "visibility" => "list:#{list.id}"
	+ })
	+
	%{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	user: user,
	mentioned: mentioned,
	following: following,
	- unrelated: unrelated
	+ unrelated: unrelated,
	+ list: list
	}
	end

	- test "is_direct?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
	+ test "is_direct?", %{
	+ public: public,
	+ private: private,
	+ direct: direct,
	+ unlisted: unlisted,
	+ list: list
	+ } do
	assert Visibility.is_direct?(direct)
	refute Visibility.is_direct?(public)
	refute Visibility.is_direct?(private)
	refute Visibility.is_direct?(unlisted)
	+ assert Visibility.is_direct?(list)
	end

	- test "is_public?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
	+ test "is_public?", %{
	+ public: public,
	+ private: private,
	+ direct: direct,
	+ unlisted: unlisted,
	+ list: list
	+ } do
	refute Visibility.is_public?(direct)
	assert Visibility.is_public?(public)
	refute Visibility.is_public?(private)
	assert Visibility.is_public?(unlisted)
	+ refute Visibility.is_public?(list)
	end

	- test "is_private?", %{public: public, private: private, direct: direct, unlisted: unlisted} do
	+ test "is_private?", %{
	+ public: public,
	+ private: private,
	+ direct: direct,
	+ unlisted: unlisted,
	+ list: list
	+ } do
	refute Visibility.is_private?(direct)
	refute Visibility.is_private?(public)
	assert Visibility.is_private?(private)
	refute Visibility.is_private?(unlisted)
	+ refute Visibility.is_private?(list)
	+ end
	+
	+ test "is_list?", %{
	+ public: public,
	+ private: private,
	+ direct: direct,
	+ unlisted: unlisted,
	+ list: list
	+ } do
	+ refute Visibility.is_list?(direct)
	+ refute Visibility.is_list?(public)
	+ refute Visibility.is_list?(private)
	+ refute Visibility.is_list?(unlisted)
	+ assert Visibility.is_list?(list)
	end

	test "visible_for_user?", %{
	public: public,
	private: private,
	direct: direct,
	unlisted: unlisted,
	user: user,
	mentioned: mentioned,
	following: following,
	- unrelated: unrelated
	+ unrelated: unrelated,
	+ list: list
	} do
	# All visible to author

	assert Visibility.visible_for_user?(public, user)
	assert Visibility.visible_for_user?(private, user)
	assert Visibility.visible_for_user?(unlisted, user)
	assert Visibility.visible_for_user?(direct, user)
	+ assert Visibility.visible_for_user?(list, user)

	- # All visible to a mentioned user
	+ # All visible to a mentioned user, except when it's a list activity

	assert Visibility.visible_for_user?(public, mentioned)
	assert Visibility.visible_for_user?(private, mentioned)
	assert Visibility.visible_for_user?(unlisted, mentioned)
	assert Visibility.visible_for_user?(direct, mentioned)
	+ refute(Visibility.visible_for_user?(list, mentioned))

	# DM not visible for just follower

	assert Visibility.visible_for_user?(public, following)
	assert Visibility.visible_for_user?(private, following)
	assert Visibility.visible_for_user?(unlisted, following)
	refute Visibility.visible_for_user?(direct, following)
	+ refute Visibility.visible_for_user?(list, following)

	# Public and unlisted visible for unrelated user

	assert Visibility.visible_for_user?(public, unrelated)
	assert Visibility.visible_for_user?(unlisted, unrelated)
	refute Visibility.visible_for_user?(private, unrelated)
	refute Visibility.visible_for_user?(direct, unrelated)
	+
	+ # Visible for a list member
	+ assert Visibility.visible_for_user?(list, unrelated)
	end

	test "doesn't die when the user doesn't exist",
	%{
	direct: direct,
	user: user
	} do
	Repo.delete(user)
	Cachex.clear(:user_cache)
	refute Visibility.is_private?(direct)
	end

	test "get_visibility", %{
	public: public,
	private: private,
	direct: direct,
	- unlisted: unlisted
	+ unlisted: unlisted,
	+ list: list
	} do
	assert Visibility.get_visibility(public) == "public"
	assert Visibility.get_visibility(private) == "private"
	assert Visibility.get_visibility(direct) == "direct"
	assert Visibility.get_visibility(unlisted) == "unlisted"
	+ assert Visibility.get_visibility(list) == "list"
	end

	test "get_visibility with directMessage flag" do
	assert Visibility.get_visibility(%{data: %{"directMessage" => true}}) == "direct"
	end

	+ test "get_visibility with listMessage flag" do
	+ assert Visibility.get_visibility(%{data: %{"listMessage" => ""}}) == "list"
	+ end
	+
	describe "entire_thread_visible_for_user?/2" do
	test "returns false if not found activity", %{user: user} do
	refute Visibility.entire_thread_visible_for_user?(%Activity{}, user)
	end

	test "returns true if activity hasn't 'Create' type", %{user: user} do
	activity = insert(:like_activity)
	assert Visibility.entire_thread_visible_for_user?(activity, user)
	end

	test "returns false when invalid recipients", %{user: user} do
	author = insert(:user)

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => ["test-user"]}
	)
	)

	refute Visibility.entire_thread_visible_for_user?(activity, user)
	end

	test "returns true if user following to author" do
	author = insert(:user)
	user = insert(:user, following: [author.ap_id])

	activity =
	insert(:note_activity,
	note:
	insert(:note,
	user: author,
	data: %{"to" => [user.ap_id]}
	)
	)

	assert Visibility.entire_thread_visible_for_user?(activity, user)
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 9, 1:23 PM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1724631
Default Alt Text: (19 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions