No OneTemporary
Actions

Size

180 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index b1ec21818..9c3051c94 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,285 +1,286 @@
	# 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]
	### Security
	- OStatus: eliminate the possibility of a protocol downgrade attack.
	- OStatus: prevent following locked accounts, bypassing the approval process.

	### Changed
	- Breaking: Configuration: A setting to explicitly disable the mailer was added, defaulting to true, if you are using a mailer add `config :pleroma, Pleroma.Emails.Mailer, enabled: true` to your config
	- Breaking: Configuration: `/media/` is now removed when `base_url` is configured, append `/media/` to your `base_url` config to keep the old behaviour if desired
	- Configuration: OpenGraph and TwitterCard providers enabled by default
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- Federation: Return 403 errors when trying to request pages from a user's follower/following collections if they have `hide_followers`/`hide_follows` set
	- NodeInfo: Return `skipThreadContainment` in `metadata` for the `skip_thread_containment` option
	- NodeInfo: Return `mailerEnabled` in `metadata`
	- Mastodon API: Unsubscribe followers when they unfollow a user
	- AdminAPI: Add "godmode" while fetching user statuses (i.e. admin can see private statuses)
	- Improve digest email template

	### Fixed
	- Not being able to pin unlisted posts
	- Objects being re-embedded to activities after being updated (e.g faved/reposted). Running 'mix pleroma.database prune_objects' again is advised.
	- Favorites timeline doing database-intensive queries
	- Metadata rendering errors resulting in the entire page being inaccessible
	- `federation_incoming_replies_max_depth` option being ignored in certain cases
	- Federation/MediaProxy not working with instances that have wrong certificate order
	- Mastodon API: Handling of search timeouts (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API: Embedded relationships not being properly rendered in the Account entity of Status entity
	- Mastodon API: follower/following counters not being nullified, when `hide_follows`/`hide_followers` is set
	- Mastodon API: `muted` in the Status entity, using author's account to determine if the tread was muted
	- Mastodon API: Add `account_id`, `type`, `offset`, and `limit` to search API (`/api/v1/search` and `/api/v2/search`)
	- Mastodon API, streaming: Fix filtering of notifications based on blocks/mutes/thread mutes
	- ActivityPub C2S: follower/following collection pages being inaccessible even when authentifucated if `hide_followers`/ `hide_follows` was set
	- Existing user id not being preserved on insert conflict
	- Rich Media: Parser failing when no TTL can be found by image TTL setters
	- Rich Media: The crawled URL is now spliced into the rich media data.
	- ActivityPub S2S: sharedInbox usage has been mostly aligned with the rules in the AP specification.
	- ActivityPub S2S: remote user deletions now work the same as local user deletions.
	- ActivityPub S2S: POST requests are now signed with `(request-target)` pseudo-header.
	- Not being able to access the Mastodon FE login page on private instances
	- Invalid SemVer version generation, when the current branch does not have commits ahead of tag/checked out on a tag
	- Pleroma.Upload base_url was not automatically whitelisted by MediaProxy. Now your custom CDN or file hosting will be accessed directly as expected.
	- Report email not being sent to admins when the reporter is a remote user
	- MRF: ensure that subdomain_match calls are case-insensitive
	- Reverse Proxy limiting `max_body_length` was incorrectly defined and only checked `Content-Length` headers which may not be sufficient in some circumstances
	- MRF: fix use of unserializable keyword lists in describe() implementations
	- ActivityPub: Deactivated user deletion

	### Added
	- Expiring/ephemeral activites. All activities can have expires_at value set, which controls when they should be deleted automatically.
	- Mastodon API: in post_status, the expires_in parameter lets you set the number of seconds until an activity expires. It must be at least one hour.
	- Mastodon API: all status JSON responses contain a `pleroma.expires_at` item which states when an activity will expire. The value is only shown to the user who created the activity. To everyone else it's empty.
	- Configuration: `ActivityExpiration.enabled` controls whether expired activites will get deleted at the appropriate time. Enabled by default.
	- Conversations: Add Pleroma-specific conversation endpoints and status posting extensions. Run the `bump_all_conversations` task again to create the necessary data.
	- Breaking: MRF describe API, which adds support for exposing configuration information about MRF policies to NodeInfo.
	Custom modules will need to be updated by adding, at the very least, `def describe, do: {:ok, %{}}` to the MRF policy modules.
	- MRF: Support for priming the mediaproxy cache (`Pleroma.Web.ActivityPub.MRF.MediaProxyWarmingPolicy`)
	- MRF: Support for excluding specific domains from Transparency.
	- MRF: Support for filtering posts based on who they mention (`Pleroma.Web.ActivityPub.MRF.MentionPolicy`)
	- MRF: Support for filtering posts based on ActivityStreams vocabulary (`Pleroma.Web.ActivityPub.MRF.VocabularyPolicy`)
	- MRF (Simple Policy): Support for wildcard domains.
	- Support for wildcard domains in user domain blocks setting.
	- Configuration: `quarantined_instances` support wildcard domains.
	- Configuration: `federation_incoming_replies_max_depth` option
	- Mastodon API: Support for the [`tagged` filter](https://github.com/tootsuite/mastodon/pull/9755) in [`GET /api/v1/accounts/:id/statuses`](https://docs.joinmastodon.org/api/rest/accounts/#get-api-v1-accounts-id-statuses)
	- Mastodon API, streaming: Add support for passing the token in the `Sec-WebSocket-Protocol` header
	- Mastodon API, extension: Ability to reset avatar, profile banner, and background
	- Mastodon API: Add support for categories for custom emojis by reusing the group feature. <https://github.com/tootsuite/mastodon/pull/11196>
	- Mastodon API: Add support for muting/unmuting notifications
	- Mastodon API: Add support for the `blocked_by` attribute in the relationship API (`GET /api/v1/accounts/relationships`). <https://github.com/tootsuite/mastodon/pull/10373>
	- Mastodon API: Add support for the `domain_blocking` attribute in the relationship API (`GET /api/v1/accounts/relationships`).
	- Mastodon API: Add `pleroma.deactivated` to the Account entity
	- Mastodon API: added `/auth/password` endpoint for password reset with rate limit.
	- Mastodon API: /api/v1/accounts/:id/statuses now supports nicknames or user id
	- Mastodon API: Improve support for the user profile custom fields
	- Admin API: Return users' tags when querying reports
	- Admin API: Return avatar and display name when querying users
	- Admin API: Allow querying user by ID
	- Admin API: Added support for `tuples`.
	- Admin API: Added endpoints to run mix tasks pleroma.config migrate_to_db & pleroma.config migrate_from_db
	- Added synchronization of following/followers counters for external users
	- Configuration: `enabled` option for `Pleroma.Emails.Mailer`, defaulting to `false`.
	- Configuration: Pleroma.Plugs.RateLimiter `bucket_name`, `params` options.
	- Configuration: `user_bio_length` and `user_name_length` options.
	- Addressable lists
	- Twitter API: added rate limit for `/api/account/password_reset` endpoint.
	- ActivityPub: Add an internal service actor for fetching ActivityPub objects.
	- ActivityPub: Optional signing of ActivityPub object fetches.
	- Admin API: Endpoint for fetching latest user's statuses
	- Pleroma API: Add `/api/v1/pleroma/accounts/confirmation_resend?email=<email>` for resending account confirmation.
	- Relays: Added a task to list relay subscriptions.
	- Mix Tasks: `mix pleroma.database fix_likes_collections`
	- Federation: Remove `likes` from objects.

	### Changed
	- Configuration: Filter.AnonymizeFilename added ability to retain file extension with custom text
	- Admin API: changed json structure for saving config settings.
	- RichMedia: parsers and their order are configured in `rich_media` config.
	- RichMedia: add the rich media ttl based on image expiration time.

	### Removed
	- Emoji: Remove longfox emojis.
	- Remove `Reply-To` header from report emails for admins.
	- ActivityPub: The `accept_blocks` configuration setting.

	## [1.0.1] - 2019-07-14
	### Security
	- OStatus: fix an object spoofing vulnerability.

	## [1.0.0] - 2019-06-29
	### Security
	- Mastodon API: Fix display names not being sanitized
	- Rich media: Do not crawl private IP ranges

	### Added
	- Digest email for inactive users
	- Add a generic settings store for frontends / clients to use.
	- Explicit addressing option for posting.
	- Optional SSH access mode. (Needs `erlang-ssh` package on some distributions).
	- [MongooseIM](https://github.com/esl/MongooseIM) http authentication support.
	- LDAP authentication
	- External OAuth provider authentication
	- Support for building a release using [`mix release`](https://hexdocs.pm/mix/master/Mix.Tasks.Release.html)
	- 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 bump_all_conversations`
	- Mix Tasks: `mix pleroma.database remove_embedded_objects`
	- Mix Tasks: `mix pleroma.database update_users_following_followers_counts`
	- Mix Tasks: `mix pleroma.user toggle_confirmed`
	- Mix Tasks: `mix pleroma.config migrate_to_db`
	- Mix Tasks: `mix pleroma.config migrate_from_db`
	- Federation: Support for `Question` and `Answer` objects
	- Federation: Support for reports
	- Configuration: `poll_limits` option
	- Configuration: `pack_extensions` option
	- Configuration: `safe_dm_mentions` option
	- Configuration: `link_name` option
	- Configuration: `fetch_initial_posts` option
	- Configuration: `notify_email` option
	- Configuration: Media proxy `whitelist` option
	- Configuration: `report_uri` option
	- Configuration: `email_notifications` option
	- Configuration: `limit_to_local_content` option
	- Pleroma API: User subscriptions
	- Pleroma API: Healthcheck endpoint
	- Pleroma API: `/api/v1/pleroma/mascot` per-user frontend mascot configuration endpoints
	- 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
	- Admin API: Endpoints for managing reports
	- Admin API: Endpoints for deleting and changing the scope of individual reported statuses
	- Admin API: Endpoints to view and change config settings.
	- AdminFE: initial release with basic user management accessible at /pleroma/admin/
	- Mastodon API: Add chat token to `verify_credentials` response
	- Mastodon API: Add background image setting to `update_credentials`
	- 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/)
	- Mastodon API: `POST /api/v1/accounts` (account creation API)
	- Mastodon API: [Polls](https://docs.joinmastodon.org/api/rest/polls/)
	- ActivityPub C2S: OAuth endpoints
	- Metadata: RelMe provider
	- OAuth: added support for refresh tokens
	- Emoji packs and emoji pack manager
	- Object pruning (`mix pleroma.database prune_objects`)
	- OAuth: added job to clean expired access tokens
	- MRF: Support for rejecting reports from specific instances (`mrf_simple`)
	- MRF: Support for stripping avatars and banner images from specific instances (`mrf_simple`)
	- MRF: Support for running subchains.
	- Configuration: `skip_thread_containment` option
	- Configuration: `rate_limit` option. See `Pleroma.Plugs.RateLimiter` documentation for details.
	- MRF: Support for filtering out likely spam messages by rejecting posts from new users that contain links.
	- Configuration: `ignore_hosts` option
	- Configuration: `ignore_tld` option
	- Configuration: default syslog tag "Pleroma" is now lowercased to "pleroma"

	### Changed
	- Breaking: bind to 127.0.0.1 instead of 0.0.0.0 by default
	- Breaking: Configuration: move from Pleroma.Mailer to Pleroma.Emails.Mailer
	- Thread containment / test for complete visibility will be skipped by default.
	- 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: Default log level in `prod` environment is now set to `warn`
	- Configuration: Added `extra_cookie_attrs` for setting non-standard cookie attributes. Defaults to ["SameSite=Lax"] so that remote follows work.
	- Timelines: Messages involving people you have blocked will be excluded from the timeline in all cases instead of just repeats.
	- Admin API: Move the user related API to `api/pleroma/admin/users`
	+- Admin API: `POST /api/pleroma/admin/users` will take list of users
	- Pleroma API: Support for emoji tags in `/api/pleroma/emoji` resulting in a breaking API change
	- 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
	- Mastodon API: Added support max_id & since_id for bookmark timeline endpoints.
	- 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
	- Hide deactivated users and their statuses
	- Posts which are marked sensitive or tagged nsfw no longer have link previews.
	- HTTP connection timeout is now set to 10 seconds.
	- Respond with a 404 Not implemented JSON error message when requested API is not implemented
	- Rich Media: crawl only https URLs.

	### Fixed
	- Follow requests don't get 'stuck' anymore.
	- 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
	- Mastodon API: Make `irreversible` field default to `false` [`POST /api/v1/filters`]
	- Mastodon API: Replace missing non-nullable Card attributes with empty strings
	- User-Agent is now sent correctly for all HTTP requests.
	- MRF: Simple policy now properly delists imported or relayed statuses

	## Removed
	- Configuration: `config :pleroma, :fe` in favor of the more flexible `config :pleroma, :frontend_configurations`

	## [0.9.99999] - 2019-05-31
	### Security
	- Mastodon API: Fix lists leaking private posts

	## [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/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 134b8bb6c..29fd6d2ea 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1607 +1,1613 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

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

	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(:following_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	embeds_one(:info, User.Info)

	timestamps()
	end

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

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

	def visible_for?(user, for_user \\ nil)

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

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

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

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

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

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

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

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

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

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

	def user_info(%User{} = user, args \\ %{}) do
	following_count =
	if args[:following_count],
	do: args[:following_count],
	else: user.info.following_count \|\| following_count(user)

	follower_count =
	if args[:follower_count], do: args[:follower_count], else: user.info.follower_count

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

	def follow_state(%User{} = user, %User{} = target) do
	follow_activity = Utils.fetch_latest_follow(user, target)

	if follow_activity,
	do: follow_activity.data["state"],
	# Ideally this would be nil, but then Cachex does not commit the value
	else: false
	end

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

	def set_follow_state_cache(user_ap_id, target_ap_id, state) do
	Cachex.put(
	:user_cache,
	"follow_state:#{user_ap_id}\|#{target_ap_id}",
	state
	)
	end

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

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

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

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

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

	params = Map.put(params, :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: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> put_change(:local, false)
	\|> put_embed(:info, info_cng)

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

	_ ->
	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
	bio_limit = Pleroma.Config.get([:instance, :user_bio_length], 5000)
	name_limit = Pleroma.Config.get([:instance, :user_name_length], 100)

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

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

	params = Map.put(params, :last_refreshed_at, NaiveDateTime.utc_now())
	info_cng = User.Info.user_upgrade(struct.info, params[:info], remote?)

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

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

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

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

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

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

	info_change =
	User.Info.confirmation_changeset(%User.Info{}, need_confirmation: need_confirmation?)

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

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

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

	changeset
	\|> put_password_hash
	\|> 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 =
	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()

	follow_all(user, autofollowed_users)
	end

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

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

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

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

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

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

	def needs_update?(_), do: true

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

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

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

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

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

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

	Enum.each(followeds, fn followed ->
	update_follower_count(followed)
	end)

	set_cache(follower)
	end

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

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

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

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

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

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

	follower = maybe_update_following_count(follower)

	{:ok, _} = update_follower_count(followed)

	set_cache(follower)
	end
	end

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

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

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

	follower = maybe_update_following_count(follower)

	{:ok, followed} = update_follower_count(followed)

	set_cache(follower)

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

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

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

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

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

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

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

	get_cached_by_nickname(nickname)
	end

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

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

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	set_cache(user)
	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
	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: PleromaJobQueue.enqueue(:background, __MODULE__, [:fetch_initial_posts, user])

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

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

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

	@spec get_followers(User.t(), pos_integer()) :: {:ok, list(User.t())}
	def get_followers(user, page \\ nil) do
	q = get_followers_query(user, page)

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

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

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

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

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

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

	def get_friends(user, page \\ nil) do
	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

	@spec get_follow_requests(User.t()) :: {:ok, [User.t()]}
	def get_follow_requests(%User{} = user) do
	users =
	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)

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

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

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	info_cng = User.Info.follow_information_update(user.info, info)

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

	update_and_set_cache(changeset)
	else
	{:error, _} = e -> e
	e -> {:error, e}
	end
	end

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

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

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

	def maybe_update_following_count(user), do: user

	def remove_duplicated_following(%User{following: following} = user) do
	uniq_following = Enum.uniq(following)

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

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

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

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

	@spec mute(User.t(), User.t(), boolean()) :: {:ok, User.t()} \| {:error, String.t()}
	def mute(muter, %User{ap_id: ap_id}, notifications? \\ true) do
	info = muter.info

	info_cng =
	User.Info.add_to_mutes(info, ap_id)
	\|> User.Info.add_to_muted_notifications(info, ap_id, notifications?)

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

	update_and_set_cache(cng)
	end

	def unmute(muter, %{ap_id: ap_id}) do
	info = muter.info

	info_cng =
	User.Info.remove_from_mutes(info, ap_id)
	\|> User.Info.remove_from_muted_notifications(info, 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

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

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

	if following?(blocked, blocker) do
	unfollow(blocked, blocker)
	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)

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

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

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

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

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

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

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

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

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

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

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

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

	def block_domain(user, domain) do
	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 deactivate_async(user, status \\ true) do
	PleromaJobQueue.enqueue(:background, __MODULE__, [:deactivate_async, user, status])
	end

	def deactivate(%User{} = user, status \\ true) do
	info_cng = User.Info.set_activation_status(user.info, status)

	with {:ok, friends} <- User.get_friends(user),
	{:ok, followers} <- User.get_followers(user),
	{:ok, user} <-
	user
	\|> change()
	\|> put_embed(:info, info_cng)
	\|> update_and_set_cache() do
	Enum.each(followers, &invalidate_cache(&1))
	Enum.each(friends, &update_follower_count(&1))

	{:ok, user}
	end
	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} = ActivityPub.delete(user)

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

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

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

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

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

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

	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
	)

	{:ok, user}
	end

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

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

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

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

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

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

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

	Repo.all(query)
	end

	def blocks_import(%User{} = blocker, blocked_identifiers) when is_list(blocked_identifiers),
	do:
	PleromaJobQueue.enqueue(:background, __MODULE__, [
	:blocks_import,
	blocker,
	blocked_identifiers
	])

	def follow_import(%User{} = follower, followed_identifiers) when is_list(followed_identifiers),
	do:
	PleromaJobQueue.enqueue(:background, __MODULE__, [
	:follow_import,
	follower,
	followed_identifiers
	])

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

	{:ok, user}
	end

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

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

	ActivityPub.unlike(user, object)
	end

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

	ActivityPub.unannounce(user, object)
	end

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

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

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

	def fetch_by_ap_id(ap_id) do
	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
	fetch_initial_posts(user)
	end
	end

	resp
	end
	end

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

	{: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}) when not is_nil(magic_key) do
	{:ok, Pleroma.Web.Salmon.decode_key(magic_key)}
	end

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

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

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

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

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

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

	# wait a period of time and return newest version of the User structs
	# this is because we have synchronous follow APIs and need to simulate them
	# with an async handshake
	def wait_and_refresh(_, %User{local: true} = a, %User{local: true} = b) do
	with %User{} = a <- 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
	User.Query.build(%{super_users: true, local: true, deactivated: false})
	\|> Repo.all()
	end

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

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

	## Examples

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

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

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

	## Examples

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

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

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

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

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

	updated_user
	end

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

	info_changeset =
	User.Info.confirmation_changeset(user.info, need_confirmation: need_confirmation?)

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

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

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

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

	def ensure_keys_present(%User{info: info} = user) do
	if info.keys do
	{:ok, user}
	else
	{:ok, pem} = Keys.generate_rsa_pem()

	user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, User.Info.set_keys(info, pem))
	\|> update_and_set_cache()
	end
	end

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

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

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

	defp put_password_hash(changeset), do: changeset

	def is_internal_user?(%User{nickname: nil}), do: true
	def is_internal_user?(%User{local: true, nickname: "internal." <> _}), do: true
	def is_internal_user?(_), do: false
	end
	diff --git a/lib/pleroma/web/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/admin_api_controller.ex
	index 2d3d0adc4..048ac8019 100644
	--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
	+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
	@@ -1,472 +1,500 @@
	# 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.Activity
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.AdminAPI.Config
	alias Pleroma.Web.AdminAPI.ConfigView
	alias Pleroma.Web.AdminAPI.ReportView
	alias Pleroma.Web.AdminAPI.Search
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.StatusView

	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: "."
	- }
	+ def users_create(conn, %{"users" => users}) do
	+ changesets =
	+ Enum.map(users, fn %{"nickname" => nickname, "email" => email, "password" => password} ->
	+ user_data = %{
	+ nickname: nickname,
	+ name: nickname,
	+ email: email,
	+ password: password,
	+ password_confirmation: password,
	+ bio: "."
	+ }
	+
	+ User.register_changeset(%User{}, user_data, need_confirmation: false)
	+ end)
	+ \|> Enum.reduce(Ecto.Multi.new(), fn changeset, multi ->
	+ Ecto.Multi.insert(multi, Ecto.UUID.generate(), changeset)
	+ end)
	+
	+ case Pleroma.Repo.transaction(changesets) do
	+ {:ok, users} ->
	+ res =
	+ users
	+ \|> Map.values()
	+ \|> Enum.map(fn user ->
	+ {:ok, user} = User.post_register_action(user)
	+ user
	+ end)
	+ \|> Enum.map(&AccountView.render("created.json", %{user: &1}))

	- changeset = User.register_changeset(%User{}, user_data, need_confirmation: false)
	- {:ok, user} = User.register(changeset)
	+ conn
	+ \|> json(res)

	- conn
	- \|> json(user.nickname)
	+ {:error, id, changeset, _} ->
	+ res =
	+ Enum.map(changesets.operations, fn
	+ {current_id, {:changeset, _current_changeset, _}} when current_id == id ->
	+ AccountView.render("create-error.json", %{changeset: changeset})
	+
	+ {_, {:changeset, current_changeset, _}} ->
	+ AccountView.render("create-error.json", %{changeset: current_changeset})
	+ end)
	+
	+ conn
	+ \|> put_status(:conflict)
	+ \|> json(res)
	+ end
	end

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

	def list_user_statuses(conn, %{"nickname" => nickname} = params) do
	godmode = params["godmode"] == "true" \|\| params["godmode"] == true

	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname) do
	{_, page_size} = page_params(params)

	activities =
	ActivityPub.fetch_user_activities(user, nil, %{
	"limit" => page_size,
	"godmode" => godmode
	})

	conn
	\|> json(StatusView.render("index.json", %{activities: activities, as: :activity}))
	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,
	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 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: %{}

	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
	render_error(conn, :not_found, "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
	render_error(conn, :forbidden, "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
	render_error(conn, :not_found, "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
	with {:ok, invite} <- UserInviteToken.find_by_token(token),
	{:ok, updated_invite} = UserInviteToken.update_invite(invite, %{used: true}) do
	conn
	\|> json(AccountView.render("invite.json", %{invite: updated_invite}))
	else
	nil -> {:error, :not_found}
	end
	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 list_reports(conn, params) do
	params =
	params
	\|> Map.put("type", "Flag")
	\|> Map.put("skip_preload", true)

	reports =
	[]
	\|> ActivityPub.fetch_activities(params)
	\|> Enum.reverse()

	conn
	\|> put_view(ReportView)
	\|> render("index.json", %{reports: reports})
	end

	def report_show(conn, %{"id" => id}) do
	with %Activity{} = report <- Activity.get_by_id(id) do
	conn
	\|> put_view(ReportView)
	\|> render("show.json", %{report: report})
	else
	_ -> {:error, :not_found}
	end
	end

	def report_update_state(conn, %{"id" => id, "state" => state}) do
	with {:ok, report} <- CommonAPI.update_report_state(id, state) do
	conn
	\|> put_view(ReportView)
	\|> render("show.json", %{report: report})
	end
	end

	def report_respond(%{assigns: %{user: user}} = conn, %{"id" => id} = params) do
	with false <- is_nil(params["status"]),
	%Activity{} <- Activity.get_by_id(id) do
	params =
	params
	\|> Map.put("in_reply_to_status_id", id)
	\|> Map.put("visibility", "direct")

	{:ok, activity} = CommonAPI.post(user, params)

	conn
	\|> put_view(StatusView)
	\|> render("status.json", %{activity: activity})
	else
	true ->
	{:param_cast, nil}

	nil ->
	{:error, :not_found}
	end
	end

	def status_update(conn, %{"id" => id} = params) do
	with {:ok, activity} <- CommonAPI.update_activity_scope(id, params) do
	conn
	\|> put_view(StatusView)
	\|> render("status.json", %{activity: activity})
	end
	end

	def status_delete(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	json(conn, %{})
	end
	end

	def migrate_to_db(conn, _params) do
	Mix.Tasks.Pleroma.Config.run(["migrate_to_db"])
	json(conn, %{})
	end

	def migrate_from_db(conn, _params) do
	Mix.Tasks.Pleroma.Config.run(["migrate_from_db", Pleroma.Config.get(:env), "true"])
	json(conn, %{})
	end

	def config_show(conn, _params) do
	configs = Pleroma.Repo.all(Config)

	conn
	\|> put_view(ConfigView)
	\|> render("index.json", %{configs: configs})
	end

	def config_update(conn, %{"configs" => configs}) do
	updated =
	if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	updated =
	Enum.map(configs, fn
	%{"group" => group, "key" => key, "delete" => "true"} = params ->
	{:ok, config} = Config.delete(%{group: group, key: key, subkeys: params["subkeys"]})
	config

	%{"group" => group, "key" => key, "value" => value} ->
	{:ok, config} = Config.update_or_create(%{group: group, key: key, value: value})
	config
	end)
	\|> Enum.reject(&is_nil(&1))

	Pleroma.Config.TransferTask.load_and_update_env()
	Mix.Tasks.Pleroma.Config.run(["migrate_from_db", Pleroma.Config.get(:env), "false"])
	updated
	else
	[]
	end

	conn
	\|> put_view(ConfigView)
	\|> render("index.json", %{configs: updated})
	end

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

	def errors(conn, {:error, reason}) do
	conn
	\|> put_status(:bad_request)
	\|> json(reason)
	end

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

	def errors(conn, _) do
	conn
	\|> put_status(:internal_server_error)
	\|> json(dgettext("errors", "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/views/account_view.ex b/lib/pleroma/web/admin_api/views/account_view.ex
	index 7e1b9c431..a96affd40 100644
	--- a/lib/pleroma/web/admin_api/views/account_view.ex
	+++ b/lib/pleroma/web/admin_api/views/account_view.ex
	@@ -1,55 +1,101 @@
	# 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.AccountView do
	use Pleroma.Web, :view

	alias Pleroma.HTML
	alias Pleroma.User
	alias Pleroma.User.Info
	alias Pleroma.Web.AdminAPI.AccountView
	alias Pleroma.Web.MediaProxy

	def render("index.json", %{users: users, count: count, page_size: page_size}) do
	%{
	users: render_many(users, AccountView, "show.json", as: :user),
	count: count,
	page_size: page_size
	}
	end

	def render("show.json", %{user: user}) do
	avatar = User.avatar_url(user) \|> MediaProxy.url()
	display_name = HTML.strip_tags(user.name \|\| user.nickname)

	%{
	"id" => user.id,
	"avatar" => avatar,
	"nickname" => user.nickname,
	"display_name" => display_name,
	"deactivated" => user.info.deactivated,
	"local" => user.local,
	"roles" => Info.roles(user.info),
	"tags" => user.tags \|\| []
	}
	end

	def render("invite.json", %{invite: invite}) do
	%{
	"id" => invite.id,
	"token" => invite.token,
	"used" => invite.used,
	"expires_at" => invite.expires_at,
	"uses" => invite.uses,
	"max_use" => invite.max_use,
	"invite_type" => invite.invite_type
	}
	end

	def render("invites.json", %{invites: invites}) do
	%{
	invites: render_many(invites, AccountView, "invite.json", as: :invite)
	}
	end
	+
	+ def render("created.json", %{user: user}) do
	+ %{
	+ type: "success",
	+ code: 200,
	+ data: %{
	+ nickname: user.nickname,
	+ email: user.email
	+ }
	+ }
	+ end
	+
	+ def render("create-error.json", %{changeset: %Ecto.Changeset{changes: changes, errors: errors}}) do
	+ %{
	+ type: "error",
	+ code: 409,
	+ error: parse_error(errors),
	+ data: %{
	+ nickname: Map.get(changes, :nickname),
	+ email: Map.get(changes, :email)
	+ }
	+ }
	+ end
	+
	+ defp parse_error([]), do: ""
	+
	+ defp parse_error(errors) do
	+ ## when nickname is duplicate ap_id constraint error is raised
	+ nickname_error = Keyword.get(errors, :nickname) \|\| Keyword.get(errors, :ap_id)
	+ email_error = Keyword.get(errors, :email)
	+ password_error = Keyword.get(errors, :password)
	+
	+ cond do
	+ nickname_error ->
	+ "nickname #{elem(nickname_error, 0)}"
	+
	+ email_error ->
	+ "email #{elem(email_error, 0)}"
	+
	+ password_error ->
	+ "password #{elem(password_error, 0)}"
	+
	+ true ->
	+ ""
	+ end
	+ end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 1eb6f7b9d..97c5016d5 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,756 +1,756 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Router do
	use Pleroma.Web, :router

	pipeline :browser do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	end

	pipeline :oauth do
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	end

	pipeline :api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :authenticated_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :admin_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.AdminSecretAuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.UserIsAdminPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :mastodon_html do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :pleroma_html do
	plug(:accepts, ["html"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :oauth_read_or_public do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{
	scopes: ["read"],
	fallback: :proceed_unauthenticated
	})

	plug(Pleroma.Plugs.EnsurePublicOrAuthenticatedPlug)
	end

	pipeline :oauth_read do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["read"]})
	end

	pipeline :oauth_write do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["write"]})
	end

	pipeline :oauth_follow do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["follow"]})
	end

	pipeline :oauth_push do
	plug(Pleroma.Plugs.OAuthScopesPlug, %{scopes: ["push"]})
	end

	pipeline :well_known do
	plug(:accepts, ["json", "jrd+json", "xml", "xrd+xml"])
	end

	pipeline :config do
	plug(:accepts, ["json", "xml"])
	end

	pipeline :pleroma_api do
	plug(:accepts, ["html", "json"])
	end

	pipeline :mailbox_preview do
	plug(:accepts, ["html"])

	plug(:put_secure_browser_headers, %{
	"content-security-policy" =>
	"default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline' 'unsafe-eval'"
	})
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)

	get("/password_reset/:token", PasswordController, :reset, as: :reset_password)
	post("/password_reset", PasswordController, :do_reset, as: :reset_password)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	get("/healthcheck", UtilController, :healthcheck)
	end

	scope "/api/pleroma", Pleroma.Web do
	pipe_through(:pleroma_api)
	post("/uploader_callback/:upload_path", UploaderController, :callback)
	end

	scope "/api/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through([:admin_api, :oauth_write])

	post("/users/follow", AdminAPIController, :user_follow)
	post("/users/unfollow", AdminAPIController, :user_unfollow)

	delete("/users", AdminAPIController, :user_delete)
	- post("/users", AdminAPIController, :user_create)
	+ post("/users", AdminAPIController, :users_create)
	patch("/users/:nickname/toggle_activation", AdminAPIController, :user_toggle_activation)
	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)

	get("/users/:nickname/permission_group", AdminAPIController, :right_get)
	get("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_get)
	post("/users/:nickname/permission_group/:permission_group", AdminAPIController, :right_add)

	delete(
	"/users/:nickname/permission_group/:permission_group",
	AdminAPIController,
	:right_delete
	)

	put("/users/:nickname/activation_status", AdminAPIController, :set_activation_status)

	post("/relay", AdminAPIController, :relay_follow)
	delete("/relay", AdminAPIController, :relay_unfollow)

	get("/users/invite_token", AdminAPIController, :get_invite_token)
	get("/users/invites", AdminAPIController, :invites)
	post("/users/revoke_invite", AdminAPIController, :revoke_invite)
	post("/users/email_invite", AdminAPIController, :email_invite)

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)

	get("/users", AdminAPIController, :list_users)
	get("/users/:nickname", AdminAPIController, :user_show)
	get("/users/:nickname/statuses", AdminAPIController, :list_user_statuses)

	get("/reports", AdminAPIController, :list_reports)
	get("/reports/:id", AdminAPIController, :report_show)
	put("/reports/:id", AdminAPIController, :report_update_state)
	post("/reports/:id/respond", AdminAPIController, :report_respond)

	put("/statuses/:id", AdminAPIController, :status_update)
	delete("/statuses/:id", AdminAPIController, :status_delete)

	get("/config", AdminAPIController, :config_show)
	post("/config", AdminAPIController, :config_update)
	get("/config/migrate_to_db", AdminAPIController, :migrate_to_db)
	get("/config/migrate_from_db", AdminAPIController, :migrate_from_db)
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)

	post("/main/ostatus", UtilController, :remote_subscribe)
	get("/ostatus_subscribe", UtilController, :remote_follow)

	scope [] do
	pipe_through(:oauth_follow)
	post("/ostatus_subscribe", UtilController, :do_remote_follow)
	end
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)

	scope [] do
	pipe_through(:oauth_write)

	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	put("/notification_settings", UtilController, :update_notificaton_settings)
	post("/disable_account", UtilController, :disable_account)
	end

	scope [] do
	pipe_through(:oauth_follow)

	post("/blocks_import", UtilController, :blocks_import)
	post("/follow_import", UtilController, :follow_import)
	end

	scope [] do
	pipe_through(:oauth_read)

	post("/notifications/read", UtilController, :notifications_read)
	end
	end

	scope "/oauth", Pleroma.Web.OAuth do
	scope [] do
	pipe_through(:oauth)
	get("/authorize", OAuthController, :authorize)
	end

	post("/authorize", OAuthController, :create_authorization)
	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	get("/registration_details", OAuthController, :registration_details)

	scope [] do
	pipe_through(:browser)

	get("/prepare_request", OAuthController, :prepare_request)
	get("/:provider", OAuthController, :request)
	get("/:provider/callback", OAuthController, :callback)
	post("/register", OAuthController, :register)
	end
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:authenticated_api)

	scope [] do
	pipe_through(:oauth_read)
	get("/conversations/:id/statuses", PleromaAPIController, :conversation_statuses)
	get("/conversations/:id", PleromaAPIController, :conversation)
	end

	scope [] do
	pipe_through(:oauth_write)
	patch("/conversations/:id", PleromaAPIController, :update_conversation)
	end
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:authenticated_api)

	scope [] do
	pipe_through(:oauth_read)

	get("/accounts/verify_credentials", MastodonAPIController, :verify_credentials)

	get("/accounts/relationships", MastodonAPIController, :relationships)

	get("/accounts/:id/lists", MastodonAPIController, :account_lists)
	get("/accounts/:id/identity_proofs", MastodonAPIController, :empty_array)

	get("/follow_requests", MastodonAPIController, :follow_requests)
	get("/blocks", MastodonAPIController, :blocks)
	get("/mutes", MastodonAPIController, :mutes)

	get("/timelines/home", MastodonAPIController, :home_timeline)
	get("/timelines/direct", MastodonAPIController, :dm_timeline)

	get("/favourites", MastodonAPIController, :favourites)
	get("/bookmarks", MastodonAPIController, :bookmarks)

	post("/notifications/clear", MastodonAPIController, :clear_notifications)
	post("/notifications/dismiss", MastodonAPIController, :dismiss_notification)
	get("/notifications", MastodonAPIController, :notifications)
	get("/notifications/:id", MastodonAPIController, :get_notification)
	delete("/notifications/destroy_multiple", MastodonAPIController, :destroy_multiple)

	get("/scheduled_statuses", MastodonAPIController, :scheduled_statuses)
	get("/scheduled_statuses/:id", MastodonAPIController, :show_scheduled_status)

	get("/lists", MastodonAPIController, :get_lists)
	get("/lists/:id", MastodonAPIController, :get_list)
	get("/lists/:id/accounts", MastodonAPIController, :list_accounts)

	get("/domain_blocks", MastodonAPIController, :domain_blocks)

	get("/filters", MastodonAPIController, :get_filters)

	get("/suggestions", MastodonAPIController, :suggestions)

	get("/conversations", MastodonAPIController, :conversations)
	post("/conversations/:id/read", MastodonAPIController, :conversation_read)

	get("/endorsements", MastodonAPIController, :empty_array)
	end

	scope [] do
	pipe_through(:oauth_write)

	patch("/accounts/update_credentials", MastodonAPIController, :update_credentials)

	post("/statuses", MastodonAPIController, :post_status)
	delete("/statuses/:id", MastodonAPIController, :delete_status)

	post("/statuses/:id/reblog", MastodonAPIController, :reblog_status)
	post("/statuses/:id/unreblog", MastodonAPIController, :unreblog_status)
	post("/statuses/:id/favourite", MastodonAPIController, :fav_status)
	post("/statuses/:id/unfavourite", MastodonAPIController, :unfav_status)
	post("/statuses/:id/pin", MastodonAPIController, :pin_status)
	post("/statuses/:id/unpin", MastodonAPIController, :unpin_status)
	post("/statuses/:id/bookmark", MastodonAPIController, :bookmark_status)
	post("/statuses/:id/unbookmark", MastodonAPIController, :unbookmark_status)
	post("/statuses/:id/mute", MastodonAPIController, :mute_conversation)
	post("/statuses/:id/unmute", MastodonAPIController, :unmute_conversation)

	put("/scheduled_statuses/:id", MastodonAPIController, :update_scheduled_status)
	delete("/scheduled_statuses/:id", MastodonAPIController, :delete_scheduled_status)

	post("/polls/:id/votes", MastodonAPIController, :poll_vote)

	post("/media", MastodonAPIController, :upload)
	put("/media/:id", MastodonAPIController, :update_media)

	delete("/lists/:id", MastodonAPIController, :delete_list)
	post("/lists", MastodonAPIController, :create_list)
	put("/lists/:id", MastodonAPIController, :rename_list)

	post("/lists/:id/accounts", MastodonAPIController, :add_to_list)
	delete("/lists/:id/accounts", MastodonAPIController, :remove_from_list)

	post("/filters", MastodonAPIController, :create_filter)
	get("/filters/:id", MastodonAPIController, :get_filter)
	put("/filters/:id", MastodonAPIController, :update_filter)
	delete("/filters/:id", MastodonAPIController, :delete_filter)

	patch("/pleroma/accounts/update_avatar", MastodonAPIController, :update_avatar)
	patch("/pleroma/accounts/update_banner", MastodonAPIController, :update_banner)
	patch("/pleroma/accounts/update_background", MastodonAPIController, :update_background)

	get("/pleroma/mascot", MastodonAPIController, :get_mascot)
	put("/pleroma/mascot", MastodonAPIController, :set_mascot)

	post("/reports", MastodonAPIController, :reports)
	end

	scope [] do
	pipe_through(:oauth_follow)

	post("/follows", MastodonAPIController, :follow)
	post("/accounts/:id/follow", MastodonAPIController, :follow)

	post("/accounts/:id/unfollow", MastodonAPIController, :unfollow)
	post("/accounts/:id/block", MastodonAPIController, :block)
	post("/accounts/:id/unblock", MastodonAPIController, :unblock)
	post("/accounts/:id/mute", MastodonAPIController, :mute)
	post("/accounts/:id/unmute", MastodonAPIController, :unmute)

	post("/follow_requests/:id/authorize", MastodonAPIController, :authorize_follow_request)
	post("/follow_requests/:id/reject", MastodonAPIController, :reject_follow_request)

	post("/domain_blocks", MastodonAPIController, :block_domain)
	delete("/domain_blocks", MastodonAPIController, :unblock_domain)

	post("/pleroma/accounts/:id/subscribe", MastodonAPIController, :subscribe)
	post("/pleroma/accounts/:id/unsubscribe", MastodonAPIController, :unsubscribe)
	end

	scope [] do
	pipe_through(:oauth_push)

	post("/push/subscription", SubscriptionController, :create)
	get("/push/subscription", SubscriptionController, :get)
	put("/push/subscription", SubscriptionController, :update)
	delete("/push/subscription", SubscriptionController, :delete)
	end
	end

	scope "/api/web", Pleroma.Web.MastodonAPI do
	pipe_through([:authenticated_api, :oauth_write])

	put("/settings", MastodonAPIController, :put_settings)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)

	post("/accounts", MastodonAPIController, :account_register)

	get("/instance", MastodonAPIController, :masto_instance)
	get("/instance/peers", MastodonAPIController, :peers)
	post("/apps", MastodonAPIController, :create_app)
	get("/apps/verify_credentials", MastodonAPIController, :verify_app_credentials)
	get("/custom_emojis", MastodonAPIController, :custom_emojis)

	get("/statuses/:id/card", MastodonAPIController, :status_card)

	get("/statuses/:id/favourited_by", MastodonAPIController, :favourited_by)
	get("/statuses/:id/reblogged_by", MastodonAPIController, :reblogged_by)

	get("/trends", MastodonAPIController, :empty_array)

	get("/accounts/search", SearchController, :account_search)

	post(
	"/pleroma/accounts/confirmation_resend",
	MastodonAPIController,
	:account_confirmation_resend
	)

	scope [] do
	pipe_through(:oauth_read_or_public)

	get("/timelines/public", MastodonAPIController, :public_timeline)
	get("/timelines/tag/:tag", MastodonAPIController, :hashtag_timeline)
	get("/timelines/list/:list_id", MastodonAPIController, :list_timeline)

	get("/statuses/:id", MastodonAPIController, :get_status)
	get("/statuses/:id/context", MastodonAPIController, :get_context)

	get("/polls/:id", MastodonAPIController, :get_poll)

	get("/accounts/:id/statuses", MastodonAPIController, :user_statuses)
	get("/accounts/:id/followers", MastodonAPIController, :followers)
	get("/accounts/:id/following", MastodonAPIController, :following)
	get("/accounts/:id", MastodonAPIController, :user)

	get("/search", SearchController, :search)

	get("/pleroma/accounts/:id/favourites", MastodonAPIController, :user_favourites)
	end
	end

	scope "/api/v2", Pleroma.Web.MastodonAPI do
	pipe_through([:api, :oauth_read_or_public])
	get("/search", SearchController, :search2)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:config)

	get("/help/test", TwitterAPI.UtilController, :help_test)
	post("/help/test", TwitterAPI.UtilController, :help_test)
	get("/statusnet/config", TwitterAPI.UtilController, :config)
	get("/statusnet/version", TwitterAPI.UtilController, :version)
	get("/pleroma/frontend_configurations", TwitterAPI.UtilController, :frontend_configurations)
	end

	scope "/api", Pleroma.Web do
	pipe_through(:api)

	post("/account/register", TwitterAPI.Controller, :register)
	post("/account/password_reset", TwitterAPI.Controller, :password_reset)

	post("/account/resend_confirmation_email", TwitterAPI.Controller, :resend_confirmation_email)

	get(
	"/account/confirm_email/:user_id/:token",
	TwitterAPI.Controller,
	:confirm_email,
	as: :confirm_email
	)

	scope [] do
	pipe_through(:oauth_read_or_public)

	get("/statuses/user_timeline", TwitterAPI.Controller, :user_timeline)
	get("/qvitter/statuses/user_timeline", TwitterAPI.Controller, :user_timeline)
	get("/users/show", TwitterAPI.Controller, :show_user)

	get("/statuses/followers", TwitterAPI.Controller, :followers)
	get("/statuses/friends", TwitterAPI.Controller, :friends)
	get("/statuses/blocks", TwitterAPI.Controller, :blocks)
	get("/statuses/show/:id", TwitterAPI.Controller, :fetch_status)
	get("/statusnet/conversation/:id", TwitterAPI.Controller, :fetch_conversation)

	get("/search", TwitterAPI.Controller, :search)
	get("/statusnet/tags/timeline/:tag", TwitterAPI.Controller, :public_and_external_timeline)
	end
	end

	scope "/api", Pleroma.Web do
	pipe_through([:api, :oauth_read_or_public])

	get("/statuses/public_timeline", TwitterAPI.Controller, :public_timeline)

	get(
	"/statuses/public_and_external_timeline",
	TwitterAPI.Controller,
	:public_and_external_timeline
	)

	get("/statuses/networkpublic_timeline", TwitterAPI.Controller, :public_and_external_timeline)
	end

	scope "/api", Pleroma.Web, as: :twitter_api_search do
	pipe_through([:api, :oauth_read_or_public])
	get("/pleroma/search_user", TwitterAPI.Controller, :search_user)
	end

	scope "/api", Pleroma.Web, as: :authenticated_twitter_api do
	pipe_through(:authenticated_api)

	get("/oauth_tokens", TwitterAPI.Controller, :oauth_tokens)
	delete("/oauth_tokens/:id", TwitterAPI.Controller, :revoke_token)

	scope [] do
	pipe_through(:oauth_read)

	get("/account/verify_credentials", TwitterAPI.Controller, :verify_credentials)
	post("/account/verify_credentials", TwitterAPI.Controller, :verify_credentials)

	get("/statuses/home_timeline", TwitterAPI.Controller, :friends_timeline)
	get("/statuses/friends_timeline", TwitterAPI.Controller, :friends_timeline)
	get("/statuses/mentions", TwitterAPI.Controller, :mentions_timeline)
	get("/statuses/mentions_timeline", TwitterAPI.Controller, :mentions_timeline)
	get("/statuses/dm_timeline", TwitterAPI.Controller, :dm_timeline)
	get("/qvitter/statuses/notifications", TwitterAPI.Controller, :notifications)

	get("/pleroma/friend_requests", TwitterAPI.Controller, :friend_requests)

	get("/friends/ids", TwitterAPI.Controller, :friends_ids)
	get("/friendships/no_retweets/ids", TwitterAPI.Controller, :empty_array)

	get("/mutes/users/ids", TwitterAPI.Controller, :empty_array)
	get("/qvitter/mutes", TwitterAPI.Controller, :raw_empty_array)

	get("/externalprofile/show", TwitterAPI.Controller, :external_profile)

	post("/qvitter/statuses/notifications/read", TwitterAPI.Controller, :notifications_read)
	end

	scope [] do
	pipe_through(:oauth_write)

	post("/account/update_profile", TwitterAPI.Controller, :update_profile)
	post("/account/update_profile_banner", TwitterAPI.Controller, :update_banner)
	post("/qvitter/update_background_image", TwitterAPI.Controller, :update_background)

	post("/statuses/update", TwitterAPI.Controller, :status_update)
	post("/statuses/retweet/:id", TwitterAPI.Controller, :retweet)
	post("/statuses/unretweet/:id", TwitterAPI.Controller, :unretweet)
	post("/statuses/destroy/:id", TwitterAPI.Controller, :delete_post)

	post("/statuses/pin/:id", TwitterAPI.Controller, :pin)
	post("/statuses/unpin/:id", TwitterAPI.Controller, :unpin)

	post("/statusnet/media/upload", TwitterAPI.Controller, :upload)
	post("/media/upload", TwitterAPI.Controller, :upload_json)
	post("/media/metadata/create", TwitterAPI.Controller, :update_media)

	post("/favorites/create/:id", TwitterAPI.Controller, :favorite)
	post("/favorites/create", TwitterAPI.Controller, :favorite)
	post("/favorites/destroy/:id", TwitterAPI.Controller, :unfavorite)

	post("/qvitter/update_avatar", TwitterAPI.Controller, :update_avatar)
	end

	scope [] do
	pipe_through(:oauth_follow)

	post("/pleroma/friendships/approve", TwitterAPI.Controller, :approve_friend_request)
	post("/pleroma/friendships/deny", TwitterAPI.Controller, :deny_friend_request)

	post("/friendships/create", TwitterAPI.Controller, :follow)
	post("/friendships/destroy", TwitterAPI.Controller, :unfollow)

	post("/blocks/create", TwitterAPI.Controller, :block)
	post("/blocks/destroy", TwitterAPI.Controller, :unblock)
	end
	end

	pipeline :ap_service_actor do
	plug(:accepts, ["activity+json", "json"])
	end

	pipeline :ostatus do
	plug(:accepts, ["html", "xml", "atom", "activity+json", "json"])
	end

	pipeline :oembed do
	plug(:accepts, ["json", "xml"])
	end

	scope "/", Pleroma.Web do
	pipe_through(:ostatus)

	get("/objects/:uuid", OStatus.OStatusController, :object)
	get("/activities/:uuid", OStatus.OStatusController, :activity)
	get("/notice/:id", OStatus.OStatusController, :notice)
	get("/notice/:id/embed_player", OStatus.OStatusController, :notice_player)
	get("/users/:nickname/feed", OStatus.OStatusController, :feed)
	get("/users/:nickname", OStatus.OStatusController, :feed_redirect)

	post("/users/:nickname/salmon", OStatus.OStatusController, :salmon_incoming)
	post("/push/hub/:nickname", Websub.WebsubController, :websub_subscription_request)
	get("/push/subscriptions/:id", Websub.WebsubController, :websub_subscription_confirmation)
	post("/push/subscriptions/:id", Websub.WebsubController, :websub_incoming)

	get("/mailer/unsubscribe/:token", Mailer.SubscriptionController, :unsubscribe)
	end

	pipeline :activitypub do
	plug(:accepts, ["activity+json", "json"])
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	plug(Pleroma.Web.Plugs.MappedSignatureToIdentityPlug)
	end

	scope "/", Pleroma.Web.ActivityPub do
	# XXX: not really ostatus
	pipe_through(:ostatus)

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	get("/objects/:uuid/likes", ActivityPubController, :object_likes)
	end

	pipeline :activitypub_client do
	plug(:accepts, ["activity+json", "json"])
	plug(:fetch_session)
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through([:activitypub_client])

	scope [] do
	pipe_through(:oauth_read)
	get("/api/ap/whoami", ActivityPubController, :whoami)
	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)
	end

	scope [] do
	pipe_through(:oauth_write)
	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	end

	scope [] do
	pipe_through(:oauth_read_or_public)
	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	end
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/inbox", ActivityPubController, :inbox)
	post("/users/:nickname/inbox", ActivityPubController, :inbox)
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :relay)
	post("/inbox", ActivityPubController, :inbox)
	end

	scope "/internal/fetch", Pleroma.Web.ActivityPub do
	pipe_through(:ap_service_actor)

	get("/", ActivityPubController, :internal_fetch)
	post("/inbox", ActivityPubController, :inbox)
	end

	scope "/.well-known", Pleroma.Web do
	pipe_through(:well_known)

	get("/host-meta", WebFinger.WebFingerController, :host_meta)
	get("/webfinger", WebFinger.WebFingerController, :webfinger)
	get("/nodeinfo", Nodeinfo.NodeinfoController, :schemas)
	end

	scope "/nodeinfo", Pleroma.Web do
	get("/:version", Nodeinfo.NodeinfoController, :nodeinfo)
	end

	scope "/", Pleroma.Web.MastodonAPI do
	pipe_through(:mastodon_html)

	get("/web/login", MastodonAPIController, :login)
	delete("/auth/sign_out", MastodonAPIController, :logout)

	post("/auth/password", MastodonAPIController, :password_reset)

	scope [] do
	pipe_through(:oauth_read)
	get("/web/*path", MastodonAPIController, :index)
	end
	end

	pipeline :remote_media do
	end

	scope "/proxy/", Pleroma.Web.MediaProxy do
	pipe_through(:remote_media)

	get("/:sig/:url", MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxyController, :remote)
	end

	if Pleroma.Config.get(:env) == :dev do
	scope "/dev" do
	pipe_through([:mailbox_preview])

	forward("/mailbox", Plug.Swoosh.MailboxPreview, base_path: "/dev/mailbox")
	end
	end

	scope "/", Pleroma.Web.MongooseIM do
	get("/user_exists", MongooseIMController, :user_exists)
	get("/check_password", MongooseIMController, :check_password)
	end

	scope "/", Fallback do
	get("/registration/:token", RedirectController, :registration_page)
	get("/:maybe_nickname_or_id", RedirectController, :redirector_with_meta)
	get("/api*path", RedirectController, :api_not_implemented)
	get("/*path", RedirectController, :redirector)

	options("/*path", RedirectController, :empty)
	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 844cd0732..ab829d6bd 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,2030 +1,2149 @@
	# 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.Activity
	alias Pleroma.HTML
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MediaProxy
	import Pleroma.Factory

	describe "/api/pleroma/admin/users" 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/users?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/users", %{
	- "nickname" => "lain",
	- "email" => "lain@example.org",
	- "password" => "test"
	+ "users" => [
	+ %{
	+ "nickname" => "lain",
	+ "email" => "lain@example.org",
	+ "password" => "test"
	+ },
	+ %{
	+ "nickname" => "lain2",
	+ "email" => "lain2@example.org",
	+ "password" => "test"
	+ }
	+ ]
	+ })
	+
	+ response = json_response(conn, 200) \|> Enum.map(&Map.get(&1, "type"))
	+ assert response == ["success", "success"]
	+ end
	+
	+ test "Cannot create user with exisiting email" 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/users", %{
	+ "users" => [
	+ %{
	+ "nickname" => "lain",
	+ "email" => user.email,
	+ "password" => "test"
	+ }
	+ ]
	})

	- assert json_response(conn, 200) == "lain"
	+ assert json_response(conn, 409) == [
	+ %{
	+ "code" => 409,
	+ "data" => %{
	+ "email" => user.email,
	+ "nickname" => "lain"
	+ },
	+ "error" => "email has already been taken",
	+ "type" => "error"
	+ }
	+ ]
	+ end
	+
	+ test "Cannot create user with exisiting nickname" 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/users", %{
	+ "users" => [
	+ %{
	+ "nickname" => user.nickname,
	+ "email" => "someuser@plerama.social",
	+ "password" => "test"
	+ }
	+ ]
	+ })
	+
	+ assert json_response(conn, 409) == [
	+ %{
	+ "code" => 409,
	+ "data" => %{
	+ "email" => "someuser@plerama.social",
	+ "nickname" => user.nickname
	+ },
	+ "error" => "nickname has already been taken",
	+ "type" => "error"
	+ }
	+ ]
	+ end
	+
	+ test "Multiple user creation works in transaction" 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/users", %{
	+ "users" => [
	+ %{
	+ "nickname" => "newuser",
	+ "email" => "newuser@pleroma.social",
	+ "password" => "test"
	+ },
	+ %{
	+ "nickname" => "lain",
	+ "email" => user.email,
	+ "password" => "test"
	+ }
	+ ]
	+ })
	+
	+ assert json_response(conn, 409) == [
	+ %{
	+ "code" => 409,
	+ "data" => %{
	+ "email" => user.email,
	+ "nickname" => "lain"
	+ },
	+ "error" => "email has already been taken",
	+ "type" => "error"
	+ },
	+ %{
	+ "code" => 409,
	+ "data" => %{
	+ "email" => "newuser@pleroma.social",
	+ "nickname" => "newuser"
	+ },
	+ "error" => "",
	+ "type" => "error"
	+ }
	+ ]
	+
	+ assert User.get_by_nickname("newuser") === nil
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}

	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/users/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/users/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/users/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/users/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/users/:nickname/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/users/#{admin.nickname}/permission_group/")

	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/users/#{user.nickname}/permission_group/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/users/#{user.nickname}/permission_group/admin")

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

	describe "PUT /api/pleroma/admin/users/:nickname/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/users/#{user.nickname}/activation_status", %{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/users/#{user.nickname}/activation_status", %{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/users/#{user.nickname}/activation_status", %{status: false})

	assert json_response(conn, :forbidden)
	end
	end

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

	clear_config([:instance, :registrations_open]) do
	Pleroma.Config.put([:instance, :registrations_open], false)
	end

	clear_config([:instance, :invites_enabled]) do
	Pleroma.Config.put([:instance, :invites_enabled], 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/users/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/users/email_invite?email=foo@bar.com&name=JD")

	assert json_response(conn, :forbidden)
	end
	end

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

	clear_config([:instance, :registrations_open])
	clear_config([:instance, :invites_enabled])

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/users/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
	Pleroma.Config.put([:instance, :registrations_open], true)
	Pleroma.Config.put([:instance, :invites_enabled], true)

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

	assert json_response(conn, :internal_server_error)
	end
	end

	test "/api/pleroma/admin/users/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/users/invite_token")

	assert conn.status == 200
	end

	test "/api/pleroma/admin/users/:nickname/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/users/#{user.nickname}/password_reset")

	assert conn.status == 200
	end

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

	conn =
	build_conn()
	\|> assign(:user, admin)

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

	users =
	[
	%{
	"deactivated" => admin.info.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname)
	},
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => false,
	"tags" => ["foo", "bar"],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

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

	test "renders empty array for the second page", %{conn: conn} do
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?page=2")

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

	test "regular search", %{conn: conn} do
	user = insert(:user, nickname: "bob")

	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	end

	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	end

	test "regular search with page size", %{conn: conn} do
	user = insert(:user, nickname: "aalice")
	user2 = insert(:user, nickname: "alice")

	conn1 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=1")

	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}

	conn2 = get(conn, "/api/pleroma/admin/users?query=a&page_size=1&page=2")

	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" => [],
	"avatar" => User.avatar_url(user2) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user2.name \|\| user2.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	end

	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")

	users =
	[
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	},
	%{
	"deactivated" => admin.info.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname)
	},
	%{
	"deactivated" => false,
	"id" => old_admin.id,
	"local" => true,
	"nickname" => old_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"tags" => [],
	"avatar" => User.avatar_url(old_admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(old_admin.name \|\| old_admin.nickname)
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 3,
	"page_size" => 50,
	"users" => users
	}
	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")

	users =
	[
	%{
	"deactivated" => false,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => admin.local,
	"tags" => [],
	"avatar" => User.avatar_url(admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(admin.name \|\| admin.nickname)
	},
	%{
	"deactivated" => false,
	"id" => second_admin.id,
	"nickname" => second_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => second_admin.local,
	"tags" => [],
	"avatar" => User.avatar_url(second_admin) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(second_admin.name \|\| second_admin.nickname)
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	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" => [],
	"avatar" => User.avatar_url(moderator) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(moderator.name \|\| moderator.nickname)
	}
	]
	}
	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")

	users =
	[
	%{
	"deactivated" => false,
	"id" => user1.id,
	"nickname" => user1.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user1.local,
	"tags" => ["first"],
	"avatar" => User.avatar_url(user1) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user1.name \|\| user1.nickname)
	},
	%{
	"deactivated" => false,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user2.local,
	"tags" => ["second"],
	"avatar" => User.avatar_url(user2) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user2.name \|\| user2.nickname)
	}
	]
	\|> Enum.sort_by(& &1["nickname"])

	assert json_response(conn, 200) == %{
	"count" => 2,
	"page_size" => 50,
	"users" => users
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	]
	}
	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" => [],
	"avatar" => User.avatar_url(user) \|> MediaProxy.url(),
	"display_name" => HTML.strip_tags(user.name \|\| user.nickname)
	}
	end

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

	conn =
	build_conn()
	\|> assign(:user, admin)

	{:ok, conn: conn}
	end

	test "without options", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/users/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", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/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", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/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", %{conn: conn} do
	conn =
	get(conn, "/api/pleroma/admin/users/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/users/invites" do
	setup do
	admin = insert(:user, info: %{is_admin: true})

	conn =
	build_conn()
	\|> assign(:user, admin)

	{:ok, conn: conn}
	end

	test "no invites", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/users/invites")

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

	test "with invite", %{conn: conn} do
	{:ok, invite} = UserInviteToken.create_invite()

	conn = get(conn, "/api/pleroma/admin/users/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/users/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/users/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

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

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

	assert json_response(conn, :not_found) == "Not found"
	end
	end

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

	%{conn: assign(conn, :user, admin)}
	end

	test "returns report by its id", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports/#{report_id}")
	\|> json_response(:ok)

	assert response["id"] == report_id
	end

	test "returns 404 when report id is invalid", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/reports/test")

	assert json_response(conn, :not_found) == "Not found"
	end
	end

	describe "PUT /api/pleroma/admin/reports/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	%{conn: assign(conn, :user, admin), id: report_id}
	end

	test "mark report as resolved", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "resolved"})
	\|> json_response(:ok)

	assert response["state"] == "resolved"
	end

	test "closes report", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "closed"})
	\|> json_response(:ok)

	assert response["state"] == "closed"
	end

	test "returns 400 when state is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> put("/api/pleroma/admin/reports/#{id}", %{"state" => "test"})

	assert json_response(conn, :bad_request) == "Unsupported state"
	end

	test "returns 404 when report is not exist", %{conn: conn} do
	conn =
	conn
	\|> put("/api/pleroma/admin/reports/test", %{"state" => "closed"})

	assert json_response(conn, :not_found) == "Not found"
	end
	end

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

	%{conn: assign(conn, :user, admin)}
	end

	test "returns empty response when no reports created", %{conn: conn} do
	response =
	conn
	\|> get("/api/pleroma/admin/reports")
	\|> json_response(:ok)

	assert Enum.empty?(response["reports"])
	end

	test "returns reports", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> get("/api/pleroma/admin/reports")
	\|> json_response(:ok)

	[report] = response["reports"]

	assert length(response["reports"]) == 1
	assert report["id"] == report_id
	end

	test "returns reports with specified state", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: first_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	{:ok, %{id: second_report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I don't like this user"
	})

	CommonAPI.update_report_state(second_report_id, "closed")

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "open"
	})
	\|> json_response(:ok)

	[open_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert open_report["id"] == first_report_id

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "closed"
	})
	\|> json_response(:ok)

	[closed_report] = response["reports"]

	assert length(response["reports"]) == 1
	assert closed_report["id"] == second_report_id

	response =
	conn
	\|> get("/api/pleroma/admin/reports", %{
	"state" => "resolved"
	})
	\|> json_response(:ok)

	assert Enum.empty?(response["reports"])
	end

	test "returns 403 when requested by a non-admin" do
	user = insert(:user)

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

	assert json_response(conn, :forbidden) == %{"error" => "User is not admin."}
	end

	test "returns 403 when requested by anonymous" do
	conn =
	build_conn()
	\|> get("/api/pleroma/admin/reports")

	assert json_response(conn, :forbidden) == %{"error" => "Invalid credentials."}
	end
	end

	describe "POST /api/pleroma/admin/reports/:id/respond" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	%{conn: assign(conn, :user, admin)}
	end

	test "returns created dm", %{conn: conn} do
	[reporter, target_user] = insert_pair(:user)
	activity = insert(:note_activity, user: target_user)

	{:ok, %{id: report_id}} =
	CommonAPI.report(reporter, %{
	"account_id" => target_user.id,
	"comment" => "I feel offended",
	"status_ids" => [activity.id]
	})

	response =
	conn
	\|> post("/api/pleroma/admin/reports/#{report_id}/respond", %{
	"status" => "I will check it out"
	})
	\|> json_response(:ok)

	recipients = Enum.map(response["mentions"], & &1["username"])

	assert reporter.nickname in recipients
	assert response["content"] == "I will check it out"
	assert response["visibility"] == "direct"
	end

	test "returns 400 when status is missing", %{conn: conn} do
	conn = post(conn, "/api/pleroma/admin/reports/test/respond")

	assert json_response(conn, :bad_request) == "Invalid parameters"
	end

	test "returns 404 when report id is invalid", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/reports/test/respond", %{
	"status" => "foo"
	})

	assert json_response(conn, :not_found) == "Not found"
	end
	end

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

	%{conn: assign(conn, :user, admin), id: activity.id}
	end

	test "toggle sensitive flag", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "true"})
	\|> json_response(:ok)

	assert response["sensitive"]

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"sensitive" => "false"})
	\|> json_response(:ok)

	refute response["sensitive"]
	end

	test "change visibility flag", %{conn: conn, id: id} do
	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "public"})
	\|> json_response(:ok)

	assert response["visibility"] == "public"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "private"})
	\|> json_response(:ok)

	assert response["visibility"] == "private"

	response =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "unlisted"})
	\|> json_response(:ok)

	assert response["visibility"] == "unlisted"
	end

	test "returns 400 when visibility is unknown", %{conn: conn, id: id} do
	conn =
	conn
	\|> put("/api/pleroma/admin/statuses/#{id}", %{"visibility" => "test"})

	assert json_response(conn, :bad_request) == "Unsupported visibility"
	end
	end

	describe "DELETE /api/pleroma/admin/statuses/:id" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})
	activity = insert(:note_activity)

	%{conn: assign(conn, :user, admin), id: activity.id}
	end

	test "deletes status", %{conn: conn, id: id} do
	conn
	\|> delete("/api/pleroma/admin/statuses/#{id}")
	\|> json_response(:ok)

	refute Activity.get_by_id(id)
	end

	test "returns error when status is not exist", %{conn: conn} do
	conn =
	conn
	\|> delete("/api/pleroma/admin/statuses/test")

	assert json_response(conn, :bad_request) == "Could not delete"
	end
	end

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

	%{conn: assign(conn, :user, admin)}
	end

	test "without any settings in db", %{conn: conn} do
	conn = get(conn, "/api/pleroma/admin/config")

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

	test "with settings in db", %{conn: conn} do
	config1 = insert(:config)
	config2 = insert(:config)

	conn = get(conn, "/api/pleroma/admin/config")

	%{
	"configs" => [
	%{
	"key" => key1,
	"value" => _
	},
	%{
	"key" => key2,
	"value" => _
	}
	]
	} = json_response(conn, 200)

	assert key1 == config1.key
	assert key2 == config2.key
	end
	end

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

	temp_file = "config/test.exported_from_db.secret.exs"

	on_exit(fn ->
	Application.delete_env(:pleroma, :key1)
	Application.delete_env(:pleroma, :key2)
	Application.delete_env(:pleroma, :key3)
	Application.delete_env(:pleroma, :key4)
	Application.delete_env(:pleroma, :keyaa1)
	Application.delete_env(:pleroma, :keyaa2)
	Application.delete_env(:pleroma, Pleroma.Web.Endpoint.NotReal)
	Application.delete_env(:pleroma, Pleroma.Captcha.NotReal)
	:ok = File.rm(temp_file)
	end)

	%{conn: assign(conn, :user, admin)}
	end

	clear_config([:instance, :dynamic_configuration]) do
	Pleroma.Config.put([:instance, :dynamic_configuration], true)
	end

	test "create new config setting in db", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: "pleroma", key: "key1", value: "value1"},
	%{
	group: "ueberauth",
	key: "Ueberauth.Strategy.Twitter.OAuth",
	value: [%{"tuple" => [":consumer_secret", "aaaa"]}]
	},
	%{
	group: "pleroma",
	key: "key2",
	value: %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	}
	},
	%{
	group: "pleroma",
	key: "key3",
	value: [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	group: "pleroma",
	key: "key4",
	value: %{":nested_5" => ":upload", "endpoint" => "https://example.com"}
	},
	%{
	group: "idna",
	key: "key5",
	value: %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => "key1",
	"value" => "value1"
	},
	%{
	"group" => "ueberauth",
	"key" => "Ueberauth.Strategy.Twitter.OAuth",
	"value" => [%{"tuple" => [":consumer_secret", "aaaa"]}]
	},
	%{
	"group" => "pleroma",
	"key" => "key2",
	"value" => %{
	":nested_1" => "nested_value1",
	":nested_2" => [
	%{":nested_22" => "nested_value222"},
	%{":nested_33" => %{":nested_44" => "nested_444"}}
	]
	}
	},
	%{
	"group" => "pleroma",
	"key" => "key3",
	"value" => [
	%{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]
	},
	%{
	"group" => "pleroma",
	"key" => "key4",
	"value" => %{"endpoint" => "https://example.com", ":nested_5" => ":upload"}
	},
	%{
	"group" => "idna",
	"key" => "key5",
	"value" => %{"tuple" => ["string", "Pleroma.Captcha.NotReal", []]}
	}
	]
	}

	assert Application.get_env(:pleroma, :key1) == "value1"

	assert Application.get_env(:pleroma, :key2) == %{
	nested_1: "nested_value1",
	nested_2: [
	%{nested_22: "nested_value222"},
	%{nested_33: %{nested_44: "nested_444"}}
	]
	}

	assert Application.get_env(:pleroma, :key3) == [
	%{"nested_3" => :nested_3, "nested_33" => "nested_33"},
	%{"nested_4" => true}
	]

	assert Application.get_env(:pleroma, :key4) == %{
	"endpoint" => "https://example.com",
	nested_5: :upload
	}

	assert Application.get_env(:idna, :key5) == {"string", Pleroma.Captcha.NotReal, []}
	end

	test "update config setting & delete", %{conn: conn} do
	config1 = insert(:config, key: "keyaa1")
	config2 = insert(:config, key: "keyaa2")

	insert(:config,
	group: "ueberauth",
	key: "Ueberauth.Strategy.Microsoft.OAuth",
	value: :erlang.term_to_binary([])
	)

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{group: config1.group, key: config1.key, value: "another_value"},
	%{group: config2.group, key: config2.key, delete: "true"},
	%{
	group: "ueberauth",
	key: "Ueberauth.Strategy.Microsoft.OAuth",
	delete: "true"
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => config1.key,
	"value" => "another_value"
	}
	]
	}

	assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	refute Application.get_env(:pleroma, :keyaa2)
	end

	test "common config example", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => "pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => "Pleroma.Captcha.NotReal",
	"value" => [
	%{"tuple" => [":enabled", false]},
	%{"tuple" => [":method", "Pleroma.Captcha.Kocaptcha"]},
	%{"tuple" => [":seconds_valid", 60]},
	%{"tuple" => [":path", ""]},
	%{"tuple" => [":key1", nil]},
	%{"tuple" => [":partial_chain", "&:hackney_connect.partial_chain/1"]}
	]
	}
	]
	}
	end

	test "tuples with more than two values", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => "pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{
	"tuple" => [
	":key2",
	[
	%{
	"tuple" => [
	":_",
	[
	%{
	"tuple" => [
	"/api/v1/streaming",
	"Pleroma.Web.MastodonAPI.WebsocketHandler",
	[]
	]
	},
	%{
	"tuple" => [
	"/websocket",
	"Phoenix.Endpoint.CowboyWebSocket",
	%{
	"tuple" => [
	"Phoenix.Transports.WebSocket",
	%{
	"tuple" => [
	"Pleroma.Web.Endpoint",
	"Pleroma.Web.UserSocket",
	[]
	]
	}
	]
	}
	]
	},
	%{
	"tuple" => [
	":_",
	"Phoenix.Endpoint.Cowboy2Handler",
	%{"tuple" => ["Pleroma.Web.Endpoint", []]}
	]
	}
	]
	]
	}
	]
	]
	}
	]
	]
	}
	]
	}
	]
	}
	end

	test "settings with nesting map", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => "pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000,
	"nested" => %{
	":max_options" => 20,
	":max_option_chars" => 200,
	":min_expiration" => 0,
	":max_expiration" => 31_536_000
	}
	}
	]
	}
	]
	}
	]
	})

	assert json_response(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => ":key1",
	"value" => [
	%{"tuple" => [":key2", "some_val"]},
	%{
	"tuple" => [
	":key3",
	%{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0,
	"nested" => %{
	":max_expiration" => 31_536_000,
	":max_option_chars" => 200,
	":max_options" => 20,
	":min_expiration" => 0
	}
	}
	]
	}
	]
	}
	]
	}
	end

	test "value as map", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => "pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	})

	assert json_response(conn, 200) ==
	%{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => ":key1",
	"value" => %{"key" => "some_val"}
	}
	]
	}
	end

	test "dispatch setting", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => "pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
	%{"tuple" => [":dispatch", ["{:_,
	[
	{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}"]]}
	]
	]
	}
	]
	}
	]
	})

	dispatch_string =
	"{:_, [{\"/api/v1/streaming\", Pleroma.Web.MastodonAPI.WebsocketHandler, []}, " <>
	"{\"/websocket\", Phoenix.Endpoint.CowboyWebSocket, {Phoenix.Transports.WebSocket, " <>
	"{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, [path: \"/websocket\"]}}}, " <>
	"{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}]}"

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => "Pleroma.Web.Endpoint.NotReal",
	"value" => [
	%{
	"tuple" => [
	":http",
	[
	%{"tuple" => [":ip", %{"tuple" => [127, 0, 0, 1]}]},
	%{
	"tuple" => [
	":dispatch",
	[
	dispatch_string
	]
	]
	}
	]
	]
	}
	]
	}
	]
	}
	end

	test "queues key as atom", %{conn: conn} do
	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	"group" => "pleroma_job_queue",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	]
	}
	]
	})

	assert json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => "pleroma_job_queue",
	"key" => ":queues",
	"value" => [
	%{"tuple" => [":federator_incoming", 50]},
	%{"tuple" => [":federator_outgoing", 50]},
	%{"tuple" => [":web_push", 50]},
	%{"tuple" => [":mailer", 10]},
	%{"tuple" => [":transmogrifier", 20]},
	%{"tuple" => [":scheduled_activities", 10]},
	%{"tuple" => [":background", 5]}
	]
	}
	]
	}
	end

	test "delete part of settings by atom subkeys", %{conn: conn} do
	config =
	insert(:config,
	key: "keyaa1",
	value: :erlang.term_to_binary(subkey1: "val1", subkey2: "val2", subkey3: "val3")
	)

	conn =
	post(conn, "/api/pleroma/admin/config", %{
	configs: [
	%{
	group: config.group,
	key: config.key,
	subkeys: [":subkey1", ":subkey3"],
	delete: "true"
	}
	]
	})

	assert(
	json_response(conn, 200) == %{
	"configs" => [
	%{
	"group" => "pleroma",
	"key" => "keyaa1",
	"value" => [%{"tuple" => [":subkey2", "val2"]}]
	}
	]
	}
	)
	end
	end

	describe "config mix tasks run" do
	setup %{conn: conn} do
	admin = insert(:user, info: %{is_admin: true})

	temp_file = "config/test.exported_from_db.secret.exs"

	Mix.shell(Mix.Shell.Quiet)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	:ok = File.rm(temp_file)
	end)

	%{conn: assign(conn, :user, admin), admin: admin}
	end

	clear_config([:instance, :dynamic_configuration]) do
	Pleroma.Config.put([:instance, :dynamic_configuration], true)
	end

	test "transfer settings to DB and to file", %{conn: conn, admin: admin} do
	assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
	conn = get(conn, "/api/pleroma/admin/config/migrate_to_db")
	assert json_response(conn, 200) == %{}
	assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) > 0

	conn =
	build_conn()
	\|> assign(:user, admin)
	\|> get("/api/pleroma/admin/config/migrate_from_db")

	assert json_response(conn, 200) == %{}
	assert Pleroma.Repo.all(Pleroma.Web.AdminAPI.Config) == []
	end
	end

	describe "GET /api/pleroma/admin/users/:nickname/statuses" do
	setup do
	admin = insert(:user, info: %{is_admin: true})
	user = insert(:user)

	date1 = (DateTime.to_unix(DateTime.utc_now()) + 2000) \|> DateTime.from_unix!()
	date2 = (DateTime.to_unix(DateTime.utc_now()) + 1000) \|> DateTime.from_unix!()
	date3 = (DateTime.to_unix(DateTime.utc_now()) + 3000) \|> DateTime.from_unix!()

	insert(:note_activity, user: user, published: date1)
	insert(:note_activity, user: user, published: date2)
	insert(:note_activity, user: user, published: date3)

	conn =
	build_conn()
	\|> assign(:user, admin)

	{:ok, conn: conn, user: user}
	end

	test "renders user's statuses", %{conn: conn, user: user} do
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")

	assert json_response(conn, 200) \|> length() == 3
	end

	test "renders user's statuses with a limit", %{conn: conn, user: user} do
	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?page_size=2")

	assert json_response(conn, 200) \|> length() == 2
	end

	test "doesn't return private statuses by default", %{conn: conn, user: user} do
	{:ok, _private_status} =
	CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})

	{:ok, _public_status} =
	CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses")

	assert json_response(conn, 200) \|> length() == 4
	end

	test "returns private statuses with godmode on", %{conn: conn, user: user} do
	{:ok, _private_status} =
	CommonAPI.post(user, %{"status" => "private", "visibility" => "private"})

	{:ok, _public_status} =
	CommonAPI.post(user, %{"status" => "public", "visibility" => "public"})

	conn = get(conn, "/api/pleroma/admin/users/#{user.nickname}/statuses?godmode=true")

	assert json_response(conn, 200) \|> length() == 5
	end
	end
	end

	# Needed for testing
	defmodule Pleroma.Web.Endpoint.NotReal do
	end

	defmodule Pleroma.Captcha.NotReal do
	end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Oct 11, 3:33 AM (1 d, 12 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1785564
Default Alt Text: (180 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions