No OneTemporary
Actions

Authored By

Unknown

Size

122 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/docs/API/differences_in_mastoapi_responses.md b/docs/API/differences_in_mastoapi_responses.md
	index 21b297529..d007a69c3 100644
	--- a/docs/API/differences_in_mastoapi_responses.md
	+++ b/docs/API/differences_in_mastoapi_responses.md
	@@ -1,150 +1,149 @@
	# Differences in Mastodon API responses from vanilla Mastodon

	A Pleroma instance can be identified by "<Mastodon version> (compatible; Pleroma <version>)" present in `version` field in response from `/api/v1/instance`

	## Flake IDs

	Pleroma uses 128-bit ids as opposed to Mastodon's 64 bits. However just like Mastodon's ids they are sortable strings

	## Attachment cap

	Some apps operate under the assumption that no more than 4 attachments can be returned or uploaded. Pleroma however does not enforce any limits on attachment count neither when returning the status object nor when posting.

	## Timelines

	Adding the parameter `with_muted=true` to the timeline queries will also return activities by muted (not by blocked!) users.

	## Statuses

	- `visibility`: has an additional possible value `list`

	Has these additional fields under the `pleroma` object:

	- `local`: true if the post was made on the local instance
	- `conversation_id`: the ID of the AP context the status is associated with (if any)
	- `direct_conversation_id`: the ID of the Mastodon direct message conversation the status is associated with (if any)
	- `in_reply_to_account_acct`: the `acct` property of User entity for replied user (if any)
	- `content`: a map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`
	- `spoiler_text`: a map consisting of alternate representations of the `spoiler_text` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`
	- `expires_at`: a datetime (iso8601) that states when the post will expire (be deleted automatically), or empty if the post won't expire
	- `thread_muted`: true if the thread the post belongs to is muted

	## Attachments

	Has these additional fields under the `pleroma` object:

	- `mime_type`: mime type of the attachment.

	## Accounts

	The `id` parameter can also be the `nickname` of the user. This only works in these endpoints, not the deeper nested ones for following etc.

	- `/api/v1/accounts/:id`
	- `/api/v1/accounts/:id/statuses`

	Has these additional fields under the `pleroma` object:

	- `tags`: Lists an array of tags for the user
	- `relationship{}`: Includes fields as documented for Mastodon API https://docs.joinmastodon.org/api/entities/#relationship
	- `is_moderator`: boolean, nullable, true if user is a moderator
	- `is_admin`: boolean, nullable, true if user is an admin
	- `confirmation_pending`: boolean, true if a new user account is waiting on email confirmation to be activated
	- `hide_followers`: boolean, true when the user has follower hiding enabled
	- `hide_follows`: boolean, true when the user has follow hiding enabled
	- `hide_followers_count`: boolean, true when the user has follower stat hiding enabled
	- `hide_follows_count`: boolean, true when the user has follow stat hiding enabled
	- `settings_store`: A generic map of settings for frontends. Opaque to the backend. Only returned in `verify_credentials` and `update_credentials`
	- `chat_token`: The token needed for Pleroma chat. Only returned in `verify_credentials`
	- `deactivated`: boolean, true when the user is deactivated
	-- `unread_conversation_count`: The count of unread conversations. Only returned to the account owner.

	### Source

	Has these additional fields under the `pleroma` object:

	- `show_role`: boolean, nullable, true when the user wants his role (e.g admin, moderator) to be shown
	- `no_rich_text` - boolean, nullable, true when html tags are stripped from all statuses requested from the API

	## Conversations

	Has an additional field under the `pleroma` object:

	- `recipients`: The list of the recipients of this Conversation. These will be addressed when replying to this conversation.

	## Account Search

	Behavior has changed:

	- `/api/v1/accounts/search`: Does not require authentication


	## Notifications

	Has these additional fields under the `pleroma` object:

	- `is_seen`: true if the notification was read by the user

	## POST `/api/v1/statuses`

	Additional parameters can be added to the JSON body/Form data:

	- `preview`: boolean, if set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example.
	- `content_type`: string, contain the MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint.
	- `to`: A list of nicknames (like `lain@soykaf.club` or `lain` on the local server) that will be used to determine who is going to be addressed by this post. Using this will disable the implicit addressing by mentioned names in the `status` body, only the people in the `to` list will be addressed. The normal rules for for post visibility are not affected by this and will still apply.
	- `visibility`: string, besides standard MastoAPI values (`direct`, `private`, `unlisted` or `public`) it can be used to address a List by setting it to `list:LIST_ID`.
	- `expires_in`: The number of seconds the posted activity should expire in. When a posted activity expires it will be deleted from the server, and a delete request for it will be federated. This needs to be longer than an hour.
	- `in_reply_to_conversation_id`: Will reply to a given conversation, addressing only the people who are part of the recipient set of that conversation. Sets the visibility to `direct`.

	## GET `/api/v1/statuses`

	An endpoint to get multiple statuses by IDs.

	Required parameters:

	- `ids`: array of activity ids

	Usage example: `GET /api/v1/statuses/?ids[]=1&ids[]=2`.

	Returns: array of Status.

	The maximum number of statuses is limited to 100 per request.

	## PATCH `/api/v1/update_credentials`

	Additional parameters can be added to the JSON body/Form data:

	- `no_rich_text` - if true, html tags are stripped from all statuses requested from the API
	- `hide_followers` - if true, user's followers will be hidden
	- `hide_follows` - if true, user's follows will be hidden
	- `hide_followers_count` - if true, user's follower count will be hidden
	- `hide_follows_count` - if true, user's follow count will be hidden
	- `hide_favorites` - if true, user's favorites timeline will be hidden
	- `show_role` - if true, user's role (e.g admin, moderator) will be exposed to anyone in the API
	- `default_scope` - the scope returned under `privacy` key in Source subentity
	- `pleroma_settings_store` - Opaque user settings to be saved on the backend.
	- `skip_thread_containment` - if true, skip filtering out broken threads
	- `pleroma_background_image` - sets the background image of the user.

	### Pleroma Settings Store
	Pleroma has mechanism that allows frontends to save blobs of json for each user on the backend. This can be used to save frontend-specific settings for a user that the backend does not need to know about.

	The parameter should have a form of `{frontend_name: {...}}`, with `frontend_name` identifying your type of client, e.g. `pleroma_fe`. It will overwrite everything under this property, but will not overwrite other frontend's settings.

	This information is returned in the `verify_credentials` endpoint.

	## Authentication

	*Pleroma supports refreshing tokens.

	`POST /oauth/token`
	Post here request with grant_type=refresh_token to obtain new access token. Returns an access token.

	## Account Registration
	`POST /api/v1/accounts`

	Has theses additionnal parameters (which are the same as in Pleroma-API):
	* `fullname`: optional
	* `bio`: optional
	* `captcha_solution`: optional, contains provider-specific captcha solution,
	* `captcha_token`: optional, contains provider-specific captcha token
	* `token`: invite token required when the registerations aren't public.
	diff --git a/lib/pleroma/conversation.ex b/lib/pleroma/conversation.ex
	index 098016af2..be5821ad7 100644
	--- a/lib/pleroma/conversation.ex
	+++ b/lib/pleroma/conversation.ex
	@@ -1,105 +1,103 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Conversation do
	alias Pleroma.Conversation.Participation
	alias Pleroma.Conversation.Participation.RecipientShip
	alias Pleroma.Repo
	alias Pleroma.User
	use Ecto.Schema
	import Ecto.Changeset

	schema "conversations" do
	# This is the context ap id.
	field(:ap_id, :string)
	has_many(:participations, Participation)
	has_many(:users, through: [:participations, :user])

	timestamps()
	end

	def creation_cng(struct, params) do
	struct
	\|> cast(params, [:ap_id])
	\|> validate_required([:ap_id])
	\|> unique_constraint(:ap_id)
	end

	def create_for_ap_id(ap_id) do
	%__MODULE__{}
	\|> creation_cng(%{ap_id: ap_id})
	\|> Repo.insert(
	on_conflict: [set: [updated_at: NaiveDateTime.utc_now()]],
	returning: true,
	conflict_target: :ap_id
	)
	end

	def get_for_ap_id(ap_id) do
	Repo.get_by(__MODULE__, ap_id: ap_id)
	end

	def maybe_create_recipientships(participation, activity) do
	participation = Repo.preload(participation, :recipients)

	if participation.recipients \|> Enum.empty?() do
	recipients = User.get_all_by_ap_id(activity.recipients)
	RecipientShip.create(recipients, participation)
	end
	end

	@doc """
	This will
	1. Create a conversation if there isn't one already
	2. Create a participation for all the people involved who don't have one already
	3. Bump all relevant participations to 'unread'
	"""
	def create_or_bump_for(activity, opts \\ []) do
	with true <- Pleroma.Web.ActivityPub.Visibility.is_direct?(activity),
	"Create" <- activity.data["type"],
	object <- Pleroma.Object.normalize(activity),
	true <- object.data["type"] in ["Note", "Question"],
	ap_id when is_binary(ap_id) and byte_size(ap_id) > 0 <- object.data["context"] do
	{:ok, conversation} = create_for_ap_id(ap_id)

	users = User.get_users_from_set(activity.recipients, false)

	participations =
	Enum.map(users, fn user ->
	- User.increment_unread_conversation_count(conversation, user)
	-
	{:ok, participation} =
	Participation.create_for_user_and_conversation(user, conversation, opts)

	maybe_create_recipientships(participation, activity)
	participation
	end)

	{:ok,
	%{
	conversation
	\| participations: participations
	}}
	else
	e -> {:error, e}
	end
	end

	@doc """
	This is only meant to be run by a mix task. It creates conversations/participations for all direct messages in the database.
	"""
	def bump_for_all_activities do
	stream =
	Pleroma.Web.ActivityPub.ActivityPub.fetch_direct_messages_query()
	\|> Repo.stream()

	Repo.transaction(
	fn ->
	stream
	\|> Enum.each(fn a -> create_or_bump_for(a, read: true) end)
	end,
	timeout: :infinity
	)
	end
	end
	diff --git a/lib/pleroma/conversation/participation.ex b/lib/pleroma/conversation/participation.ex
	index ab81f3217..e946f6de2 100644
	--- a/lib/pleroma/conversation/participation.ex
	+++ b/lib/pleroma/conversation/participation.ex
	@@ -1,155 +1,138 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Conversation.Participation do
	use Ecto.Schema
	alias Pleroma.Conversation
	alias Pleroma.Conversation.Participation.RecipientShip
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	import Ecto.Changeset
	import Ecto.Query

	schema "conversation_participations" do
	belongs_to(:user, User, type: FlakeId.Ecto.CompatType)
	belongs_to(:conversation, Conversation)
	field(:read, :boolean, default: false)
	field(:last_activity_id, FlakeId.Ecto.CompatType, virtual: true)

	has_many(:recipient_ships, RecipientShip)
	has_many(:recipients, through: [:recipient_ships, :user])

	timestamps()
	end

	def creation_cng(struct, params) do
	struct
	\|> cast(params, [:user_id, :conversation_id, :read])
	\|> validate_required([:user_id, :conversation_id])
	end

	def create_for_user_and_conversation(user, conversation, opts \\ []) do
	read = !!opts[:read]

	%__MODULE__{}
	\|> creation_cng(%{user_id: user.id, conversation_id: conversation.id, read: read})
	\|> Repo.insert(
	on_conflict: [set: [read: read, updated_at: NaiveDateTime.utc_now()]],
	returning: true,
	conflict_target: [:user_id, :conversation_id]
	)
	end

	def read_cng(struct, params) do
	struct
	\|> cast(params, [:read])
	\|> validate_required([:read])
	end

	def mark_as_read(participation) do
	participation
	\|> read_cng(%{read: true})
	\|> Repo.update()
	- \|> case do
	- {:ok, participation} ->
	- participation = Repo.preload(participation, :user)
	- User.set_unread_conversation_count(participation.user)
	- {:ok, participation}
	-
	- error ->
	- error
	- end
	end

	def mark_as_unread(participation) do
	participation
	\|> read_cng(%{read: false})
	\|> Repo.update()
	end

	def for_user(user, params \\ %{}) do
	from(p in __MODULE__,
	where: p.user_id == ^user.id,
	order_by: [desc: p.updated_at],
	preload: [conversation: [:users]]
	)
	\|> Pleroma.Pagination.fetch_paginated(params)
	end

	def for_user_and_conversation(user, conversation) do
	from(p in __MODULE__,
	where: p.user_id == ^user.id,
	where: p.conversation_id == ^conversation.id
	)
	\|> Repo.one()
	end

	def for_user_with_last_activity_id(user, params \\ %{}) do
	for_user(user, params)
	\|> Enum.map(fn participation ->
	activity_id =
	ActivityPub.fetch_latest_activity_id_for_context(participation.conversation.ap_id, %{
	"user" => user,
	"blocking_user" => user
	})

	%{
	participation
	\| last_activity_id: activity_id
	}
	end)
	\|> Enum.filter(& &1.last_activity_id)
	end

	def get(_, _ \\ [])
	def get(nil, _), do: nil

	def get(id, params) do
	query =
	if preload = params[:preload] do
	from(p in __MODULE__,
	preload: ^preload
	)
	else
	__MODULE__
	end

	Repo.get(query, id)
	end

	def set_recipients(participation, user_ids) do
	user_ids =
	[participation.user_id \| user_ids]
	\|> Enum.uniq()

	Repo.transaction(fn ->
	query =
	from(r in RecipientShip,
	where: r.participation_id == ^participation.id
	)

	Repo.delete_all(query)

	users =
	from(u in User,
	where: u.id in ^user_ids
	)
	\|> Repo.all()

	RecipientShip.create(users, participation)
	:ok
	end)

	{:ok, Repo.preload(participation, :recipients, force: true)}
	end
	-
	- def unread_conversation_count_for_user(user) do
	- from(p in __MODULE__,
	- where: p.user_id == ^user.id,
	- where: not p.read,
	- select: %{count: count(p.id)}
	- )
	- end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 494a67f22..c2f8fa0d7 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1629 +1,1573 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

	alias Comeonin.Pbkdf2
	alias Ecto.Multi
	alias Pleroma.Activity
	- alias Pleroma.Conversation.Participation
	alias Pleroma.Delivery
	alias Pleroma.Keys
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.RepoStreamer
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.RelMe
	alias Pleroma.Web.Websub
	alias Pleroma.Workers.BackgroundWorker

	require Logger

	@type t :: %__MODULE__{}

	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@email_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])?)$/

	@strict_local_nickname_regex ~r/^[a-zA-Z\d]+$/
	@extended_local_nickname_regex ~r/^[a-zA-Z\d_-]+$/

	schema "users" do
	field(:bio, :string)
	field(:email, :string)
	field(:name, :string)
	field(:nickname, :string)
	field(:password_hash, :string)
	field(:password, :string, virtual: true)
	field(:password_confirmation, :string, virtual: true)
	field(:following, {:array, :string}, default: [])
	field(:ap_id, :string)
	field(:avatar, :map)
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	has_many(:deliveries, Delivery)
	embeds_one(:info, User.Info)

	timestamps()
	end

	def auth_active?(%User{info: %User.Info{confirmation_pending: true}}),
	do: !Pleroma.Config.get([:instance, :account_activation_required])

	def auth_active?(%User{}), do: true

	def visible_for?(user, for_user \\ nil)

	def visible_for?(%User{id: user_id}, %User{id: for_id}) when user_id == for_id, do: true

	def visible_for?(%User{} = user, for_user) do
	auth_active?(user) \|\| superuser?(for_user)
	end

	def visible_for?(_, _), do: false

	def superuser?(%User{local: true, info: %User.Info{is_admin: true}}), do: true
	def superuser?(%User{local: true, info: %User.Info{is_moderator: true}}), do: true
	def superuser?(_), do: false

	def avatar_url(user, options \\ []) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> !options[:no_default] && "#{Web.base_url()}/images/avi.png"
	end
	end

	def banner_url(user, options \\ []) do
	case user.info.banner do
	%{"url" => [%{"href" => href} \| _]} -> href
	_ -> !options[:no_default] && "#{Web.base_url()}/images/banner.png"
	end
	end

	def profile_url(%User{info: %{source_data: %{"url" => url}}}), do: url
	def profile_url(%User{ap_id: ap_id}), do: ap_id
	def profile_url(_), do: nil

	def ap_id(%User{nickname: nickname}), do: "#{Web.base_url()}/users/#{nickname}"

	def ap_followers(%User{follower_address: fa}) when is_binary(fa), do: fa
	def ap_followers(%User{} = user), do: "#{ap_id(user)}/followers"

	@spec ap_following(User.t()) :: Sring.t()
	def ap_following(%User{following_address: fa}) when is_binary(fa), do: fa
	def ap_following(%User{} = user), do: "#{ap_id(user)}/following"

	def user_info(%User{} = user, args \\ %{}) do
	following_count =
	Map.get(args, :following_count, user.info.following_count \|\| following_count(user))

	follower_count = Map.get(args, :follower_count, user.info.follower_count)

	%{
	note_count: user.info.note_count,
	locked: user.info.locked,
	confirmation_pending: user.info.confirmation_pending,
	default_scope: user.info.default_scope
	}
	\|> Map.put(:following_count, following_count)
	\|> Map.put(:follower_count, follower_count)
	end

	def follow_state(%User{} = user, %User{} = target) do
	case Utils.fetch_latest_follow(user, target) do
	%{data: %{"state" => state}} -> state
	# Ideally this would be nil, but then Cachex does not commit the value
	_ -> false
	end
	end

	def get_cached_follow_state(user, target) do
	key = "follow_state:#{user.ap_id}\|#{target.ap_id}"
	Cachex.fetch!(:user_cache, key, fn _ -> {:commit, follow_state(user, target)} end)
	end

	@spec set_follow_state_cache(String.t(), String.t(), String.t()) :: {:ok \| :error, boolean()}
	def set_follow_state_cache(user_ap_id, target_ap_id, state) do
	Cachex.put(:user_cache, "follow_state:#{user_ap_id}\|#{target_ap_id}", state)
	end

	def set_info_cache(user, args) do
	Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user, args))
	end

	@spec restrict_deactivated(Ecto.Query.t()) :: Ecto.Query.t()
	def restrict_deactivated(query) do
	from(u in query,
	where: not fragment("? \\? 'deactivated' AND ?->'deactivated' @> 'true'", u.info, u.info)
	)
	end

	def following_count(%User{following: []}), do: 0

	def following_count(%User{} = user) do
	user
	\|> get_friends_query()
	\|> Repo.aggregate(:count, :id)
	end

	defp truncate_if_exists(params, key, max_length) do
	if Map.has_key?(params, key) and is_binary(params[key]) do
	{value, _chopped} = String.split_at(params[key], max_length)
	Map.put(params, key, value)
	else
	params
	end
	end

	def remote_user_creation(params) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	params =
	params
	\|> Map.put(:info, params[:info] \|\| %{})
	\|> truncate_if_exists(:name, name_limit)
	\|> truncate_if_exists(:bio, bio_limit)

	changeset =
	%User{local: false}
	\|> cast(params, [:bio, :name, :ap_id, :nickname, :avatar])
	\|> validate_required([:name, :ap_id])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> change_info(&User.Info.remote_user_creation(&1, params[:info]))

	case params[:info][:source_data] do
	%{"followers" => followers, "following" => following} ->
	changeset
	\|> put_change(:follower_address, followers)
	\|> put_change(:following_address, following)

	_ ->
	followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})
	put_change(changeset, :follower_address, followers)
	end
	end

	def update_changeset(struct, params \\ %{}) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	struct
	\|> cast(params, [:bio, :name, :avatar, :following])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	end

	def upgrade_changeset(struct, params \\ %{}, remote? \\ false) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	params = Map.put(params, :last_refreshed_at, NaiveDateTime.utc_now())

	struct
	\|> cast(params, [
	:bio,
	:name,
	:follower_address,
	:following_address,
	:avatar,
	:last_refreshed_at
	])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> change_info(&User.Info.user_upgrade(&1, params[:info], remote?))
	end

	def password_update_changeset(struct, params) do
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> put_password_hash
	\|> put_embed(:info, User.Info.set_password_reset_pending(struct.info, false))
	end

	@spec reset_password(User.t(), map) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def reset_password(%User{id: user_id} = user, data) do
	multi =
	Multi.new()
	\|> Multi.update(:user, password_update_changeset(user, data))
	\|> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
	\|> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))

	case Repo.transaction(multi) do
	{:ok, %{user: user} = _} -> set_cache(user)
	{:error, _, changeset, _} -> {:error, changeset}
	end
	end

	def force_password_reset_async(user) do
	BackgroundWorker.enqueue("force_password_reset", %{"user_id" => user.id})
	end

	@spec force_password_reset(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def force_password_reset(user) do
	info_cng = User.Info.set_password_reset_pending(user.info, true)

	user
	\|> change()
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache()
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

	need_confirmation? =
	if is_nil(opts[:need_confirmation]) do
	Pleroma.Config.get([:instance, :account_activation_required])
	else
	opts[:need_confirmation]
	end

	struct
	\|> cast(params, [:bio, :email, :name, :nickname, :password, :password_confirmation])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> unique_constraint(:nickname)
	\|> validate_exclusion(:nickname, Pleroma.Config.get([User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_format(:email, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> change_info(&User.Info.confirmation_changeset(&1, need_confirmation: need_confirmation?))
	\|> maybe_validate_required_email(opts[:external])
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_address()
	end

	def maybe_validate_required_email(changeset, true), do: changeset
	def maybe_validate_required_email(changeset, _), do: validate_required(changeset, [:email])

	defp put_ap_id(changeset) do
	ap_id = ap_id(%User{nickname: get_field(changeset, :nickname)})
	put_change(changeset, :ap_id, ap_id)
	end

	defp put_following_and_follower_address(changeset) do
	followers = ap_followers(%User{nickname: get_field(changeset, :nickname)})

	changeset
	\|> put_change(:following, [followers])
	\|> put_change(:follower_address, followers)
	end

	defp autofollow_users(user) do
	candidates = Pleroma.Config.get([:instance, :autofollowed_nicknames])

	autofollowed_users =
	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()

	follow_all(user, autofollowed_users)
	end

	@doc "Inserts provided changeset, performs post-registration actions (confirmation email sending etc.)"
	def register(%Ecto.Changeset{} = changeset) do
	with {:ok, user} <- Repo.insert(changeset) do
	post_register_action(user)
	end
	end

	def post_register_action(%User{} = user) do
	with {:ok, user} <- autofollow_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- User.WelcomeMessage.post_welcome_message_to_user(user),
	{:ok, _} <- try_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def try_send_confirmation_email(%User{} = user) do
	if user.info.confirmation_pending &&
	Pleroma.Config.get([:instance, :account_activation_required]) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def needs_update?(%User{local: true}), do: false

	def needs_update?(%User{local: false, last_refreshed_at: nil}), do: true

	def needs_update?(%User{local: false} = user) do
	NaiveDateTime.diff(NaiveDateTime.utc_now(), user.last_refreshed_at) >= 86_400
	end

	def needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def maybe_direct_follow(%User{} = follower, %User{local: true, info: %{locked: true}}) do
	{:ok, follower}
	end

	def maybe_direct_follow(%User{} = follower, %User{local: true} = followed) do
	follow(follower, followed)
	end

	def maybe_direct_follow(%User{} = follower, %User{} = followed) do
	if not ap_enabled?(followed) do
	follow(follower, followed)
	else
	{:ok, follower}
	end
	end

	@doc "A mass follow for local users. Respects blocks in both directions but does not create activities."
	@spec follow_all(User.t(), list(User.t())) :: {atom(), User.t()}
	def follow_all(follower, followeds) do
	followed_addresses =
	followeds
	\|> Enum.reject(fn followed -> blocks?(follower, followed) \|\| blocks?(followed, follower) end)
	\|> Enum.map(fn %{follower_address: fa} -> fa end)

	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [
	set: [
	following:
	fragment(
	"array(select distinct unnest (array_cat(?, ?)))",
	u.following,
	^followed_addresses
	)
	]
	],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	Enum.each(followeds, &update_follower_count/1)

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{info: info} = followed) do
	deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])
	ap_followers = followed.follower_address

	cond do
	info.deactivated ->
	{:error, "Could not follow user: You are deactivated."}

	deny_follow_blocked and blocks?(followed, follower) ->
	{:error, "Could not follow user: #{followed.nickname} blocked you."}

	true ->
	if !followed.local && follower.local && !ap_enabled?(followed) do
	Websub.subscribe(follower, followed)
	end

	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [push: [following: ^ap_followers]],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	follower = maybe_update_following_count(follower)

	{:ok, _} = update_follower_count(followed)

	set_cache(follower)
	end
	end

	def unfollow(%User{} = follower, %User{} = followed) do
	ap_followers = followed.follower_address

	if following?(follower, followed) and follower.ap_id != followed.ap_id do
	q =
	from(u in User,
	where: u.id == ^follower.id,
	update: [pull: [following: ^ap_followers]],
	select: u
	)

	{1, [follower]} = Repo.update_all(q, [])

	follower = maybe_update_following_count(follower)

	{:ok, followed} = update_follower_count(followed)

	set_cache(follower)

	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}
	else
	{:error, "Not subscribed!"}
	end
	end

	@spec following?(User.t(), User.t()) :: boolean
	def following?(%User{} = follower, %User{} = followed) do
	Enum.member?(follower.following, followed.follower_address)
	end

	def locked?(%User{} = user) do
	user.info.locked \|\| false
	end

	def get_by_id(id) do
	Repo.get_by(User, id: id)
	end

	def get_by_ap_id(ap_id) do
	Repo.get_by(User, ap_id: ap_id)
	end

	def get_all_by_ap_id(ap_ids) do
	from(u in __MODULE__,
	where: u.ap_id in ^ap_ids
	)
	\|> Repo.all()
	end

	def get_all_by_ids(ids) do
	from(u in __MODULE__, where: u.id in ^ids)
	\|> Repo.all()
	end

	# This is mostly an SPC migration fix. This guesses the user nickname by taking the last part
	# of the ap_id and the domain and tries to get that user
	def get_by_guessed_nickname(ap_id) do
	domain = URI.parse(ap_id).host
	name = List.last(String.split(ap_id, "/"))
	nickname = "#{name}@#{domain}"

	get_cached_by_nickname(nickname)
	end

	def set_cache({:ok, user}), do: set_cache(user)
	def set_cache({:error, err}), do: {:error, err}

	def set_cache(%User{} = user) do
	Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	Cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	Cachex.put(:user_cache, "user_info:#{user.id}", user_info(user))
	{:ok, user}
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	set_cache(user)
	end
	end

	def invalidate_cache(user) do
	Cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	Cachex.del(:user_cache, "nickname:#{user.nickname}")
	Cachex.del(:user_cache, "user_info:#{user.id}")
	end

	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"
	Cachex.fetch!(:user_cache, key, fn _ -> get_by_ap_id(ap_id) end)
	end

	def get_cached_by_id(id) do
	key = "id:#{id}"

	ap_id =
	Cachex.fetch!(:user_cache, key, fn _ ->
	user = get_by_id(id)

	if user do
	Cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	{:commit, user.ap_id}
	else
	{:ignore, ""}
	end
	end)

	get_cached_by_ap_id(ap_id)
	end

	def get_cached_by_nickname(nickname) do
	key = "nickname:#{nickname}"

	Cachex.fetch!(:user_cache, key, fn ->
	case get_or_fetch_by_nickname(nickname) do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id, opts \\ []) do
	restrict_to_local = Pleroma.Config.get([:instance, :limit_to_local_content])

	cond do
	is_integer(nickname_or_id) or FlakeId.flake_id?(nickname_or_id) ->
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)

	restrict_to_local == false or not String.contains?(nickname_or_id, "@") ->
	get_cached_by_nickname(nickname_or_id)

	restrict_to_local == :unauthenticated and match?(%User{}, opts[:for]) ->
	get_cached_by_nickname(nickname_or_id)

	true ->
	nil
	end
	end

	def get_by_nickname(nickname) do
	Repo.get_by(User, nickname: nickname) \|\|
	if Regex.match?(~r(@#{Pleroma.Web.Endpoint.host()})i, nickname) do
	Repo.get_by(User, nickname: local_nickname(nickname))
	end
	end

	def get_by_email(email), do: Repo.get_by(User, email: email)

	def get_by_nickname_or_email(nickname_or_email) do
	get_by_nickname(nickname_or_email) \|\| get_by_email(nickname_or_email)
	end

	def get_cached_user_info(user) do
	key = "user_info:#{user.id}"
	Cachex.fetch!(:user_cache, key, fn -> user_info(user) end)
	end

	def fetch_by_nickname(nickname) do
	case ActivityPub.make_user_from_nickname(nickname) do
	{:ok, user} -> {:ok, user}
	_ -> OStatus.make_user(nickname)
	end
	end

	def get_or_fetch_by_nickname(nickname) do
	with %User{} = user <- get_by_nickname(nickname) do
	{:ok, user}
	else
	_e ->
	with [_nick, _domain] <- String.split(nickname, "@"),
	{:ok, user} <- fetch_by_nickname(nickname) do
	if Pleroma.Config.get([:fetch_initial_posts, :enabled]) do
	fetch_initial_posts(user)
	end

	{:ok, user}
	else
	_e -> {:error, "not found " <> nickname}
	end
	end
	end

	@doc "Fetch some posts when the user has just been federated with"
	def fetch_initial_posts(user) do
	BackgroundWorker.enqueue("fetch_initial_posts", %{"user_id" => user.id})
	end

	@spec get_followers_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_followers_query(%User{} = user, nil) do
	User.Query.build(%{followers: user, deactivated: false})
	end

	def get_followers_query(user, page) do
	user
	\|> get_followers_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_followers_query(User.t()) :: Ecto.Query.t()
	def get_followers_query(user), do: get_followers_query(user, nil)

	@spec get_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
	def get_followers(user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> Repo.all()
	end

	@spec get_external_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
	def get_external_followers(user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> User.Query.build(%{external: true})
	\|> Repo.all()
	end

	def get_followers_ids(user, page \\ nil) do
	user
	\|> get_followers_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	@spec get_friends_query(User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_friends_query(%User{} = user, nil) do
	User.Query.build(%{friends: user, deactivated: false})
	end

	def get_friends_query(user, page) do
	user
	\|> get_friends_query(nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_friends_query(User.t()) :: Ecto.Query.t()
	def get_friends_query(user), do: get_friends_query(user, nil)

	def get_friends(user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

	def get_friends_ids(user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> select([u], u.id)
	\|> Repo.all()
	end

	@spec get_follow_requests(User.t()) :: {:ok, [User.t()]}
	def get_follow_requests(%User{} = user) do
	user
	\|> Activity.follow_requests_for_actor()
	\|> join(:inner, [a], u in User, on: a.actor == u.ap_id)
	\|> where([a, u], not fragment("? @> ?", u.following, ^[user.follower_address]))
	\|> group_by([a, u], u.id)
	\|> select([a, u], u)
	\|> Repo.all()
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	info:
	fragment(
	"jsonb_set(?, '{note_count}', ((?->>'note_count')::int + 1)::varchar::jsonb, true)",
	u.info,
	u.info
	)
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def decrease_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u],
	set: [
	info:
	fragment(
	"jsonb_set(?, '{note_count}', (greatest(0, (?->>'note_count')::int - 1))::varchar::jsonb, true)",
	u.info,
	u.info
	)
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def update_note_count(%User{} = user) do
	note_count =
	from(
	a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)
	)
	\|> Repo.one()

	update_info(user, &User.Info.set_note_count(&1, note_count))
	end

	def update_mascot(user, url) do
	info_changeset =
	User.Info.mascot_update(
	user.info,
	url
	)

	user
	\|> change()
	\|> put_embed(:info, info_changeset)
	\|> update_and_set_cache()
	end

	@spec maybe_fetch_follow_information(User.t()) :: User.t()
	def maybe_fetch_follow_information(user) do
	with {:ok, user} <- fetch_follow_information(user) do
	user
	else
	e ->
	Logger.error("Follower/Following counter update for #{user.ap_id} failed.\n#{inspect(e)}")

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	update_info(user, &User.Info.follow_information_update(&1, info))
	end
	end

	def update_follower_count(%User{} = user) do
	if user.local or !Pleroma.Config.get([:instance, :external_user_synchronization]) do
	follower_count_query =
	User.Query.build(%{followers: user, deactivated: false})
	\|> select([u], %{count: count(u.id)})

	User
	\|> where(id: ^user.id)
	\|> join(:inner, [u], s in subquery(follower_count_query))
	\|> update([u, s],
	set: [
	info:
	fragment(
	"jsonb_set(?, '{follower_count}', ?::varchar::jsonb, true)",
	u.info,
	s.count
	)
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	else
	{:ok, maybe_fetch_follow_information(user)}
	end
	end

	@spec maybe_update_following_count(User.t()) :: User.t()
	def maybe_update_following_count(%User{local: false} = user) do
	if Pleroma.Config.get([:instance, :external_user_synchronization]) do
	maybe_fetch_follow_information(user)
	else
	user
	end
	end

	def maybe_update_following_count(user), do: user

	- def set_unread_conversation_count(%User{local: true} = user) do
	- unread_query = Participation.unread_conversation_count_for_user(user)
	-
	- User
	- \|> where([u], u.id == ^user.id)
	- \|> join(:inner, [u], p in subquery(unread_query))
	- \|> update([u, p],
	- set: [
	- info:
	- fragment(
	- "jsonb_set(?, '{unread_conversation_count}', ?::varchar::jsonb, true)",
	- u.info,
	- p.count
	- )
	- ]
	- )
	- \|> select([u], u)
	- \|> Repo.update_all([])
	- \|> case do
	- {1, [%{info: %User.Info{}} = user]} -> set_cache(user)
	- _ -> {:error, user}
	- end
	- end
	-
	- def set_unread_conversation_count(_), do: :noop
	-
	- def increment_unread_conversation_count(conversation, %User{local: true} = user) do
	- unread_query =
	- Participation.unread_conversation_count_for_user(user)
	- \|> where([p], p.conversation_id == ^conversation.id)
	-
	- User
	- \|> join(:inner, [u], p in subquery(unread_query))
	- \|> update([u, p],
	- set: [
	- info:
	- fragment(
	- "jsonb_set(?, '{unread_conversation_count}', ((?->>'unread_conversation_count')::int + 1)::varchar::jsonb, true)",
	- u.info,
	- u.info
	- )
	- ]
	- )
	- \|> where([u], u.id == ^user.id)
	- \|> where([u, p], p.count == 0)
	- \|> select([u], u)
	- \|> Repo.update_all([])
	- \|> case do
	- {1, [%{info: %User.Info{}} = user]} -> set_cache(user)
	- _ -> {:error, user}
	- end
	- end
	-
	- def increment_unread_conversation_count(_, _), do: :noop
	-
	def remove_duplicated_following(%User{following: following} = user) do
	uniq_following = Enum.uniq(following)

	if length(following) == length(uniq_following) do
	{:ok, user}
	else
	user
	\|> update_changeset(%{following: uniq_following})
	\|> update_and_set_cache()
	end
	end

	@spec get_users_from_set([String.t()], boolean()) :: [User.t()]
	def get_users_from_set(ap_ids, local_only \\ true) do
	criteria = %{ap_id: ap_ids, deactivated: false}
	criteria = if local_only, do: Map.put(criteria, :local, true), else: criteria

	User.Query.build(criteria)
	\|> Repo.all()
	end

	@spec get_recipients_from_activity(Activity.t()) :: [User.t()]
	def get_recipients_from_activity(%Activity{recipients: to}) do
	User.Query.build(%{recipients_from_activity: to, local: true, deactivated: false})
	\|> Repo.all()
	end

	@spec mute(User.t(), User.t(), boolean()) :: {:ok, User.t()} \| {:error, String.t()}
	def mute(muter, %User{ap_id: ap_id}, notifications? \\ true) do
	update_info(muter, &User.Info.add_to_mutes(&1, ap_id, notifications?))
	end

	def unmute(muter, %{ap_id: ap_id}) do
	update_info(muter, &User.Info.remove_from_mutes(&1, ap_id))
	end

	def subscribe(subscriber, %{ap_id: ap_id}) do
	with %User{} = subscribed <- get_cached_by_ap_id(ap_id) do
	deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])

	if blocks?(subscribed, subscriber) and deny_follow_blocked do
	{:error, "Could not subscribe: #{subscribed.nickname} is blocking you"}
	else
	update_info(subscribed, &User.Info.add_to_subscribers(&1, subscriber.ap_id))
	end
	end
	end

	def unsubscribe(unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	update_info(user, &User.Info.remove_from_subscribers(&1, unsubscriber.ap_id))
	end
	end

	def block(blocker, %User{ap_id: ap_id} = blocked) do
	# sever any follow relationships to prevent leaks per activitypub (Pleroma issue #213)
	blocker =
	if following?(blocker, blocked) do
	{:ok, blocker, _} = unfollow(blocker, blocked)
	blocker
	else
	blocker
	end

	# clear any requested follows as well
	blocked =
	case CommonAPI.reject_follow_request(blocked, blocker) do
	{:ok, %User{} = updated_blocked} -> updated_blocked
	nil -> blocked
	end

	blocker =
	if subscribed_to?(blocked, blocker) do
	{:ok, blocker} = unsubscribe(blocked, blocker)
	blocker
	else
	blocker
	end

	if following?(blocked, blocker), do: unfollow(blocked, blocker)

	{:ok, blocker} = update_follower_count(blocker)

	update_info(blocker, &User.Info.add_to_block(&1, ap_id))
	end

	# helper to handle the block given only an actor's AP id
	def block(blocker, %{ap_id: ap_id}) do
	block(blocker, get_cached_by_ap_id(ap_id))
	end

	def unblock(blocker, %{ap_id: ap_id}) do
	update_info(blocker, &User.Info.remove_from_block(&1, ap_id))
	end

	def mutes?(nil, _), do: false
	def mutes?(user, %{ap_id: ap_id}), do: Enum.member?(user.info.mutes, ap_id)

	@spec muted_notifications?(User.t() \| nil, User.t() \| map()) :: boolean()
	def muted_notifications?(nil, _), do: false

	def muted_notifications?(user, %{ap_id: ap_id}),
	do: Enum.member?(user.info.muted_notifications, ap_id)

	def blocks?(%User{} = user, %User{} = target) do
	blocks_ap_id?(user, target) \|\| blocks_domain?(user, target)
	end

	def blocks?(nil, _), do: false

	def blocks_ap_id?(%User{} = user, %User{} = target) do
	Enum.member?(user.info.blocks, target.ap_id)
	end

	def blocks_ap_id?(_, _), do: false

	def blocks_domain?(%User{} = user, %User{} = target) do
	domain_blocks = Pleroma.Web.ActivityPub.MRF.subdomains_regex(user.info.domain_blocks)
	%{host: host} = URI.parse(target.ap_id)
	Pleroma.Web.ActivityPub.MRF.subdomain_match?(domain_blocks, host)
	end

	def blocks_domain?(_, _), do: false

	def subscribed_to?(user, %{ap_id: ap_id}) do
	with %User{} = target <- get_cached_by_ap_id(ap_id) do
	Enum.member?(target.info.subscribers, user.ap_id)
	end
	end

	@spec muted_users(User.t()) :: [User.t()]
	def muted_users(user) do
	User.Query.build(%{ap_id: user.info.mutes, deactivated: false})
	\|> Repo.all()
	end

	@spec blocked_users(User.t()) :: [User.t()]
	def blocked_users(user) do
	User.Query.build(%{ap_id: user.info.blocks, deactivated: false})
	\|> Repo.all()
	end

	@spec subscribers(User.t()) :: [User.t()]
	def subscribers(user) do
	User.Query.build(%{ap_id: user.info.subscribers, deactivated: false})
	\|> Repo.all()
	end

	def block_domain(user, domain) do
	update_info(user, &User.Info.add_to_domain_block(&1, domain))
	end

	def unblock_domain(user, domain) do
	update_info(user, &User.Info.remove_from_domain_block(&1, domain))
	end

	def deactivate_async(user, status \\ true) do
	BackgroundWorker.enqueue("deactivate_user", %{"user_id" => user.id, "status" => status})
	end

	def deactivate(%User{} = user, status \\ true) do
	with {:ok, user} <- update_info(user, &User.Info.set_activation_status(&1, status)) do
	Enum.each(get_followers(user), &invalidate_cache/1)
	Enum.each(get_friends(user), &update_follower_count/1)

	{:ok, user}
	end
	end

	def update_notification_settings(%User{} = user, settings \\ %{}) do
	update_info(user, &User.Info.update_notification_settings(&1, settings))
	end

	def delete(%User{} = user) do
	BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
	end

	def perform(:force_password_reset, user), do: force_password_reset(user)

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:delete, %User{} = user) do
	{:ok, _user} = ActivityPub.delete(user)

	# Remove all relationships
	user
	\|> get_followers()
	\|> Enum.each(fn follower ->
	ActivityPub.unfollow(follower, user)
	unfollow(follower, user)
	end)

	user
	\|> get_friends()
	\|> Enum.each(fn followed ->
	ActivityPub.unfollow(user, followed)
	unfollow(user, followed)
	end)

	delete_user_activities(user)
	invalidate_cache(user)
	Repo.delete(user)
	end

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:fetch_initial_posts, %User{} = user) do
	pages = Pleroma.Config.get!([:fetch_initial_posts, :pages])

	# Insert all the posts in reverse order, so they're in the right order on the timeline
	user.info.source_data["outbox"]
	\|> Utils.fetch_ordered_collection(pages)
	\|> Enum.reverse()
	\|> Enum.each(&Pleroma.Web.Federator.incoming_ap_doc/1)
	end

	def perform(:deactivate_async, user, status), do: deactivate(user, status)

	@spec perform(atom(), User.t(), list()) :: list() \| {:error, any()}
	def perform(:blocks_import, %User{} = blocker, blocked_identifiers)
	when is_list(blocked_identifiers) do
	Enum.map(
	blocked_identifiers,
	fn blocked_identifier ->
	with {:ok, %User{} = blocked} <- get_or_fetch(blocked_identifier),
	{:ok, blocker} <- block(blocker, blocked),
	{:ok, _} <- ActivityPub.block(blocker, blocked) do
	blocked
	else
	err ->
	Logger.debug("blocks_import failed for #{blocked_identifier} with: #{inspect(err)}")
	err
	end
	end
	)
	end

	@spec perform(atom(), User.t(), list()) :: list() \| {:error, any()}
	def perform(:follow_import, %User{} = follower, followed_identifiers)
	when is_list(followed_identifiers) do
	Enum.map(
	followed_identifiers,
	fn followed_identifier ->
	with {:ok, %User{} = followed} <- get_or_fetch(followed_identifier),
	{:ok, follower} <- maybe_direct_follow(follower, followed),
	{:ok, _} <- ActivityPub.follow(follower, followed) do
	followed
	else
	err ->
	Logger.debug("follow_import failed for #{followed_identifier} with: #{inspect(err)}")
	err
	end
	end
	)
	end

	@spec external_users_query() :: Ecto.Query.t()
	def external_users_query do
	User.Query.build(%{
	external: true,
	active: true,
	order_by: :id
	})
	end

	@spec external_users(keyword()) :: [User.t()]
	def external_users(opts \\ []) do
	query =
	external_users_query()
	\|> select([u], struct(u, [:id, :ap_id, :info]))

	query =
	if opts[:max_id],
	do: where(query, [u], u.id > ^opts[:max_id]),
	else: query

	query =
	if opts[:limit],
	do: limit(query, ^opts[:limit]),
	else: query

	Repo.all(query)
	end

	def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers) do
	BackgroundWorker.enqueue("blocks_import", %{
	"blocker_id" => blocker.id,
	"blocked_identifiers" => blocked_identifiers
	})
	end

	def follow_import(%User{} = follower, followed_identifiers)
	when is_list(followed_identifiers) do
	BackgroundWorker.enqueue("follow_import", %{
	"follower_id" => follower.id,
	"followed_identifiers" => followed_identifiers
	})
	end

	def delete_user_activities(%User{ap_id: ap_id}) do
	ap_id
	\|> Activity.Queries.by_actor()
	\|> RepoStreamer.chunk_stream(50)
	\|> Stream.each(fn activities -> Enum.each(activities, &delete_activity/1) end)
	\|> Stream.run()
	end

	defp delete_activity(%{data: %{"type" => "Create"}} = activity) do
	activity
	\|> Object.normalize()
	\|> ActivityPub.delete()
	end

	defp delete_activity(%{data: %{"type" => "Like"}} = activity) do
	object = Object.normalize(activity)

	activity.actor
	\|> get_cached_by_ap_id()
	\|> ActivityPub.unlike(object)
	end

	defp delete_activity(%{data: %{"type" => "Announce"}} = activity) do
	object = Object.normalize(activity)

	activity.actor
	\|> get_cached_by_ap_id()
	\|> ActivityPub.unannounce(object)
	end

	defp delete_activity(_activity), do: "Doing nothing"

	def html_filter_policy(%User{info: %{no_rich_text: true}}) do
	Pleroma.HTML.Scrubber.TwitterText
	end

	def html_filter_policy(_), do: Pleroma.Config.get([:markup, :scrub_policy])

	def fetch_by_ap_id(ap_id) do
	case ActivityPub.make_user_from_ap_id(ap_id) do
	{:ok, user} ->
	{:ok, user}

	_ ->
	case OStatus.make_user(ap_id) do
	{:ok, user} -> {:ok, user}
	_ -> {:error, "Could not fetch by AP id"}
	end
	end
	end

	def get_or_fetch_by_ap_id(ap_id) do
	user = get_cached_by_ap_id(ap_id)

	if !is_nil(user) and !needs_update?(user) do
	{:ok, user}
	else
	# Whether to fetch initial posts for the user (if it's a new user & the fetching is enabled)
	should_fetch_initial = is_nil(user) and Pleroma.Config.get([:fetch_initial_posts, :enabled])

	resp = fetch_by_ap_id(ap_id)

	if should_fetch_initial do
	with {:ok, %User{} = user} <- resp do
	fetch_initial_posts(user)
	end
	end

	resp
	end
	end

	@doc "Creates an internal service actor by URI if missing. Optionally takes nickname for addressing."
	def get_or_create_service_actor_by_ap_id(uri, nickname \\ nil) do
	with %User{} = user <- get_cached_by_ap_id(uri) do
	user
	else
	_ ->
	{:ok, user} =
	%User{info: %User.Info{}}
	\|> cast(%{}, [:ap_id, :nickname, :local])
	\|> put_change(:ap_id, uri)
	\|> put_change(:nickname, nickname)
	\|> put_change(:local, true)
	\|> put_change(:follower_address, uri <> "/followers")
	\|> Repo.insert()

	user
	end
	end

	# AP style
	def public_key_from_info(%{
	source_data: %{"publicKey" => %{"publicKeyPem" => public_key_pem}}
	}) do
	key =
	public_key_pem
	\|> :public_key.pem_decode()
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

	# OStatus Magic Key
	def public_key_from_info(%{magic_key: magic_key}) when not is_nil(magic_key) do
	{:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
	end

	def public_key_from_info(_), do: {:error, "not found key"}

	def get_public_key_for_ap_id(ap_id) do
	with {:ok, %User{} = user} <- get_or_fetch_by_ap_id(ap_id),
	{:ok, public_key} <- public_key_from_info(user.info) do
	{:ok, public_key}
	else
	_ -> :error
	end
	end

	defp blank?(""), do: nil
	defp blank?(n), do: n

	def insert_or_update_user(data) do
	data
	\|> Map.put(:name, blank?(data[:name]) \|\| data[:nickname])
	\|> remote_user_creation()
	\|> Repo.insert(on_conflict: :replace_all_except_primary_key, conflict_target: :nickname)
	\|> set_cache()
	end

	def ap_enabled?(%User{local: true}), do: true
	def ap_enabled?(%User{info: info}), do: info.ap_enabled
	def ap_enabled?(_), do: false

	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: {:ok, User.t()} \| {:error, String.t()}
	def get_or_fetch("http" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

	# wait a period of time and return newest version of the User structs
	# this is because we have synchronous follow APIs and need to simulate them
	# with an async handshake
	def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
	with %User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
	with :ok <- :timer.sleep(timeout),
	%User{} = a <- get_cached_by_id(a.id),
	%User{} = b <- get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	nil -> :error
	end
	end

	def parse_bio(bio) when is_binary(bio) and bio != "" do
	bio
	\|> CommonUtils.format_input("text/plain", mentions_format: :full)
	\|> elem(0)
	end

	def parse_bio(_), do: ""

	def parse_bio(bio, user) when is_binary(bio) and bio != "" do
	# TODO: get profile URLs other than user.ap_id
	profile_urls = [user.ap_id]

	bio
	\|> CommonUtils.format_input("text/plain",
	mentions_format: :full,
	rel: &RelMe.maybe_put_rel_me(&1, profile_urls)
	)
	\|> elem(0)
	end

	def parse_bio(_, _), do: ""

	def tag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: tag(user_identifier, tags)
	end)
	end

	def tag(nickname, tags) when is_binary(nickname),
	do: tag(get_by_nickname(nickname), tags)

	def tag(%User{} = user, tags),
	do: update_tags(user, Enum.uniq((user.tags \|\| []) ++ normalize_tags(tags)))

	def untag(user_identifiers, tags) when is_list(user_identifiers) do
	Repo.transaction(fn ->
	for user_identifier <- user_identifiers, do: untag(user_identifier, tags)
	end)
	end

	def untag(nickname, tags) when is_binary(nickname),
	do: untag(get_by_nickname(nickname), tags)

	def untag(%User{} = user, tags),
	do: update_tags(user, (user.tags \|\| []) -- normalize_tags(tags))

	defp update_tags(%User{} = user, new_tags) do
	{:ok, updated_user} =
	user
	\|> change(%{tags: new_tags})
	\|> update_and_set_cache()

	updated_user
	end

	defp normalize_tags(tags) do
	[tags]
	\|> List.flatten()
	\|> Enum.map(&String.downcase/1)
	end

	defp local_nickname_regex do
	if Pleroma.Config.get([:instance, :extended_nickname_format]) do
	@extended_local_nickname_regex
	else
	@strict_local_nickname_regex
	end
	end

	def local_nickname(nickname_or_mention) do
	nickname_or_mention
	\|> full_nickname()
	\|> String.split("@")
	\|> hd()
	end

	def full_nickname(nickname_or_mention),
	do: String.trim_leading(nickname_or_mention, "@")

	def error_user(ap_id) do
	%User{
	name: ap_id,
	ap_id: ap_id,
	info: %User.Info{},
	nickname: "erroruser@example.com",
	inserted_at: NaiveDateTime.utc_now()
	}
	end

	@spec all_superusers() :: [User.t()]
	def all_superusers do
	User.Query.build(%{super_users: true, local: true, deactivated: false})
	\|> Repo.all()
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	target.ap_id not in user.info.muted_reblogs
	end

	@doc """
	The function returns a query to get users with no activity for given interval of days.
	Inactive users are those who didn't read any notification, or had any activity where
	the user is the activity's actor, during `inactivity_threshold` days.
	Deactivated users will not appear in this list.

	## Examples

	iex> Pleroma.User.list_inactive_users()
	%Ecto.Query{}
	"""
	@spec list_inactive_users_query(integer()) :: Ecto.Query.t()
	def list_inactive_users_query(inactivity_threshold \\ 7) do
	negative_inactivity_threshold = -inactivity_threshold
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)
	# Subqueries are not supported in `where` clauses, join gets too complicated.
	has_read_notifications =
	from(n in Pleroma.Notification,
	where: n.seen == true,
	group_by: n.id,
	having: max(n.updated_at) > datetime_add(^now, ^negative_inactivity_threshold, "day"),
	select: n.user_id
	)
	\|> Pleroma.Repo.all()

	from(u in Pleroma.User,
	left_join: a in Pleroma.Activity,
	on: u.ap_id == a.actor,
	where: not is_nil(u.nickname),
	where: fragment("not (?->'deactivated' @> 'true')", u.info),
	where: u.id not in ^has_read_notifications,
	group_by: u.id,
	having:
	max(a.inserted_at) < datetime_add(^now, ^negative_inactivity_threshold, "day") or
	is_nil(max(a.inserted_at))
	)
	end

	@doc """
	Enable or disable email notifications for user

	## Examples

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{info: %{email_notifications: %{"digest" => false}}}, "digest", true)
	Pleroma.User{info: %{email_notifications: %{"digest" => true}}}

	iex> Pleroma.User.switch_email_notifications(Pleroma.User{info: %{email_notifications: %{"digest" => true}}}, "digest", false)
	Pleroma.User{info: %{email_notifications: %{"digest" => false}}}
	"""
	@spec switch_email_notifications(t(), String.t(), boolean()) ::
	{:ok, t()} \| {:error, Ecto.Changeset.t()}
	def switch_email_notifications(user, type, status) do
	update_info(user, &User.Info.update_email_notifications(&1, %{type => status}))
	end

	@doc """
	Set `last_digest_emailed_at` value for the user to current time
	"""
	@spec touch_last_digest_emailed_at(t()) :: t()
	def touch_last_digest_emailed_at(user) do
	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	{:ok, updated_user} =
	user
	\|> change(%{last_digest_emailed_at: now})
	\|> update_and_set_cache()

	updated_user
	end

	@spec toggle_confirmation(User.t()) :: {:ok, User.t()} \| {:error, Changeset.t()}
	def toggle_confirmation(%User{} = user) do
	need_confirmation? = !user.info.confirmation_pending

	user
	\|> update_info(&User.Info.confirmation_changeset(&1, need_confirmation: need_confirmation?))
	end

	def get_mascot(%{info: %{mascot: %{} = mascot}}) when not is_nil(mascot) do
	mascot
	end

	def get_mascot(%{info: %{mascot: mascot}}) when is_nil(mascot) do
	# use instance-default
	config = Pleroma.Config.get([:assets, :mascots])
	default_mascot = Pleroma.Config.get([:assets, :default_mascot])
	mascot = Keyword.get(config, default_mascot)

	%{
	"id" => "default-mascot",
	"url" => mascot[:url],
	"preview_url" => mascot[:url],
	"pleroma" => %{
	"mime_type" => mascot[:mime_type]
	}
	}
	end

	def ensure_keys_present(%{info: %{keys: keys}} = user) when not is_nil(keys), do: {:ok, user}

	def ensure_keys_present(%User{} = user) do
	with {:ok, pem} <- Keys.generate_rsa_pem() do
	update_info(user, &User.Info.set_keys(&1, pem))
	end
	end

	def get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	select: u.ap_id
	)
	\|> Repo.all()
	end

	defdelegate search(query, opts \\ []), to: User.Search

	defp put_password_hash(
	%Ecto.Changeset{valid?: true, changes: %{password: password}} = changeset
	) do
	change(changeset, password_hash: Pbkdf2.hashpwsalt(password))
	end

	defp put_password_hash(changeset), do: changeset

	def is_internal_user?(%User{nickname: nil}), do: true
	def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
	def is_internal_user?(_), do: false

	# A hack because user delete activities have a fake id for whatever reason
	# TODO: Get rid of this
	def get_delivered_users_by_object_id("pleroma:fake_object_id"), do: []

	def get_delivered_users_by_object_id(object_id) do
	from(u in User,
	inner_join: delivery in assoc(u, :deliveries),
	where: delivery.object_id == ^object_id
	)
	\|> Repo.all()
	end

	def change_email(user, email) do
	user
	\|> cast(%{email: email}, [:email])
	\|> validate_required([:email])
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> update_and_set_cache()
	end

	@doc """
	Changes `user.info` and returns the user changeset.

	`fun` is called with the `user.info`.
	"""
	def change_info(user, fun) do
	changeset = change(user)
	info = get_field(changeset, :info) \|\| %User.Info{}
	put_embed(changeset, :info, fun.(info))
	end

	@doc """
	Updates `user.info` and sets cache.

	`fun` is called with the `user.info`.
	"""
	def update_info(user, fun) do
	user
	\|> change_info(fun)
	\|> update_and_set_cache()
	end
	end
	diff --git a/lib/pleroma/user/info.ex b/lib/pleroma/user/info.ex
	index 4b5b43d7f..ebd4ddebf 100644
	--- a/lib/pleroma/user/info.ex
	+++ b/lib/pleroma/user/info.ex
	@@ -1,478 +1,477 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.Info do
	use Ecto.Schema
	import Ecto.Changeset

	alias Pleroma.User.Info

	@type t :: %__MODULE__{}

	embedded_schema do
	field(:banner, :map, default: %{})
	field(:background, :map, default: %{})
	field(:source_data, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	# Should be filled in only for remote users
	field(:following_count, :integer, default: nil)
	field(:locked, :boolean, default: false)
	field(:confirmation_pending, :boolean, default: false)
	field(:password_reset_pending, :boolean, default: false)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:blocks, {:array, :string}, default: [])
	field(:domain_blocks, {:array, :string}, default: [])
	field(:mutes, {:array, :string}, default: [])
	field(:muted_reblogs, {:array, :string}, default: [])
	field(:muted_notifications, {:array, :string}, default: [])
	field(:subscribers, {:array, :string}, default: [])
	field(:deactivated, :boolean, default: false)
	field(:no_rich_text, :boolean, default: false)
	field(:ap_enabled, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	field(:keys, :string, default: nil)
	field(:settings, :map, default: nil)
	field(:magic_key, :string, default: nil)
	field(:uri, :string, default: nil)
	field(:topic, :string, default: nil)
	field(:hub, :string, default: nil)
	field(:salmon, :string, default: nil)
	field(:hide_followers_count, :boolean, default: false)
	field(:hide_follows_count, :boolean, default: false)
	field(:hide_followers, :boolean, default: false)
	field(:hide_follows, :boolean, default: false)
	field(:hide_favorites, :boolean, default: true)
	- field(:unread_conversation_count, :integer, default: 0)
	field(:pinned_activities, {:array, :string}, default: [])
	field(:email_notifications, :map, default: %{"digest" => false})
	field(:mascot, :map, default: nil)
	field(:emoji, {:array, :map}, default: [])
	field(:pleroma_settings_store, :map, default: %{})
	field(:fields, {:array, :map}, default: nil)
	field(:raw_fields, {:array, :map}, default: [])
	field(:discoverable, :boolean, default: false)

	field(:notification_settings, :map,
	default: %{
	"followers" => true,
	"follows" => true,
	"non_follows" => true,
	"non_followers" => true
	}
	)

	field(:skip_thread_containment, :boolean, default: false)

	# Found in the wild
	# ap_id -> Where is this used?
	# bio -> Where is this used?
	# avatar -> Where is this used?
	# fqn -> Where is this used?
	# host -> Where is this used?
	# subject _> Where is this used?
	end

	def set_activation_status(info, deactivated) do
	params = %{deactivated: deactivated}

	info
	\|> cast(params, [:deactivated])
	\|> validate_required([:deactivated])
	end

	def set_password_reset_pending(info, pending) do
	params = %{password_reset_pending: pending}

	info
	\|> cast(params, [:password_reset_pending])
	\|> validate_required([:password_reset_pending])
	end

	def update_notification_settings(info, settings) do
	settings =
	settings
	\|> Enum.map(fn {k, v} -> {k, v in [true, "true", "True", "1"]} end)
	\|> Map.new()

	notification_settings =
	info.notification_settings
	\|> Map.merge(settings)
	\|> Map.take(["followers", "follows", "non_follows", "non_followers"])

	params = %{notification_settings: notification_settings}

	info
	\|> cast(params, [:notification_settings])
	\|> validate_required([:notification_settings])
	end

	@doc """
	Update email notifications in the given User.Info struct.

	Examples:

	iex> update_email_notifications(%Pleroma.User.Info{email_notifications: %{"digest" => false}}, %{"digest" => true})
	%Pleroma.User.Info{email_notifications: %{"digest" => true}}

	"""
	@spec update_email_notifications(t(), map()) :: Ecto.Changeset.t()
	def update_email_notifications(info, settings) do
	email_notifications =
	info.email_notifications
	\|> Map.merge(settings)
	\|> Map.take(["digest"])

	params = %{email_notifications: email_notifications}
	fields = [:email_notifications]

	info
	\|> cast(params, fields)
	\|> validate_required(fields)
	end

	def add_to_note_count(info, number) do
	set_note_count(info, info.note_count + number)
	end

	def set_note_count(info, number) do
	params = %{note_count: Enum.max([0, number])}

	info
	\|> cast(params, [:note_count])
	\|> validate_required([:note_count])
	end

	def set_follower_count(info, number) do
	params = %{follower_count: Enum.max([0, number])}

	info
	\|> cast(params, [:follower_count])
	\|> validate_required([:follower_count])
	end

	def set_mutes(info, mutes) do
	params = %{mutes: mutes}

	info
	\|> cast(params, [:mutes])
	\|> validate_required([:mutes])
	end

	@spec set_notification_mutes(Changeset.t(), [String.t()], boolean()) :: Changeset.t()
	def set_notification_mutes(changeset, muted_notifications, notifications?) do
	if notifications? do
	put_change(changeset, :muted_notifications, muted_notifications)
	\|> validate_required([:muted_notifications])
	else
	changeset
	end
	end

	def set_blocks(info, blocks) do
	params = %{blocks: blocks}

	info
	\|> cast(params, [:blocks])
	\|> validate_required([:blocks])
	end

	def set_subscribers(info, subscribers) do
	params = %{subscribers: subscribers}

	info
	\|> cast(params, [:subscribers])
	\|> validate_required([:subscribers])
	end

	@spec add_to_mutes(Info.t(), String.t(), boolean()) :: Changeset.t()
	def add_to_mutes(info, muted, notifications?) do
	info
	\|> set_mutes(Enum.uniq([muted \| info.mutes]))
	\|> set_notification_mutes(
	Enum.uniq([muted \| info.muted_notifications]),
	notifications?
	)
	end

	@spec remove_from_mutes(Info.t(), String.t()) :: Changeset.t()
	def remove_from_mutes(info, muted) do
	info
	\|> set_mutes(List.delete(info.mutes, muted))
	\|> set_notification_mutes(List.delete(info.muted_notifications, muted), true)
	end

	def add_to_block(info, blocked) do
	set_blocks(info, Enum.uniq([blocked \| info.blocks]))
	end

	def remove_from_block(info, blocked) do
	set_blocks(info, List.delete(info.blocks, blocked))
	end

	def add_to_subscribers(info, subscribed) do
	set_subscribers(info, Enum.uniq([subscribed \| info.subscribers]))
	end

	def remove_from_subscribers(info, subscribed) do
	set_subscribers(info, List.delete(info.subscribers, subscribed))
	end

	def set_domain_blocks(info, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

	info
	\|> cast(params, [:domain_blocks])
	\|> validate_required([:domain_blocks])
	end

	def add_to_domain_block(info, domain_blocked) do
	set_domain_blocks(info, Enum.uniq([domain_blocked \| info.domain_blocks]))
	end

	def remove_from_domain_block(info, domain_blocked) do
	set_domain_blocks(info, List.delete(info.domain_blocks, domain_blocked))
	end

	def set_keys(info, keys) do
	params = %{keys: keys}

	info
	\|> cast(params, [:keys])
	\|> validate_required([:keys])
	end

	def remote_user_creation(info, params) do
	params =
	if Map.has_key?(params, :fields) do
	Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
	else
	params
	end

	info
	\|> cast(params, [
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key,
	:uri,
	:hub,
	:topic,
	:salmon,
	:hide_followers,
	:hide_follows,
	:hide_followers_count,
	:hide_follows_count,
	:follower_count,
	:fields,
	:following_count,
	:discoverable
	])
	\|> validate_fields(true)
	end

	def user_upgrade(info, params, remote? \\ false) do
	info
	\|> cast(params, [
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key,
	:follower_count,
	:following_count,
	:hide_follows,
	:fields,
	:hide_followers,
	:discoverable,
	:hide_followers_count,
	:hide_follows_count
	])
	\|> validate_fields(remote?)
	end

	def profile_update(info, params) do
	info
	\|> cast(params, [
	:locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:hide_followers_count,
	:hide_follows_count,
	:hide_favorites,
	:background,
	:show_role,
	:skip_thread_containment,
	:fields,
	:raw_fields,
	:pleroma_settings_store,
	:discoverable
	])
	\|> validate_fields()
	end

	def validate_fields(changeset, remote? \\ false) do
	limit_name = if remote?, do: :max_remote_account_fields, else: :max_account_fields
	limit = Pleroma.Config.get([:instance, limit_name], 0)

	changeset
	\|> validate_length(:fields, max: limit)
	\|> validate_change(:fields, fn :fields, fields ->
	if Enum.all?(fields, &valid_field?/1) do
	[]
	else
	[fields: "invalid"]
	end
	end)
	end

	defp valid_field?(%{"name" => name, "value" => value}) do
	name_limit = Pleroma.Config.get([:instance, :account_field_name_length], 255)
	value_limit = Pleroma.Config.get([:instance, :account_field_value_length], 255)

	is_binary(name) && is_binary(value) && String.length(name) <= name_limit &&
	String.length(value) <= value_limit
	end

	defp valid_field?(_), do: false

	defp truncate_field(%{"name" => name, "value" => value}) do
	{name, _chopped} =
	String.split_at(name, Pleroma.Config.get([:instance, :account_field_name_length], 255))

	{value, _chopped} =
	String.split_at(value, Pleroma.Config.get([:instance, :account_field_value_length], 255))

	%{"name" => name, "value" => value}
	end

	@spec confirmation_changeset(Info.t(), keyword()) :: Changeset.t()
	def confirmation_changeset(info, opts) do
	need_confirmation? = Keyword.get(opts, :need_confirmation)

	params =
	if need_confirmation? do
	%{
	confirmation_pending: true,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	}
	else
	%{
	confirmation_pending: false,
	confirmation_token: nil
	}
	end

	cast(info, params, [:confirmation_pending, :confirmation_token])
	end

	def mastodon_settings_update(info, settings) do
	params = %{settings: settings}

	info
	\|> cast(params, [:settings])
	\|> validate_required([:settings])
	end

	def mascot_update(info, url) do
	params = %{mascot: url}

	info
	\|> cast(params, [:mascot])
	\|> validate_required([:mascot])
	end

	def set_source_data(info, source_data) do
	params = %{source_data: source_data}

	info
	\|> cast(params, [:source_data])
	\|> validate_required([:source_data])
	end

	def admin_api_update(info, params) do
	info
	\|> cast(params, [
	:is_moderator,
	:is_admin,
	:show_role
	])
	end

	def add_pinnned_activity(info, %Pleroma.Activity{id: id}) do
	if id not in info.pinned_activities do
	max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
	params = %{pinned_activities: info.pinned_activities ++ [id]}

	info
	\|> cast(params, [:pinned_activities])
	\|> validate_length(:pinned_activities,
	max: max_pinned_statuses,
	message: "You have already pinned the maximum number of statuses"
	)
	else
	change(info)
	end
	end

	def remove_pinnned_activity(info, %Pleroma.Activity{id: id}) do
	params = %{pinned_activities: List.delete(info.pinned_activities, id)}

	cast(info, params, [:pinned_activities])
	end

	def roles(%Info{is_moderator: is_moderator, is_admin: is_admin}) do
	%{
	admin: is_admin,
	moderator: is_moderator
	}
	end

	def add_reblog_mute(info, ap_id) do
	params = %{muted_reblogs: info.muted_reblogs ++ [ap_id]}

	cast(info, params, [:muted_reblogs])
	end

	def remove_reblog_mute(info, ap_id) do
	params = %{muted_reblogs: List.delete(info.muted_reblogs, ap_id)}

	cast(info, params, [:muted_reblogs])
	end

	# ``fields`` is an array of mastodon profile field, containing ``{"name": "…", "value": "…"}``.
	# For example: [{"name": "Pronoun", "value": "she/her"}, …]
	def fields(%{fields: nil, source_data: %{"attachment" => attachment}}) do
	limit = Pleroma.Config.get([:instance, :max_remote_account_fields], 0)

	attachment
	\|> Enum.filter(fn %{"type" => t} -> t == "PropertyValue" end)
	\|> Enum.map(fn fields -> Map.take(fields, ["name", "value"]) end)
	\|> Enum.take(limit)
	end

	def fields(%{fields: nil}), do: []

	def fields(%{fields: fields}), do: fields

	def follow_information_update(info, params) do
	info
	\|> cast(params, [
	:hide_followers,
	:hide_follows,
	:follower_count,
	:following_count,
	:hide_followers_count,
	:hide_follows_count
	])
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/account_view.ex b/lib/pleroma/web/mastodon_api/views/account_view.ex
	index 2d4976891..99169ef95 100644
	--- a/lib/pleroma/web/mastodon_api/views/account_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/account_view.ex
	@@ -1,264 +1,253 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountView do
	use Pleroma.Web, :view

	alias Pleroma.HTML
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MediaProxy

	def render("index.json", %{users: users} = opts) do
	users
	\|> render_many(AccountView, "show.json", opts)
	\|> Enum.filter(&Enum.any?/1)
	end

	def render("show.json", %{user: user} = opts) do
	if User.visible_for?(user, opts[:for]),
	do: do_render("show.json", opts),
	else: %{}
	end

	def render("mention.json", %{user: user}) do
	%{
	id: to_string(user.id),
	acct: user.nickname,
	username: username_from_nickname(user.nickname),
	url: User.profile_url(user)
	}
	end

	def render("relationship.json", %{user: nil, target: _target}) do
	%{}
	end

	def render("relationship.json", %{user: %User{} = user, target: %User{} = target}) do
	follow_state = User.get_cached_follow_state(user, target)

	requested =
	if follow_state && !User.following?(user, target) do
	follow_state == "pending"
	else
	false
	end

	%{
	id: to_string(target.id),
	following: User.following?(user, target),
	followed_by: User.following?(target, user),
	blocking: User.blocks_ap_id?(user, target),
	blocked_by: User.blocks_ap_id?(target, user),
	muting: User.mutes?(user, target),
	muting_notifications: User.muted_notifications?(user, target),
	subscribing: User.subscribed_to?(user, target),
	requested: requested,
	domain_blocking: User.blocks_domain?(user, target),
	showing_reblogs: User.showing_reblogs?(user, target),
	endorsed: false
	}
	end

	def render("relationships.json", %{user: user, targets: targets}) do
	render_many(targets, AccountView, "relationship.json", user: user, as: :target)
	end

	defp do_render("show.json", %{user: user} = opts) do
	display_name = HTML.strip_tags(user.name \|\| user.nickname)

	image = User.avatar_url(user) \|> MediaProxy.url()
	header = User.banner_url(user) \|> MediaProxy.url()
	user_info = User.get_cached_user_info(user)

	following_count =
	if !user.info.hide_follows_count or !user.info.hide_follows or opts[:for] == user do
	user_info.following_count
	else
	0
	end

	followers_count =
	if !user.info.hide_followers_count or !user.info.hide_followers or opts[:for] == user do
	user_info.follower_count
	else
	0
	end

	bot = (user.info.source_data["type"] \|\| "Person") in ["Application", "Service"]

	emojis =
	(user.info.source_data["tag"] \|\| [])
	\|> Enum.filter(fn %{"type" => t} -> t == "Emoji" end)
	\|> Enum.map(fn %{"icon" => %{"url" => url}, "name" => name} ->
	%{
	"shortcode" => String.trim(name, ":"),
	"url" => MediaProxy.url(url),
	"static_url" => MediaProxy.url(url),
	"visible_in_picker" => false
	}
	end)

	fields =
	user.info
	\|> User.Info.fields()
	\|> Enum.map(fn %{"name" => name, "value" => value} ->
	%{
	"name" => Pleroma.HTML.strip_tags(name),
	"value" => Pleroma.HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly)
	}
	end)

	raw_fields = Map.get(user.info, :raw_fields, [])

	bio = HTML.filter_tags(user.bio, User.html_filter_policy(opts[:for]))
	relationship = render("relationship.json", %{user: opts[:for], target: user})

	discoverable = user.info.discoverable

	%{
	id: to_string(user.id),
	username: username_from_nickname(user.nickname),
	acct: user.nickname,
	display_name: display_name,
	locked: user_info.locked,
	created_at: Utils.to_masto_date(user.inserted_at),
	followers_count: followers_count,
	following_count: following_count,
	statuses_count: user_info.note_count,
	note: bio \|\| "",
	url: User.profile_url(user),
	avatar: image,
	avatar_static: image,
	header: header,
	header_static: header,
	emojis: emojis,
	fields: fields,
	bot: bot,
	source: %{
	note: HTML.strip_tags((user.bio \|\| "") \|> String.replace("<br>", "\n")),
	sensitive: false,
	fields: raw_fields,
	pleroma: %{
	discoverable: discoverable
	}
	},

	# Pleroma extension
	pleroma: %{
	confirmation_pending: user_info.confirmation_pending,
	tags: user.tags,
	hide_followers_count: user.info.hide_followers_count,
	hide_follows_count: user.info.hide_follows_count,
	hide_followers: user.info.hide_followers,
	hide_follows: user.info.hide_follows,
	hide_favorites: user.info.hide_favorites,
	relationship: relationship,
	skip_thread_containment: user.info.skip_thread_containment,
	background_image: image_url(user.info.background) \|> MediaProxy.url()
	}
	}
	\|> maybe_put_role(user, opts[:for])
	\|> maybe_put_settings(user, opts[:for], user_info)
	\|> maybe_put_notification_settings(user, opts[:for])
	\|> maybe_put_settings_store(user, opts[:for], opts)
	\|> maybe_put_chat_token(user, opts[:for], opts)
	\|> maybe_put_activation_status(user, opts[:for])
	\|> maybe_put_follow_requests_count(user, opts[:for])
	- \|> maybe_put_unread_conversation_count(user, opts[:for])
	end

	defp username_from_nickname(string) when is_binary(string) do
	hd(String.split(string, "@"))
	end

	defp username_from_nickname(_), do: nil

	defp maybe_put_follow_requests_count(
	data,
	%User{id: user_id} = user,
	%User{id: user_id}
	) do
	count =
	User.get_follow_requests(user)
	\|> length()

	data
	\|> Kernel.put_in([:follow_requests_count], count)
	end

	defp maybe_put_follow_requests_count(data, _, _), do: data

	defp maybe_put_settings(
	data,
	%User{id: user_id} = user,
	%User{id: user_id},
	user_info
	) do
	data
	\|> Kernel.put_in([:source, :privacy], user_info.default_scope)
	\|> Kernel.put_in([:source, :pleroma, :show_role], user.info.show_role)
	\|> Kernel.put_in([:source, :pleroma, :no_rich_text], user.info.no_rich_text)
	end

	defp maybe_put_settings(data, _, _, _), do: data

	defp maybe_put_settings_store(data, %User{info: info, id: id}, %User{id: id}, %{
	with_pleroma_settings: true
	}) do
	data
	\|> Kernel.put_in([:pleroma, :settings_store], info.pleroma_settings_store)
	end

	defp maybe_put_settings_store(data, _, _, _), do: data

	defp maybe_put_chat_token(data, %User{id: id}, %User{id: id}, %{
	with_chat_token: token
	}) do
	data
	\|> Kernel.put_in([:pleroma, :chat_token], token)
	end

	defp maybe_put_chat_token(data, _, _, _), do: data

	defp maybe_put_role(data, %User{info: %{show_role: true}} = user, _) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.info.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.info.is_moderator)
	end

	defp maybe_put_role(data, %User{id: user_id} = user, %User{id: user_id}) do
	data
	\|> Kernel.put_in([:pleroma, :is_admin], user.info.is_admin)
	\|> Kernel.put_in([:pleroma, :is_moderator], user.info.is_moderator)
	end

	defp maybe_put_role(data, _, _), do: data

	defp maybe_put_notification_settings(data, %User{id: user_id} = user, %User{id: user_id}) do
	Kernel.put_in(data, [:pleroma, :notification_settings], user.info.notification_settings)
	end

	defp maybe_put_notification_settings(data, _, _), do: data

	defp maybe_put_activation_status(data, user, %User{info: %{is_admin: true}}) do
	Kernel.put_in(data, [:pleroma, :deactivated], user.info.deactivated)
	end

	defp maybe_put_activation_status(data, _, _), do: data

	- defp maybe_put_unread_conversation_count(data, %User{id: user_id} = user, %User{id: user_id}) do
	- data
	- \|> Kernel.put_in(
	- [:pleroma, :unread_conversation_count],
	- user.info.unread_conversation_count
	- )
	- end
	-
	- defp maybe_put_unread_conversation_count(data, _, _), do: data
	-
	defp image_url(%{"url" => [%{"href" => href} \| _]}), do: href
	defp image_url(_), do: nil
	end
	diff --git a/test/conversation/participation_test.exs b/test/conversation/participation_test.exs
	index f430bdf75..a27167d42 100644
	--- a/test/conversation/participation_test.exs
	+++ b/test/conversation/participation_test.exs
	@@ -1,172 +1,168 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Conversation.ParticipationTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.Conversation.Participation
	- alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	test "getting a participation will also preload things" do
	user = insert(:user)
	other_user = insert(:user)

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

	[participation] = Participation.for_user(user)

	participation = Participation.get(participation.id, preload: [:conversation])

	assert %Pleroma.Conversation{} = participation.conversation
	end

	test "for a new conversation, it sets the recipents of the participation" do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

	- user = User.get_cached_by_id(user.id)
	- other_user = User.get_cached_by_id(user.id)
	[participation] = Participation.for_user(user)
	participation = Pleroma.Repo.preload(participation, :recipients)

	assert length(participation.recipients) == 2
	assert user in participation.recipients
	assert other_user in participation.recipients

	# Mentioning another user in the same conversation will not add a new recipients.

	{:ok, _activity} =
	CommonAPI.post(user, %{
	"in_reply_to_status_id" => activity.id,
	"status" => "Hey @#{third_user.nickname}.",
	"visibility" => "direct"
	})

	[participation] = Participation.for_user(user)
	participation = Pleroma.Repo.preload(participation, :recipients)

	assert length(participation.recipients) == 2
	end

	test "it creates a participation for a conversation and a user" do
	user = insert(:user)
	conversation = insert(:conversation)

	{:ok, %Participation{} = participation} =
	Participation.create_for_user_and_conversation(user, conversation)

	assert participation.user_id == user.id
	assert participation.conversation_id == conversation.id

	:timer.sleep(1000)
	# Creating again returns the same participation
	{:ok, %Participation{} = participation_two} =
	Participation.create_for_user_and_conversation(user, conversation)

	assert participation.id == participation_two.id
	refute participation.updated_at == participation_two.updated_at
	end

	test "recreating an existing participations sets it to unread" do
	participation = insert(:participation, %{read: true})

	{:ok, participation} =
	Participation.create_for_user_and_conversation(
	participation.user,
	participation.conversation
	)

	refute participation.read
	end

	test "it marks a participation as read" do
	participation = insert(:participation, %{read: false})
	{:ok, participation} = Participation.mark_as_read(participation)

	assert participation.read
	end

	test "it marks a participation as unread" do
	participation = insert(:participation, %{read: true})
	{:ok, participation} = Participation.mark_as_unread(participation)

	refute participation.read
	end

	test "gets all the participations for a user, ordered by updated at descending" do
	user = insert(:user)
	{:ok, activity_one} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
	:timer.sleep(1000)
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "x", "visibility" => "direct"})
	:timer.sleep(1000)

	{:ok, activity_three} =
	CommonAPI.post(user, %{
	"status" => "x",
	"visibility" => "direct",
	"in_reply_to_status_id" => activity_one.id
	})

	assert [participation_one, participation_two] = Participation.for_user(user)

	object2 = Pleroma.Object.normalize(activity_two)
	object3 = Pleroma.Object.normalize(activity_three)

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

	assert participation_one.conversation.ap_id == object3.data["context"]
	assert participation_two.conversation.ap_id == object2.data["context"]
	assert participation_one.conversation.users == [user]

	# Pagination
	assert [participation_one] = Participation.for_user(user, %{"limit" => 1})

	assert participation_one.conversation.ap_id == object3.data["context"]

	# With last_activity_id
	assert [participation_one] =
	Participation.for_user_with_last_activity_id(user, %{"limit" => 1})

	assert participation_one.last_activity_id == activity_three.id
	end

	test "Doesn't die when the conversation gets empty" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
	[participation] = Participation.for_user_with_last_activity_id(user)

	assert participation.last_activity_id == activity.id

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

	[] = Participation.for_user_with_last_activity_id(user)
	end

	test "it sets recipients, always keeping the owner of the participation even when not explicitly set" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} = CommonAPI.post(user, %{"status" => ".", "visibility" => "direct"})
	[participation] = Participation.for_user_with_last_activity_id(user)

	participation = Repo.preload(participation, :recipients)
	- user = User.get_cached_by_id(user.id)

	assert participation.recipients \|> length() == 1
	assert user in participation.recipients

	{:ok, participation} = Participation.set_recipients(participation, [other_user.id])

	assert participation.recipients \|> length() == 2
	assert user in participation.recipients
	assert other_user in participation.recipients
	end
	end
	diff --git a/test/web/mastodon_api/controllers/conversation_controller_test.exs b/test/web/mastodon_api/controllers/conversation_controller_test.exs
	index a308a7620..7117fc76a 100644
	--- a/test/web/mastodon_api/controllers/conversation_controller_test.exs
	+++ b/test/web/mastodon_api/controllers/conversation_controller_test.exs
	@@ -1,156 +1,75 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.ConversationControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	- test "returns a list of conversations", %{conn: conn} do
	+ test "Conversations", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	- assert User.get_cached_by_id(user_two.id).info.unread_conversation_count == 0
	-
	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}, @#{user_three.nickname}!",
	"visibility" => "direct"
	})

	- assert User.get_cached_by_id(user_two.id).info.unread_conversation_count == 1
	-
	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	res_conn =
	conn
	\|> assign(:user, user_one)
	\|> get("/api/v1/conversations")

	assert response = json_response(res_conn, 200)

	assert [
	%{
	"id" => res_id,
	"accounts" => res_accounts,
	"last_status" => res_last_status,
	"unread" => unread
	}
	] = response

	account_ids = Enum.map(res_accounts, & &1["id"])
	assert length(res_accounts) == 2
	assert user_two.id in account_ids
	assert user_three.id in account_ids
	assert is_binary(res_id)
	assert unread == true
	assert res_last_status["id"] == direct.id
	- assert User.get_cached_by_id(user_one.id).info.unread_conversation_count == 1
	- end
	-
	- test "updates the last_status on reply", %{conn: conn} do
	- user_one = insert(:user)
	- user_two = insert(:user)
	-
	- {:ok, direct} =
	- CommonAPI.post(user_one, %{
	- "status" => "Hi @#{user_two.nickname}",
	- "visibility" => "direct"
	- })
	-
	- {:ok, direct_reply} =
	- CommonAPI.post(user_two, %{
	- "status" => "reply",
	- "visibility" => "direct",
	- "in_reply_to_status_id" => direct.id
	- })
	-
	- [%{"last_status" => res_last_status}] =
	- conn
	- \|> assign(:user, user_one)
	- \|> get("/api/v1/conversations")
	- \|> json_response(200)
	-
	- assert res_last_status["id"] == direct_reply.id
	- end
	-
	- test "the user marks a conversation as read", %{conn: conn} do
	- user_one = insert(:user)
	- user_two = insert(:user)
	-
	- {:ok, direct} =
	- CommonAPI.post(user_one, %{
	- "status" => "Hi @#{user_two.nickname}",
	- "visibility" => "direct"
	- })

	- [%{"id" => direct_conversation_id, "unread" => true}] =
	- conn
	- \|> assign(:user, user_one)
	- \|> get("/api/v1/conversations")
	- \|> json_response(200)
	-
	- %{"unread" => false} =
	- conn
	- \|> assign(:user, user_one)
	- \|> post("/api/v1/conversations/#{direct_conversation_id}/read")
	- \|> json_response(200)
	-
	- assert User.get_cached_by_id(user_one.id).info.unread_conversation_count == 0
	-
	- # The conversation is marked as unread on reply
	- {:ok, _} =
	- CommonAPI.post(user_two, %{
	- "status" => "reply",
	- "visibility" => "direct",
	- "in_reply_to_status_id" => direct.id
	- })
	-
	- [%{"unread" => true}] =
	+ # Apparently undocumented API endpoint
	+ res_conn =
	conn
	\|> assign(:user, user_one)
	- \|> get("/api/v1/conversations")
	- \|> json_response(200)
	-
	- assert User.get_cached_by_id(user_one.id).info.unread_conversation_count == 1
	+ \|> post("/api/v1/conversations/#{res_id}/read")

	- # A reply doesn't increment the user's unread_conversation_count if the conversation is unread
	- {:ok, _} =
	- CommonAPI.post(user_two, %{
	- "status" => "reply",
	- "visibility" => "direct",
	- "in_reply_to_status_id" => direct.id
	- })
	-
	- assert User.get_cached_by_id(user_one.id).info.unread_conversation_count == 1
	- end
	-
	- test "(vanilla) Mastodon frontend behaviour", %{conn: conn} do
	- user_one = insert(:user)
	- user_two = insert(:user)
	-
	- {:ok, direct} =
	- CommonAPI.post(user_one, %{
	- "status" => "Hi @#{user_two.nickname}!",
	- "visibility" => "direct"
	- })
	+ assert response = json_response(res_conn, 200)
	+ assert length(response["accounts"]) == 2
	+ assert response["last_status"]["id"] == direct.id
	+ assert response["unread"] == false

	+ # (vanilla) Mastodon frontend behaviour
	res_conn =
	conn
	\|> assign(:user, user_one)
	- \|> get("/api/v1/statuses/#{direct.id}/context")
	+ \|> get("/api/v1/statuses/#{res_last_status["id"]}/context")

	assert %{"ancestors" => [], "descendants" => []} == json_response(res_conn, 200)
	end
	end
	diff --git a/test/web/mastodon_api/views/account_view_test.exs b/test/web/mastodon_api/views/account_view_test.exs
	index b7a4938a6..62b2ab7e3 100644
	--- a/test/web/mastodon_api/views/account_view_test.exs
	+++ b/test/web/mastodon_api/views/account_view_test.exs
	@@ -1,518 +1,497 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.AccountViewTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView

	test "Represent a user account" do
	source_data = %{
	"tag" => [
	%{
	"type" => "Emoji",
	"icon" => %{"url" => "/file.png"},
	"name" => ":karjalanpiirakka:"
	}
	]
	}

	background_image = %{
	"url" => [%{"href" => "https://example.com/images/asuka_hospital.png"}]
	}

	user =
	insert(:user, %{
	info: %{
	note_count: 5,
	follower_count: 3,
	source_data: source_data,
	background: background_image
	},
	nickname: "shp@shitposter.club",
	name: ":karjalanpiirakka: shp",
	bio: "<script src=\"invalid-html\"></script><span>valid html</span>",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: "<span>valid html</span>",
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [
	%{
	"static_url" => "/file.png",
	"url" => "/file.png",
	"shortcode" => "karjalanpiirakka",
	"visible_in_picker" => false
	}
	],
	fields: [],
	bot: false,
	source: %{
	note: "valid html",
	sensitive: false,
	pleroma: %{
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: "https://example.com/images/asuka_hospital.png",
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user})
	end

	test "Represent the user account for the account owner" do
	user = insert(:user)

	notification_settings = %{
	"followers" => true,
	"follows" => true,
	"non_follows" => true,
	"non_followers" => true
	}

	privacy = user.info.default_scope

	assert %{
	pleroma: %{notification_settings: ^notification_settings},
	source: %{privacy: ^privacy}
	} = AccountView.render("show.json", %{user: user, for: user})
	end

	test "Represent a Service(bot) account" do
	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 3, source_data: %{"type" => "Service"}},
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 3,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user})
	end

	test "Represent a deactivated user for an admin" do
	admin = insert(:user, %{info: %{is_admin: true}})
	deactivated_user = insert(:user, %{info: %{deactivated: true}})
	represented = AccountView.render("show.json", %{user: deactivated_user, for: admin})
	assert represented[:pleroma][:deactivated] == true
	end

	test "Represent a smaller mention" do
	user = insert(:user)

	expected = %{
	id: to_string(user.id),
	acct: user.nickname,
	username: user.nickname,
	url: user.ap_id
	}

	assert expected == AccountView.render("mention.json", %{user: user})
	end

	describe "relationship" do
	test "represent a relationship for the following and followed user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, other_user} = User.subscribe(user, other_user)
	{:ok, user} = User.mute(user, other_user, true)
	{:ok, user} = CommonAPI.hide_reblogs(user, other_user)

	expected = %{
	id: to_string(other_user.id),
	following: true,
	followed_by: true,
	blocking: false,
	blocked_by: false,
	muting: true,
	muting_notifications: true,
	subscribing: true,
	requested: false,
	domain_blocking: false,
	showing_reblogs: false,
	endorsed: false
	}

	assert expected ==
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent a relationship for the blocking and blocked user" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.follow(user, other_user)
	{:ok, other_user} = User.subscribe(user, other_user)
	{:ok, user} = User.block(user, other_user)
	{:ok, other_user} = User.block(other_user, user)

	expected = %{
	id: to_string(other_user.id),
	following: false,
	followed_by: false,
	blocking: true,
	blocked_by: true,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	assert expected ==
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent a relationship for the user blocking a domain" do
	user = insert(:user)
	other_user = insert(:user, ap_id: "https://bad.site/users/other_user")

	{:ok, user} = User.block_domain(user, "bad.site")

	assert %{domain_blocking: true, blocking: false} =
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end

	test "represent a relationship for the user with a pending follow request" do
	user = insert(:user)
	other_user = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, user, other_user, _} = CommonAPI.follow(user, other_user)
	user = User.get_cached_by_id(user.id)
	other_user = User.get_cached_by_id(other_user.id)

	expected = %{
	id: to_string(other_user.id),
	following: false,
	followed_by: false,
	blocking: false,
	blocked_by: false,
	muting: false,
	muting_notifications: false,
	subscribing: false,
	requested: true,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	}

	assert expected ==
	AccountView.render("relationship.json", %{user: user, target: other_user})
	end
	end

	test "represent an embedded relationship" do
	user =
	insert(:user, %{
	info: %{note_count: 5, follower_count: 0, source_data: %{"type" => "Service"}},
	nickname: "shp@shitposter.club",
	inserted_at: ~N[2017-08-15 15:47:06.597036]
	})

	other_user = insert(:user)
	{:ok, other_user} = User.follow(other_user, user)
	{:ok, other_user} = User.block(other_user, user)
	{:ok, _} = User.follow(insert(:user), user)

	expected = %{
	id: to_string(user.id),
	username: "shp",
	acct: user.nickname,
	display_name: user.name,
	locked: false,
	created_at: "2017-08-15T15:47:06.000Z",
	followers_count: 1,
	following_count: 0,
	statuses_count: 5,
	note: user.bio,
	url: user.ap_id,
	avatar: "http://localhost:4001/images/avi.png",
	avatar_static: "http://localhost:4001/images/avi.png",
	header: "http://localhost:4001/images/banner.png",
	header_static: "http://localhost:4001/images/banner.png",
	emojis: [],
	fields: [],
	bot: true,
	source: %{
	note: user.bio,
	sensitive: false,
	pleroma: %{
	discoverable: false
	},
	fields: []
	},
	pleroma: %{
	background_image: nil,
	confirmation_pending: false,
	tags: [],
	is_admin: false,
	is_moderator: false,
	hide_favorites: true,
	hide_followers: false,
	hide_follows: false,
	hide_followers_count: false,
	hide_follows_count: false,
	relationship: %{
	id: to_string(user.id),
	following: false,
	followed_by: false,
	blocking: true,
	blocked_by: false,
	subscribing: false,
	muting: false,
	muting_notifications: false,
	requested: false,
	domain_blocking: false,
	showing_reblogs: true,
	endorsed: false
	},
	skip_thread_containment: false
	}
	}

	assert expected == AccountView.render("show.json", %{user: user, for: other_user})
	end

	test "returns the settings store if the requesting user is the represented user and it's requested specifically" do
	user = insert(:user, %{info: %User.Info{pleroma_settings_store: %{fe: "test"}}})

	result =
	AccountView.render("show.json", %{user: user, for: user, with_pleroma_settings: true})

	assert result.pleroma.settings_store == %{:fe => "test"}

	result = AccountView.render("show.json", %{user: user, with_pleroma_settings: true})
	assert result.pleroma[:settings_store] == nil

	result = AccountView.render("show.json", %{user: user, for: user})
	assert result.pleroma[:settings_store] == nil
	end

	test "sanitizes display names" do
	user = insert(:user, name: "<marquee> username </marquee>")
	result = AccountView.render("show.json", %{user: user})
	refute result.display_name == "<marquee> username </marquee>"
	end

	describe "hiding follows/following" do
	test "shows when follows/followers stats are hidden and sets follow/follower count to 0" do
	info = %{
	hide_followers: true,
	hide_followers_count: true,
	hide_follows: true,
	hide_follows_count: true
	}

	user = insert(:user, info: info)

	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 0,
	following_count: 0,
	pleroma: %{hide_follows_count: true, hide_followers_count: true}
	} = AccountView.render("show.json", %{user: user})
	end

	test "shows when follows/followers are hidden" do
	user = insert(:user, info: %{hide_followers: true, hide_follows: true})
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1,
	pleroma: %{hide_follows: true, hide_followers: true}
	} = AccountView.render("show.json", %{user: user})
	end

	test "shows actual follower/following count to the account owner" do
	user = insert(:user, info: %{hide_followers: true, hide_follows: true})
	other_user = insert(:user)
	{:ok, user, other_user, _activity} = CommonAPI.follow(user, other_user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{
	followers_count: 1,
	following_count: 1
	} = AccountView.render("show.json", %{user: user, for: user})
	end
	-
	- test "shows unread_conversation_count only to the account owner" do
	- user = insert(:user)
	- other_user = insert(:user)
	-
	- {:ok, _activity} =
	- CommonAPI.post(user, %{
	- "status" => "Hey @#{other_user.nickname}.",
	- "visibility" => "direct"
	- })
	-
	- user = User.get_cached_by_ap_id(user.ap_id)
	-
	- assert AccountView.render("show.json", %{user: user, for: other_user})[:pleroma][
	- :unread_conversation_count
	- ] == nil
	-
	- assert AccountView.render("show.json", %{user: user, for: user})[:pleroma][
	- :unread_conversation_count
	- ] == 1
	- end
	end

	describe "follow requests counter" do
	test "shows zero when no follow requests are pending" do
	user = insert(:user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when follow requests are pending" do
	user = insert(:user, %{info: %{locked: true}})

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when accepting a follow request" do
	user = insert(:user, %{info: %{locked: true}})

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.accept_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "decreases when rejecting a follow request" do
	user = insert(:user, %{info: %{locked: true}})

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, other_user, user, _activity} = CommonAPI.follow(other_user, user)

	assert %{locked: true, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})

	{:ok, _other_user} = CommonAPI.reject_follow_request(other_user, user)

	assert %{locked: true, follow_requests_count: 0} =
	AccountView.render("show.json", %{user: user, for: user})
	end

	test "shows non-zero when historical unapproved requests are present" do
	user = insert(:user, %{info: %{locked: true}})

	assert %{locked: true} = AccountView.render("show.json", %{user: user, for: user})

	other_user = insert(:user)
	{:ok, _other_user, user, _activity} = CommonAPI.follow(other_user, user)

	{:ok, user} = User.update_info(user, &User.Info.user_upgrade(&1, %{locked: false}))

	assert %{locked: false, follow_requests_count: 1} =
	AccountView.render("show.json", %{user: user, for: user})
	end
	end
	end
	diff --git a/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs b/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
	index 44ea85b45..3a5dbdeea 100644
	--- a/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
	+++ b/test/web/pleroma_api/controllers/pleroma_api_controller_test.exs
	@@ -1,212 +1,210 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.PleromaAPI.PleromaAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Conversation.Participation
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	- alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "POST /api/v1/pleroma/statuses/:id/react_with_emoji", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

	result =
	conn
	\|> assign(:user, other_user)
	\|> post("/api/v1/pleroma/statuses/#{activity.id}/react_with_emoji", %{"emoji" => "☕"})

	assert %{"id" => id} = json_response(result, 200)
	assert to_string(activity.id) == id
	end

	test "POST /api/v1/pleroma/statuses/:id/unreact_with_emoji", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#cofe"})
	{:ok, activity, _object} = CommonAPI.react_with_emoji(activity.id, other_user, "☕")

	result =
	conn
	\|> assign(:user, other_user)
	\|> post("/api/v1/pleroma/statuses/#{activity.id}/unreact_with_emoji", %{"emoji" => "☕"})

	assert %{"id" => id} = json_response(result, 200)
	assert to_string(activity.id) == id

	object = Object.normalize(activity)

	assert object.data["reaction_count"] == 0
	end

	test "GET /api/v1/pleroma/statuses/:id/emoji_reactions_by", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/emoji_reactions_by")
	\|> json_response(200)

	assert result == %{}

	{:ok, _, _} = CommonAPI.react_with_emoji(activity.id, other_user, "🎅")

	result =
	conn
	\|> get("/api/v1/pleroma/statuses/#{activity.id}/emoji_reactions_by")
	\|> json_response(200)

	[represented_user] = result["🎅"]
	assert represented_user["id"] == other_user.id
	end

	test "/api/v1/pleroma/conversations/:id", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

	[participation] = Participation.for_user(other_user)

	result =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/pleroma/conversations/#{participation.id}")
	\|> json_response(200)

	assert result["id"] == participation.id \|> to_string()
	end

	test "/api/v1/pleroma/conversations/:id/statuses", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)

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

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

	[participation] = Participation.for_user(other_user)

	{:ok, activity_two} =
	CommonAPI.post(other_user, %{
	"status" => "Hi!",
	"in_reply_to_status_id" => activity.id,
	"in_reply_to_conversation_id" => participation.id
	})

	result =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/pleroma/conversations/#{participation.id}/statuses")
	\|> json_response(200)

	assert length(result) == 2

	id_one = activity.id
	id_two = activity_two.id
	assert [%{"id" => ^id_one}, %{"id" => ^id_two}] = result
	end

	test "PATCH /api/v1/pleroma/conversations/:id", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

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

	[participation] = Participation.for_user(user)

	participation = Repo.preload(participation, :recipients)

	- user = User.get_cached_by_id(user.id)
	assert [user] == participation.recipients
	assert other_user not in participation.recipients

	result =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/pleroma/conversations/#{participation.id}", %{
	"recipients" => [user.id, other_user.id]
	})
	\|> json_response(200)

	assert result["id"] == participation.id \|> to_string

	[participation] = Participation.for_user(user)
	participation = Repo.preload(participation, :recipients)

	assert user in participation.recipients
	assert other_user in participation.recipients
	end

	describe "POST /api/v1/pleroma/notifications/read" do
	test "it marks a single notification as read", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, activity1} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"})
	{:ok, activity2} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"})
	{:ok, [notification1]} = Notification.create_notifications(activity1)
	{:ok, [notification2]} = Notification.create_notifications(activity2)

	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/v1/pleroma/notifications/read", %{"id" => "#{notification1.id}"})
	\|> json_response(:ok)

	assert %{"pleroma" => %{"is_seen" => true}} = response
	assert Repo.get(Notification, notification1.id).seen
	refute Repo.get(Notification, notification2.id).seen
	end

	test "it marks multiple notifications as read", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	{:ok, _activity1} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"})
	{:ok, _activity2} = CommonAPI.post(user2, %{"status" => "hi @#{user1.nickname}"})
	{:ok, _activity3} = CommonAPI.post(user2, %{"status" => "HIE @#{user1.nickname}"})

	[notification3, notification2, notification1] = Notification.for_user(user1, %{limit: 3})

	[response1, response2] =
	conn
	\|> assign(:user, user1)
	\|> post("/api/v1/pleroma/notifications/read", %{"max_id" => "#{notification2.id}"})
	\|> json_response(:ok)

	assert %{"pleroma" => %{"is_seen" => true}} = response1
	assert %{"pleroma" => %{"is_seen" => true}} = response2
	assert Repo.get(Notification, notification1.id).seen
	assert Repo.get(Notification, notification2.id).seen
	refute Repo.get(Notification, notification3.id).seen
	end

	test "it returns error when notification not found", %{conn: conn} do
	user1 = insert(:user)

	response =
	conn
	\|> assign(:user, user1)
	\|> post("/api/v1/pleroma/notifications/read", %{"id" => "22222222222222"})
	\|> json_response(:bad_request)

	assert response == %{"error" => "Cannot get notification"}
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 2, 8:16 AM (17 h, 7 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803759
Default Alt Text: (122 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions