No OneTemporary
Actions

Size

117 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index 210aae2e4..b0a761c4a 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,115 +1,116 @@
	# Changelog
	All notable changes to this project will be documented in this file.

	The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

	## [unreleased]
	### Added
	- LDAP authentication
	- External OAuth provider authentication
	- A [job queue](https://git.pleroma.social/pleroma/pleroma_job_queue) for federation, emails, web push, etc.
	- [Prometheus](https://prometheus.io/) metrics
	- Support for Mastodon's remote interaction
	- Mix Tasks: `mix pleroma.database remove_embedded_objects`
	- Federation: Support for reports
	- Configuration: `safe_dm_mentions` option
	- Configuration: `link_name` option
	- Configuration: `fetch_initial_posts` option
	- Configuration: `notify_email` option
	- Configuration: Media proxy `whitelist` option
	- Pleroma API: User subscriptions
	- Pleroma API: Healthcheck endpoint
	- Admin API: Endpoints for listing/revoking invite tokens
	- Admin API: Endpoints for making users follow/unfollow each other
	+- Admin API: added filters (role, tags, email, name) for users endpoint
	- Mastodon API: [Scheduled statuses](https://docs.joinmastodon.org/api/rest/scheduled-statuses/)
	- Mastodon API: `/api/v1/notifications/destroy_multiple` (glitch-soc extension)
	- Mastodon API: `/api/v1/pleroma/accounts/:id/favourites` (API extension)
	- Mastodon API: [Reports](https://docs.joinmastodon.org/api/rest/reports/)
	- ActivityPub C2S: OAuth endpoints
	- Metadata RelMe provider
	- OAuth: added support for refresh tokens
	- Emoji packs and emoji pack manager

	### Changed
	- Breaking: Configuration: move from Pleroma.Mailer to Pleroma.Emails.Mailer
	- Enforcement of OAuth scopes
	- Add multiple use/time expiring invite token
	- Restyled OAuth pages to fit with Pleroma's default theme
	- Link/mention/hashtag detection is now handled by [auto_linker](https://git.pleroma.social/pleroma/auto_linker)
	- NodeInfo: Return `safe_dm_mentions` feature flag
	- Federation: Expand the audience of delete activities to all recipients of the deleted object
	- Federation: Removed `inReplyToStatusId` from objects
	- Configuration: Dedupe enabled by default
	- Configuration: Added `extra_cookie_attrs` for setting non-standard cookie attributes. Defaults to ["SameSite=Lax"] so that remote follows work.
	- Pleroma API: Support for emoji tags in `/api/pleroma/emoji` resulting in a breaking API change
	- Timelines: Messages involving people you have blocked will be excluded from the timeline in all cases instead of just repeats.
	- Mastodon API: Support for `exclude_types`, `limit` and `min_id` in `/api/v1/notifications`
	- Mastodon API: Add `languages` and `registrations` to `/api/v1/instance`
	- Mastodon API: Provide plaintext versions of cw/content in the Status entity
	- Mastodon API: Add `pleroma.conversation_id`, `pleroma.in_reply_to_account_acct` fields to the Status entity
	- Mastodon API: Add `pleroma.tags`, `pleroma.relationship{}`, `pleroma.is_moderator`, `pleroma.is_admin`, `pleroma.confirmation_pending`, `pleroma.hide_followers`, `pleroma.hide_follows`, `pleroma.hide_favorites` fields to the User entity
	- Mastodon API: Add `pleroma.show_role`, `pleroma.no_rich_text` fields to the Source subentity
	- Mastodon API: Add support for updating `no_rich_text`, `hide_followers`, `hide_follows`, `hide_favorites`, `show_role` in `PATCH /api/v1/update_credentials`
	- Mastodon API: Add `pleroma.is_seen` to the Notification entity
	- Mastodon API: Add `pleroma.local` to the Status entity
	- Mastodon API: Add `preview` parameter to `POST /api/v1/statuses`
	- Mastodon API: Add `with_muted` parameter to timeline endpoints
	- Mastodon API: Actual reblog hiding instead of a dummy
	- Mastodon API: Remove attachment limit in the Status entity
	- Deps: Updated Cowboy to 2.6
	- Deps: Updated Ecto to 3.0.7
	- Don't ship finmoji by default, they can be installed as an emoji pack
	- Mastodon API: Added support max_id & since_id for bookmark timeline endpoints.

	### Fixed
	- Added an FTS index on objects. Running `vacuum analyze` and setting a larger `work_mem` is recommended.
	- Followers counter not being updated when a follower is blocked
	- Deactivated users being able to request an access token
	- Limit on request body in rich media/relme parsers being ignored resulting in a possible memory leak
	- proper Twitter Card generation instead of a dummy
	- Deletions failing for users with a large number of posts
	- NodeInfo: Include admins in `staffAccounts`
	- ActivityPub: Crashing when requesting empty local user's outbox
	- Federation: Handling of objects without `summary` property
	- Federation: Add a language tag to activities as required by ActivityStreams 2.0
	- Federation: Do not federate avatar/banner if set to default allowing other servers/clients to use their defaults
	- Federation: Cope with missing or explicitly nulled address lists
	- Federation: Explicitly ensure activities addressed to `as:Public` become addressed to the followers collection
	- Federation: Better cope with actors which do not declare a followers collection and use `as:Public` with these semantics
	- Federation: Follow requests from remote users who have been blocked will be automatically rejected if appropriate
	- MediaProxy: Parse name from content disposition headers even for non-whitelisted types
	- MediaProxy: S3 link encoding
	- Rich Media: Reject any data which cannot be explicitly encoded into JSON
	- Pleroma API: Importing follows from Mastodon 2.8+
	- Twitter API: Exposing default scope, `no_rich_text` of the user to anyone
	- Twitter API: Returning the `role` object in user entity despite `show_role = false`
	- Mastodon API: `/api/v1/favourites` serving only public activities
	- Mastodon API: Reblogs having `in_reply_to_id` - `null` even when they are replies
	- Mastodon API: Streaming API broadcasting wrong activity id
	- Mastodon API: 500 errors when requesting a card for a private conversation
	- Mastodon API: Handling of `reblogs` in `/api/v1/accounts/:id/follow`
	- Mastodon API: Correct `reblogged`, `favourited`, and `bookmarked` values in the reblog status JSON
	- Mastodon API: Exposing default scope of the user to anyone

	## [0.9.9999] - 2019-04-05
	### Security
	- Mastodon API: Fix content warnings skipping HTML sanitization

	## [0.9.999] - 2019-03-13
	Frontend changes only.
	### Added
	- Added floating action button for posting status on mobile
	### Changed
	- Changed user-settings icon to a pencil
	### Fixed
	- Keyboard shortcuts activating when typing a message
	- Gaps when scrolling down on a timeline after showing new

	## [0.9.99] - 2019-03-08
	### Changed
	- Update the frontend to the 0.9.99 tag
	### Fixed
	- Sign the date header in federation to fix Mastodon federation.

	## [0.9.9] - 2019-02-22
	This is our first stable release.
	diff --git a/docs/api/admin_api.md b/docs/api/admin_api.md
	index 8befa8ea0..2657d1243 100644
	--- a/docs/api/admin_api.md
	+++ b/docs/api/admin_api.md
	@@ -1,277 +1,282 @@
	# Admin API

	Authentication is required and the user must be an admin.

	## `/api/pleroma/admin/users`

	### List users

	- Method `GET`
	- Query Params:
	- - optional `query`: string search term
	+ - optional `query`: string search term (e.g. nickname, domain, nickname@domain)
	- optional `filters`: string comma-separated string of filters:
	- `local`: only local users
	- `external`: only external users
	- `active`: only active users
	- `deactivated`: only deactivated users
	+ - `is_admin`: users with admin role
	+ - `is_moderator`: users with moderator role
	- optional `page`: integer page number
	- optional `page_size`: integer number of users per page (default is `50`)
	-- Example: `https://mypleroma.org/api/pleroma/admin/users?query=john&filters=local,active&page=1&page_size=10`
	+ - optional `tags`: [string] tags list
	+ - optional `name`: string user display name
	+ - optional `email`: string user email
	+- Example: `https://mypleroma.org/api/pleroma/admin/users?query=john&filters=local,active&page=1&page_size=10&tags[]=some_tag&tags[]=another_tag&name=display_name&email=email@example.com`
	- Response:

	```JSON
	{
	"page_size": integer,
	"count": integer,
	"users": [
	{
	"deactivated": bool,
	"id": integer,
	"nickname": string,
	"roles": {
	"admin": bool,
	"moderator": bool
	},
	"local": bool,
	"tags": array
	},
	...
	]
	}
	```

	## `/api/pleroma/admin/user`

	### Remove a user

	- Method `DELETE`
	- Params:
	- `nickname`
	- Response: User’s nickname

	### Create a user

	- Method: `POST`
	- Params:
	- `nickname`
	- `email`
	- `password`
	- Response: User’s nickname

	## `/api/pleroma/admin/user/follow`
	### Make a user follow another user

	- Methods: `POST`
	- Params:
	- `follower`: The nickname of the follower
	- `followed`: The nickname of the followed
	- Response:
	- "ok"

	## `/api/pleroma/admin/user/unfollow`
	### Make a user unfollow another user

	- Methods: `POST`
	- Params:
	- `follower`: The nickname of the follower
	- `followed`: The nickname of the followed
	- Response:
	- "ok"

	## `/api/pleroma/admin/users/:nickname/toggle_activation`

	### Toggle user activation

	- Method: `PATCH`
	- Params:
	- `nickname`
	- Response: User’s object

	```JSON
	{
	"deactivated": bool,
	"id": integer,
	"nickname": string
	}
	```

	## `/api/pleroma/admin/users/tag`

	### Tag a list of users

	- Method: `PUT`
	- Params:
	- `nickname`
	- `tags`

	### Untag a list of users

	- Method: `DELETE`
	- Params:
	- `nickname`
	- `tags`

	## `/api/pleroma/admin/permission_group/:nickname`

	### Get user user permission groups membership

	- Method: `GET`
	- Params: none
	- Response:

	```JSON
	{
	"is_moderator": bool,
	"is_admin": bool
	}
	```

	## `/api/pleroma/admin/permission_group/:nickname/:permission_group`

	Note: Available `:permission_group` is currently moderator and admin. 404 is returned when the permission group doesn’t exist.

	### Get user user permission groups membership per permission group

	- Method: `GET`
	- Params: none
	- Response:

	```JSON
	{
	"is_moderator": bool,
	"is_admin": bool
	}
	```

	### Add user in permission group

	- Method: `POST`
	- Params: none
	- Response:
	- On failure: `{"error": "…"}`
	- On success: JSON of the `user.info`

	### Remove user from permission group

	- Method: `DELETE`
	- Params: none
	- Response:
	- On failure: `{"error": "…"}`
	- On success: JSON of the `user.info`
	- Note: An admin cannot revoke their own admin status.

	## `/api/pleroma/admin/activation_status/:nickname`

	### Active or deactivate a user

	- Method: `PUT`
	- Params:
	- `nickname`
	- `status` BOOLEAN field, false value means deactivation.

	## `/api/pleroma/admin/users/:nickname`

	### Retrive the details of a user

	- Method: `GET`
	- Params:
	- `nickname`
	- Response:
	- On failure: `Not found`
	- On success: JSON of the user

	## `/api/pleroma/admin/relay`

	### Follow a Relay

	- Methods: `POST`
	- Params:
	- `relay_url`
	- Response:
	- On success: URL of the followed relay

	### Unfollow a Relay

	- Methods: `DELETE`
	- Params:
	- `relay_url`
	- Response:
	- On success: URL of the unfollowed relay

	## `/api/pleroma/admin/invite_token`

	### Get an account registration invite token

	- Methods: `GET`
	- Params:
	- optional `invite` => [
	- optional `max_use` (integer)
	- optional `expires_at` (date string e.g. "2019-04-07")
	]
	- Response: invite token (base64 string)

	## `/api/pleroma/admin/invites`

	### Get a list of generated invites

	- Methods: `GET`
	- Params: none
	- Response:

	```JSON
	{

	"invites": [
	{
	"id": integer,
	"token": string,
	"used": boolean,
	"expires_at": date,
	"uses": integer,
	"max_use": integer,
	"invite_type": string (possible values: `one_time`, `reusable`, `date_limited`, `reusable_date_limited`)
	},
	...
	]
	}
	```

	## `/api/pleroma/admin/revoke_invite`

	### Revoke invite by token

	- Methods: `POST`
	- Params:
	- `token`
	- Response:

	```JSON
	{
	"id": integer,
	"token": string,
	"used": boolean,
	"expires_at": date,
	"uses": integer,
	"max_use": integer,
	"invite_type": string (possible values: `one_time`, `reusable`, `date_limited`, `reusable_date_limited`)

	}
	```


	## `/api/pleroma/admin/email_invite`

	### Sends registration invite via email

	- Methods: `POST`
	- Params:
	- `email`
	- `name`, optional

	## `/api/pleroma/admin/password_reset`

	### Get a password reset token for a given nickname

	- Methods: `GET`
	- Params: none
	- Response: password reset token (base64 string)
	diff --git a/lib/pleroma/activity.ex b/lib/pleroma/activity.ex
	index 2b661edc1..c121e800f 100644
	--- a/lib/pleroma/activity.ex
	+++ b/lib/pleroma/activity.ex
	@@ -1,294 +1,317 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.Bookmark
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User

	import Ecto.Changeset
	import Ecto.Query

	@type t :: %__MODULE__{}
	@type actor :: String.t()

	@primary_key {:id, Pleroma.FlakeId, autogenerate: true}

	# https://github.com/tootsuite/mastodon/blob/master/app/models/notification.rb#L19
	@mastodon_notification_types %{
	"Create" => "mention",
	"Follow" => "follow",
	"Announce" => "reblog",
	"Like" => "favourite"
	}

	@mastodon_to_ap_notification_types for {k, v} <- @mastodon_notification_types,
	into: %{},
	do: {v, k}

	schema "activities" do
	field(:data, :map)
	field(:local, :boolean, default: true)
	field(:actor, :string)
	field(:recipients, {:array, :string}, default: [])
	# This is a fake relation, do not use outside of with_preloaded_bookmark/get_bookmark
	has_one(:bookmark, Bookmark)
	has_many(:notifications, Notification, on_delete: :delete_all)

	# Attention: this is a fake relation, don't try to preload it blindly and expect it to work!
	# The foreign key is embedded in a jsonb field.
	#
	# To use it, you probably want to do an inner join and a preload:
	#
	# ```
	# \|> join(:inner, [activity], o in Object,
	# on: fragment("(?->>'id') = COALESCE((?)->'object'->> 'id', (?)->>'object')",
	# o.data, activity.data, activity.data))
	# \|> preload([activity, object], [object: object])
	# ```
	#
	# As a convenience, Activity.with_preloaded_object() sets up an inner join and preload for the
	# typical case.
	has_one(:object, Object, on_delete: :nothing, foreign_key: :id)

	timestamps()
	end

	def with_preloaded_object(query) do
	query
	\|> join(
	:inner,
	[activity],
	o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	)
	)
	\|> preload([activity, object], object: object)
	end

	def with_preloaded_bookmark(query, %User{} = user) do
	from([a] in query,
	left_join: b in Bookmark,
	on: b.user_id == ^user.id and b.activity_id == a.id,
	preload: [bookmark: b]
	)
	end

	def with_preloaded_bookmark(query, _), do: query

	def get_by_ap_id(ap_id) do
	Repo.one(
	from(
	activity in Activity,
	where: fragment("(?)->>'id' = ?", activity.data, ^to_string(ap_id))
	)
	)
	end

	def get_bookmark(%Activity{} = activity, %User{} = user) do
	if Ecto.assoc_loaded?(activity.bookmark) do
	activity.bookmark
	else
	Bookmark.get(user.id, activity.id)
	end
	end

	def get_bookmark(_, _), do: nil

	def change(struct, params \\ %{}) do
	struct
	\|> cast(params, [:data])
	\|> validate_required([:data])
	\|> unique_constraint(:ap_id, name: :activities_unique_apid_index)
	end

	def get_by_ap_id_with_object(ap_id) do
	Repo.one(
	from(
	activity in Activity,
	where: fragment("(?)->>'id' = ?", activity.data, ^to_string(ap_id)),
	left_join: o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	preload: [object: o]
	)
	)
	end

	def get_by_id(id) do
	Repo.get(Activity, id)
	end

	def get_by_id_with_object(id) do
	from(activity in Activity,
	where: activity.id == ^id,
	inner_join: o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	preload: [object: o]
	)
	\|> Repo.one()
	end

	def by_object_ap_id(ap_id) do
	from(
	activity in Activity,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^to_string(ap_id)
	)
	)
	end

	def create_by_object_ap_id(ap_ids) when is_list(ap_ids) do
	from(
	activity in Activity,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ANY(?)",
	activity.data,
	activity.data,
	^ap_ids
	),
	where: fragment("(?)->>'type' = 'Create'", activity.data)
	)
	end

	def create_by_object_ap_id(ap_id) when is_binary(ap_id) do
	from(
	activity in Activity,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^to_string(ap_id)
	),
	where: fragment("(?)->>'type' = 'Create'", activity.data)
	)
	end

	def create_by_object_ap_id(_), do: nil

	def get_all_create_by_object_ap_id(ap_id) do
	Repo.all(create_by_object_ap_id(ap_id))
	end

	def get_create_by_object_ap_id(ap_id) when is_binary(ap_id) do
	create_by_object_ap_id(ap_id)
	\|> Repo.one()
	end

	def get_create_by_object_ap_id(_), do: nil

	def create_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
	from(
	activity in Activity,
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^to_string(ap_id)
	),
	where: fragment("(?)->>'type' = 'Create'", activity.data),
	inner_join: o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	preload: [object: o]
	)
	end

	def create_by_object_ap_id_with_object(_), do: nil

	def get_create_by_object_ap_id_with_object(ap_id) when is_binary(ap_id) do
	ap_id
	\|> create_by_object_ap_id_with_object()
	\|> Repo.one()
	end

	def get_create_by_object_ap_id_with_object(_), do: nil

	defp get_in_reply_to_activity_from_object(%Object{data: %{"inReplyTo" => ap_id}}) do
	get_create_by_object_ap_id_with_object(ap_id)
	end

	defp get_in_reply_to_activity_from_object(_), do: nil

	def get_in_reply_to_activity(%Activity{data: %{"object" => object}}) do
	get_in_reply_to_activity_from_object(Object.normalize(object))
	end

	def normalize(obj) when is_map(obj), do: get_by_ap_id_with_object(obj["id"])
	def normalize(ap_id) when is_binary(ap_id), do: get_by_ap_id_with_object(ap_id)
	def normalize(_), do: nil

	def delete_by_ap_id(id) when is_binary(id) do
	by_object_ap_id(id)
	\|> select([u], u)
	\|> Repo.delete_all()
	\|> elem(1)
	\|> Enum.find(fn
	%{data: %{"type" => "Create", "object" => ap_id}} when is_binary(ap_id) -> ap_id == id
	%{data: %{"type" => "Create", "object" => %{"id" => ap_id}}} -> ap_id == id
	_ -> nil
	end)
	end

	def delete_by_ap_id(_), do: nil

	for {ap_type, type} <- @mastodon_notification_types do
	def mastodon_notification_type(%Activity{data: %{"type" => unquote(ap_type)}}),
	do: unquote(type)
	end

	def mastodon_notification_type(%Activity{}), do: nil

	def from_mastodon_notification_type(type) do
	Map.get(@mastodon_to_ap_notification_types, type)
	end

	def all_by_actor_and_id(actor, status_ids \\ [])
	def all_by_actor_and_id(_actor, []), do: []

	def all_by_actor_and_id(actor, status_ids) do
	Activity
	\|> where([s], s.id in ^status_ids)
	\|> where([s], s.actor == ^actor)
	\|> Repo.all()
	end

	+ def follow_requests_for_actor(%Pleroma.User{ap_id: ap_id}) do
	+ from(
	+ a in Activity,
	+ where:
	+ fragment(
	+ "? ->> 'type' = 'Follow'",
	+ a.data
	+ ),
	+ where:
	+ fragment(
	+ "? ->> 'state' = 'pending'",
	+ a.data
	+ ),
	+ where:
	+ fragment(
	+ "coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	+ a.data,
	+ a.data,
	+ ^ap_id
	+ )
	+ )
	+ end
	+
	@spec query_by_actor(actor()) :: Ecto.Query.t()
	def query_by_actor(actor) do
	from(a in Activity, where: a.actor == ^actor)
	end
	end
	diff --git a/lib/pleroma/stats.ex b/lib/pleroma/stats.ex
	index 2e7d747df..5b242927b 100644
	--- a/lib/pleroma/stats.ex
	+++ b/lib/pleroma/stats.ex
	@@ -1,56 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Stats do
	import Ecto.Query
	alias Pleroma.Repo
	alias Pleroma.User

	def start_link do
	agent = Agent.start_link(fn -> {[], %{}} end, name: __MODULE__)
	spawn(fn -> schedule_update() end)
	agent
	end

	def get_stats do
	Agent.get(__MODULE__, fn {_, stats} -> stats end)
	end

	def get_peers do
	Agent.get(__MODULE__, fn {peers, _} -> peers end)
	end

	def schedule_update do
	spawn(fn ->
	# 1 hour
	Process.sleep(1000 * 60 * 60)
	schedule_update()
	end)

	update_stats()
	end

	def update_stats do
	peers =
	from(
	- u in Pleroma.User,
	+ u in User,
	select: fragment("distinct split_part(?, '@', 2)", u.nickname),
	where: u.local != ^true
	)
	\|> Repo.all()
	\|> Enum.filter(& &1)

	domain_count = Enum.count(peers)

	status_query =
	- from(u in User.local_user_query(), select: fragment("sum((?->>'note_count')::int)", u.info))
	+ from(u in User.Query.build(%{local: true}),
	+ select: fragment("sum((?->>'note_count')::int)", u.info)
	+ )

	status_count = Repo.one(status_query)
	- user_count = Repo.aggregate(User.active_local_user_query(), :count, :id)
	+
	+ user_count = Repo.aggregate(User.Query.build(%{local: true, active: true}), :count, :id)

	Agent.update(__MODULE__, fn _ ->
	{peers, %{domain_count: domain_count, status_count: status_count, user_count: user_count}}
	end)
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index b1adaad2f..427400aa1 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1445 +1,1329 @@
	# 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 Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.RelMe
	alias Pleroma.Web.Websub

	require Logger

	@type t :: %__MODULE__{}

	@primary_key {:id, Pleroma.FlakeId, 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(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	embeds_one(:info, Pleroma.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}"
	end

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

	def user_info(%User{} = user) do
	oneself = if user.local, do: 1, else: 0

	%{
	following_count: length(user.following) - oneself,
	note_count: user.info.note_count,
	follower_count: user.info.follower_count,
	locked: user.info.locked,
	confirmation_pending: user.info.confirmation_pending,
	default_scope: user.info.default_scope
	}
	end

	def remote_user_creation(params) do
	params =
	params
	\|> Map.put(:info, params[:info] \|\| %{})

	info_cng = User.Info.remote_user_creation(%User.Info{}, params[:info])

	changes =
	%User{}
	\|> 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: 5000)
	\|> validate_length(:name, max: 100)
	\|> put_change(:local, false)
	\|> put_embed(:info, info_cng)

	if changes.valid? do
	case info_cng.changes[:source_data] do
	%{"followers" => followers} ->
	changes
	\|> put_change(:follower_address, followers)

	_ ->
	followers = User.ap_followers(%User{nickname: changes.changes[:nickname]})

	changes
	\|> put_change(:follower_address, followers)
	end
	else
	changes
	end
	end

	def update_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:bio, :name, :avatar])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, min: 1, max: 100)
	end

	def upgrade_changeset(struct, params \\ %{}) do
	params =
	params
	\|> Map.put(:last_refreshed_at, NaiveDateTime.utc_now())

	info_cng =
	struct.info
	\|> User.Info.user_upgrade(params[:info])

	struct
	\|> cast(params, [:bio, :name, :follower_address, :avatar, :last_refreshed_at])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, max: 100)
	\|> put_embed(:info, info_cng)
	end

	def password_update_changeset(struct, params) do
	changeset =
	struct
	\|> cast(params, [:password, :password_confirmation])
	\|> validate_required([:password, :password_confirmation])
	\|> validate_confirmation(:password)

	OAuth.Token.delete_user_tokens(struct)
	OAuth.Authorization.delete_user_authorizations(struct)

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])

	changeset
	\|> put_change(:password_hash, hashed)
	else
	changeset
	end
	end

	def reset_password(user, data) do
	update_and_set_cache(password_update_changeset(user, data))
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	confirmation_status =
	if opts[:confirmed] \|\| !Pleroma.Config.get([:instance, :account_activation_required]) do
	:confirmed
	else
	:unconfirmed
	end

	info_change = User.Info.confirmation_changeset(%User.Info{}, confirmation_status)

	changeset =
	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([Pleroma.User, :restricted_nicknames]))
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_format(:email, @email_regex)
	\|> validate_length(:bio, max: 1000)
	\|> validate_length(:name, min: 1, max: 100)
	\|> put_change(:info, info_change)

	changeset =
	if opts[:external] do
	changeset
	else
	validate_required(changeset, [:email])
	end

	if changeset.valid? do
	hashed = Pbkdf2.hashpwsalt(changeset.changes[:password])
	ap_id = User.ap_id(%User{nickname: changeset.changes[:nickname]})
	followers = User.ap_followers(%User{nickname: changeset.changes[:nickname]})

	changeset
	\|> put_change(:password_hash, hashed)
	\|> put_change(:ap_id, ap_id)
	\|> unique_constraint(:ap_id)
	\|> put_change(:following, [followers])
	\|> put_change(:follower_address, followers)
	else
	changeset
	end
	end

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

	autofollowed_users =
	- from(u in User,
	- where: u.local == true,
	- where: u.nickname in ^candidates
	- )
	+ User.Query.build(%{nickname: candidates, local: true})
	\|> 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),
	{:ok, user} <- autofollow_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- Pleroma.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

	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 User.ap_enabled?(followed) do
	follow(follower, followed)
	else
	{:ok, follower}
	end
	end

	def maybe_follow(%User{} = follower, %User{info: _info} = followed) do
	if not following?(follower, 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, fn followed ->
	update_follower_count(followed)
	end)

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{info: info} = followed) do
	user_config = Application.get_env(:pleroma, :user)
	deny_follow_blocked = Keyword.get(user_config, :deny_follow_blocked)

	ap_followers = followed.follower_address

	cond do
	following?(follower, followed) or info.deactivated ->
	{:error, "Could not follow user: #{followed.nickname} is already on your list."}

	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, [])

	{: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, [])

	{: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 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

	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

	# 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) do
	set_cache(user)
	else
	e -> e
	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 ->
	user_result = get_or_fetch_by_nickname(nickname)

	case user_result do
	{:ok, user} -> {:commit, user}
	{:error, _error} -> {:ignore, nil}
	end
	end)
	end

	def get_cached_by_nickname_or_id(nickname_or_id) do
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)
	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
	ap_try = ActivityPub.make_user_from_nickname(nickname)

	case ap_try 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
	# TODO turn into job
	{:ok, _} = Task.start(__MODULE__, :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
	pages = Pleroma.Config.get!([:fetch_initial_posts, :pages])

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

	- def get_followers_query(%User{id: id, follower_address: follower_address}, nil) do
	- from(
	- u in User,
	- where: fragment("? <@ ?", ^[follower_address], u.following),
	- where: u.id != ^id
	- )
	+ @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})
	end

	def get_followers_query(user, page) do
	from(u in get_followers_query(user, nil))
	- \|> paginate(page, 20)
	+ \|> 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)

	def get_followers(user, page \\ nil) do
	q = get_followers_query(user, page)

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

	def get_followers_ids(user, page \\ nil) do
	q = get_followers_query(user, page)

	Repo.all(from(u in q, select: u.id))
	end

	- def get_friends_query(%User{id: id, following: following}, nil) do
	- from(
	- u in User,
	- where: u.follower_address in ^following,
	- where: u.id != ^id
	- )
	+ @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})
	end

	def get_friends_query(user, page) do
	from(u in get_friends_query(user, nil))
	- \|> paginate(page, 20)
	+ \|> 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
	q = get_friends_query(user, page)

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

	def get_friends_ids(user, page \\ nil) do
	q = get_friends_query(user, page)

	Repo.all(from(u in q, select: u.id))
	end

	- def get_follow_requests_query(%User{} = user) do
	- from(
	- a in Activity,
	- where:
	- fragment(
	- "? ->> 'type' = 'Follow'",
	- a.data
	- ),
	- where:
	- fragment(
	- "? ->> 'state' = 'pending'",
	- a.data
	- ),
	- where:
	- fragment(
	- "coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	- a.data,
	- a.data,
	- ^user.ap_id
	- )
	- )
	- end
	-
	+ @spec get_follow_requests(User.t()) :: {:ok, [User.t()]}
	def get_follow_requests(%User{} = user) do
	users =
	- user
	- \|> User.get_follow_requests_query()
	+ Activity.follow_requests_for_actor(user)
	\|> 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()

	{:ok, users}
	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_query =
	from(
	a in Object,
	where: fragment("?->>'actor' = ? and ?->>'type' = 'Note'", a.data, ^user.ap_id, a.data),
	select: count(a.id)
	)

	note_count = Repo.one(note_count_query)

	info_cng = User.Info.set_note_count(user.info, note_count)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def update_follower_count(%User{} = user) do
	follower_count_query =
	- User
	- \|> where([u], ^user.follower_address in u.following)
	- \|> where([u], u.id != ^user.id)
	- \|> select([u], %{count: count(u.id)})
	+ User.Query.build(%{followers: user}) \|> 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
	end

	- def get_users_from_set_query(ap_ids, false) do
	- from(
	- u in User,
	- where: u.ap_id in ^ap_ids
	- )
	- end
	-
	- def get_users_from_set_query(ap_ids, true) do
	- query = get_users_from_set_query(ap_ids, false)
	-
	- from(
	- u in query,
	- where: u.local == true
	- )
	- end
	-
	+ @spec get_users_from_set([String.t()], boolean()) :: [User.t()]
	def get_users_from_set(ap_ids, local_only \\ true) do
	- get_users_from_set_query(ap_ids, local_only)
	+ criteria = %{ap_id: ap_ids}
	+ 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
	- query =
	- from(
	- u in User,
	- where: u.ap_id in ^to,
	- or_where: fragment("? && ?", u.following, ^to)
	- )
	-
	- query = from(u in query, where: u.local == true)
	-
	- Repo.all(query)
	+ User.Query.build(%{recipients_from_activity: to, local: true})
	+ \|> Repo.all()
	end

	def search(query, resolve \\ false, for_user \\ nil) do
	# Strip the beginning @ off if there is a query
	query = String.trim_leading(query, "@")

	if resolve, do: get_or_fetch(query)

	{:ok, results} =
	Repo.transaction(fn ->
	Ecto.Adapters.SQL.query(Repo, "select set_limit(0.25)", [])
	Repo.all(search_query(query, for_user))
	end)

	results
	end

	def search_query(query, for_user) do
	fts_subquery = fts_search_subquery(query)
	trigram_subquery = trigram_search_subquery(query)
	union_query = from(s in trigram_subquery, union_all: ^fts_subquery)
	distinct_query = from(s in subquery(union_query), order_by: s.search_type, distinct: s.id)

	from(s in subquery(boost_search_rank_query(distinct_query, for_user)),
	order_by: [desc: s.search_rank],
	limit: 20
	)
	end

	defp boost_search_rank_query(query, nil), do: query

	defp boost_search_rank_query(query, for_user) do
	friends_ids = get_friends_ids(for_user)
	followers_ids = get_followers_ids(for_user)

	from(u in subquery(query),
	select_merge: %{
	search_rank:
	fragment(
	"""
	CASE WHEN (?) THEN (?) * 1.3
	WHEN (?) THEN (?) * 1.2
	WHEN (?) THEN (?) * 1.1
	ELSE (?) END
	""",
	u.id in ^friends_ids and u.id in ^followers_ids,
	u.search_rank,
	u.id in ^friends_ids,
	u.search_rank,
	u.id in ^followers_ids,
	u.search_rank,
	u.search_rank
	)
	}
	)
	end

	defp fts_search_subquery(term, query \\ User) do
	processed_query =
	term
	\|> String.replace(~r/\W+/, " ")
	\|> String.trim()
	\|> String.split()
	\|> Enum.map(&(&1 <> ":*"))
	\|> Enum.join(" \| ")

	from(
	u in query,
	select_merge: %{
	search_type: ^0,
	search_rank:
	fragment(
	"""
	ts_rank_cd(
	setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') \|\|
	setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B'),
	to_tsquery('simple', ?),
	32
	)
	""",
	u.nickname,
	u.name,
	^processed_query
	)
	},
	where:
	fragment(
	"""
	(setweight(to_tsvector('simple', regexp_replace(?, '\\W', ' ', 'g')), 'A') \|\|
	setweight(to_tsvector('simple', regexp_replace(coalesce(?, ''), '\\W', ' ', 'g')), 'B')) @@ to_tsquery('simple', ?)
	""",
	u.nickname,
	u.name,
	^processed_query
	)
	)
	end

	defp trigram_search_subquery(term) do
	from(
	u in User,
	select_merge: %{
	# ^1 gives 'Postgrex expected a binary, got 1' for some weird reason
	search_type: fragment("?", 1),
	search_rank:
	fragment(
	"similarity(?, trim(? \|\| ' ' \|\| coalesce(?, '')))",
	^term,
	u.nickname,
	u.name
	)
	},
	where: fragment("trim(? \|\| ' ' \|\| coalesce(?, '')) % ?", u.nickname, u.name, ^term)
	)
	end

	def 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

	def mute(muter, %User{ap_id: ap_id}) do
	info_cng =
	muter.info
	\|> User.Info.add_to_mutes(ap_id)

	cng =
	change(muter)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def unmute(muter, %{ap_id: ap_id}) do
	info_cng =
	muter.info
	\|> User.Info.remove_from_mutes(ap_id)

	cng =
	change(muter)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def subscribe(subscriber, %{ap_id: ap_id}) do
	deny_follow_blocked = Pleroma.Config.get([:user, :deny_follow_blocked])

	with %User{} = subscribed <- get_cached_by_ap_id(ap_id) do
	blocked = blocks?(subscribed, subscriber) and deny_follow_blocked

	if blocked do
	{:error, "Could not subscribe: #{subscribed.nickname} is blocking you"}
	else
	info_cng =
	subscribed.info
	\|> User.Info.add_to_subscribers(subscriber.ap_id)

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

	def unsubscribe(unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	info_cng =
	user.info
	\|> User.Info.remove_from_subscribers(unsubscriber.ap_id)

	change(user)
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache()
	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

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

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

	{:ok, blocker} = update_follower_count(blocker)

	info_cng =
	blocker.info
	\|> User.Info.add_to_block(ap_id)

	cng =
	change(blocker)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	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
	info_cng =
	blocker.info
	\|> User.Info.remove_from_block(ap_id)

	cng =
	change(blocker)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

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

	def blocks?(user, %{ap_id: ap_id}) do
	blocks = user.info.blocks
	domain_blocks = user.info.domain_blocks
	%{host: host} = URI.parse(ap_id)

	Enum.member?(blocks, ap_id) \|\|
	Enum.any?(domain_blocks, fn domain ->
	host == domain
	end)
	end

	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

	- def muted_users(user),
	- do: Repo.all(from(u in User, where: u.ap_id in ^user.info.mutes))
	+ @spec muted_users(User.t()) :: [User.t()]
	+ def muted_users(user) do
	+ User.Query.build(%{ap_id: user.info.mutes})
	+ \|> Repo.all()
	+ end

	- def blocked_users(user),
	- do: Repo.all(from(u in User, where: u.ap_id in ^user.info.blocks))
	+ @spec blocked_users(User.t()) :: [User.t()]
	+ def blocked_users(user) do
	+ User.Query.build(%{ap_id: user.info.blocks})
	+ \|> Repo.all()
	+ end

	- def subscribers(user),
	- do: Repo.all(from(u in User, where: u.ap_id in ^user.info.subscribers))
	+ @spec subscribers(User.t()) :: [User.t()]
	+ def subscribers(user) do
	+ User.Query.build(%{ap_id: user.info.subscribers})
	+ \|> Repo.all()
	+ end

	def block_domain(user, domain) do
	info_cng =
	user.info
	\|> User.Info.add_to_domain_block(domain)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def unblock_domain(user, domain) do
	info_cng =
	user.info
	\|> User.Info.remove_from_domain_block(domain)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	- def maybe_local_user_query(query, local) do
	- if local, do: local_user_query(query), else: query
	- end
	-
	- def local_user_query(query \\ User) do
	- from(
	- u in query,
	- where: u.local == true,
	- where: not is_nil(u.nickname)
	- )
	- end
	-
	- def maybe_external_user_query(query, external) do
	- if external, do: external_user_query(query), else: query
	- end
	-
	- def external_user_query(query \\ User) do
	- from(
	- u in query,
	- where: u.local == false,
	- where: not is_nil(u.nickname)
	- )
	- end
	-
	- def maybe_active_user_query(query, active) do
	- if active, do: active_user_query(query), else: query
	- end
	-
	- def active_user_query(query \\ User) do
	- from(
	- u in query,
	- where: fragment("not (?->'deactivated' @> 'true')", u.info),
	- where: not is_nil(u.nickname)
	- )
	- end
	-
	- def maybe_deactivated_user_query(query, deactivated) do
	- if deactivated, do: deactivated_user_query(query), else: query
	- end
	-
	- def deactivated_user_query(query \\ User) do
	- from(
	- u in query,
	- where: fragment("(?->'deactivated' @> 'true')", u.info),
	- where: not is_nil(u.nickname)
	- )
	- end
	-
	- def active_local_user_query do
	- from(
	- u in local_user_query(),
	- where: fragment("not (?->'deactivated' @> 'true')", u.info)
	- )
	- end
	-
	- def moderator_user_query do
	- from(
	- u in User,
	- where: u.local == true,
	- where: fragment("?->'is_moderator' @> 'true'", u.info)
	- )
	- end
	-
	def deactivate(%User{} = user, status \\ true) do
	info_cng = User.Info.set_activation_status(user.info, status)

	cng =
	change(user)
	\|> put_embed(:info, info_cng)

	update_and_set_cache(cng)
	end

	def update_notification_settings(%User{} = user, settings \\ %{}) do
	info_changeset = User.Info.update_notification_settings(user.info, settings)

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

	@spec delete(User.t()) :: :ok
	def delete(%User{} = user),
	do: PleromaJobQueue.enqueue(:background, __MODULE__, [:delete, user])

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

	# Remove all relationships
	{:ok, followers} = User.get_followers(user)

	Enum.each(followers, fn follower -> User.unfollow(follower, user) end)

	{:ok, friends} = User.get_friends(user)

	Enum.each(friends, fn followed -> User.unfollow(user, followed) end)

	delete_user_activities(user)
	end

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	stream =
	ap_id
	\|> Activity.query_by_actor()
	\|> Activity.with_preloaded_object()
	\|> Repo.stream()

	Repo.transaction(fn -> Enum.each(stream, &delete_activity(&1)) end, timeout: :infinity)

	{:ok, user}
	end

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

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

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

	@default_scrubbers Pleroma.Config.get([:markup, :scrub_policy])

	def html_filter_policy(_), do: @default_scrubbers

	def fetch_by_ap_id(ap_id) do
	ap_try = ActivityPub.make_user_from_ap_id(ap_id)

	case ap_try 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 !User.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
	{:ok, _} = Task.start(__MODULE__, :fetch_initial_posts, [user])
	end
	end

	resp
	end
	end

	def get_or_create_instance_user do
	relay_uri = "#{Pleroma.Web.Endpoint.url()}/relay"

	if user = get_cached_by_ap_id(relay_uri) do
	user
	else
	changes =
	%User{info: %User.Info{}}
	\|> cast(%{}, [:ap_id, :nickname, :local])
	\|> put_change(:ap_id, relay_uri)
	\|> put_change(:nickname, nil)
	\|> put_change(:local, true)
	\|> put_change(:follower_address, relay_uri <> "/followers")

	{:ok, user} = Repo.insert(changes)
	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}) do
	{:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
	end

	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, 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()) :: User.t()
	+ @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 <- User.get_cached_by_id(a.id),
	%User{} = b <- User.get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	_e ->
	:error
	end
	end

	def wait_and_refresh(timeout, %User{} = a, %User{} = b) do
	with :ok <- :timer.sleep(timeout),
	%User{} = a <- User.get_cached_by_id(a.id),
	%User{} = b <- User.get_cached_by_id(b.id) do
	{:ok, a, b}
	else
	_e ->
	: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
	- from(
	- u in User,
	- where: u.local == true,
	- where: fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
	- )
	+ User.Query.build(%{super_users: true, local: true})
	\|> Repo.all()
	end

	- defp paginate(query, page, page_size) do
	- from(u in query,
	- limit: ^page_size,
	- offset: ^((page - 1) * page_size)
	- )
	- end
	-
	def showing_reblogs?(%User{} = user, %User{} = target) do
	target.ap_id not in user.info.muted_reblogs
	end
	end
	diff --git a/lib/pleroma/user/query.ex b/lib/pleroma/user/query.ex
	new file mode 100644
	index 000000000..2dfe5ce92
	--- /dev/null
	+++ b/lib/pleroma/user/query.ex
	@@ -0,0 +1,150 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.User.Query do
	+ @moduledoc """
	+ User query builder module. Builds query from new query or another user query.
	+
	+ ## Example:
	+ query = Pleroma.User.Query(%{nickname: "nickname"})
	+ another_query = Pleroma.User.Query.build(query, %{email: "email@example.com"})
	+ Pleroma.Repo.all(query)
	+ Pleroma.Repo.all(another_query)
	+
	+ Adding new rules:
	+ - ilike criteria
	+ - add field to @ilike_criteria list
	+ - pass non empty string
	+ - e.g. Pleroma.User.Query.build(%{nickname: "nickname"})
	+ - equal criteria
	+ - add field to @equal_criteria list
	+ - pass non empty string
	+ - e.g. Pleroma.User.Query.build(%{email: "email@example.com"})
	+ - contains criteria
	+ - add field to @containns_criteria list
	+ - pass values list
	+ - e.g. Pleroma.User.Query.build(%{ap_id: ["http://ap_id1", "http://ap_id2"]})
	+ """
	+ import Ecto.Query
	+ import Pleroma.Web.AdminAPI.Search, only: [not_empty_string: 1]
	+ alias Pleroma.User
	+
	+ @type criteria ::
	+ %{
	+ query: String.t(),
	+ tags: [String.t()],
	+ name: String.t(),
	+ email: String.t(),
	+ local: boolean(),
	+ external: boolean(),
	+ active: boolean(),
	+ deactivated: boolean(),
	+ is_admin: boolean(),
	+ is_moderator: boolean(),
	+ super_users: boolean(),
	+ followers: User.t(),
	+ friends: User.t(),
	+ recipients_from_activity: [String.t()],
	+ nickname: [String.t()],
	+ ap_id: [String.t()]
	+ }
	+ \| %{}
	+
	+ @ilike_criteria [:nickname, :name, :query]
	+ @equal_criteria [:email]
	+ @role_criteria [:is_admin, :is_moderator]
	+ @contains_criteria [:ap_id, :nickname]
	+
	+ @spec build(criteria()) :: Query.t()
	+ def build(query \\ base_query(), criteria) do
	+ prepare_query(query, criteria)
	+ end
	+
	+ @spec paginate(Ecto.Query.t(), pos_integer(), pos_integer()) :: Ecto.Query.t()
	+ def paginate(query, page, page_size) do
	+ from(u in query,
	+ limit: ^page_size,
	+ offset: ^((page - 1) * page_size)
	+ )
	+ end
	+
	+ defp base_query do
	+ from(u in User)
	+ end
	+
	+ defp prepare_query(query, criteria) do
	+ Enum.reduce(criteria, query, &compose_query/2)
	+ end
	+
	+ defp compose_query({key, value}, query)
	+ when key in @ilike_criteria and not_empty_string(value) do
	+ # hack for :query key
	+ key = if key == :query, do: :nickname, else: key
	+ where(query, [u], ilike(field(u, ^key), ^"%#{value}%"))
	+ end
	+
	+ defp compose_query({key, value}, query)
	+ when key in @equal_criteria and not_empty_string(value) do
	+ where(query, [u], ^[{key, value}])
	+ end
	+
	+ defp compose_query({key, values}, query) when key in @contains_criteria and is_list(values) do
	+ where(query, [u], field(u, ^key) in ^values)
	+ end
	+
	+ defp compose_query({:tags, tags}, query) when is_list(tags) and length(tags) > 0 do
	+ Enum.reduce(tags, query, &prepare_tag_criteria/2)
	+ end
	+
	+ defp compose_query({key, _}, query) when key in @role_criteria do
	+ where(query, [u], fragment("(?->? @> 'true')", u.info, ^to_string(key)))
	+ end
	+
	+ defp compose_query({:super_users, _}, query) do
	+ where(
	+ query,
	+ [u],
	+ fragment("?->'is_admin' @> 'true' OR ?->'is_moderator' @> 'true'", u.info, u.info)
	+ )
	+ end
	+
	+ defp compose_query({:local, _}, query), do: location_query(query, true)
	+
	+ defp compose_query({:external, _}, query), do: location_query(query, false)
	+
	+ defp compose_query({:active, _}, query) do
	+ where(query, [u], fragment("not (?->'deactivated' @> 'true')", u.info))
	+ \|> where([u], not is_nil(u.nickname))
	+ end
	+
	+ defp compose_query({:deactivated, _}, query) do
	+ where(query, [u], fragment("?->'deactivated' @> 'true'", u.info))
	+ \|> where([u], not is_nil(u.nickname))
	+ end
	+
	+ defp compose_query({:followers, %User{id: id, follower_address: follower_address}}, query) do
	+ where(query, [u], fragment("? <@ ?", ^[follower_address], u.following))
	+ \|> where([u], u.id != ^id)
	+ end
	+
	+ defp compose_query({:friends, %User{id: id, following: following}}, query) do
	+ where(query, [u], u.follower_address in ^following)
	+ \|> where([u], u.id != ^id)
	+ end
	+
	+ defp compose_query({:recipients_from_activity, to}, query) do
	+ where(query, [u], u.ap_id in ^to or fragment("? && ?", u.following, ^to))
	+ end
	+
	+ defp compose_query(_unsupported_param, query), do: query
	+
	+ defp prepare_tag_criteria(tag, query) do
	+ or_where(query, [u], fragment("? = any(?)", ^tag, u.tags))
	+ end
	+
	+ defp location_query(query, local) do
	+ where(query, [u], u.local == ^local)
	+ \|> where([u], not is_nil(u.nickname))
	+ end
	+end
	diff --git a/lib/pleroma/web/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/admin_api_controller.ex
	index 711f233a6..b553d96a8 100644
	--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
	+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
	@@ -1,326 +1,329 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIController do
	use Pleroma.Web, :controller
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.AdminAPI.Search

	import Pleroma.Web.ControllerHelper, only: [json_response: 3]

	require Logger

	@users_page_size 50

	action_fallback(:errors)

	def user_delete(conn, %{"nickname" => nickname}) do
	User.get_cached_by_nickname(nickname)
	\|> User.delete()

	conn
	\|> json(nickname)
	end

	def user_follow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.follow(follower, followed)
	end

	conn
	\|> json("ok")
	end

	def user_unfollow(conn, %{"follower" => follower_nick, "followed" => followed_nick}) do
	with %User{} = follower <- User.get_cached_by_nickname(follower_nick),
	%User{} = followed <- User.get_cached_by_nickname(followed_nick) do
	User.unfollow(follower, followed)
	end

	conn
	\|> json("ok")
	end

	def user_create(
	conn,
	%{"nickname" => nickname, "email" => email, "password" => password}
	) do
	user_data = %{
	nickname: nickname,
	name: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	bio: "."
	}

	changeset = User.register_changeset(%User{}, user_data, confirmed: true)
	{:ok, user} = User.register(changeset)

	conn
	\|> json(user.nickname)
	end

	def user_show(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	conn
	\|> json(AccountView.render("show.json", %{user: user}))
	else
	_ -> {:error, :not_found}
	end
	end

	def user_toggle_activation(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)

	{:ok, updated_user} = User.deactivate(user, !user.info.deactivated)

	conn
	\|> json(AccountView.render("show.json", %{user: updated_user}))
	end

	def tag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.tag(nicknames, tags),
	do: json_response(conn, :no_content, "")
	end

	def untag_users(conn, %{"nicknames" => nicknames, "tags" => tags}) do
	with {:ok, _} <- User.untag(nicknames, tags),
	do: json_response(conn, :no_content, "")
	end

	def list_users(conn, params) do
	{page, page_size} = page_params(params)
	filters = maybe_parse_filters(params["filters"])

	search_params = %{
	query: params["query"],
	page: page,
	- page_size: page_size
	+ page_size: page_size,
	+ tags: params["tags"],
	+ name: params["name"],
	+ email: params["email"]
	}

	with {:ok, users, count} <- Search.user(Map.merge(search_params, filters)),
	do:
	conn
	\|> json(
	AccountView.render("index.json",
	users: users,
	count: count,
	page_size: page_size
	)
	)
	end

	- @filters ~w(local external active deactivated)
	+ @filters ~w(local external active deactivated is_admin is_moderator)

	+ @spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} \| %{}
	defp maybe_parse_filters(filters) when is_nil(filters) or filters == "", do: %{}

	- @spec maybe_parse_filters(String.t()) :: %{required(String.t()) => true} \| %{}
	defp maybe_parse_filters(filters) do
	filters
	\|> String.split(",")
	\|> Enum.filter(&Enum.member?(@filters, &1))
	\|> Enum.map(&String.to_atom(&1))
	\|> Enum.into(%{}, &{&1, true})
	end

	def right_add(conn, %{"permission_group" => permission_group, "nickname" => nickname})
	when permission_group in ["moderator", "admin"] do
	user = User.get_cached_by_nickname(nickname)

	info =
	%{}
	\|> Map.put("is_" <> permission_group, true)

	info_cng = User.Info.admin_api_update(user.info, info)

	cng =
	user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, info_cng)

	{:ok, _user} = User.update_and_set_cache(cng)

	json(conn, info)
	end

	def right_add(conn, _) do
	conn
	\|> put_status(404)
	\|> json(%{error: "No such permission_group"})
	end

	def right_get(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)

	conn
	\|> json(%{
	is_moderator: user.info.is_moderator,
	is_admin: user.info.is_admin
	})
	end

	def right_delete(
	%{assigns: %{user: %User{:nickname => admin_nickname}}} = conn,
	%{
	"permission_group" => permission_group,
	"nickname" => nickname
	}
	)
	when permission_group in ["moderator", "admin"] do
	if admin_nickname == nickname do
	conn
	\|> put_status(403)
	\|> json(%{error: "You can't revoke your own admin status."})
	else
	user = User.get_cached_by_nickname(nickname)

	info =
	%{}
	\|> Map.put("is_" <> permission_group, false)

	info_cng = User.Info.admin_api_update(user.info, info)

	cng =
	Ecto.Changeset.change(user)
	\|> Ecto.Changeset.put_embed(:info, info_cng)

	{:ok, _user} = User.update_and_set_cache(cng)

	json(conn, info)
	end
	end

	def right_delete(conn, _) do
	conn
	\|> put_status(404)
	\|> json(%{error: "No such permission_group"})
	end

	def set_activation_status(conn, %{"nickname" => nickname, "status" => status}) do
	with {:ok, status} <- Ecto.Type.cast(:boolean, status),
	%User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, _} <- User.deactivate(user, !status),
	do: json_response(conn, :no_content, "")
	end

	def relay_follow(conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.follow(target) do
	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	def relay_unfollow(conn, %{"relay_url" => target}) do
	with {:ok, _message} <- Relay.unfollow(target) do
	json(conn, target)
	else
	_ ->
	conn
	\|> put_status(500)
	\|> json(target)
	end
	end

	@doc "Sends registration invite via email"
	def email_invite(%{assigns: %{user: user}} = conn, %{"email" => email} = params) do
	with true <-
	Pleroma.Config.get([:instance, :invites_enabled]) &&
	!Pleroma.Config.get([:instance, :registrations_open]),
	{:ok, invite_token} <- UserInviteToken.create_invite(),
	email <-
	Pleroma.Emails.UserEmail.user_invitation_email(
	user,
	invite_token,
	email,
	params["name"]
	),
	{:ok, _} <- Pleroma.Emails.Mailer.deliver(email) do
	json_response(conn, :no_content, "")
	end
	end

	@doc "Get a account registeration invite token (base64 string)"
	def get_invite_token(conn, params) do
	options = params["invite"] \|\| %{}
	{:ok, invite} = UserInviteToken.create_invite(options)

	conn
	\|> json(invite.token)
	end

	@doc "Get list of created invites"
	def invites(conn, _params) do
	invites = UserInviteToken.list_invites()

	conn
	\|> json(AccountView.render("invites.json", %{invites: invites}))
	end

	@doc "Revokes invite by token"
	def revoke_invite(conn, %{"token" => token}) do
	invite = UserInviteToken.find_by_token!(token)
	{:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true})

	conn
	\|> json(AccountView.render("invite.json", %{invite: updated_invite}))
	end

	@doc "Get a password reset token (base64 string) for given nickname"
	def get_password_reset(conn, %{"nickname" => nickname}) do
	(%User{local: true} = user) = User.get_cached_by_nickname(nickname)
	{:ok, token} = Pleroma.PasswordResetToken.create_token(user)

	conn
	\|> json(token.token)
	end

	def errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(404)
	\|> json("Not found")
	end

	def errors(conn, {:param_cast, _}) do
	conn
	\|> put_status(400)
	\|> json("Invalid parameters")
	end

	def errors(conn, _) do
	conn
	\|> put_status(500)
	\|> json("Something went wrong")
	end

	defp page_params(params) do
	{get_page(params["page"]), get_page_size(params["page_size"])}
	end

	defp get_page(page_string) when is_nil(page_string), do: 1

	defp get_page(page_string) do
	case Integer.parse(page_string) do
	{page, _} -> page
	:error -> 1
	end
	end

	defp get_page_size(page_size_string) when is_nil(page_size_string), do: @users_page_size

	defp get_page_size(page_size_string) do
	case Integer.parse(page_size_string) do
	{page_size, _} -> page_size
	:error -> @users_page_size
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/search.ex b/lib/pleroma/web/admin_api/search.ex
	index 9a8e41c2a..ed919833e 100644
	--- a/lib/pleroma/web/admin_api/search.ex
	+++ b/lib/pleroma/web/admin_api/search.ex
	@@ -1,54 +1,32 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.Search do
	import Ecto.Query

	alias Pleroma.Repo
	alias Pleroma.User

	@page_size 50

	- def user(%{query: term} = params) when is_nil(term) or term == "" do
	- query = maybe_filtered_query(params)
	+ defmacro not_empty_string(string) do
	+ quote do
	+ is_binary(unquote(string)) and unquote(string) != ""
	+ end
	+ end
	+
	+ @spec user(map()) :: {:ok, [User.t()], pos_integer()}
	+ def user(params \\ %{}) do
	+ query = User.Query.build(params) \|> order_by([u], u.nickname)

	paginated_query =
	- maybe_filtered_query(params)
	- \|> paginate(params[:page] \|\| 1, params[:page_size] \|\| @page_size)
	+ User.Query.paginate(query, params[:page] \|\| 1, params[:page_size] \|\| @page_size)

	- count = query \|> Repo.aggregate(:count, :id)
	+ count = Repo.aggregate(query, :count, :id)

	results = Repo.all(paginated_query)

	{:ok, results, count}
	end
	-
	- def user(%{query: term} = params) when is_binary(term) do
	- search_query = from(u in maybe_filtered_query(params), where: ilike(u.nickname, ^"%#{term}%"))
	-
	- count = search_query \|> Repo.aggregate(:count, :id)
	-
	- results =
	- search_query
	- \|> paginate(params[:page] \|\| 1, params[:page_size] \|\| @page_size)
	- \|> Repo.all()
	-
	- {:ok, results, count}
	- end
	-
	- defp maybe_filtered_query(params) do
	- from(u in User, order_by: u.nickname)
	- \|> User.maybe_local_user_query(params[:local])
	- \|> User.maybe_external_user_query(params[:external])
	- \|> User.maybe_active_user_query(params[:active])
	- \|> User.maybe_deactivated_user_query(params[:deactivated])
	- end
	-
	- defp paginate(query, page, page_size) do
	- from(u in query,
	- limit: ^page_size,
	- offset: ^((page - 1) * page_size)
	- )
	- end
	end
	diff --git a/test/web/admin_api/admin_api_controller_test.exs b/test/web/admin_api/admin_api_controller_test.exs
	index b89c42327..f433f6be2 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,784 +1,950 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.AdminAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.User
	alias Pleroma.UserInviteToken
	import Pleroma.Factory

	describe "/api/pleroma/admin/user" do
	test "Delete" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/user?nickname=#{user.nickname}")

	assert json_response(conn, 200) == user.nickname
	end

	test "Create" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/user", %{
	"nickname" => "lain",
	"email" => "lain@example.org",
	"password" => "test"
	})

	assert json_response(conn, 200) == "lain"
	end
	end

	describe "/api/pleroma/admin/users/:nickname" do
	test "Show", %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users/#{user.nickname}")

	expected = %{
	"deactivated" => false,
	"id" => to_string(user.id),
	"local" => true,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"tags" => []
	}

	assert expected == json_response(conn, 200)
	end

	test "when the user doesn't exist", %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	user = build(:user)

	conn =
	conn
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users/#{user.nickname}")

	assert "Not found" == json_response(conn, 404)
	end
	end

	describe "/api/pleroma/admin/user/follow" do
	test "allows to force-follow another user" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)
	follower = insert(:user)

	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/user/follow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, user)
	end
	end

	describe "/api/pleroma/admin/user/unfollow" do
	test "allows to force-unfollow another user" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/user/unfollow", %{
	"follower" => follower.nickname,
	"followed" => user.nickname
	})

	user = User.get_cached_by_id(user.id)
	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, user)
	end
	end

	describe "PUT /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> put(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=foo&tags[]=bar"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it appends specified tags to users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == ["x", "foo", "bar"]
	assert User.get_cached_by_id(user2.id).tags == ["y", "foo", "bar"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "DELETE /api/pleroma/admin/users/tag" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user1 = insert(:user, %{tags: ["x"]})
	user2 = insert(:user, %{tags: ["y", "z"]})
	user3 = insert(:user, %{tags: ["unchanged"]})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete(
	"/api/pleroma/admin/users/tag?nicknames[]=#{user1.nickname}&nicknames[]=#{
	user2.nickname
	}&tags[]=x&tags[]=z"
	)

	%{conn: conn, user1: user1, user2: user2, user3: user3}
	end

	test "it removes specified tags from users with specified nicknames", %{
	conn: conn,
	user1: user1,
	user2: user2
	} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user1.id).tags == []
	assert User.get_cached_by_id(user2.id).tags == ["y"]
	end

	test "it does not modify tags of not specified users", %{conn: conn, user3: user3} do
	assert json_response(conn, :no_content)
	assert User.get_cached_by_id(user3.id).tags == ["unchanged"]
	end
	end

	describe "/api/pleroma/admin/permission_group" do
	test "GET is giving user_info" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/permission_group/#{admin.nickname}")

	assert json_response(conn, 200) == %{
	"is_admin" => true,
	"is_moderator" => false
	}
	end

	test "/:right POST, can add to a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> post("/api/pleroma/admin/permission_group/#{user.nickname}/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => true
	}
	end

	test "/:right DELETE, can remove from a permission group" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> delete("/api/pleroma/admin/permission_group/#{user.nickname}/admin")

	assert json_response(conn, 200) == %{
	"is_admin" => false
	}
	end
	end

	describe "PUT /api/pleroma/admin/activation_status" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	conn
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")

	%{conn: conn}
	end

	test "deactivates the user", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})

	user = User.get_cached_by_id(user.id)
	assert user.info.deactivated == true
	assert json_response(conn, :no_content)
	end

	test "activates the user", %{conn: conn} do
	user = insert(:user, info: %{deactivated: true})

	conn =
	conn
	\|> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: true})

	user = User.get_cached_by_id(user.id)
	assert user.info.deactivated == false
	assert json_response(conn, :no_content)
	end

	test "returns 403 when requested by a non-admin", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/pleroma/admin/activation_status/#{user.nickname}", %{status: false})

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/email_invite, with valid config" do
	setup do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	[user: insert(:user, info: %{is_admin: true})]
	end

	test "sends invitation and returns 204", %{conn: conn, user: user} do
	recipient_email = "foo@bar.com"
	recipient_name = "J. D."

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/email_invite?email=#{recipient_email}&name=#{recipient_name}")

	assert json_response(conn, :no_content)

	token_record = List.last(Pleroma.Repo.all(Pleroma.UserInviteToken))
	assert token_record
	refute token_record.used

	notify_email = Pleroma.Config.get([:instance, :notify_email])
	instance_name = Pleroma.Config.get([:instance, :name])

	email =
	Pleroma.Emails.UserEmail.user_invitation_email(
	user,
	token_record,
	recipient_email,
	recipient_name
	)

	Swoosh.TestAssertions.assert_email_sent(
	from: {instance_name, notify_email},
	to: {recipient_name, recipient_email},
	html_body: email.html_body
	)
	end

	test "it returns 403 if requested by a non-admin", %{conn: conn} do
	non_admin_user = insert(:user)

	conn =
	conn
	\|> assign(:user, non_admin_user)
	\|> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :forbidden)
	end
	end

	describe "POST /api/pleroma/admin/email_invite, with invalid config" do
	setup do
	[user: insert(:user, info: %{is_admin: true})]
	end

	test "it returns 500 if `invites_enabled` is not enabled", %{conn: conn, user: user} do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], false)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end

	test "it returns 500 if `registrations_open` is enabled", %{conn: conn, user: user} do
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], true)
	Pleroma.Config.put([:instance, :invites_enabled], true)

	on_exit(fn ->
	Pleroma.Config.put([:instance, :registrations_open], registrations_open)
	Pleroma.Config.put([:instance, :invites_enabled], invites_enabled)
	:ok
	end)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :internal_server_error)
	end
	end

	test "/api/pleroma/admin/invite_token" do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/invite_token")

	assert conn.status == 200
	end

	test "/api/pleroma/admin/password_reset" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> put_req_header("accept", "application/json")
	\|> get("/api/pleroma/admin/password_reset?nickname=#{user.nickname}")

	assert conn.status == 200
	end

	describe "GET /api/pleroma/admin/users" do
	- test "renders users array for the first page" do
	+ setup do
	admin = insert(:user, info: %{is_admin: true})
	- user = insert(:user, local: false, tags: ["foo", "bar"])

	conn =
	build_conn()
	\|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/users?page=1")
	+
	+ {:ok, conn: conn, admin: admin}
	+ end
	+
	+ test "renders users array for the first page", %{conn: conn, admin: admin} do
	+ user = insert(:user, local: false, tags: ["foo", "bar"])
	+ conn = get(conn, "/api/pleroma/admin/users?page=1")

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => admin.info.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => []
	},
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => false,
	"tags" => ["foo", "bar"]
	}
	]
	}
	end

	- test "renders empty array for the second page" do
	- admin = insert(:user, info: %{is_admin: true})
	+ test "renders empty array for the second page", %{conn: conn} do
	insert(:user)

	- conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/users?page=2")
	+ conn = get(conn, "/api/pleroma/admin/users?page=2")

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => []
	}
	end

	- test "regular search" do
	- admin = insert(:user, info: %{is_admin: true})
	+ test "regular search", %{conn: conn} do
	user = insert(:user, nickname: "bob")

	- conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/users?query=bo")
	+ conn = get(conn, "/api/pleroma/admin/users?query=bo")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	- test "regular search with page size" do
	- admin = insert(:user, info: %{is_admin: true})
	+ test "search by domain", %{conn: conn} do
	+ user = insert(:user, nickname: "nickname@domain.com")
	+ insert(:user)
	+
	+ conn = get(conn, "/api/pleroma/admin/users?query=domain.com")
	+
	+ assert json_response(conn, 200) == %{
	+ "count" => 1,
	+ "page_size" => 50,
	+ "users" => [
	+ %{
	+ "deactivated" => user.info.deactivated,
	+ "id" => user.id,
	+ "nickname" => user.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => true,
	+ "tags" => []
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "search by full nickname", %{conn: conn} do
	+ user = insert(:user, nickname: "nickname@domain.com")
	+ insert(:user)
	+
	+ conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")
	+
	+ assert json_response(conn, 200) == %{
	+ "count" => 1,
	+ "page_size" => 50,
	+ "users" => [
	+ %{
	+ "deactivated" => user.info.deactivated,
	+ "id" => user.id,
	+ "nickname" => user.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => true,
	+ "tags" => []
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "search by display name", %{conn: conn} do
	+ user = insert(:user, name: "Display name")
	+ insert(:user)
	+
	+ conn = get(conn, "/api/pleroma/admin/users?name=display")
	+
	+ assert json_response(conn, 200) == %{
	+ "count" => 1,
	+ "page_size" => 50,
	+ "users" => [
	+ %{
	+ "deactivated" => user.info.deactivated,
	+ "id" => user.id,
	+ "nickname" => user.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => true,
	+ "tags" => []
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "search by email", %{conn: conn} do
	+ user = insert(:user, email: "email@example.com")
	+ insert(:user)
	+
	+ conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")
	+
	+ assert json_response(conn, 200) == %{
	+ "count" => 1,
	+ "page_size" => 50,
	+ "users" => [
	+ %{
	+ "deactivated" => user.info.deactivated,
	+ "id" => user.id,
	+ "nickname" => user.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => true,
	+ "tags" => []
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "regular search with page size", %{conn: conn} do
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	- conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/users?query=a&page_size=1&page=1")
	+ conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")

	- assert json_response(conn, 200) == %{
	+ assert json_response(conn1, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}

	- conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/users?query=a&page_size=1&page=2")
	+ conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")

	- assert json_response(conn, 200) == %{
	+ assert json_response(conn2, 200) == %{
	"count" => 2,
	"page_size" => 1,
	"users" => [
	%{
	"deactivated" => user2.info.deactivated,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	test "only local users" do
	admin = insert(:user, info: %{is_admin: true}, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?query=bo&filters=local")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	]
	}
	end

	- test "only local users with no query" do
	+ test "only local users with no query", %{admin: old_admin} do
	admin = insert(:user, info: %{is_admin: true}, nickname: "john")
	user = insert(:user, nickname: "bob")

	insert(:user, nickname: "bobb", local: false)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?filters=local")

	assert json_response(conn, 200) == %{
	- "count" => 2,
	+ "count" => 3,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	},
	%{
	"deactivated" => admin.info.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => []
	+ },
	+ %{
	+ "deactivated" => false,
	+ "id" => old_admin.id,
	+ "local" => true,
	+ "nickname" => old_admin.nickname,
	+ "roles" => %{"admin" => true, "moderator" => false},
	+ "tags" => []
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "load only admins", %{conn: conn, admin: admin} do
	+ second_admin = insert(:user, info: %{is_admin: true})
	+ insert(:user)
	+ insert(:user)
	+
	+ conn = get(conn, "/api/pleroma/admin/users?filters=is_admin")
	+
	+ assert json_response(conn, 200) == %{
	+ "count" => 2,
	+ "page_size" => 50,
	+ "users" => [
	+ %{
	+ "deactivated" => false,
	+ "id" => admin.id,
	+ "nickname" => admin.nickname,
	+ "roles" => %{"admin" => true, "moderator" => false},
	+ "local" => admin.local,
	+ "tags" => []
	+ },
	+ %{
	+ "deactivated" => false,
	+ "id" => second_admin.id,
	+ "nickname" => second_admin.nickname,
	+ "roles" => %{"admin" => true, "moderator" => false},
	+ "local" => second_admin.local,
	+ "tags" => []
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "load only moderators", %{conn: conn} do
	+ moderator = insert(:user, info: %{is_moderator: true})
	+ insert(:user)
	+ insert(:user)
	+
	+ conn = get(conn, "/api/pleroma/admin/users?filters=is_moderator")
	+
	+ assert json_response(conn, 200) == %{
	+ "count" => 1,
	+ "page_size" => 50,
	+ "users" => [
	+ %{
	+ "deactivated" => false,
	+ "id" => moderator.id,
	+ "nickname" => moderator.nickname,
	+ "roles" => %{"admin" => false, "moderator" => true},
	+ "local" => moderator.local,
	+ "tags" => []
	+ }
	+ ]
	+ }
	+ end
	+
	+ test "load users with tags list", %{conn: conn} do
	+ user1 = insert(:user, tags: ["first"])
	+ user2 = insert(:user, tags: ["second"])
	+ insert(:user)
	+ insert(:user)
	+
	+ conn = get(conn, "/api/pleroma/admin/users?tags[]=first&tags[]=second")
	+
	+ assert json_response(conn, 200) == %{
	+ "count" => 2,
	+ "page_size" => 50,
	+ "users" => [
	+ %{
	+ "deactivated" => false,
	+ "id" => user1.id,
	+ "nickname" => user1.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => user1.local,
	+ "tags" => ["first"]
	+ },
	+ %{
	+ "deactivated" => false,
	+ "id" => user2.id,
	+ "nickname" => user2.nickname,
	+ "roles" => %{"admin" => false, "moderator" => false},
	+ "local" => user2.local,
	+ "tags" => ["second"]
	}
	]
	}
	end

	test "it works with multiple filters" do
	admin = insert(:user, nickname: "john", info: %{is_admin: true})
	user = insert(:user, nickname: "bob", local: false, info: %{deactivated: true})

	insert(:user, nickname: "ken", local: true, info: %{deactivated: true})
	insert(:user, nickname: "bobb", local: false, info: %{deactivated: false})

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/users?filters=deactivated,external")

	assert json_response(conn, 200) == %{
	"count" => 1,
	"page_size" => 50,
	"users" => [
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user.local,
	"tags" => []
	}
	]
	}
	end
	end

	test "PATCH /api/pleroma/admin/users/:nickname/toggle_activation" do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> patch("/api/pleroma/admin/users/#{user.nickname}/toggle_activation")

	assert json_response(conn, 200) ==
	%{
	"deactivated" => !user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => []
	}
	end

	describe "GET /api/pleroma/admin/invite_token" do
	- test "without options" do
	+ setup do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/invite_token")
	+
	+ {:ok, conn: conn}
	+ end
	+
	+ test "without options", %{conn: conn} do
	+ conn = get(conn, "/api/pleroma/admin/invite_token")

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	refute invite.expires_at
	refute invite.max_use
	assert invite.invite_type == "one_time"
	end

	- test "with expires_at" do
	- admin = insert(:user, info: %{is_admin: true})
	-
	+ test "with expires_at", %{conn: conn} do
	conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/invite_token", %{
	+ get(conn, "/api/pleroma/admin/invite_token", %{
	"invite" => %{"expires_at" => Date.to_string(Date.utc_today())}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)

	refute invite.used
	assert invite.expires_at == Date.utc_today()
	refute invite.max_use
	assert invite.invite_type == "date_limited"
	end

	- test "with max_use" do
	- admin = insert(:user, info: %{is_admin: true})
	-
	+ test "with max_use", %{conn: conn} do
	conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/invite_token", %{
	+ get(conn, "/api/pleroma/admin/invite_token", %{
	"invite" => %{"max_use" => 150}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	refute invite.expires_at
	assert invite.max_use == 150
	assert invite.invite_type == "reusable"
	end

	- test "with max use and expires_at" do
	- admin = insert(:user, info: %{is_admin: true})
	-
	+ test "with max use and expires_at", %{conn: conn} do
	conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/invite_token", %{
	+ get(conn, "/api/pleroma/admin/invite_token", %{
	"invite" => %{"max_use" => 150, "expires_at" => Date.to_string(Date.utc_today())}
	})

	token = json_response(conn, 200)
	invite = UserInviteToken.find_by_token!(token)
	refute invite.used
	assert invite.expires_at == Date.utc_today()
	assert invite.max_use == 150
	assert invite.invite_type == "reusable_date_limited"
	end
	end

	describe "GET /api/pleroma/admin/invites" do
	- test "no invites" do
	+ setup do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/invites")
	+
	+ {:ok, conn: conn}
	+ end
	+
	+ test "no invites", %{conn: conn} do
	+ conn = get(conn, "/api/pleroma/admin/invites")

	assert json_response(conn, 200) == %{"invites" => []}
	end

	- test "with invite" do
	- admin = insert(:user, info: %{is_admin: true})
	+ test "with invite", %{conn: conn} do
	{:ok, invite} = UserInviteToken.create_invite()

	- conn =
	- build_conn()
	- \|> assign(:user, admin)
	- \|> get("/api/pleroma/admin/invites")
	+ conn = get(conn, "/api/pleroma/admin/invites")

	assert json_response(conn, 200) == %{
	"invites" => [
	%{
	"expires_at" => nil,
	"id" => invite.id,
	"invite_type" => "one_time",
	"max_use" => nil,
	"token" => invite.token,
	"used" => false,
	"uses" => 0
	}
	]
	}
	end
	end

	describe "POST /api/pleroma/admin/revoke_invite" do
	test "with token" do
	admin = insert(:user, info: %{is_admin: true})
	{:ok, invite} = UserInviteToken.create_invite()

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> post("/api/pleroma/admin/revoke_invite", %{"token" => invite.token})

	assert json_response(conn, 200) == %{
	"expires_at" => nil,
	"id" => invite.id,
	"invite_type" => "one_time",
	"max_use" => nil,
	"token" => invite.token,
	"used" => true,
	"uses" => 0
	}
	end
	end
	end
	diff --git a/test/web/admin_api/search_test.exs b/test/web/admin_api/search_test.exs
	index 3950996ed..501a8d007 100644
	--- a/test/web/admin_api/search_test.exs
	+++ b/test/web/admin_api/search_test.exs
	@@ -1,88 +1,170 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.AdminAPI.SearchTest do
	use Pleroma.Web.ConnCase

	alias Pleroma.Web.AdminAPI.Search

	import Pleroma.Factory

	describe "search for admin" do
	test "it ignores case" do
	insert(:user, nickname: "papercoach")
	insert(:user, nickname: "CanadaPaperCoach")

	{:ok, _results, count} =
	Search.user(%{
	query: "paper",
	local: false,
	page: 1,
	page_size: 50
	})

	assert count == 2
	end

	test "it returns local/external users" do
	insert(:user, local: true)
	insert(:user, local: false)
	insert(:user, local: false)

	{:ok, _results, local_count} =
	Search.user(%{
	query: "",
	local: true
	})

	{:ok, _results, external_count} =
	Search.user(%{
	query: "",
	external: true
	})

	assert local_count == 1
	assert external_count == 2
	end

	test "it returns active/deactivated users" do
	insert(:user, info: %{deactivated: true})
	insert(:user, info: %{deactivated: true})
	insert(:user, info: %{deactivated: false})

	{:ok, _results, active_count} =
	Search.user(%{
	query: "",
	active: true
	})

	{:ok, _results, deactivated_count} =
	Search.user(%{
	query: "",
	deactivated: true
	})

	assert active_count == 1
	assert deactivated_count == 2
	end

	test "it returns specific user" do
	insert(:user)
	insert(:user)
	- insert(:user, nickname: "bob", local: true, info: %{deactivated: false})
	+ user = insert(:user, nickname: "bob", local: true, info: %{deactivated: false})

	{:ok, _results, total_count} = Search.user(%{query: ""})

	- {:ok, _results, count} =
	+ {:ok, [^user], count} =
	Search.user(%{
	query: "Bo",
	active: true,
	local: true
	})

	assert total_count == 3
	assert count == 1
	end
	+
	+ test "it returns user by domain" do
	+ insert(:user)
	+ insert(:user)
	+ user = insert(:user, nickname: "some@domain.com")
	+
	+ {:ok, _results, total} = Search.user()
	+ {:ok, [^user], count} = Search.user(%{query: "domain.com"})
	+ assert total == 3
	+ assert count == 1
	+ end
	+
	+ test "it return user by full nickname" do
	+ insert(:user)
	+ insert(:user)
	+ user = insert(:user, nickname: "some@domain.com")
	+
	+ {:ok, _results, total} = Search.user()
	+ {:ok, [^user], count} = Search.user(%{query: "some@domain.com"})
	+ assert total == 3
	+ assert count == 1
	+ end
	+
	+ test "it returns admin user" do
	+ admin = insert(:user, info: %{is_admin: true})
	+ insert(:user)
	+ insert(:user)
	+
	+ {:ok, _results, total} = Search.user()
	+ {:ok, [^admin], count} = Search.user(%{is_admin: true})
	+ assert total == 3
	+ assert count == 1
	+ end
	+
	+ test "it returns moderator user" do
	+ moderator = insert(:user, info: %{is_moderator: true})
	+ insert(:user)
	+ insert(:user)
	+
	+ {:ok, _results, total} = Search.user()
	+ {:ok, [^moderator], count} = Search.user(%{is_moderator: true})
	+ assert total == 3
	+ assert count == 1
	+ end
	+
	+ test "it returns users with tags" do
	+ user1 = insert(:user, tags: ["first"])
	+ user2 = insert(:user, tags: ["second"])
	+ insert(:user)
	+ insert(:user)
	+
	+ {:ok, _results, total} = Search.user()
	+ {:ok, users, count} = Search.user(%{tags: ["first", "second"]})
	+ assert total == 4
	+ assert count == 2
	+ assert user1 in users
	+ assert user2 in users
	+ end
	+
	+ test "it returns user by display name" do
	+ user = insert(:user, name: "Display name")
	+ insert(:user)
	+ insert(:user)
	+
	+ {:ok, _results, total} = Search.user()
	+ {:ok, [^user], count} = Search.user(%{name: "display"})
	+
	+ assert total == 3
	+ assert count == 1
	+ end
	+
	+ test "it returns user by email" do
	+ user = insert(:user, email: "some@example.com")
	+ insert(:user)
	+ insert(:user)
	+
	+ {:ok, _results, total} = Search.user()
	+ {:ok, [^user], count} = Search.user(%{email: "some@example.com"})
	+
	+ assert total == 3
	+ assert count == 1
	+ end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Thu, Nov 28, 5:03 AM (1 d, 20 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 40830
Default Alt Text: (117 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions