No OneTemporary
Actions

Authored By

Unknown

Size

290 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index 7ecdfe939..89e8adb41 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,160 +1,163 @@
	# Changelog
	All notable changes to this project will be documented in this file.

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

	## [unreleased]
	### Added
	- 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: `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: `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: [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.

	### Changed
	- 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`
	- 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

	### 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/config/config.exs b/config/config.exs
	index f866e8d2b..7f46a8755 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,512 +1,513 @@
	# .i;;;;i.
	# iYcviii;vXY:
	# .YXi .i1c.
	# .YC. . in7.
	# .vc. ...... ;1c.
	# i7, .. .;1;
	# i7, .. ... .Y1i
	# ,7v .6MMM@; .YX,
	# .7;. ..IMMMMMM1 :t7.
	# .;Y. ;$MMMMMM9. :tc.
	# vY. .. .nMMM@MMU. ;1v.
	# i7i ... .#MM@M@C. .....:71i
	# it: .... $MMM@9;.,i;;;i,;tti
	# :t7. ..... 0MMMWv.,iii:::,,;St.
	# .nC. ..... IMMMQ..,::::::,.,czX.
	# .ct: ....... .ZMMMI..,:::::::,,:76Y.
	# c2: ......,i..Y$M@t..:::::::,,..inZY
	# vov ......:ii..c$MBc..,,,,,,,,,,..iI9i
	# i9Y ......iii:..7@MA,..,,,,,,,,,....;AA:
	# iIS. ......:ii::..;@MI....,............;Ez.
	# .I9. ......:i::::...8M1..................C0z.
	# .z9; ......:i::::,.. .i:...................zWX.
	# vbv ......,i::::,,. ................. :AQY
	# c6Y. .,...,::::,,..:t0@@QY. ................ :8bi
	# :6S. ..,,...,:::,,,..EMMMMMMI. ............... .;bZ,
	# :6o, .,,,,..:::,,,..i#MMMMMM#v................. YW2.
	# .n8i ..,,,,,,,::,,,,.. tMMMMM@C:.................. .1Wn
	# 7Uc. .:::,,,,,::,,,,.. i1t;,..................... .UEi
	# 7C...::::::::::::,,,,.. .................... vSi.
	# ;1;...,,::::::,......... .................. Yz:
	# v97,......... .voC.
	# izAotX7777777777777777777777777777777777777777Y7n92:
	# .;CoIIIIIUAA666666699999ZZZZZZZZZZZZZZZZZZZZ6ov.
	#
	# !!! ATTENTION !!!
	# DO NOT EDIT THIS FILE! THIS FILE CONTAINS THE DEFAULT VALUES FOR THE CON-
	# FIGURATION! EDIT YOUR SECRET FILE (either prod.secret.exs, dev.secret.exs).
	#
	# This file is responsible for configuring your application
	# and its dependencies with the aid of the Mix.Config module.
	#
	# This configuration file is loaded before any dependency and
	# is restricted to this project.
	use Mix.Config

	# General application configuration
	config :pleroma, ecto_repos: [Pleroma.Repo]

	config :pleroma, Pleroma.Repo,
	types: Pleroma.PostgresTypes,
	telemetry_event: [Pleroma.Repo.Instrumenter],
	migration_lock: nil

	config :pleroma, Pleroma.Captcha,
	enabled: false,
	seconds_valid: 60,
	method: Pleroma.Captcha.Kocaptcha

	config :pleroma, :hackney_pools,
	federation: [
	max_connections: 50,
	timeout: 150_000
	],
	media: [
	max_connections: 50,
	timeout: 150_000
	],
	upload: [
	max_connections: 25,
	timeout: 300_000
	]

	config :pleroma, Pleroma.Captcha.Kocaptcha, endpoint: "https://captcha.kotobank.ch"

	# Upload configuration
	config :pleroma, Pleroma.Upload,
	uploader: Pleroma.Uploaders.Local,
	filters: [Pleroma.Upload.Filter.Dedupe],
	link_name: true,
	proxy_remote: false,
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	]

	config :pleroma, Pleroma.Uploaders.Local, uploads: "uploads"

	config :pleroma, Pleroma.Uploaders.S3,
	bucket: nil,
	public_endpoint: "https://s3.amazonaws.com"

	config :pleroma, Pleroma.Uploaders.MDII,
	cgi: "https://mdii.sakura.ne.jp/mdii-post.cgi",
	files: "https://mdii.sakura.ne.jp"

	config :pleroma, :emoji,
	shortcode_globs: ["/emoji/custom/*/.png"],
	groups: [
	# Put groups that have higher priority than defaults here. Example in `docs/config/custom_emoji.md`
	Custom: ["/emoji/.png", "/emoji//.png"]
	],
	default_manifest: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json"

	config :pleroma, :uri_schemes,
	valid_schemes: [
	"https",
	"http",
	"dat",
	"dweb",
	"gopher",
	"ipfs",
	"ipns",
	"irc",
	"ircs",
	"magnet",
	"mailto",
	"mumble",
	"ssb",
	"xmpp"
	]

	websocket_config = [
	path: "/websocket",
	serializer: [
	{Phoenix.Socket.V1.JSONSerializer, "~> 1.0.0"},
	{Phoenix.Socket.V2.JSONSerializer, "~> 2.0.0"}
	],
	timeout: 60_000,
	transport_log: false,
	compress: false
	]

	# Configures the endpoint
	config :pleroma, Pleroma.Web.Endpoint,
	instrumenters: [Pleroma.Web.Endpoint.Instrumenter],
	url: [host: "localhost"],
	http: [
	dispatch: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, websocket_config}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	]
	],
	protocol: "https",
	secret_key_base: "aK4Abxf29xU9TTDKre9coZPUgevcVCFQJe/5xP/7Lt4BEif6idBIbjupVbOrbKxl",
	signing_salt: "CqaoopA2",
	render_errors: [view: Pleroma.Web.ErrorView, accepts: ~w(json)],
	pubsub: [name: Pleroma.PubSub, adapter: Phoenix.PubSub.PG2],
	secure_cookie_flag: true,
	extra_cookie_attrs: [
	"SameSite=Lax"
	]

	# Configures Elixir's Logger
	config :logger, :console,
	format: "$time $metadata[$level] $message\n",
	metadata: [:request_id]

	config :logger, :ex_syslogger,
	level: :debug,
	ident: "Pleroma",
	format: "$metadata[$level] $message",
	metadata: [:request_id]

	config :quack,
	level: :warn,
	meta: [:all],
	webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"

	config :mime, :types, %{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"application/jrd+json" => ["jrd+json"],
	"application/activity+json" => ["activity+json"],
	"application/ld+json" => ["activity+json"]
	}

	config :tesla, adapter: Tesla.Adapter.Hackney

	# Configures http settings, upstream proxy etc.
	config :pleroma, :http,
	proxy_url: nil,
	send_user_agent: true,
	adapter: [
	ssl_options: [
	# We don't support TLS v1.3 yet
	versions: [:tlsv1, :"tlsv1.1", :"tlsv1.2"]
	]
	]

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	limit: 5_000,
	remote_limit: 100_000,
	upload_limit: 16_000_000,
	avatar_upload_limit: 2_000_000,
	background_upload_limit: 4_000_000,
	banner_upload_limit: 4_000_000,
	poll_limits: %{
	max_options: 20,
	max_option_chars: 200,
	min_expiration: 0,
	max_expiration: 365 * 24 * 60 * 60
	},
	registrations_open: true,
	federating: true,
	federation_reachability_timeout_days: 7,
	federation_publisher_modules: [
	Pleroma.Web.ActivityPub.Publisher,
	Pleroma.Web.Websub,
	Pleroma.Web.Salmon
	],
	allow_relay: true,
	rewrite_policy: Pleroma.Web.ActivityPub.MRF.NoOpPolicy,
	public: true,
	quarantined_instances: [],
	managed_config: true,
	static_dir: "instance/static/",
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	],
	mrf_transparency: true,
	autofollowed_nicknames: [],
	max_pinned_statuses: 1,
	no_attachment_links: false,
	welcome_user_nickname: nil,
	welcome_message: nil,
	max_report_comment_size: 1000,
	safe_dm_mentions: false,
	healthcheck: false,
	remote_post_retention_days: 90,
	skip_thread_containment: true,
	- limit_to_local_content: :unauthenticated
	+ limit_to_local_content: :unauthenticated,
	+ dynamic_configuration: false

	config :pleroma, :markup,
	# XXX - unfortunately, inline images must be enabled by default right now, because
	# of custom emoji. Issue #275 discusses defanging that somehow.
	allow_inline_images: true,
	allow_headings: false,
	allow_tables: false,
	allow_fonts: false,
	scrub_policy: [
	Pleroma.HTML.Transform.MediaProxy,
	Pleroma.HTML.Scrubber.Default
	]

	config :pleroma, :frontend_configurations,
	pleroma_fe: %{
	theme: "pleroma-dark",
	logo: "/static/logo.png",
	background: "/images/city.jpg",
	redirectRootNoLogin: "/main/all",
	redirectRootLogin: "/main/friends",
	showInstanceSpecificPanel: true,
	scopeOptionsEnabled: false,
	formattingOptionsEnabled: false,
	collapseMessageWithSubject: false,
	hidePostStats: false,
	hideUserStats: false,
	scopeCopy: true,
	subjectLineBehavior: "email",
	alwaysShowSubjectInput: true
	},
	masto_fe: %{
	showInstanceSpecificPanel: true
	}

	config :pleroma, :assets,
	mascots: [
	pleroma_fox_tan: %{
	url: "/images/pleroma-fox-tan-smol.png",
	mime_type: "image/png"
	},
	pleroma_fox_tan_shy: %{
	url: "/images/pleroma-fox-tan-shy.png",
	mime_type: "image/png"
	}
	],
	default_mascot: :pleroma_fox_tan

	config :pleroma, :activitypub,
	accept_blocks: true,
	unfollow_blocked: true,
	outgoing_blocks: true,
	follow_handshake_timeout: 500

	config :pleroma, :user, deny_follow_blocked: true

	config :pleroma, :mrf_normalize_markup, scrub_policy: Pleroma.HTML.Scrubber.Default

	config :pleroma, :mrf_rejectnonpublic,
	allow_followersonly: false,
	allow_direct: false

	config :pleroma, :mrf_hellthread,
	delist_threshold: 10,
	reject_threshold: 20

	config :pleroma, :mrf_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	report_removal: [],
	reject: [],
	accept: [],
	avatar_removal: [],
	banner_removal: []

	config :pleroma, :mrf_keyword,
	reject: [],
	federated_timeline_removal: [],
	replace: []

	config :pleroma, :mrf_subchain, match_actor: %{}

	config :pleroma, :rich_media, enabled: true

	config :pleroma, :media_proxy,
	enabled: false,
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	http: [
	follow_redirect: true,
	pool: :media
	]
	],
	whitelist: []

	config :pleroma, :chat, enabled: true

	config :phoenix, :format_encoders, json: Jason

	config :pleroma, :gopher,
	enabled: false,
	ip: {0, 0, 0, 0},
	port: 9999

	config :pleroma, Pleroma.Web.Metadata,
	providers: [Pleroma.Web.Metadata.Providers.RelMe],
	unfurl_nsfw: false

	config :pleroma, :suggestions,
	enabled: false,
	third_party_engine:
	"http://vinayaka.distsn.org/cgi-bin/vinayaka-user-match-suggestions-api.cgi?{{host}}+{{user}}",
	timeout: 300_000,
	limit: 40,
	web: "https://vinayaka.distsn.org"

	config :pleroma, :http_security,
	enabled: true,
	sts: false,
	sts_max_age: 31_536_000,
	ct_max_age: 2_592_000,
	referrer_policy: "same-origin"

	config :cors_plug,
	max_age: 86_400,
	methods: ["POST", "PUT", "DELETE", "GET", "PATCH", "OPTIONS"],
	expose: [
	"Link",
	"X-RateLimit-Reset",
	"X-RateLimit-Limit",
	"X-RateLimit-Remaining",
	"X-Request-Id",
	"Idempotency-Key"
	],
	credentials: true,
	headers: ["Authorization", "Content-Type", "Idempotency-Key"]

	config :pleroma, Pleroma.User,
	restricted_nicknames: [
	".well-known",
	"~",
	"about",
	"activities",
	"api",
	"auth",
	"check_password",
	"dev",
	"friend-requests",
	"inbox",
	"internal",
	"main",
	"media",
	"nodeinfo",
	"notice",
	"oauth",
	"objects",
	"ostatus_subscribe",
	"pleroma",
	"proxy",
	"push",
	"registration",
	"relay",
	"settings",
	"status",
	"tag",
	"user-search",
	"user_exists",
	"users",
	"web"
	]

	config :pleroma, Pleroma.Web.Federator.RetryQueue,
	enabled: false,
	max_jobs: 20,
	initial_timeout: 30,
	max_retries: 5

	config :pleroma_job_queue, :queues,
	federator_incoming: 50,
	federator_outgoing: 50,
	web_push: 50,
	mailer: 10,
	transmogrifier: 20,
	scheduled_activities: 10,
	background: 5

	config :pleroma, :fetch_initial_posts,
	enabled: false,
	pages: 5

	config :auto_linker,
	opts: [
	scheme: true,
	extra: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: false
	]

	config :pleroma, :ldap,
	enabled: System.get_env("LDAP_ENABLED") == "true",
	host: System.get_env("LDAP_HOST") \|\| "localhost",
	port: String.to_integer(System.get_env("LDAP_PORT") \|\| "389"),
	ssl: System.get_env("LDAP_SSL") == "true",
	sslopts: [],
	tls: System.get_env("LDAP_TLS") == "true",
	tlsopts: [],
	base: System.get_env("LDAP_BASE") \|\| "dc=example,dc=com",
	uid: System.get_env("LDAP_UID") \|\| "cn"

	config :esshd,
	enabled: false

	oauth_consumer_strategies =
	System.get_env("OAUTH_CONSUMER_STRATEGIES")
	\|> to_string()
	\|> String.split()
	\|> Enum.map(&hd(String.split(&1, ":")))

	ueberauth_providers =
	for strategy <- oauth_consumer_strategies do
	strategy_module_name = "Elixir.Ueberauth.Strategy.#{String.capitalize(strategy)}"
	strategy_module = String.to_atom(strategy_module_name)
	{String.to_atom(strategy), {strategy_module, [callback_params: ["state"]]}}
	end

	config :ueberauth,
	Ueberauth,
	base_path: "/oauth",
	providers: ueberauth_providers

	config :pleroma, :auth, oauth_consumer_strategies: oauth_consumer_strategies

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Sendmail

	config :prometheus, Pleroma.Web.Endpoint.MetricsExporter, path: "/api/pleroma/app_metrics"

	config :pleroma, Pleroma.ScheduledActivity,
	daily_user_limit: 25,
	total_user_limit: 300,
	enabled: true

	config :pleroma, :oauth2,
	token_expires_in: 600,
	issue_new_refresh_token: true,
	clean_expired_tokens: false,
	clean_expired_tokens_interval: 86_400_000

	config :pleroma, :database, rum_enabled: false

	config :pleroma, :env, Mix.env()

	config :http_signatures,
	adapter: Pleroma.Signature

	config :pleroma, :rate_limit,
	search: [{1000, 10}, {1000, 30}],
	app_account_creation: {1_800_000, 25}

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env()}.exs"
	diff --git a/config/dev.exs b/config/dev.exs
	index 0432adce7..71b11f7c3 100644
	--- a/config/dev.exs
	+++ b/config/dev.exs
	@@ -1,61 +1,64 @@
	use Mix.Config

	# For development, we disable any cache and enable
	# debugging and code reloading.
	#
	# The watchers configuration can be used to run external
	# watchers to your application. For example, we use it
	# with brunch.io to recompile .js and .css sources.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [
	port: 4000,
	protocol_options: [max_request_line_length: 8192, max_header_value_length: 8192]
	],
	protocol: "http",
	debug_errors: true,
	code_reloader: true,
	check_origin: false,
	watchers: [],
	secure_cookie_flag: false

	config :pleroma, Pleroma.Emails.Mailer, adapter: Swoosh.Adapters.Local

	# ## SSL Support
	#
	# In order to use HTTPS in development, a self-signed
	# certificate can be generated by running the following
	# command from your terminal:
	#
	# openssl req -new -newkey rsa:4096 -days 365 -nodes -x509 -subj "/C=US/ST=Denial/L=Springfield/O=Dis/CN=www.example.com" -keyout priv/server.key -out priv/server.pem
	#
	# The `http:` config above can be replaced with:
	#
	# https: [port: 4000, keyfile: "priv/server.key", certfile: "priv/server.pem"],
	#
	# If desired, both `http:` and `https:` keys can be
	# configured to run both http and https servers on
	# different ports.

	# Do not include metadata nor timestamps in development logs
	config :logger, :console, format: "[$level] $message\n"

	# Set a higher stacktrace during development. Avoid configuring such
	# in production as building large stacktraces may be expensive.
	config :phoenix, :stacktrace_depth, 20

	# Configure your database
	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "postgres",
	password: "postgres",
	database: "pleroma_dev",
	hostname: "localhost",
	pool_size: 10

	if File.exists?("./config/dev.secret.exs") do
	import_config "dev.secret.exs"
	else
	IO.puts(
	"!!! RUNNING IN LOCALHOST DEV MODE! !!!\nFEDERATION WON'T WORK UNTIL YOU CONFIGURE A dev.secret.exs"
	)
	end
	+
	+if File.exists?("./config/dev.migrated.secret.exs"),
	+ do: import_config("./config/dev.migrated.secret.exs")
	diff --git a/config/prod.exs b/config/prod.exs
	index bf1a97de0..42edccf64 100644
	--- a/config/prod.exs
	+++ b/config/prod.exs
	@@ -1,65 +1,68 @@
	use Mix.Config

	# For production, we often load configuration from external
	# sources, such as your system environment. For this reason,
	# you won't find the :http configuration below, but set inside
	# Pleroma.Web.Endpoint.load_from_system_env/1 dynamically.
	# Any dynamic configuration should be moved to such function.
	#
	# Don't forget to configure the url host to something meaningful,
	# Phoenix uses this information when generating URLs.
	#
	# Finally, we also include the path to a cache manifest
	# containing the digested version of static files. This
	# manifest is generated by the mix phoenix.digest task
	# which you typically run after static files are built.
	config :pleroma, Pleroma.Web.Endpoint,
	http: [port: 4000],
	protocol: "http"

	config :phoenix, serve_endpoints: true

	# Do not print debug messages in production
	config :logger, level: :warn

	# ## SSL Support
	#
	# To get SSL working, you will need to add the `https` key
	# to the previous section and set your `:url` port to 443:
	#
	# config :pleroma, Pleroma.Web.Endpoint,
	# ...
	# url: [host: "example.com", port: 443],
	# https: [:inet6,
	# port: 443,
	# keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"),
	# certfile: System.get_env("SOME_APP_SSL_CERT_PATH")]
	#
	# Where those two env variables return an absolute path to
	# the key and cert in disk or a relative path inside priv,
	# for example "priv/ssl/server.key".
	#
	# We also recommend setting `force_ssl`, ensuring no data is
	# ever sent via http, always redirecting to https:
	#
	# config :pleroma, Pleroma.Web.Endpoint,
	# force_ssl: [hsts: true]
	#
	# Check `Plug.SSL` for all available options in `force_ssl`.

	# ## Using releases
	#
	# If you are doing OTP releases, you need to instruct Phoenix
	# to start the server for all endpoints:
	#
	# config :phoenix, :serve_endpoints, true
	#
	# Alternatively, you can configure exactly which server to
	# start per endpoint:
	#
	# config :pleroma, Pleroma.Web.Endpoint, server: true
	#

	# Finally import the config/prod.secret.exs
	# which should be versioned separately.
	import_config "prod.secret.exs"
	+
	+if File.exists?("./config/prod.migrated.secret.exs"),
	+ do: import_config("./config/prod.migrated.secret.exs")
	diff --git a/docs/api/admin_api.md b/docs/api/admin_api.md
	index b45c5e285..5dcc8d059 100644
	--- a/docs/api/admin_api.md
	+++ b/docs/api/admin_api.md
	@@ -1,559 +1,639 @@
	# Admin API

	Authentication is required and the user must be an admin.

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

	### List users

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

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

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

	### Remove a user

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

	### Create a user

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

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

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

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

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

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

	### Toggle user activation

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

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

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

	### Tag a list of users

	- Method: `PUT`
	- Params:
	- `nicknames` (array)
	- `tags` (array)

	### Untag a list of users

	- Method: `DELETE`
	- Params:
	- `nicknames` (array)
	- `tags` (array)

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

	### Get user user permission groups membership

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

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

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

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

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

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

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

	### Add user in permission group

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

	### Remove user from permission group

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

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

	### Active or deactivate a user

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

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

	### Retrive the details of a user

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

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

	### Follow a Relay

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

	### Unfollow a Relay

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

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

	### Get an account registration invite token

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

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

	### Get a list of generated invites

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

	```json
	{

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

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

	### Revoke invite by token

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

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

	}
	```


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

	### Sends registration invite via email

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

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

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

	- Methods: `GET`
	- Params: none
	- Response: password reset token (base64 string)

	## `/api/pleroma/admin/reports`
	### Get a list of reports
	- Method `GET`
	- Params:
	- `state`: optional, the state of reports. Valid values are `open`, `closed` and `resolved`
	- `limit`: optional, the number of records to retrieve
	- `since_id`: optional, returns results that are more recent than the specified id
	- `max_id`: optional, returns results that are older than the specified id
	-- Response:
	+- Response:
	- On failure: 403 Forbidden error `{"error": "error_msg"}` when requested by anonymous or non-admin
	- On success: JSON, returns a list of reports, where:
	- `account`: the user who has been reported
	- `actor`: the user who has sent the report
	- `statuses`: list of statuses that have been included to the report

	```json
	{
	"reports": [
	{
	"account": {
	"acct": "user",
	"avatar": "https://pleroma.example.org/images/avi.png",
	"avatar_static": "https://pleroma.example.org/images/avi.png",
	"bot": false,
	"created_at": "2019-04-23T17:32:04.000Z",
	"display_name": "User",
	"emojis": [],
	"fields": [],
	"followers_count": 1,
	"following_count": 1,
	"header": "https://pleroma.example.org/images/banner.png",
	"header_static": "https://pleroma.example.org/images/banner.png",
	"id": "9i6dAJqSGSKMzLG2Lo",
	"locked": false,
	"note": "",
	"pleroma": {
	"confirmation_pending": false,
	"hide_favorites": true,
	"hide_followers": false,
	"hide_follows": false,
	"is_admin": false,
	"is_moderator": false,
	"relationship": {},
	"tags": []
	},
	"source": {
	"note": "",
	"pleroma": {},
	"sensitive": false
	},
	"statuses_count": 3,
	"url": "https://pleroma.example.org/users/user",
	"username": "user"
	},
	"actor": {
	"acct": "lain",
	"avatar": "https://pleroma.example.org/images/avi.png",
	"avatar_static": "https://pleroma.example.org/images/avi.png",
	"bot": false,
	"created_at": "2019-03-28T17:36:03.000Z",
	"display_name": "Roger Braun",
	"emojis": [],
	"fields": [],
	"followers_count": 1,
	"following_count": 1,
	"header": "https://pleroma.example.org/images/banner.png",
	"header_static": "https://pleroma.example.org/images/banner.png",
	"id": "9hEkA5JsvAdlSrocam",
	"locked": false,
	"note": "",
	"pleroma": {
	"confirmation_pending": false,
	"hide_favorites": false,
	"hide_followers": false,
	"hide_follows": false,
	"is_admin": false,
	"is_moderator": false,
	"relationship": {},
	"tags": []
	},
	"source": {
	"note": "",
	"pleroma": {},
	"sensitive": false
	},
	"statuses_count": 1,
	"url": "https://pleroma.example.org/users/lain",
	"username": "lain"
	},
	"content": "Please delete it",
	"created_at": "2019-04-29T19:48:15.000Z",
	"id": "9iJGOv1j8hxuw19bcm",
	"state": "open",
	"statuses": [
	{
	"account": { ... },
	"application": {
	"name": "Web",
	"website": null
	},
	"bookmarked": false,
	"card": null,
	"content": "<span class=\"h-card\"><a data-user=\"9hEkA5JsvAdlSrocam\" class=\"u-url mention\" href=\"https://pleroma.example.org/users/lain\">@<span>lain</span></a></span> click on my link <a href=\"https://www.google.com/\">https://www.google.com/</a>",
	"created_at": "2019-04-23T19:15:47.000Z",
	"emojis": [],
	"favourited": false,
	"favourites_count": 0,
	"id": "9i6mQ9uVrrOmOime8m",
	"in_reply_to_account_id": null,
	"in_reply_to_id": null,
	"language": null,
	"media_attachments": [],
	"mentions": [
	{
	"acct": "lain",
	"id": "9hEkA5JsvAdlSrocam",
	"url": "https://pleroma.example.org/users/lain",
	"username": "lain"
	},
	{
	"acct": "user",
	"id": "9i6dAJqSGSKMzLG2Lo",
	"url": "https://pleroma.example.org/users/user",
	"username": "user"
	}
	],
	"muted": false,
	"pinned": false,
	"pleroma": {
	"content": {
	"text/plain": "@lain click on my link https://www.google.com/"
	},
	"conversation_id": 28,
	"in_reply_to_account_acct": null,
	"local": true,
	"spoiler_text": {
	"text/plain": ""
	}
	},
	"reblog": null,
	"reblogged": false,
	"reblogs_count": 0,
	"replies_count": 0,
	"sensitive": false,
	"spoiler_text": "",
	"tags": [],
	"uri": "https://pleroma.example.org/objects/8717b90f-8e09-4b58-97b0-e3305472b396",
	"url": "https://pleroma.example.org/notice/9i6mQ9uVrrOmOime8m",
	"visibility": "direct"
	}
	]
	}
	]
	}
	```

	## `/api/pleroma/admin/reports/:id`
	### Get an individual report
	- Method `GET`
	- Params:
	- `id`
	- Response:
	- - On failure:
	+ - On failure:
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, Report object (see above)

	## `/api/pleroma/admin/reports/:id`
	### Change the state of the report
	- Method `PUT`
	- Params:
	- `id`
	- `state`: required, the new state. Valid values are `open`, `closed` and `resolved`
	-- Response:
	- - On failure:
	+- Response:
	+ - On failure:
	- 400 Bad Request `"Unsupported state"`
	- 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, Report object (see above)

	## `/api/pleroma/admin/reports/:id/respond`
	### Respond to a report
	- Method `POST`
	- Params:
	- `id`
	- `status`: required, the message
	-- Response:
	- - On failure:
	- - 400 Bad Request `"Invalid parameters"` when `status` is missing
	- - 403 Forbidden `{"error": "error_msg"}`
	+- Response:
	+ - On failure:
	+ - 400 Bad Request `"Invalid parameters"` when `status` is missing
	+ - 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, created Mastodon Status entity

	```json
	{
	"account": { ... },
	"application": {
	"name": "Web",
	"website": null
	},
	"bookmarked": false,
	"card": null,
	"content": "Your claim is going to be closed",
	"created_at": "2019-05-11T17:13:03.000Z",
	"emojis": [],
	"favourited": false,
	"favourites_count": 0,
	"id": "9ihuiSL1405I65TmEq",
	"in_reply_to_account_id": null,
	"in_reply_to_id": null,
	"language": null,
	"media_attachments": [],
	"mentions": [
	{
	"acct": "user",
	"id": "9i6dAJqSGSKMzLG2Lo",
	"url": "https://pleroma.example.org/users/user",
	"username": "user"
	},
	{
	"acct": "admin",
	"id": "9hEkA5JsvAdlSrocam",
	"url": "https://pleroma.example.org/users/admin",
	"username": "admin"
	}
	],
	"muted": false,
	"pinned": false,
	"pleroma": {
	"content": {
	"text/plain": "Your claim is going to be closed"
	},
	"conversation_id": 35,
	"in_reply_to_account_acct": null,
	"local": true,
	"spoiler_text": {
	"text/plain": ""
	}
	},
	"reblog": null,
	"reblogged": false,
	"reblogs_count": 0,
	"replies_count": 0,
	"sensitive": false,
	"spoiler_text": "",
	"tags": [],
	"uri": "https://pleroma.example.org/objects/cab0836d-9814-46cd-a0ea-529da9db5fcb",
	"url": "https://pleroma.example.org/notice/9ihuiSL1405I65TmEq",
	"visibility": "direct"
	}
	```

	## `/api/pleroma/admin/statuses/:id`
	### Change the scope of an individual reported status
	- Method `PUT`
	- Params:
	- `id`
	- `sensitive`: optional, valid values are `true` or `false`
	- `visibility`: optional, valid values are `public`, `private` and `unlisted`
	-- Response:
	- - On failure:
	+- Response:
	+ - On failure:
	- 400 Bad Request `"Unsupported visibility"`
	- - 403 Forbidden `{"error": "error_msg"}`
	+ - 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: JSON, Mastodon Status entity

	## `/api/pleroma/admin/statuses/:id`
	### Delete an individual reported status
	- Method `DELETE`
	- Params:
	- `id`
	-- Response:
	- - On failure:
	- - 403 Forbidden `{"error": "error_msg"}`
	+- Response:
	+ - On failure:
	+ - 403 Forbidden `{"error": "error_msg"}`
	- 404 Not Found `"Not found"`
	- On success: 200 OK `{}`
	+
	+## `/api/pleroma/admin/config`
	+### List config settings
	+- Method `GET`
	+- Params: none
	+- Response:
	+
	+```json
	+{
	+ configs: [
	+ {
	+ "key": string,
	+ "value": string or {} or []
	+ }
	+ ]
	+}
	+```
	+
	+## `/api/pleroma/admin/config`
	+### Update config settings
	+Module name can be passed as string, which starts with `Pleroma`, e.g. `"Pleroma.Upload"`.
	+Atom or boolean value can be passed with `:` in the beginning, e.g. `":true"`, `":upload"`.
	+Integer with `i:`, e.g. `"i:150"`.
	+
	+Compile time settings (need instance reboot):
	+- all settings by this keys:
	+ - `:hackney_pools`
	+ - `:chat`
	+ - `Pleroma.Web.Endpoint`
	+ - `Pleroma.Repo`
	+- part settings:
	+ - `Pleroma.Captcha` -> `:seconds_valid`
	+ - `Pleroma.Upload` -> `:proxy_remote`
	+ - `:instance` -> `:upload_limit`
	+
	+- Method `POST`
	+- Params:
	+ - `configs` => [
	+ - `key` (string)
	+ - `value` (string, [], {})
	+ - `delete` = true (optional, if parameter must be deleted)
	+ ]
	+
	+- Request (example):
	+
	+```json
	+{
	+ configs: [
	+ {
	+ "key": "Pleroma.Upload",
	+ "value": {
	+ "uploader": "Pleroma.Uploaders.Local",
	+ "filters": ["Pleroma.Upload.Filter.Dedupe"],
	+ "link_name": ":true",
	+ "proxy_remote": ":false",
	+ "proxy_opts": {
	+ "redirect_on_failure": ":false",
	+ "max_body_length": "i:1048576",
	+ "http": {
	+ "follow_redirect": ":true",
	+ "pool": ":upload"
	+ }
	+ }
	+ }
	+ }
	+ ]
	+}
	+
	+- Response:
	+
	+```json
	+{
	+ configs: [
	+ {
	+ "key": string,
	+ "value": string or {} or []
	+ }
	+ ]
	+}
	+```
	diff --git a/docs/config.md b/docs/config.md
	index 2b0f5726b..ed8e465c6 100644
	--- a/docs/config.md
	+++ b/docs/config.md
	@@ -1,625 +1,626 @@
	# Configuration

	This file describe the configuration, it is recommended to edit the relevant *.secret.exs file instead of the others founds in the ``config`` directory.
	If you run Pleroma with ``MIX_ENV=prod`` the file is ``prod.secret.exs``, otherwise it is ``dev.secret.exs``.

	## Pleroma.Upload
	* `uploader`: Select which `Pleroma.Uploaders` to use
	* `filters`: List of `Pleroma.Upload.Filter` to use.
	* `link_name`: When enabled Pleroma will add a `name` parameter to the url of the upload, for example `https://instance.tld/media/corndog.png?name=corndog.png`. This is needed to provide the correct filename in Content-Disposition headers when using filters like `Pleroma.Upload.Filter.Dedupe`
	* `base_url`: The base URL to access a user-uploaded file. Useful when you want to proxy the media files via another host.
	* `proxy_remote`: If you\'re using a remote uploader, Pleroma will proxy media requests instead of redirecting to it.
	* `proxy_opts`: Proxy options, see `Pleroma.ReverseProxy` documentation.

	Note: `strip_exif` has been replaced by `Pleroma.Upload.Filter.Mogrify`.

	## Pleroma.Uploaders.Local
	* `uploads`: Which directory to store the user-uploads in, relative to pleroma’s working directory

	## Pleroma.Upload.Filter.Mogrify

	* `args`: List of actions for the `mogrify` command like `"strip"` or `["strip", "auto-orient", {"impode", "1"}]`.

	## Pleroma.Upload.Filter.Dedupe

	No specific configuration.

	## Pleroma.Upload.Filter.AnonymizeFilename

	This filter replaces the filename (not the path) of an upload. For complete obfuscation, add
	`Pleroma.Upload.Filter.Dedupe` before AnonymizeFilename.

	* `text`: Text to replace filenames in links. If empty, `{random}.extension` will be used.

	## Pleroma.Emails.Mailer
	* `adapter`: one of the mail adapters listed in [Swoosh readme](https://github.com/swoosh/swoosh#adapters), or `Swoosh.Adapters.Local` for in-memory mailbox.
	* `api_key` / `password` and / or other adapter-specific settings, per the above documentation.

	An example for Sendgrid adapter:

	```elixir
	config :pleroma, Pleroma.Emails.Mailer,
	adapter: Swoosh.Adapters.Sendgrid,
	api_key: "YOUR_API_KEY"
	```

	An example for SMTP adapter:

	```elixir
	config :pleroma, Pleroma.Emails.Mailer,
	adapter: Swoosh.Adapters.SMTP,
	relay: "smtp.gmail.com",
	username: "YOUR_USERNAME@gmail.com",
	password: "YOUR_SMTP_PASSWORD",
	port: 465,
	ssl: true,
	tls: :always,
	auth: :always
	```

	## :uri_schemes
	* `valid_schemes`: List of the scheme part that is considered valid to be an URL

	## :instance
	* `name`: The instance’s name
	* `email`: Email used to reach an Administrator/Moderator of the instance
	* `notify_email`: Email used for notifications.
	* `description`: The instance’s description, can be seen in nodeinfo and ``/api/v1/instance``
	* `limit`: Posts character limit (CW/Subject included in the counter)
	* `remote_limit`: Hard character limit beyond which remote posts will be dropped.
	* `upload_limit`: File size limit of uploads (except for avatar, background, banner)
	* `avatar_upload_limit`: File size limit of user’s profile avatars
	* `background_upload_limit`: File size limit of user’s profile backgrounds
	* `banner_upload_limit`: File size limit of user’s profile banners
	* `poll_limits`: A map with poll limits for local polls
	* `max_options`: Maximum number of options
	* `max_option_chars`: Maximum number of characters per option
	* `min_expiration`: Minimum expiration time (in seconds)
	* `max_expiration`: Maximum expiration time (in seconds)
	* `registrations_open`: Enable registrations for anyone, invitations can be enabled when false.
	* `invites_enabled`: Enable user invitations for admins (depends on `registrations_open: false`).
	* `account_activation_required`: Require users to confirm their emails before signing in.
	* `federating`: Enable federation with other instances
	* `federation_reachability_timeout_days`: Timeout (in days) of each external federation target being unreachable prior to pausing federating to it.
	* `allow_relay`: Enable Pleroma’s Relay, which makes it possible to follow a whole instance
	* `rewrite_policy`: Message Rewrite Policy, either one or a list. Here are the ones available by default:
	* `Pleroma.Web.ActivityPub.MRF.NoOpPolicy`: Doesn’t modify activities (default)
	* `Pleroma.Web.ActivityPub.MRF.DropPolicy`: Drops all activities. It generally doesn’t makes sense to use in production
	* `Pleroma.Web.ActivityPub.MRF.SimplePolicy`: Restrict the visibility of activities from certains instances (See ``:mrf_simple`` section)
	* `Pleroma.Web.ActivityPub.MRF.TagPolicy`: Applies policies to individual users based on tags, which can be set using pleroma-fe/admin-fe/any other app that supports Pleroma Admin API. For example it allows marking posts from individual users nsfw (sensitive)
	* `Pleroma.Web.ActivityPub.MRF.SubchainPolicy`: Selectively runs other MRF policies when messages match (see ``:mrf_subchain`` section)
	* `Pleroma.Web.ActivityPub.MRF.RejectNonPublic`: Drops posts with non-public visibility settings (See ``:mrf_rejectnonpublic`` section)
	* `Pleroma.Web.ActivityPub.MRF.EnsureRePrepended`: Rewrites posts to ensure that replies to posts with subjects do not have an identical subject and instead begin with re:.
	* `public`: Makes the client API in authentificated mode-only except for user-profiles. Useful for disabling the Local Timeline and The Whole Known Network.
	* `quarantined_instances`: List of ActivityPub instances where private(DMs, followers-only) activities will not be send.
	* `managed_config`: Whenether the config for pleroma-fe is configured in this config or in ``static/config.json``
	* `allowed_post_formats`: MIME-type list of formats allowed to be posted (transformed into HTML)
	* `mrf_transparency`: Make the content of your Message Rewrite Facility settings public (via nodeinfo).
	* `scope_copy`: Copy the scope (private/unlisted/public) in replies to posts by default.
	* `subject_line_behavior`: Allows changing the default behaviour of subject lines in replies. Valid values:
	* "email": Copy and preprend re:, as in email.
	* "masto": Copy verbatim, as in Mastodon.
	* "noop": Don't copy the subject.
	* `always_show_subject_input`: When set to false, auto-hide the subject field when it's empty.
	* `extended_nickname_format`: Set to `true` to use extended local nicknames format (allows underscores/dashes). This will break federation with
	older software for theses nicknames.
	* `max_pinned_statuses`: The maximum number of pinned statuses. `0` will disable the feature.
	* `autofollowed_nicknames`: Set to nicknames of (local) users that every new user should automatically follow.
	* `no_attachment_links`: Set to true to disable automatically adding attachment link text to statuses
	* `welcome_message`: A message that will be send to a newly registered users as a direct message.
	* `welcome_user_nickname`: The nickname of the local user that sends the welcome message.
	* `max_report_comment_size`: The maximum size of the report comment (Default: `1000`)
	* `safe_dm_mentions`: If set to true, only mentions at the beginning of a post will be used to address people in direct messages. This is to prevent accidental mentioning of people when talking about them (e.g. "@friend hey i really don't like @enemy"). Default: `false`.
	* `healthcheck`: If set to true, system data will be shown on ``/api/pleroma/healthcheck``.
	* `remote_post_retention_days`: The default amount of days to retain remote posts when pruning the database.
	* `skip_thread_containment`: Skip filter out broken threads. The default is `false`.
	* `limit_to_local_content`: Limit unauthenticated users to search for local statutes and users only. Possible values: `:unauthenticated`, `:all` and `false`. The default is `:unauthenticated`.
	+* `dynamic_configuration`: Allow transferring configuration to DB with the subsequent customization from Admin api.


	## :logger
	* `backends`: `:console` is used to send logs to stdout, `{ExSyslogger, :ex_syslogger}` to log to syslog, and `Quack.Logger` to log to Slack

	An example to enable ONLY ExSyslogger (f/ex in ``prod.secret.exs``) with info and debug suppressed:
	```elixir
	config :logger,
	backends: [{ExSyslogger, :ex_syslogger}]

	config :logger, :ex_syslogger,
	level: :warn
	```

	Another example, keeping console output and adding the pid to syslog output:
	```elixir
	config :logger,
	backends: [:console, {ExSyslogger, :ex_syslogger}]

	config :logger, :ex_syslogger,
	level: :warn,
	option: [:pid, :ndelay]
	```

	See: [logger’s documentation](https://hexdocs.pm/logger/Logger.html) and [ex_syslogger’s documentation](https://hexdocs.pm/ex_syslogger/)

	An example of logging info to local syslog, but warn to a Slack channel:
	```elixir
	config :logger,
	backends: [ {ExSyslogger, :ex_syslogger}, Quack.Logger ],
	level: :info

	config :logger, :ex_syslogger,
	level: :info,
	ident: "pleroma",
	format: "$metadata[$level] $message"

	config :quack,
	level: :warn,
	meta: [:all],
	webhook_url: "https://hooks.slack.com/services/YOUR-API-KEY-HERE"
	```

	See the [Quack Github](https://github.com/azohra/quack) for more details

	## :frontend_configurations

	This can be used to configure a keyword list that keeps the configuration data for any kind of frontend. By default, settings for `pleroma_fe` and `masto_fe` are configured.

	Frontends can access these settings at `/api/pleroma/frontend_configurations`

	To add your own configuration for PleromaFE, use it like this:

	```elixir
	config :pleroma, :frontend_configurations,
	pleroma_fe: %{
	theme: "pleroma-dark",
	# ... see /priv/static/static/config.json for the available keys.
	},
	masto_fe: %{
	showInstanceSpecificPanel: true
	}
	```

	These settings need to be complete, they will override the defaults.

	NOTE: for versions < 1.0, you need to set [`:fe`](#fe) to false, as shown a few lines below.

	## :fe
	__THIS IS DEPRECATED__

	If you are using this method, please change it to the [`frontend_configurations`](#frontend_configurations) method.
	Please set this option to false in your config like this:

	```elixir
	config :pleroma, :fe, false
	```

	This section is used to configure Pleroma-FE, unless ``:managed_config`` in ``:instance`` is set to false.

	* `theme`: Which theme to use, they are defined in ``styles.json``
	* `logo`: URL of the logo, defaults to Pleroma’s logo
	* `logo_mask`: Whether to use only the logo's shape as a mask (true) or as a regular image (false)
	* `logo_margin`: What margin to use around the logo
	* `background`: URL of the background, unless viewing a user profile with a background that is set
	* `redirect_root_no_login`: relative URL which indicates where to redirect when a user isn’t logged in.
	* `redirect_root_login`: relative URL which indicates where to redirect when a user is logged in.
	* `show_instance_panel`: Whenether to show the instance’s specific panel.
	* `scope_options_enabled`: Enable setting an notice visibility and subject/CW when posting
	* `formatting_options_enabled`: Enable setting a formatting different than plain-text (ie. HTML, Markdown) when posting, relates to ``:instance, allowed_post_formats``
	* `collapse_message_with_subjects`: When a message has a subject(aka Content Warning), collapse it by default
	* `hide_post_stats`: Hide notices statistics(repeats, favorites, …)
	* `hide_user_stats`: Hide profile statistics(posts, posts per day, followers, followings, …)

	## :assets

	This section configures assets to be used with various frontends. Currently the only option
	relates to mascots on the mastodon frontend

	* `mascots`: KeywordList of mascots, each element __MUST__ contain both a `url` and a
	`mime_type` key.
	* `default_mascot`: An element from `mascots` - This will be used as the default mascot
	on MastoFE (default: `:pleroma_fox_tan`)

	## :mrf_simple
	* `media_removal`: List of instances to remove medias from
	* `media_nsfw`: List of instances to put medias as NSFW(sensitive) from
	* `federated_timeline_removal`: List of instances to remove from Federated (aka The Whole Known Network) Timeline
	* `reject`: List of instances to reject any activities from
	* `accept`: List of instances to accept any activities from
	* `report_removal`: List of instances to reject reports from
	* `avatar_removal`: List of instances to strip avatars from
	* `banner_removal`: List of instances to strip banners from

	## :mrf_subchain
	This policy processes messages through an alternate pipeline when a given message matches certain criteria.
	All criteria are configured as a map of regular expressions to lists of policy modules.

	* `match_actor`: Matches a series of regular expressions against the actor field.

	Example:

	```
	config :pleroma, :mrf_subchain,
	match_actor: %{
	~r/https:\/\/example.com/s => [Pleroma.Web.ActivityPub.MRF.DropPolicy]
	}
	```

	## :mrf_rejectnonpublic
	* `allow_followersonly`: whether to allow followers-only posts
	* `allow_direct`: whether to allow direct messages

	## :mrf_hellthread
	* `delist_threshold`: Number of mentioned users after which the message gets delisted (the message can still be seen, but it will not show up in public timelines and mentioned users won't get notifications about it). Set to 0 to disable.
	* `reject_threshold`: Number of mentioned users after which the messaged gets rejected. Set to 0 to disable.

	## :mrf_keyword
	* `reject`: A list of patterns which result in message being rejected, each pattern can be a string or a [regular expression](https://hexdocs.pm/elixir/Regex.html)
	* `federated_timeline_removal`: A list of patterns which result in message being removed from federated timelines (a.k.a unlisted), each pattern can be a string or a [regular expression](https://hexdocs.pm/elixir/Regex.html)
	* `replace`: A list of tuples containing `{pattern, replacement}`, `pattern` can be a string or a [regular expression](https://hexdocs.pm/elixir/Regex.html)

	## :media_proxy
	* `enabled`: Enables proxying of remote media to the instance’s proxy
	* `base_url`: The base URL to access a user-uploaded file. Useful when you want to proxy the media files via another host/CDN fronts.
	* `proxy_opts`: All options defined in `Pleroma.ReverseProxy` documentation, defaults to `[max_body_length: (25*1_048_576)]`.
	* `whitelist`: List of domains to bypass the mediaproxy

	## :gopher
	* `enabled`: Enables the gopher interface
	* `ip`: IP address to bind to
	* `port`: Port to bind to
	* `dstport`: Port advertised in urls (optional, defaults to `port`)

	## Pleroma.Web.Endpoint
	`Phoenix` endpoint configuration, all configuration options can be viewed [here](https://hexdocs.pm/phoenix/Phoenix.Endpoint.html#module-dynamic-configuration), only common options are listed here
	* `http` - a list containing http protocol configuration, all configuration options can be viewed [here](https://hexdocs.pm/plug_cowboy/Plug.Cowboy.html#module-options), only common options are listed here
	- `ip` - a tuple consisting of 4 integers
	- `port`
	* `url` - a list containing the configuration for generating urls, accepts
	- `host` - the host without the scheme and a post (e.g `example.com`, not `https://example.com:2020`)
	- `scheme` - e.g `http`, `https`
	- `port`
	- `path`
	* `extra_cookie_attrs` - a list of `Key=Value` strings to be added as non-standard cookie attributes. Defaults to `["SameSite=Lax"]`. See the [SameSite article](https://www.owasp.org/index.php/SameSite) on OWASP for more info.



	Important note: if you modify anything inside these lists, default `config.exs` values will be overwritten, which may result in breakage, to make sure this does not happen please copy the default value for the list from `config.exs` and modify/add only what you need

	Example:
	```elixir
	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "example.com", port: 2020, scheme: "https"],
	http: [
	# start copied from config.exs
	dispatch: [
	{:_,
	[
	{"/api/v1/streaming", Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{Phoenix.Transports.WebSocket,
	{Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, websocket_config}}},
	{:_, Phoenix.Endpoint.Cowboy2Handler, {Pleroma.Web.Endpoint, []}}
	]}
	# end copied from config.exs
	],
	port: 8080,
	ip: {127, 0, 0, 1}
	]
	```

	This will make Pleroma listen on `127.0.0.1` port `8080` and generate urls starting with `https://example.com:2020`

	## :activitypub
	* ``accept_blocks``: Whether to accept incoming block activities from other instances
	* ``unfollow_blocked``: Whether blocks result in people getting unfollowed
	* ``outgoing_blocks``: Whether to federate blocks to other instances
	* ``deny_follow_blocked``: Whether to disallow following an account that has blocked the user in question

	## :http_security
	* ``enabled``: Whether the managed content security policy is enabled
	* ``sts``: Whether to additionally send a `Strict-Transport-Security` header
	* ``sts_max_age``: The maximum age for the `Strict-Transport-Security` header if sent
	* ``ct_max_age``: The maximum age for the `Expect-CT` header if sent
	* ``referrer_policy``: The referrer policy to use, either `"same-origin"` or `"no-referrer"`
	* ``report_uri``: Adds the specified url to `report-uri` and `report-to` group in CSP header.

	## :mrf_user_allowlist

	The keys in this section are the domain names that the policy should apply to.
	Each key should be assigned a list of users that should be allowed through by
	their ActivityPub ID.

	An example:

	```elixir
	config :pleroma, :mrf_user_allowlist,
	"example.org": ["https://example.org/users/admin"]
	```

	## :web_push_encryption, :vapid_details

	Web Push Notifications configuration. You can use the mix task `mix web_push.gen.keypair` to generate it.

	* ``subject``: a mailto link for the administrative contact. It’s best if this email is not a personal email address, but rather a group email so that if a person leaves an organization, is unavailable for an extended period, or otherwise can’t respond, someone else on the list can.
	* ``public_key``: VAPID public key
	* ``private_key``: VAPID private key

	## Pleroma.Captcha
	* `enabled`: Whether the captcha should be shown on registration
	* `method`: The method/service to use for captcha
	* `seconds_valid`: The time in seconds for which the captcha is valid

	### Pleroma.Captcha.Kocaptcha
	Kocaptcha is a very simple captcha service with a single API endpoint,
	the source code is here: https://github.com/koto-bank/kocaptcha. The default endpoint
	`https://captcha.kotobank.ch` is hosted by the developer.

	* `endpoint`: the kocaptcha endpoint to use

	## :admin_token

	Allows to set a token that can be used to authenticate with the admin api without using an actual user by giving it as the 'admin_token' parameter. Example:

	```elixir
	config :pleroma, :admin_token, "somerandomtoken"
	```

	You can then do

	```sh
	curl "http://localhost:4000/api/pleroma/admin/invite_token?admin_token=somerandomtoken"
	```

	## :pleroma_job_queue

	[Pleroma Job Queue](https://git.pleroma.social/pleroma/pleroma_job_queue) configuration: a list of queues with maximum concurrent jobs.

	Pleroma has the following queues:

	* `federator_outgoing` - Outgoing federation
	* `federator_incoming` - Incoming federation
	* `mailer` - Email sender, see [`Pleroma.Emails.Mailer`](#pleroma-emails-mailer)
	* `transmogrifier` - Transmogrifier
	* `web_push` - Web push notifications
	* `scheduled_activities` - Scheduled activities, see [`Pleroma.ScheduledActivities`](#pleromascheduledactivity)

	Example:

	```elixir
	config :pleroma_job_queue, :queues,
	federator_incoming: 50,
	federator_outgoing: 50
	```

	This config contains two queues: `federator_incoming` and `federator_outgoing`. Both have the `max_jobs` set to `50`.

	## Pleroma.Web.Federator.RetryQueue

	* `enabled`: If set to `true`, failed federation jobs will be retried
	* `max_jobs`: The maximum amount of parallel federation jobs running at the same time.
	* `initial_timeout`: The initial timeout in seconds
	* `max_retries`: The maximum number of times a federation job is retried

	## Pleroma.Web.Metadata
	* `providers`: a list of metadata providers to enable. Providers available:
	* Pleroma.Web.Metadata.Providers.OpenGraph
	* Pleroma.Web.Metadata.Providers.TwitterCard
	* Pleroma.Web.Metadata.Providers.RelMe - add links from user bio with rel=me into the `<header>` as `<link rel=me>`
	* `unfurl_nsfw`: If set to `true` nsfw attachments will be shown in previews

	## :rich_media
	* `enabled`: if enabled the instance will parse metadata from attached links to generate link previews

	## :fetch_initial_posts
	* `enabled`: if enabled, when a new user is federated with, fetch some of their latest posts
	* `pages`: the amount of pages to fetch

	## :hackney_pools

	Advanced. Tweaks Hackney (http client) connections pools.

	There's three pools used:

	* `:federation` for the federation jobs.
	You may want this pool max_connections to be at least equal to the number of federator jobs + retry queue jobs.
	* `:media` for rich media, media proxy
	* `:upload` for uploaded media (if using a remote uploader and `proxy_remote: true`)

	For each pool, the options are:

	* `max_connections` - how much connections a pool can hold
	* `timeout` - retention duration for connections

	## :auto_linker

	Configuration for the `auto_linker` library:

	* `class: "auto-linker"` - specify the class to be added to the generated link. false to clear
	* `rel: "noopener noreferrer"` - override the rel attribute. false to clear
	* `new_window: true` - set to false to remove `target='_blank'` attribute
	* `scheme: false` - Set to true to link urls with schema `http://google.com`
	* `truncate: false` - Set to a number to truncate urls longer then the number. Truncated urls will end in `..`
	* `strip_prefix: true` - Strip the scheme prefix
	* `extra: false` - link urls with rarely used schemes (magnet, ipfs, irc, etc.)

	Example:

	```elixir
	config :auto_linker,
	opts: [
	scheme: true,
	extra: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: false
	]
	```

	## Pleroma.ScheduledActivity

	* `daily_user_limit`: the number of scheduled activities a user is allowed to create in a single day (Default: `25`)
	* `total_user_limit`: the number of scheduled activities a user is allowed to create in total (Default: `300`)
	* `enabled`: whether scheduled activities are sent to the job queue to be executed

	## Pleroma.Web.Auth.Authenticator

	* `Pleroma.Web.Auth.PleromaAuthenticator`: default database authenticator
	* `Pleroma.Web.Auth.LDAPAuthenticator`: LDAP authentication

	## :ldap

	Use LDAP for user authentication. When a user logs in to the Pleroma
	instance, the name and password will be verified by trying to authenticate
	(bind) to an LDAP server. If a user exists in the LDAP directory but there
	is no account with the same name yet on the Pleroma instance then a new
	Pleroma account will be created with the same name as the LDAP user name.

	* `enabled`: enables LDAP authentication
	* `host`: LDAP server hostname
	* `port`: LDAP port, e.g. 389 or 636
	* `ssl`: true to use SSL, usually implies the port 636
	* `sslopts`: additional SSL options
	* `tls`: true to start TLS, usually implies the port 389
	* `tlsopts`: additional TLS options
	* `base`: LDAP base, e.g. "dc=example,dc=com"
	* `uid`: LDAP attribute name to authenticate the user, e.g. when "cn", the filter will be "cn=username,base"

	## BBS / SSH access

	To enable simple command line interface accessible over ssh, add a setting like this to your configuration file:

	```exs
	app_dir = File.cwd!
	priv_dir = Path.join([app_dir, "priv/ssh_keys"])

	config :esshd,
	enabled: true,
	priv_dir: priv_dir,
	handler: "Pleroma.BBS.Handler",
	port: 10_022,
	password_authenticator: "Pleroma.BBS.Authenticator"
	```

	Feel free to adjust the priv_dir and port number. Then you will have to create the key for the keys (in the example `priv/ssh_keys`) and create the host keys with `ssh-keygen -m PEM -N "" -b 2048 -t rsa -f ssh_host_rsa_key`. After restarting, you should be able to connect to your Pleroma instance with `ssh username@server -p $PORT`

	## :auth

	* `Pleroma.Web.Auth.PleromaAuthenticator`: default database authenticator
	* `Pleroma.Web.Auth.LDAPAuthenticator`: LDAP authentication

	Authentication / authorization settings.

	* `auth_template`: authentication form template. By default it's `show.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/show.html.eex`.
	* `oauth_consumer_template`: OAuth consumer mode authentication form template. By default it's `consumer.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex`.
	* `oauth_consumer_strategies`: the list of enabled OAuth consumer strategies; by default it's set by `OAUTH_CONSUMER_STRATEGIES` environment variable. Each entry in this space-delimited string should be of format `<strategy>` or `<strategy>:<dependency>` (e.g. `twitter` or `keycloak:ueberauth_keycloak_strategy` in case dependency is named differently than `ueberauth_<strategy>`).

	## OAuth consumer mode

	OAuth consumer mode allows sign in / sign up via external OAuth providers (e.g. Twitter, Facebook, Google, Microsoft, etc.).
	Implementation is based on Ueberauth; see the list of [available strategies](https://github.com/ueberauth/ueberauth/wiki/List-of-Strategies).

	Note: each strategy is shipped as a separate dependency; in order to get the strategies, run `OAUTH_CONSUMER_STRATEGIES="..." mix deps.get`,
	e.g. `OAUTH_CONSUMER_STRATEGIES="twitter facebook google microsoft" mix deps.get`.
	The server should also be started with `OAUTH_CONSUMER_STRATEGIES="..." mix phx.server` in case you enable any strategies.

	Note: each strategy requires separate setup (on external provider side and Pleroma side). Below are the guidelines on setting up most popular strategies.

	Note: make sure that `"SameSite=Lax"` is set in `extra_cookie_attrs` when you have this feature enabled. OAuth consumer mode will not work with `"SameSite=Strict"`

	* For Twitter, [register an app](https://developer.twitter.com/en/apps), configure callback URL to https://<your_host>/oauth/twitter/callback

	* For Facebook, [register an app](https://developers.facebook.com/apps), configure callback URL to https://<your_host>/oauth/facebook/callback, enable Facebook Login service at https://developers.facebook.com/apps/<app_id>/fb-login/settings/

	* For Google, [register an app](https://console.developers.google.com), configure callback URL to https://<your_host>/oauth/google/callback

	* For Microsoft, [register an app](https://portal.azure.com), configure callback URL to https://<your_host>/oauth/microsoft/callback

	Once the app is configured on external OAuth provider side, add app's credentials and strategy-specific settings (if any — e.g. see Microsoft below) to `config/prod.secret.exs`,
	per strategy's documentation (e.g. [ueberauth_twitter](https://github.com/ueberauth/ueberauth_twitter)). Example config basing on environment variables:

	```elixir
	# Twitter
	config :ueberauth, Ueberauth.Strategy.Twitter.OAuth,
	consumer_key: System.get_env("TWITTER_CONSUMER_KEY"),
	consumer_secret: System.get_env("TWITTER_CONSUMER_SECRET")

	# Facebook
	config :ueberauth, Ueberauth.Strategy.Facebook.OAuth,
	client_id: System.get_env("FACEBOOK_APP_ID"),
	client_secret: System.get_env("FACEBOOK_APP_SECRET"),
	redirect_uri: System.get_env("FACEBOOK_REDIRECT_URI")

	# Google
	config :ueberauth, Ueberauth.Strategy.Google.OAuth,
	client_id: System.get_env("GOOGLE_CLIENT_ID"),
	client_secret: System.get_env("GOOGLE_CLIENT_SECRET"),
	redirect_uri: System.get_env("GOOGLE_REDIRECT_URI")

	# Microsoft
	config :ueberauth, Ueberauth.Strategy.Microsoft.OAuth,
	client_id: System.get_env("MICROSOFT_CLIENT_ID"),
	client_secret: System.get_env("MICROSOFT_CLIENT_SECRET")

	config :ueberauth, Ueberauth,
	providers: [
	microsoft: {Ueberauth.Strategy.Microsoft, [callback_params: []]}
	]

	# Keycloak
	# Note: make sure to add `keycloak:ueberauth_keycloak_strategy` entry to `OAUTH_CONSUMER_STRATEGIES` environment variable
	keycloak_url = "https://publicly-reachable-keycloak-instance.org:8080"

	config :ueberauth, Ueberauth.Strategy.Keycloak.OAuth,
	client_id: System.get_env("KEYCLOAK_CLIENT_ID"),
	client_secret: System.get_env("KEYCLOAK_CLIENT_SECRET"),
	site: keycloak_url,
	authorize_url: "#{keycloak_url}/auth/realms/master/protocol/openid-connect/auth",
	token_url: "#{keycloak_url}/auth/realms/master/protocol/openid-connect/token",
	userinfo_url: "#{keycloak_url}/auth/realms/master/protocol/openid-connect/userinfo",
	token_method: :post

	config :ueberauth, Ueberauth,
	providers: [
	keycloak: {Ueberauth.Strategy.Keycloak, [uid_field: :email]}
	]
	```

	## OAuth 2.0 provider - :oauth2

	Configure OAuth 2 provider capabilities:

	* `token_expires_in` - The lifetime in seconds of the access token.
	* `issue_new_refresh_token` - Keeps old refresh token or generate new refresh token when to obtain an access token.
	* `clean_expired_tokens` - Enable a background job to clean expired oauth tokens. Defaults to `false`.
	* `clean_expired_tokens_interval` - Interval to run the job to clean expired tokens. Defaults to `86_400_000` (24 hours).

	## :emoji
	* `shortcode_globs`: Location of custom emoji files. `` can be used as a wildcard. Example `["/emoji/custom//.png"]`
	* `groups`: Emojis are ordered in groups (tags). This is an array of key-value pairs where the key is the groupname and the value the location or array of locations. `` can be used as a wildcard. Example `[Custom: ["/emoji/.png", "/emoji/custom/*.png"]]`
	* `default_manifest`: Location of the JSON-manifest. This manifest contains information about the emoji-packs you can download. Currently only one manifest can be added (no arrays).

	## Database options

	### RUM indexing for full text search
	* `rum_enabled`: If RUM indexes should be used. Defaults to `false`.

	RUM indexes are an alternative indexing scheme that is not included in PostgreSQL by default. While they may eventually be mainlined, for now they have to be installed as a PostgreSQL extension from https://github.com/postgrespro/rum.

	Their advantage over the standard GIN indexes is that they allow efficient ordering of search results by timestamp, which makes search queries a lot faster on larger servers, by one or two orders of magnitude. They take up around 3 times as much space as GIN indexes.

	To enable them, both the `rum_enabled` flag has to be set and the following special migration has to be run:

	`mix ecto.migrate --migrations-path priv/repo/optional_migrations/rum_indexing/`

	This will probably take a long time.

	## :rate_limit

	A keyword list of rate limiters where a key is a limiter name and value is the limiter configuration. The basic configuration is a tuple where:

	* The first element: `scale` (Integer). The time scale in milliseconds.
	* The second element: `limit` (Integer). How many requests to limit in the time scale provided.

	It is also possible to have different limits for unauthenticated and authenticated users: the keyword value must be a list of two tuples where the first one is a config for unauthenticated users and the second one is for authenticated.

	See [`Pleroma.Plugs.RateLimiter`](Pleroma.Plugs.RateLimiter.html) documentation for examples.
	diff --git a/lib/mix/tasks/pleroma/config.ex b/lib/mix/tasks/pleroma/config.ex
	new file mode 100644
	index 000000000..1fe03088d
	--- /dev/null
	+++ b/lib/mix/tasks/pleroma/config.ex
	@@ -0,0 +1,68 @@
	+defmodule Mix.Tasks.Pleroma.Config do
	+ use Mix.Task
	+ alias Mix.Tasks.Pleroma.Common
	+ alias Pleroma.Repo
	+ alias Pleroma.Web.AdminAPI.Config
	+ @shortdoc "Manages the location of the config"
	+ @moduledoc """
	+ Manages the location of the config.
	+
	+ ## Transfers config from file to DB.
	+
	+ mix pleroma.config migrate_to_db
	+
	+ ## Transfers config from DB to file.
	+
	+ mix pleroma.config migrate_from_db ENV
	+ """
	+
	+ def run(["migrate_to_db"]) do
	+ Common.start_pleroma()
	+
	+ if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	+ Application.get_all_env(:pleroma)
	+ \|> Enum.reject(fn {k, _v} -> k in [Pleroma.Repo, :env] end)
	+ \|> Enum.each(fn {k, v} ->
	+ key = to_string(k) \|> String.replace("Elixir.", "")
	+ {:ok, _} = Config.update_or_create(%{key: key, value: v})
	+ Mix.shell().info("#{key} is migrated.")
	+ end)
	+
	+ Mix.shell().info("Settings migrated.")
	+ else
	+ Mix.shell().info(
	+ "Migration is not allowed by config. You can change this behavior in instance settings."
	+ )
	+ end
	+ end
	+
	+ def run(["migrate_from_db", env]) do
	+ Common.start_pleroma()
	+
	+ if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	+ config_path = "config/#{env}.migrated.secret.exs"
	+
	+ {:ok, file} = File.open(config_path, [:write])
	+
	+ Repo.all(Config)
	+ \|> Enum.each(fn config ->
	+ mark = if String.starts_with?(config.key, "Pleroma."), do: ",", else: ":"
	+
	+ IO.write(
	+ file,
	+ "config :pleroma, #{config.key}#{mark} #{inspect(Config.from_binary(config.value))}\r\n"
	+ )
	+
	+ {:ok, _} = Repo.delete(config)
	+ Mix.shell().info("#{config.key} deleted from DB.")
	+ end)
	+
	+ File.close(file)
	+ System.cmd("mix", ["format", config_path])
	+ else
	+ Mix.shell().info(
	+ "Migration is not allowed by config. You can change this behavior in instance settings."
	+ )
	+ end
	+ end
	+end
	diff --git a/lib/mix/tasks/pleroma/emoji.ex b/lib/mix/tasks/pleroma/emoji.ex
	index d2ddf450a..c2225af7d 100644
	--- a/lib/mix/tasks/pleroma/emoji.ex
	+++ b/lib/mix/tasks/pleroma/emoji.ex
	@@ -1,301 +1,301 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Emoji do
	use Mix.Task

	@shortdoc "Manages emoji packs"
	@moduledoc """
	Manages emoji packs

	## ls-packs

	mix pleroma.emoji ls-packs [OPTION...]

	Lists the emoji packs and metadata specified in the manifest.

	### Options

	- `-m, --manifest PATH/URL` - path to a custom manifest, it can
	either be an URL starting with `http`, in that case the
	manifest will be fetched from that address, or a local path

	## get-packs

	mix pleroma.emoji get-packs [OPTION...] PACKS

	Fetches, verifies and installs the specified PACKS from the
	manifest into the `STATIC-DIR/emoji/PACK-NAME`

	### Options

	- `-m, --manifest PATH/URL` - same as ls-packs

	## gen-pack

	mix pleroma.emoji gen-pack PACK-URL

	Creates a new manifest entry and a file list from the specified
	remote pack file. Currently, only .zip archives are recognized
	as remote pack files and packs are therefore assumed to be zip
	archives. This command is intended to run interactively and will
	first ask you some basic questions about the pack, then download
	the remote file and generate an SHA256 checksum for it, then
	generate an emoji file list for you.

	The manifest entry will either be written to a newly created
	`index.json` file or appended to the existing one, replacing
	the old pack with the same name if it was in the file previously.

	The file list will be written to the file specified previously,
	replacing that file. You _should_ check that the file list doesn't
	contain anything you don't need in the pack, that is, anything that is
	not an emoji (the whole pack is downloaded, but only emoji files
	are extracted).
	"""

	- @default_manifest Pleroma.Config.get!([:emoji, :default_manifest])
	-
	def run(["ls-packs" \| args]) do
	Application.ensure_all_started(:hackney)

	{options, [], []} = parse_global_opts(args)

	manifest =
	- fetch_manifest(if options[:manifest], do: options[:manifest], else: @default_manifest)
	+ fetch_manifest(if options[:manifest], do: options[:manifest], else: default_manifest())

	Enum.each(manifest, fn {name, info} ->
	to_print = [
	{"Name", name},
	{"Homepage", info["homepage"]},
	{"Description", info["description"]},
	{"License", info["license"]},
	{"Source", info["src"]}
	]

	for {param, value} <- to_print do
	IO.puts(IO.ANSI.format([:bright, param, :normal, ": ", value]))
	end

	# A newline
	IO.puts("")
	end)
	end

	def run(["get-packs" \| args]) do
	Application.ensure_all_started(:hackney)

	{options, pack_names, []} = parse_global_opts(args)

	- manifest_url = if options[:manifest], do: options[:manifest], else: @default_manifest
	+ manifest_url = if options[:manifest], do: options[:manifest], else: default_manifest()

	manifest = fetch_manifest(manifest_url)

	for pack_name <- pack_names do
	if Map.has_key?(manifest, pack_name) do
	pack = manifest[pack_name]
	src_url = pack["src"]

	IO.puts(
	IO.ANSI.format([
	"Downloading ",
	:bright,
	pack_name,
	:normal,
	" from ",
	:underline,
	src_url
	])
	)

	binary_archive = Tesla.get!(client(), src_url).body
	archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()

	sha_status_text = ["SHA256 of ", :bright, pack_name, :normal, " source file is ", :bright]

	if archive_sha == String.upcase(pack["src_sha256"]) do
	IO.puts(IO.ANSI.format(sha_status_text ++ [:green, "OK"]))
	else
	IO.puts(IO.ANSI.format(sha_status_text ++ [:red, "BAD"]))

	raise "Bad SHA256 for #{pack_name}"
	end

	# The url specified in files should be in the same directory
	files_url = Path.join(Path.dirname(manifest_url), pack["files"])

	IO.puts(
	IO.ANSI.format([
	"Fetching the file list for ",
	:bright,
	pack_name,
	:normal,
	" from ",
	:underline,
	files_url
	])
	)

	files = Tesla.get!(client(), files_url).body \|> Jason.decode!()

	IO.puts(IO.ANSI.format(["Unpacking ", :bright, pack_name]))

	pack_path =
	Path.join([
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji",
	pack_name
	])

	files_to_unzip =
	Enum.map(
	files,
	fn {_, f} -> to_charlist(f) end
	)

	{:ok, _} =
	:zip.unzip(binary_archive,
	cwd: pack_path,
	file_list: files_to_unzip
	)

	IO.puts(IO.ANSI.format(["Writing emoji.txt for ", :bright, pack_name]))

	emoji_txt_str =
	Enum.map(
	files,
	fn {shortcode, path} ->
	emojo_path = Path.join("/emoji/#{pack_name}", path)
	"#{shortcode}, #{emojo_path}"
	end
	)
	\|> Enum.join("\n")

	File.write!(Path.join(pack_path, "emoji.txt"), emoji_txt_str)
	else
	IO.puts(IO.ANSI.format([:bright, :red, "No pack named \"#{pack_name}\" found"]))
	end
	end
	end

	def run(["gen-pack", src]) do
	Application.ensure_all_started(:hackney)

	proposed_name = Path.basename(src) \|> Path.rootname()
	name = String.trim(IO.gets("Pack name [#{proposed_name}]: "))
	# If there's no name, use the default one
	name = if String.length(name) > 0, do: name, else: proposed_name

	license = String.trim(IO.gets("License: "))
	homepage = String.trim(IO.gets("Homepage: "))
	description = String.trim(IO.gets("Description: "))

	proposed_files_name = "#{name}.json"
	files_name = String.trim(IO.gets("Save file list to [#{proposed_files_name}]: "))
	files_name = if String.length(files_name) > 0, do: files_name, else: proposed_files_name

	default_exts = [".png", ".gif"]
	default_exts_str = Enum.join(default_exts, " ")

	exts =
	String.trim(
	IO.gets("Emoji file extensions (separated with spaces) [#{default_exts_str}]: ")
	)

	exts =
	if String.length(exts) > 0 do
	String.split(exts, " ")
	\|> Enum.filter(fn e -> e \|> String.trim() \|> String.length() > 0 end)
	else
	default_exts
	end

	IO.puts("Downloading the pack and generating SHA256")

	binary_archive = Tesla.get!(client(), src).body
	archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()

	IO.puts("SHA256 is #{archive_sha}")

	pack_json = %{
	name => %{
	license: license,
	homepage: homepage,
	description: description,
	src: src,
	src_sha256: archive_sha,
	files: files_name
	}
	}

	tmp_pack_dir = Path.join(System.tmp_dir!(), "emoji-pack-#{name}")

	{:ok, _} =
	:zip.unzip(
	binary_archive,
	cwd: tmp_pack_dir
	)

	emoji_map = Pleroma.Emoji.make_shortcode_to_file_map(tmp_pack_dir, exts)

	File.write!(files_name, Jason.encode!(emoji_map, pretty: true))

	IO.puts("""

	#{files_name} has been created and contains the list of all found emojis in the pack.
	Please review the files in the remove those not needed.
	""")

	if File.exists?("index.json") do
	existing_data = File.read!("index.json") \|> Jason.decode!()

	File.write!(
	"index.json",
	Jason.encode!(
	Map.merge(
	existing_data,
	pack_json
	),
	pretty: true
	)
	)

	IO.puts("index.json file has been update with the #{name} pack")
	else
	File.write!("index.json", Jason.encode!(pack_json, pretty: true))

	IO.puts("index.json has been created with the #{name} pack")
	end
	end

	defp fetch_manifest(from) do
	Jason.decode!(
	if String.starts_with?(from, "http") do
	Tesla.get!(client(), from).body
	else
	File.read!(from)
	end
	)
	end

	defp parse_global_opts(args) do
	OptionParser.parse(
	args,
	strict: [
	manifest: :string
	],
	aliases: [
	m: :manifest
	]
	)
	end

	defp client do
	middleware = [
	{Tesla.Middleware.FollowRedirects, [max_redirects: 3]}
	]

	Tesla.client(middleware)
	end
	+
	+ defp default_manifest, do: Pleroma.Config.get!([:emoji, :default_manifest])
	end
	diff --git a/lib/mix/tasks/pleroma/instance.ex b/lib/mix/tasks/pleroma/instance.ex
	index 88925dbaf..44e49cb69 100644
	--- a/lib/mix/tasks/pleroma/instance.ex
	+++ b/lib/mix/tasks/pleroma/instance.ex
	@@ -1,213 +1,224 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.Instance do
	use Mix.Task
	alias Mix.Tasks.Pleroma.Common

	@shortdoc "Manages Pleroma instance"
	@moduledoc """
	Manages Pleroma instance.

	## Generate a new instance config.

	mix pleroma.instance gen [OPTION...]

	If any options are left unspecified, you will be prompted interactively

	## Options

	- `-f`, `--force` - overwrite any output files
	- `-o PATH`, `--output PATH` - the output file for the generated configuration
	- `--output-psql PATH` - the output file for the generated PostgreSQL setup
	- `--domain DOMAIN` - the domain of your instance
	- `--instance-name INSTANCE_NAME` - the name of your instance
	- `--admin-email ADMIN_EMAIL` - the email address of the instance admin
	- `--notify-email NOTIFY_EMAIL` - email address for notifications
	- `--dbhost HOSTNAME` - the hostname of the PostgreSQL database to use
	- `--dbname DBNAME` - the name of the database to use
	- `--dbuser DBUSER` - the user (aka role) to use for the database connection
	- `--dbpass DBPASS` - the password to use for the database connection
	- `--indexable Y/N` - Allow/disallow indexing site by search engines
	+ - `--db-configurable Y/N` - Allow/disallow configuring instance from admin part
	"""

	def run(["gen" \| rest]) do
	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	force: :boolean,
	output: :string,
	output_psql: :string,
	domain: :string,
	instance_name: :string,
	admin_email: :string,
	notify_email: :string,
	dbhost: :string,
	dbname: :string,
	dbuser: :string,
	dbpass: :string,
	- indexable: :string
	+ indexable: :string,
	+ db_configurable: :string
	],
	aliases: [
	o: :output,
	f: :force
	]
	)

	paths =
	[config_path, psql_path] = [
	Keyword.get(options, :output, "config/generated_config.exs"),
	Keyword.get(options, :output_psql, "config/setup_db.psql")
	]

	will_overwrite = Enum.filter(paths, &File.exists?/1)
	proceed? = Enum.empty?(will_overwrite) or Keyword.get(options, :force, false)

	if proceed? do
	[domain, port \| _] =
	String.split(
	Common.get_option(
	options,
	:domain,
	"What domain will your instance use? (e.g pleroma.soykaf.com)"
	),
	":"
	) ++ [443]

	name =
	Common.get_option(
	options,
	:instance_name,
	"What is the name of your instance? (e.g. Pleroma/Soykaf)"
	)

	email = Common.get_option(options, :admin_email, "What is your admin email address?")

	notify_email =
	Common.get_option(
	options,
	:notify_email,
	"What email address do you want to use for sending email notifications?",
	email
	)

	indexable =
	Common.get_option(
	options,
	:indexable,
	"Do you want search engines to index your site? (y/n)",
	"y"
	) === "y"

	+ db_configurable? =
	+ Common.get_option(
	+ options,
	+ :db_configurable,
	+ "Do you want to be able to configure instance from admin part? (y/n)",
	+ "y"
	+ ) === "y"
	+
	dbhost =
	Common.get_option(options, :dbhost, "What is the hostname of your database?", "localhost")

	dbname =
	Common.get_option(options, :dbname, "What is the name of your database?", "pleroma_dev")

	dbuser =
	Common.get_option(
	options,
	:dbuser,
	"What is the user used to connect to your database?",
	"pleroma"
	)

	dbpass =
	Common.get_option(
	options,
	:dbpass,
	"What is the password used to connect to your database?",
	:crypto.strong_rand_bytes(64) \|> Base.encode64() \|> binary_part(0, 64),
	"autogenerated"
	)

	secret = :crypto.strong_rand_bytes(64) \|> Base.encode64() \|> binary_part(0, 64)
	signing_salt = :crypto.strong_rand_bytes(8) \|> Base.encode64() \|> binary_part(0, 8)
	{web_push_public_key, web_push_private_key} = :crypto.generate_key(:ecdh, :prime256v1)

	result_config =
	EEx.eval_file(
	"sample_config.eex" \|> Path.expand(__DIR__),
	domain: domain,
	port: port,
	email: email,
	notify_email: notify_email,
	name: name,
	dbhost: dbhost,
	dbname: dbname,
	dbuser: dbuser,
	dbpass: dbpass,
	version: Pleroma.Mixfile.project() \|> Keyword.get(:version),
	secret: secret,
	signing_salt: signing_salt,
	web_push_public_key: Base.url_encode64(web_push_public_key, padding: false),
	- web_push_private_key: Base.url_encode64(web_push_private_key, padding: false)
	+ web_push_private_key: Base.url_encode64(web_push_private_key, padding: false),
	+ db_configurable?: db_configurable?
	)

	result_psql =
	EEx.eval_file(
	"sample_psql.eex" \|> Path.expand(__DIR__),
	dbname: dbname,
	dbuser: dbuser,
	dbpass: dbpass
	)

	Common.shell_info(
	"Writing config to #{config_path}. You should rename it to config/prod.secret.exs or config/dev.secret.exs."
	)

	File.write(config_path, result_config)
	Common.shell_info("Writing #{psql_path}.")
	File.write(psql_path, result_psql)

	write_robots_txt(indexable)

	Common.shell_info(
	"\n" <>
	"""
	To get started:
	1. Verify the contents of the generated files.
	2. Run `sudo -u postgres psql -f #{Common.escape_sh_path(psql_path)}`.
	""" <>
	if config_path in ["config/dev.secret.exs", "config/prod.secret.exs"] do
	""
	else
	"3. Run `mv #{Common.escape_sh_path(config_path)} 'config/prod.secret.exs'`."
	end
	)
	else
	Common.shell_error(
	"The task would have overwritten the following files:\n" <>
	(Enum.map(paths, &"- #{&1}\n") \|> Enum.join("")) <>
	"Rerun with `--force` to overwrite them."
	)
	end
	end

	defp write_robots_txt(indexable) do
	robots_txt =
	EEx.eval_file(
	Path.expand("robots_txt.eex", __DIR__),
	indexable: indexable
	)

	static_dir = Pleroma.Config.get([:instance, :static_dir], "instance/static/")

	unless File.exists?(static_dir) do
	File.mkdir_p!(static_dir)
	end

	robots_txt_path = Path.join(static_dir, "robots.txt")

	if File.exists?(robots_txt_path) do
	File.cp!(robots_txt_path, "#{robots_txt_path}.bak")
	Common.shell_info("Backing up existing robots.txt to #{robots_txt_path}.bak")
	end

	File.write(robots_txt_path, robots_txt)
	Common.shell_info("Writing #{robots_txt_path}.")
	end
	end
	diff --git a/lib/mix/tasks/pleroma/sample_config.eex b/lib/mix/tasks/pleroma/sample_config.eex
	index 52bd57cb7..73d9217be 100644
	--- a/lib/mix/tasks/pleroma/sample_config.eex
	+++ b/lib/mix/tasks/pleroma/sample_config.eex
	@@ -1,78 +1,79 @@
	# Pleroma instance configuration

	# NOTE: This file should not be committed to a repo or otherwise made public
	# without removing sensitive information.

	use Mix.Config

	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "<%= domain %>", scheme: "https", port: <%= port %>],
	secret_key_base: "<%= secret %>",
	signing_salt: "<%= signing_salt %>"

	config :pleroma, :instance,
	name: "<%= name %>",
	email: "<%= email %>",
	notify_email: "<%= notify_email %>",
	limit: 5000,
	registrations_open: true,
	- dedupe_media: false
	+ dedupe_media: false,
	+ dynamic_configuration: <%= db_configurable? %>

	config :pleroma, :media_proxy,
	enabled: false,
	redirect_on_failure: true
	#base_url: "https://cache.pleroma.social"

	config :pleroma, Pleroma.Repo,
	adapter: Ecto.Adapters.Postgres,
	username: "<%= dbuser %>",
	password: "<%= dbpass %>",
	database: "<%= dbname %>",
	hostname: "<%= dbhost %>",
	pool_size: 10

	# Configure web push notifications
	config :web_push_encryption, :vapid_details,
	subject: "mailto:<%= email %>",
	public_key: "<%= web_push_public_key %>",
	private_key: "<%= web_push_private_key %>"

	# Enable Strict-Transport-Security once SSL is working:
	# config :pleroma, :http_security,
	# sts: true

	# Configure S3 support if desired.
	# The public S3 endpoint is different depending on region and provider,
	# consult your S3 provider's documentation for details on what to use.
	#
	# config :pleroma, Pleroma.Uploaders.S3,
	# bucket: "some-bucket",
	# public_endpoint: "https://s3.amazonaws.com"
	#
	# Configure S3 credentials:
	# config :ex_aws, :s3,
	# access_key_id: "xxxxxxxxxxxxx",
	# secret_access_key: "yyyyyyyyyyyy",
	# region: "us-east-1",
	# scheme: "https://"
	#
	# For using third-party S3 clones like wasabi, also do:
	# config :ex_aws, :s3,
	# host: "s3.wasabisys.com"


	# Configure Openstack Swift support if desired.
	#
	# Many openstack deployments are different, so config is left very open with
	# no assumptions made on which provider you're using. This should allow very
	# wide support without needing separate handlers for OVH, Rackspace, etc.
	#
	# config :pleroma, Pleroma.Uploaders.Swift,
	# container: "some-container",
	# username: "api-username-yyyy",
	# password: "api-key-xxxx",
	# tenant_id: "<openstack-project/tenant-id>",
	# auth_url: "https://keystone-endpoint.provider.com",
	# storage_url: "https://swift-endpoint.prodider.com/v1/AUTH_<tenant>/<container>",
	# object_url: "https://cdn-endpoint.provider.com/<container>"
	#
	diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
	index 9c93c7a35..ba4cf8486 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,224 +1,225 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Application do
	use Application

	@name Mix.Project.config()[:name]
	@version Mix.Project.config()[:version]
	@repository Mix.Project.config()[:source_url]
	def name, do: @name
	def version, do: @version
	def named_version, do: @name <> " " <> @version
	def repository, do: @repository

	def user_agent do
	info = "#{Pleroma.Web.base_url()} <#{Pleroma.Config.get([:instance, :email], "")}>"
	named_version() <> "; " <> info
	end

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	import Cachex.Spec

	Pleroma.Config.DeprecationWarnings.warn()
	setup_instrumenters()

	# Define workers and child supervisors to be supervised
	children =
	[
	# Start the Ecto repository
	%{id: Pleroma.Repo, start: {Pleroma.Repo, :start_link, []}, type: :supervisor},
	+ %{id: Pleroma.Config.TransferTask, start: {Pleroma.Config.TransferTask, :start_link, []}},
	%{id: Pleroma.Emoji, start: {Pleroma.Emoji, :start_link, []}},
	%{id: Pleroma.Captcha, start: {Pleroma.Captcha, :start_link, []}},
	%{
	id: :cachex_used_captcha_cache,
	start:
	{Cachex, :start_link,
	[
	:used_captcha_cache,
	[
	ttl_interval:
	:timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))
	]
	]}
	},
	%{
	id: :cachex_user,
	start:
	{Cachex, :start_link,
	[
	:user_cache,
	[
	default_ttl: 25_000,
	ttl_interval: 1000,
	limit: 2500
	]
	]}
	},
	%{
	id: :cachex_object,
	start:
	{Cachex, :start_link,
	[
	:object_cache,
	[
	default_ttl: 25_000,
	ttl_interval: 1000,
	limit: 2500
	]
	]}
	},
	%{
	id: :cachex_rich_media,
	start:
	{Cachex, :start_link,
	[
	:rich_media_cache,
	[
	default_ttl: :timer.minutes(120),
	limit: 5000
	]
	]}
	},
	%{
	id: :cachex_scrubber,
	start:
	{Cachex, :start_link,
	[
	:scrubber_cache,
	[
	limit: 2500
	]
	]}
	},
	%{
	id: :cachex_idem,
	start:
	{Cachex, :start_link,
	[
	:idempotency_cache,
	[
	expiration:
	expiration(
	default: :timer.seconds(6 * 60 * 60),
	interval: :timer.seconds(60)
	),
	limit: 2500
	]
	]}
	},
	%{id: Pleroma.FlakeId, start: {Pleroma.FlakeId, :start_link, []}},
	%{
	id: Pleroma.ScheduledActivityWorker,
	start: {Pleroma.ScheduledActivityWorker, :start_link, []}
	}
	] ++
	hackney_pool_children() ++
	[
	%{
	id: Pleroma.Web.Federator.RetryQueue,
	start: {Pleroma.Web.Federator.RetryQueue, :start_link, []}
	},
	%{
	id: Pleroma.Web.OAuth.Token.CleanWorker,
	start: {Pleroma.Web.OAuth.Token.CleanWorker, :start_link, []}
	},
	%{
	id: Pleroma.Stats,
	start: {Pleroma.Stats, :start_link, []}
	},
	%{
	id: :web_push_init,
	start: {Task, :start_link, [&Pleroma.Web.Push.init/0]},
	restart: :temporary
	},
	%{
	id: :federator_init,
	start: {Task, :start_link, [&Pleroma.Web.Federator.init/0]},
	restart: :temporary
	}
	] ++
	streamer_child() ++
	chat_child() ++
	[
	# Start the endpoint when the application starts
	%{
	id: Pleroma.Web.Endpoint,
	start: {Pleroma.Web.Endpoint, :start_link, []},
	type: :supervisor
	},
	%{id: Pleroma.Gopher.Server, start: {Pleroma.Gopher.Server, :start_link, []}}
	]

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
	Supervisor.start_link(children, opts)
	end

	defp setup_instrumenters do
	require Prometheus.Registry

	if Application.get_env(:prometheus, Pleroma.Repo.Instrumenter) do
	:ok =
	:telemetry.attach(
	"prometheus-ecto",
	[:pleroma, :repo, :query],
	&Pleroma.Repo.Instrumenter.handle_event/4,
	%{}
	)

	Pleroma.Repo.Instrumenter.setup()
	end

	Pleroma.Web.Endpoint.MetricsExporter.setup()
	Pleroma.Web.Endpoint.PipelineInstrumenter.setup()
	Pleroma.Web.Endpoint.Instrumenter.setup()
	end

	def enabled_hackney_pools do
	[:media] ++
	if Application.get_env(:tesla, :adapter) == Tesla.Adapter.Hackney do
	[:federation]
	else
	[]
	end ++
	- if Pleroma.Config.get([Pleroma.Uploader, :proxy_remote]) do
	+ if Pleroma.Config.get([Pleroma.Upload, :proxy_remote]) do
	[:upload]
	else
	[]
	end
	end

	if Pleroma.Config.get(:env) == :test do
	defp streamer_child, do: []
	defp chat_child, do: []
	else
	defp streamer_child do
	[%{id: Pleroma.Web.Streamer, start: {Pleroma.Web.Streamer, :start_link, []}}]
	end

	defp chat_child do
	if Pleroma.Config.get([:chat, :enabled]) do
	[
	%{
	id: Pleroma.Web.ChatChannel.ChatChannelState,
	start: {Pleroma.Web.ChatChannel.ChatChannelState, :start_link, []}
	}
	]
	else
	[]
	end
	end
	end

	defp hackney_pool_children do
	for pool <- enabled_hackney_pools() do
	options = Pleroma.Config.get([:hackney_pools, pool])
	:hackney_pool.child_spec(pool, options)
	end
	end
	end
	diff --git a/lib/pleroma/config/transfer_task.ex b/lib/pleroma/config/transfer_task.ex
	new file mode 100644
	index 000000000..0d6ece807
	--- /dev/null
	+++ b/lib/pleroma/config/transfer_task.ex
	@@ -0,0 +1,41 @@
	+defmodule Pleroma.Config.TransferTask do
	+ use Task
	+ alias Pleroma.Web.AdminAPI.Config
	+
	+ def start_link do
	+ load_and_update_env()
	+ if Pleroma.Config.get(:env) == :test, do: Ecto.Adapters.SQL.Sandbox.checkin(Pleroma.Repo)
	+ :ignore
	+ end
	+
	+ def load_and_update_env do
	+ if Pleroma.Config.get([:instance, :dynamic_configuration]) do
	+ Pleroma.Repo.all(Config)
	+ \|> Enum.each(&update_env(&1))
	+ end
	+ end
	+
	+ defp update_env(setting) do
	+ try do
	+ key =
	+ if String.starts_with?(setting.key, "Pleroma.") do
	+ "Elixir." <> setting.key
	+ else
	+ setting.key
	+ end
	+
	+ Application.put_env(
	+ :pleroma,
	+ String.to_existing_atom(key),
	+ Config.from_binary(setting.value)
	+ )
	+ rescue
	+ e ->
	+ require Logger
	+
	+ Logger.warn(
	+ "updating env causes error, key: #{inspect(setting.key)}, error: #{inspect(e)}"
	+ )
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/emoji.ex b/lib/pleroma/emoji.ex
	index b77b26f7f..854d46b1a 100644
	--- a/lib/pleroma/emoji.ex
	+++ b/lib/pleroma/emoji.ex
	@@ -1,260 +1,261 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Emoji do
	@moduledoc """
	The emojis are loaded from:

	* emoji packs in INSTANCE-DIR/emoji
	* the files: `config/emoji.txt` and `config/custom_emoji.txt`
	* glob paths, nested folder is used as tag name for grouping e.g. priv/static/emoji/custom/nested_folder

	This GenServer stores in an ETS table the list of the loaded emojis, and also allows to reload the list at runtime.
	"""
	use GenServer

	require Logger

	@type pattern :: Regex.t() \| module() \| String.t()
	@type patterns :: pattern() \| [pattern()]
	@type group_patterns :: keyword(patterns())

	@ets __MODULE__.Ets
	@ets_options [:ordered_set, :protected, :named_table, {:read_concurrency, true}]
	- @groups Pleroma.Config.get([:emoji, :groups])

	@doc false
	def start_link do
	GenServer.start_link(__MODULE__, [], name: __MODULE__)
	end

	@doc "Reloads the emojis from disk."
	@spec reload() :: :ok
	def reload do
	GenServer.call(__MODULE__, :reload)
	end

	@doc "Returns the path of the emoji `name`."
	@spec get(String.t()) :: String.t() \| nil
	def get(name) do
	case :ets.lookup(@ets, name) do
	[{_, path}] -> path
	_ -> nil
	end
	end

	@doc "Returns all the emojos!!"
	@spec get_all() :: [{String.t(), String.t()}, ...]
	def get_all do
	:ets.tab2list(@ets)
	end

	@doc false
	def init(_) do
	@ets = :ets.new(@ets, @ets_options)
	GenServer.cast(self(), :reload)
	{:ok, nil}
	end

	@doc false
	def handle_cast(:reload, state) do
	load()
	{:noreply, state}
	end

	@doc false
	def handle_call(:reload, _from, state) do
	load()
	{:reply, :ok, state}
	end

	@doc false
	def terminate(_, _) do
	:ok
	end

	@doc false
	def code_change(_old_vsn, state, _extra) do
	load()
	{:ok, state}
	end

	defp load do
	emoji_dir_path =
	Path.join(
	Pleroma.Config.get!([:instance, :static_dir]),
	"emoji"
	)

	+ emoji_groups = Pleroma.Config.get([:emoji, :groups])
	+
	case File.ls(emoji_dir_path) do
	{:error, :enoent} ->
	# The custom emoji directory doesn't exist,
	# don't do anything
	nil

	{:error, e} ->
	# There was some other error
	Logger.error("Could not access the custom emoji directory #{emoji_dir_path}: #{e}")

	{:ok, results} ->
	grouped =
	Enum.group_by(results, fn file -> File.dir?(Path.join(emoji_dir_path, file)) end)

	packs = grouped[true] \|\| []
	files = grouped[false] \|\| []

	# Print the packs we've found
	Logger.info("Found emoji packs: #{Enum.join(packs, ", ")}")

	if not Enum.empty?(files) do
	Logger.warn(
	"Found files in the emoji folder. These will be ignored, please move them to a subdirectory\nFound files: #{
	Enum.join(files, ", ")
	}"
	)
	end

	emojis =
	Enum.flat_map(
	packs,
	- fn pack -> load_pack(Path.join(emoji_dir_path, pack)) end
	+ fn pack -> load_pack(Path.join(emoji_dir_path, pack), emoji_groups) end
	)

	true = :ets.insert(@ets, emojis)
	end

	# Compat thing for old custom emoji handling & default emoji,
	# it should run even if there are no emoji packs
	shortcode_globs = Pleroma.Config.get([:emoji, :shortcode_globs], [])

	emojis =
	- (load_from_file("config/emoji.txt") ++
	- load_from_file("config/custom_emoji.txt") ++
	- load_from_globs(shortcode_globs))
	+ (load_from_file("config/emoji.txt", emoji_groups) ++
	+ load_from_file("config/custom_emoji.txt", emoji_groups) ++
	+ load_from_globs(shortcode_globs, emoji_groups))
	\|> Enum.reject(fn value -> value == nil end)

	true = :ets.insert(@ets, emojis)

	:ok
	end

	- defp load_pack(pack_dir) do
	+ defp load_pack(pack_dir, emoji_groups) do
	pack_name = Path.basename(pack_dir)

	emoji_txt = Path.join(pack_dir, "emoji.txt")

	if File.exists?(emoji_txt) do
	- load_from_file(emoji_txt)
	+ load_from_file(emoji_txt, emoji_groups)
	else
	Logger.info(
	"No emoji.txt found for pack \"#{pack_name}\", assuming all .png files are emoji"
	)

	make_shortcode_to_file_map(pack_dir, [".png"])
	\|> Enum.map(fn {shortcode, rel_file} ->
	filename = Path.join("/emoji/#{pack_name}", rel_file)

	- {shortcode, filename, [to_string(match_extra(@groups, filename))]}
	+ {shortcode, filename, [to_string(match_extra(emoji_groups, filename))]}
	end)
	end
	end

	def make_shortcode_to_file_map(pack_dir, exts) do
	find_all_emoji(pack_dir, exts)
	\|> Enum.map(&Path.relative_to(&1, pack_dir))
	\|> Enum.map(fn f -> {f \|> Path.basename() \|> Path.rootname(), f} end)
	\|> Enum.into(%{})
	end

	def find_all_emoji(dir, exts) do
	Enum.reduce(
	File.ls!(dir),
	[],
	fn f, acc ->
	filepath = Path.join(dir, f)

	if File.dir?(filepath) do
	acc ++ find_all_emoji(filepath, exts)
	else
	acc ++ [filepath]
	end
	end
	)
	\|> Enum.filter(fn f -> Path.extname(f) in exts end)
	end

	- defp load_from_file(file) do
	+ defp load_from_file(file, emoji_groups) do
	if File.exists?(file) do
	- load_from_file_stream(File.stream!(file))
	+ load_from_file_stream(File.stream!(file), emoji_groups)
	else
	[]
	end
	end

	- defp load_from_file_stream(stream) do
	+ defp load_from_file_stream(stream, emoji_groups) do
	stream
	\|> Stream.map(&String.trim/1)
	\|> Stream.map(fn line ->
	case String.split(line, ~r/,\s*/) do
	[name, file] ->
	- {name, file, [to_string(match_extra(@groups, file))]}
	+ {name, file, [to_string(match_extra(emoji_groups, file))]}

	[name, file \| tags] ->
	{name, file, tags}

	_ ->
	nil
	end
	end)
	\|> Enum.to_list()
	end

	- defp load_from_globs(globs) do
	+ defp load_from_globs(globs, emoji_groups) do
	static_path = Path.join(:code.priv_dir(:pleroma), "static")

	paths =
	Enum.map(globs, fn glob ->
	Path.join(static_path, glob)
	\|> Path.wildcard()
	end)
	\|> Enum.concat()

	Enum.map(paths, fn path ->
	- tag = match_extra(@groups, Path.join("/", Path.relative_to(path, static_path)))
	+ tag = match_extra(emoji_groups, Path.join("/", Path.relative_to(path, static_path)))
	shortcode = Path.basename(path, Path.extname(path))
	external_path = Path.join("/", Path.relative_to(path, static_path))
	{shortcode, external_path, [to_string(tag)]}
	end)
	end

	@doc """
	Finds a matching group for the given emoji filename
	"""
	@spec match_extra(group_patterns(), String.t()) :: atom() \| nil
	def match_extra(group_patterns, filename) do
	match_group_patterns(group_patterns, fn pattern ->
	case pattern do
	%Regex{} = regex -> Regex.match?(regex, filename)
	string when is_binary(string) -> filename == string
	end
	end)
	end

	defp match_group_patterns(group_patterns, matcher) do
	Enum.find_value(group_patterns, fn {group, patterns} ->
	patterns =
	patterns
	\|> List.wrap()
	\|> Enum.map(fn pattern ->
	if String.contains?(pattern, "*") do
	~r(#{String.replace(pattern, "", ".")})
	else
	pattern
	end
	end)

	Enum.any?(patterns, matcher) && group
	end)
	end
	end
	diff --git a/lib/pleroma/instances.ex b/lib/pleroma/instances.ex
	index 5e107f4c9..fa5043bc5 100644
	--- a/lib/pleroma/instances.ex
	+++ b/lib/pleroma/instances.ex
	@@ -1,36 +1,36 @@
	defmodule Pleroma.Instances do
	@moduledoc "Instances context."

	@adapter Pleroma.Instances.Instance

	defdelegate filter_reachable(urls_or_hosts), to: @adapter
	defdelegate reachable?(url_or_host), to: @adapter
	defdelegate set_reachable(url_or_host), to: @adapter
	defdelegate set_unreachable(url_or_host, unreachable_since \\ nil), to: @adapter

	def set_consistently_unreachable(url_or_host),
	do: set_unreachable(url_or_host, reachability_datetime_threshold())

	def reachability_datetime_threshold do
	federation_reachability_timeout_days =
	- Pleroma.Config.get(:instance)[:federation_reachability_timeout_days] \|\| 0
	+ Pleroma.Config.get([:instance, :federation_reachability_timeout_days], 0)

	if federation_reachability_timeout_days > 0 do
	NaiveDateTime.add(
	NaiveDateTime.utc_now(),
	-federation_reachability_timeout_days * 24 * 3600,
	:second
	)
	else
	~N[0000-01-01 00:00:00]
	end
	end

	def host(url_or_host) when is_binary(url_or_host) do
	if url_or_host =~ ~r/^http/i do
	URI.parse(url_or_host).host
	else
	url_or_host
	end
	end
	end
	diff --git a/lib/pleroma/plugs/uploaded_media.ex b/lib/pleroma/plugs/uploaded_media.ex
	index fd77b8d8f..8d0fac7ee 100644
	--- a/lib/pleroma/plugs/uploaded_media.ex
	+++ b/lib/pleroma/plugs/uploaded_media.ex
	@@ -1,90 +1,90 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Plugs.UploadedMedia do
	@moduledoc """
	"""

	import Plug.Conn
	require Logger

	@behaviour Plug
	# no slashes
	@path "media"

	def init(_opts) do
	static_plug_opts =
	[]
	\|> Keyword.put(:from, "__unconfigured_media_plug")
	\|> Keyword.put(:at, "/__unconfigured_media_plug")
	\|> Plug.Static.init()

	%{static_plug_opts: static_plug_opts}
	end

	def call(%{request_path: <<"/", @path, "/", file::binary>>} = conn, opts) do
	conn =
	case fetch_query_params(conn) do
	%{query_params: %{"name" => name}} = conn ->
	name = String.replace(name, "\"", "\\\"")

	conn
	\|> put_resp_header("content-disposition", "filename=\"#{name}\"")

	conn ->
	conn
	end

	- config = Pleroma.Config.get([Pleroma.Upload])
	+ config = Pleroma.Config.get(Pleroma.Upload)

	with uploader <- Keyword.fetch!(config, :uploader),
	proxy_remote = Keyword.get(config, :proxy_remote, false),
	{:ok, get_method} <- uploader.get_file(file) do
	get_media(conn, get_method, proxy_remote, opts)
	else
	_ ->
	conn
	\|> send_resp(500, "Failed")
	\|> halt()
	end
	end

	def call(conn, _opts), do: conn

	defp get_media(conn, {:static_dir, directory}, _, opts) do
	static_opts =
	Map.get(opts, :static_plug_opts)
	\|> Map.put(:at, [@path])
	\|> Map.put(:from, directory)

	conn = Plug.Static.call(conn, static_opts)

	if conn.halted do
	conn
	else
	conn
	\|> send_resp(404, "Not found")
	\|> halt()
	end
	end

	defp get_media(conn, {:url, url}, true, _) do
	conn
	\|> Pleroma.ReverseProxy.call(url, Pleroma.Config.get([Pleroma.Upload, :proxy_opts], []))
	end

	defp get_media(conn, {:url, url}, _, _) do
	conn
	\|> Phoenix.Controller.redirect(external: url)
	\|> halt()
	end

	defp get_media(conn, unknown, _, _) do
	Logger.error("#{__MODULE__}: Unknown get startegy: #{inspect(unknown)}")

	conn
	\|> send_resp(500, "Internal Error")
	\|> halt()
	end
	end
	diff --git a/lib/pleroma/reverse_proxy.ex b/lib/pleroma/reverse_proxy.ex
	index 285d57309..de0f6e1bc 100644
	--- a/lib/pleroma/reverse_proxy.ex
	+++ b/lib/pleroma/reverse_proxy.ex
	@@ -1,380 +1,382 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ReverseProxy do
	alias Pleroma.HTTP

	@keep_req_headers ~w(accept user-agent accept-encoding cache-control if-modified-since) ++
	~w(if-unmodified-since if-none-match if-range range)
	@resp_cache_headers ~w(etag date last-modified cache-control)
	@keep_resp_headers @resp_cache_headers ++
	~w(content-type content-disposition content-encoding content-range) ++
	~w(accept-ranges vary)
	@default_cache_control_header "public, max-age=1209600"
	@valid_resp_codes [200, 206, 304]
	@max_read_duration :timer.seconds(30)
	@max_body_length :infinity
	@methods ~w(GET HEAD)

	@moduledoc """
	A reverse proxy.

	Pleroma.ReverseProxy.call(conn, url, options)

	It is not meant to be added into a plug pipeline, but to be called from another plug or controller.

	Supports `#{inspect(@methods)}` HTTP methods, and only allows `#{inspect(@valid_resp_codes)}` status codes.

	Responses are chunked to the client while downloading from the upstream.

	Some request / responses headers are preserved:

	* request: `#{inspect(@keep_req_headers)}`
	* response: `#{inspect(@keep_resp_headers)}`

	If no caching headers (`#{inspect(@resp_cache_headers)}`) are returned by upstream, `cache-control` will be
	set to `#{inspect(@default_cache_control_header)}`.

	Options:

	* `redirect_on_failure` (default `false`). Redirects the client to the real remote URL if there's any HTTP
	errors. Any error during body processing will not be redirected as the response is chunked. This may expose
	remote URL, clients IPs, ….

	* `max_body_length` (default `#{inspect(@max_body_length)}`): limits the content length to be approximately the
	specified length. It is validated with the `content-length` header and also verified when proxying.

	* `max_read_duration` (default `#{inspect(@max_read_duration)}` ms): the total time the connection is allowed to
	read from the remote upstream.

	* `inline_content_types`:
	* `true` will not alter `content-disposition` (up to the upstream),
	* `false` will add `content-disposition: attachment` to any request,
	* a list of whitelisted content types

	* `keep_user_agent` will forward the client's user-agent to the upstream. This may be useful if the upstream is
	doing content transformation (encoding, …) depending on the request.

	* `req_headers`, `resp_headers` additional headers.

	* `http`: options for [hackney](https://github.com/benoitc/hackney).

	"""
	@default_hackney_options []

	@inline_content_types [
	"image/gif",
	"image/jpeg",
	"image/jpg",
	"image/png",
	"image/svg+xml",
	"audio/mpeg",
	"audio/mp3",
	"video/webm",
	"video/mp4",
	"video/quicktime"
	]

	require Logger
	import Plug.Conn

	@type option() ::
	{:keep_user_agent, boolean}
	\| {:max_read_duration, :timer.time() \| :infinity}
	\| {:max_body_length, non_neg_integer() \| :infinity}
	\| {:http, []}
	\| {:req_headers, [{String.t(), String.t()}]}
	\| {:resp_headers, [{String.t(), String.t()}]}
	\| {:inline_content_types, boolean() \| [String.t()]}
	\| {:redirect_on_failure, boolean()}

	@spec call(Plug.Conn.t(), url :: String.t(), [option()]) :: Plug.Conn.t()
	def call(_conn, _url, _opts \\ [])

	def call(conn = %{method: method}, url, opts) when method in @methods do
	hackney_opts =
	@default_hackney_options
	\|> Keyword.merge(Keyword.get(opts, :http, []))
	\|> HTTP.process_request_options()

	req_headers = build_req_headers(conn.req_headers, opts)

	opts =
	if filename = Pleroma.Web.MediaProxy.filename(url) do
	Keyword.put_new(opts, :attachment_name, filename)
	else
	opts
	end

	with {:ok, code, headers, client} <- request(method, url, req_headers, hackney_opts),
	:ok <- header_length_constraint(headers, Keyword.get(opts, :max_body_length)) do
	response(conn, client, url, code, headers, opts)
	else
	{:ok, code, headers} ->
	head_response(conn, url, code, headers, opts)
	\|> halt()

	{:error, {:invalid_http_response, code}} ->
	Logger.error("#{__MODULE__}: request to #{inspect(url)} failed with HTTP status #{code}")

	conn
	\|> error_or_redirect(
	url,
	code,
	"Request failed: " <> Plug.Conn.Status.reason_phrase(code),
	opts
	)
	\|> halt()

	{:error, error} ->
	Logger.error("#{__MODULE__}: request to #{inspect(url)} failed: #{inspect(error)}")

	conn
	\|> error_or_redirect(url, 500, "Request failed", opts)
	\|> halt()
	end
	end

	def call(conn, _, _) do
	conn
	\|> send_resp(400, Plug.Conn.Status.reason_phrase(400))
	\|> halt()
	end

	defp request(method, url, headers, hackney_opts) do
	Logger.debug("#{__MODULE__} #{method} #{url} #{inspect(headers)}")
	method = method \|> String.downcase() \|> String.to_existing_atom()

	- case :hackney.request(method, url, headers, "", hackney_opts) do
	+ case hackney().request(method, url, headers, "", hackney_opts) do
	{:ok, code, headers, client} when code in @valid_resp_codes ->
	{:ok, code, downcase_headers(headers), client}

	{:ok, code, headers} when code in @valid_resp_codes ->
	{:ok, code, downcase_headers(headers)}

	{:ok, code, _, _} ->
	{:error, {:invalid_http_response, code}}

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

	defp response(conn, client, url, status, headers, opts) do
	result =
	conn
	\|> put_resp_headers(build_resp_headers(headers, opts))
	\|> send_chunked(status)
	\|> chunk_reply(client, opts)

	case result do
	{:ok, conn} ->
	halt(conn)

	{:error, :closed, conn} ->
	:hackney.close(client)
	halt(conn)

	{:error, error, conn} ->
	Logger.warn(
	"#{__MODULE__} request to #{url} failed while reading/chunking: #{inspect(error)}"
	)

	:hackney.close(client)
	halt(conn)
	end
	end

	defp chunk_reply(conn, client, opts) do
	chunk_reply(conn, client, opts, 0, 0)
	end

	defp chunk_reply(conn, client, opts, sent_so_far, duration) do
	with {:ok, duration} <-
	check_read_duration(
	duration,
	Keyword.get(opts, :max_read_duration, @max_read_duration)
	),
	- {:ok, data} <- :hackney.stream_body(client),
	+ {:ok, data} <- hackney().stream_body(client),
	{:ok, duration} <- increase_read_duration(duration),
	sent_so_far = sent_so_far + byte_size(data),
	:ok <- body_size_constraint(sent_so_far, Keyword.get(opts, :max_body_size)),
	{:ok, conn} <- chunk(conn, data) do
	chunk_reply(conn, client, opts, sent_so_far, duration)
	else
	:done -> {:ok, conn}
	{:error, error} -> {:error, error, conn}
	end
	end

	defp head_response(conn, _url, code, headers, opts) do
	conn
	\|> put_resp_headers(build_resp_headers(headers, opts))
	\|> send_resp(code, "")
	end

	defp error_or_redirect(conn, url, code, body, opts) do
	if Keyword.get(opts, :redirect_on_failure, false) do
	conn
	\|> Phoenix.Controller.redirect(external: url)
	\|> halt()
	else
	conn
	\|> send_resp(code, body)
	\|> halt
	end
	end

	defp downcase_headers(headers) do
	Enum.map(headers, fn {k, v} ->
	{String.downcase(k), v}
	end)
	end

	defp get_content_type(headers) do
	{_, content_type} =
	List.keyfind(headers, "content-type", 0, {"content-type", "application/octet-stream"})

	[content_type \| _] = String.split(content_type, ";")
	content_type
	end

	defp put_resp_headers(conn, headers) do
	Enum.reduce(headers, conn, fn {k, v}, conn ->
	put_resp_header(conn, k, v)
	end)
	end

	defp build_req_headers(headers, opts) do
	headers
	\|> downcase_headers()
	\|> Enum.filter(fn {k, _} -> k in @keep_req_headers end)
	\|> (fn headers ->
	headers = headers ++ Keyword.get(opts, :req_headers, [])

	if Keyword.get(opts, :keep_user_agent, false) do
	List.keystore(
	headers,
	"user-agent",
	0,
	{"user-agent", Pleroma.Application.user_agent()}
	)
	else
	headers
	end
	end).()
	end

	defp build_resp_headers(headers, opts) do
	headers
	\|> Enum.filter(fn {k, _} -> k in @keep_resp_headers end)
	\|> build_resp_cache_headers(opts)
	\|> build_resp_content_disposition_header(opts)
	\|> (fn headers -> headers ++ Keyword.get(opts, :resp_headers, []) end).()
	end

	defp build_resp_cache_headers(headers, _opts) do
	has_cache? = Enum.any?(headers, fn {k, _} -> k in @resp_cache_headers end)
	has_cache_control? = List.keymember?(headers, "cache-control", 0)

	cond do
	has_cache? && has_cache_control? ->
	headers

	has_cache? ->
	# There's caching header present but no cache-control -- we need to explicitely override it
	# to public as Plug defaults to "max-age=0, private, must-revalidate"
	List.keystore(headers, "cache-control", 0, {"cache-control", "public"})

	true ->
	List.keystore(
	headers,
	"cache-control",
	0,
	{"cache-control", @default_cache_control_header}
	)
	end
	end

	defp build_resp_content_disposition_header(headers, opts) do
	opt = Keyword.get(opts, :inline_content_types, @inline_content_types)

	content_type = get_content_type(headers)

	attachment? =
	cond do
	is_list(opt) && !Enum.member?(opt, content_type) -> true
	opt == false -> true
	true -> false
	end

	if attachment? do
	name =
	try do
	{{"content-disposition", content_disposition_string}, _} =
	List.keytake(headers, "content-disposition", 0)

	[name \| _] =
	Regex.run(
	~r/filename="((?:[^"\\]\|\\.)*)"/u,
	content_disposition_string \|\| "",
	capture: :all_but_first
	)

	name
	rescue
	MatchError -> Keyword.get(opts, :attachment_name, "attachment")
	end

	disposition = "attachment; filename=\"#{name}\""

	List.keystore(headers, "content-disposition", 0, {"content-disposition", disposition})
	else
	headers
	end
	end

	defp header_length_constraint(headers, limit) when is_integer(limit) and limit > 0 do
	with {_, size} <- List.keyfind(headers, "content-length", 0),
	{size, _} <- Integer.parse(size),
	true <- size <= limit do
	:ok
	else
	false ->
	{:error, :body_too_large}

	_ ->
	:ok
	end
	end

	defp header_length_constraint(_, _), do: :ok

	defp body_size_constraint(size, limit) when is_integer(limit) and limit > 0 and size >= limit do
	{:error, :body_too_large}
	end

	defp body_size_constraint(_, _), do: :ok

	defp check_read_duration(duration, max)
	when is_integer(duration) and is_integer(max) and max > 0 do
	if duration > max do
	{:error, :read_duration_exceeded}
	else
	{:ok, {duration, :erlang.system_time(:millisecond)}}
	end
	end

	defp check_read_duration(_, _), do: {:ok, :no_duration_limit, :no_duration_limit}

	defp increase_read_duration({previous_duration, started})
	when is_integer(previous_duration) and is_integer(started) do
	duration = :erlang.system_time(:millisecond) - started
	{:ok, previous_duration + duration}
	end

	defp increase_read_duration(_) do
	{:ok, :no_duration_limit, :no_duration_limit}
	end
	+
	+ defp hackney, do: Pleroma.Config.get(:hackney, :hackney)
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 9449a88d0..3a9ae8d73 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,1330 +1,1328 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query

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

	require Logger

	@type t :: %__MODULE__{}

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

	# credo:disable-for-next-line Credo.Check.Readability.MaxLineLength
	@email_regex ~r/^[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)$/

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

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

	timestamps()
	end

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

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

	def visible_for?(user, for_user \\ nil)

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

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

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

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

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

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

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

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

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

	def user_info(%User{} = user) do
	%{
	following_count: following_count(user),
	note_count: user.info.note_count,
	follower_count: user.info.follower_count,
	locked: user.info.locked,
	confirmation_pending: user.info.confirmation_pending,
	default_scope: user.info.default_scope
	}
	end

	def 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
	params =
	params
	\|> Map.put(:info, params[:info] \|\| %{})

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

	changes =
	%User{}
	\|> cast(params, [:bio, :name, :ap_id, :nickname, :avatar])
	\|> validate_required([:name, :ap_id])
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: 5000)
	\|> validate_length(:name, max: 100)
	\|> put_change(:local, false)
	\|> put_embed(:info, info_cng)

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

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

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

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

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

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

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

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

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

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

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

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

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	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: 1000)
	\|> validate_length(:name, min: 1, max: 100)
	\|> put_change(:info, info_change)

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

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

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

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

	autofollowed_users =
	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} <- 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

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

	{:ok, _} = update_follower_count(followed)

	set_cache(follower)
	end
	end

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

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

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

	{:ok, followed} = update_follower_count(followed)

	set_cache(follower)

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

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

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

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

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

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

	get_cached_by_nickname(nickname)
	end

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

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

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

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

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

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

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

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

	get_cached_by_ap_id(ap_id)
	end

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

	Cachex.fetch!(:user_cache, key, fn ->
	user_result = get_or_fetch_by_nickname(nickname)

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

	def get_cached_by_nickname_or_id(nickname_or_id) do
	get_cached_by_id(nickname_or_id) \|\| get_cached_by_nickname(nickname_or_id)
	end

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

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

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

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

	def fetch_by_nickname(nickname) do
	ap_try = ActivityPub.make_user_from_nickname(nickname)

	case ap_try do
	{:ok, user} -> {:ok, user}
	_ -> OStatus.make_user(nickname)
	end
	end

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

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

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

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

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

	@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

	def update_follower_count(%User{} = user) 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
	end

	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

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

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

	update_and_set_cache(cng)
	end

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

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

	update_and_set_cache(cng)
	end

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

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

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

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

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

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

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

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

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

	{:ok, blocker} = update_follower_count(blocker)

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

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

	update_and_set_cache(cng)
	end

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

	def unblock(blocker, %{ap_id: ap_id}) do
	info_cng =
	blocker.info
	\|> User.Info.remove_from_block(ap_id)

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

	update_and_set_cache(cng)
	end

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

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

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

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

	@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} = User.deactivate(user)

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

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

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

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

	delete_user_activities(user)
	end

	@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

	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
	stream =
	ap_id
	\|> Activity.query_by_actor()
	\|> Repo.stream()

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

	{:ok, user}
	end

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

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

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

	- @default_scrubbers Pleroma.Config.get([:markup, :scrub_policy])
	-
	- def html_filter_policy(_), do: @default_scrubbers
	+ def 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

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

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

	{:ok, user} = Repo.insert(changes)
	user
	end
	end

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

	{:ok, key}
	end

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

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

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

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

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

	@doc "Gets or fetch a user by uri or nickname."
	@spec get_or_fetch(String.t()) :: {: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

	@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) do
	info = user.info

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

	info_cng =
	info
	\|> User.Info.set_keys(pem)

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

	update_and_set_cache(cng)
	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
	end
	diff --git a/lib/pleroma/web/activity_pub/publisher.ex b/lib/pleroma/web/activity_pub/publisher.ex
	index 8f1399ce6..a05e03263 100644
	--- a/lib/pleroma/web/activity_pub/publisher.ex
	+++ b/lib/pleroma/web/activity_pub/publisher.ex
	@@ -1,151 +1,151 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Publisher do
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.HTTP
	alias Pleroma.Instances
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier

	import Pleroma.Web.ActivityPub.Visibility

	@behaviour Pleroma.Web.Federator.Publisher

	require Logger

	@moduledoc """
	ActivityPub outgoing federation module.
	"""

	@doc """
	Determine if an activity can be represented by running it through Transmogrifier.
	"""
	def is_representable?(%Activity{} = activity) do
	with {:ok, _data} <- Transmogrifier.prepare_outgoing(activity.data) do
	true
	else
	_e ->
	false
	end
	end

	@doc """
	Publish a single message to a peer. Takes a struct with the following
	parameters set:

	* `inbox`: the inbox to publish to
	* `json`: the JSON message body representing the ActivityPub message
	* `actor`: the actor which is signing the message
	* `id`: the ActivityStreams URI of the message
	"""
	def publish_one(%{inbox: inbox, json: json, actor: %User{} = actor, id: id} = params) do
	Logger.info("Federating #{id} to #{inbox}")
	host = URI.parse(inbox).host

	digest = "SHA-256=" <> (:crypto.hash(:sha256, json) \|> Base.encode64())

	date =
	NaiveDateTime.utc_now()
	\|> Timex.format!("{WDshort}, {0D} {Mshort} {YYYY} {h24}:{m}:{s} GMT")

	signature =
	Pleroma.Signature.sign(actor, %{
	host: host,
	"content-length": byte_size(json),
	digest: digest,
	date: date
	})

	with {:ok, %{status: code}} when code in 200..299 <-
	result =
	HTTP.post(
	inbox,
	json,
	[
	{"Content-Type", "application/activity+json"},
	{"Date", date},
	{"signature", signature},
	{"digest", digest}
	]
	) do
	if !Map.has_key?(params, :unreachable_since) \|\| params[:unreachable_since],
	do: Instances.set_reachable(inbox)

	result
	else
	{_post_result, response} ->
	unless params[:unreachable_since], do: Instances.set_unreachable(inbox)
	{:error, response}
	end
	end

	defp should_federate?(inbox, public) do
	if public do
	true
	else
	inbox_info = URI.parse(inbox)
	- !Enum.member?(Pleroma.Config.get([:instance, :quarantined_instances], []), inbox_info.host)
	+ !Enum.member?(Config.get([:instance, :quarantined_instances], []), inbox_info.host)
	end
	end

	@doc """
	Publishes an activity to all relevant peers.
	"""
	def publish(%User{} = actor, %Activity{} = activity) do
	remote_followers =
	if actor.follower_address in activity.recipients do
	{:ok, followers} = User.get_followers(actor)
	followers \|> Enum.filter(&(!&1.local))
	else
	[]
	end

	public = is_public?(activity)

	if public && Config.get([:instance, :allow_relay]) do
	Logger.info(fn -> "Relaying #{activity.data["id"]} out" end)
	Relay.publish(activity)
	end

	{:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
	json = Jason.encode!(data)

	(Pleroma.Web.Salmon.remote_users(activity) ++ remote_followers)
	\|> Enum.filter(fn user -> User.ap_enabled?(user) end)
	\|> Enum.map(fn %{info: %{source_data: data}} ->
	(is_map(data["endpoints"]) && Map.get(data["endpoints"], "sharedInbox")) \|\| data["inbox"]
	end)
	\|> Enum.uniq()
	\|> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
	\|> Instances.filter_reachable()
	\|> Enum.each(fn {inbox, unreachable_since} ->
	Pleroma.Web.Federator.Publisher.enqueue_one(
	__MODULE__,
	%{
	inbox: inbox,
	json: json,
	actor: actor,
	id: activity.data["id"],
	unreachable_since: unreachable_since
	}
	)
	end)
	end

	def gather_webfinger_links(%User{} = user) do
	[
	%{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
	%{
	"rel" => "self",
	"type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
	"href" => user.ap_id
	}
	]
	end

	def gather_nodeinfo_protocol_names, do: ["activitypub"]
	end
	diff --git a/lib/pleroma/web/admin_api/admin_api_controller.ex b/lib/pleroma/web/admin_api/admin_api_controller.ex
	index de2a13c01..03dfdca82 100644
	--- a/lib/pleroma/web/admin_api/admin_api_controller.ex
	+++ b/lib/pleroma/web/admin_api/admin_api_controller.ex
	@@ -1,410 +1,447 @@
	# 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: "."
	}

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

	conn
	\|> json(user.nickname)
	end

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

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

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

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

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

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

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

	search_params = %{
	query: params["query"],
	page: page,
	page_size: page_size,
	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
	conn
	\|> put_status(404)
	\|> json(%{error: "No such permission_group"})
	end

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

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

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

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

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

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

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

	json(conn, info)
	end
	end

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

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

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

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

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

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

	conn
	\|> json(invite.token)
	end

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

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

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

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

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

	conn
	\|> json(token.token)
	end

	def 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 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
	+ %{"key" => key, "value" => value} ->
	+ {:ok, config} = Config.update_or_create(%{key: key, value: value})
	+ config
	+
	+ %{"key" => key, "delete" => "true"} ->
	+ {:ok, _} = Config.delete(key)
	+ nil
	+ 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)])
	+ updated
	+ else
	+ []
	+ end
	+
	+ conn
	+ \|> put_view(ConfigView)
	+ \|> render("index.json", %{configs: updated})
	+ end
	+
	def errors(conn, {:error, :not_found}) do
	conn
	\|> put_status(404)
	\|> json("Not found")
	end

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

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

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

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

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

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

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

	defp get_page_size(page_size_string) do
	case Integer.parse(page_size_string) do
	{page_size, _} -> page_size
	:error -> @users_page_size
	end
	end
	end
	diff --git a/lib/pleroma/web/admin_api/config.ex b/lib/pleroma/web/admin_api/config.ex
	new file mode 100644
	index 000000000..b7072f050
	--- /dev/null
	+++ b/lib/pleroma/web/admin_api/config.ex
	@@ -0,0 +1,144 @@
	+# 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.Config do
	+ use Ecto.Schema
	+ import Ecto.Changeset
	+ alias __MODULE__
	+ alias Pleroma.Repo
	+
	+ @type t :: %__MODULE__{}
	+
	+ schema "config" do
	+ field(:key, :string)
	+ field(:value, :binary)
	+
	+ timestamps()
	+ end
	+
	+ @spec get_by_key(String.t()) :: Config.t() \| nil
	+ def get_by_key(key), do: Repo.get_by(Config, key: key)
	+
	+ @spec changeset(Config.t(), map()) :: Changeset.t()
	+ def changeset(config, params \\ %{}) do
	+ config
	+ \|> cast(params, [:key, :value])
	+ \|> validate_required([:key, :value])
	+ \|> unique_constraint(:key)
	+ end
	+
	+ @spec create(map()) :: {:ok, Config.t()} \| {:error, Changeset.t()}
	+ def create(%{key: key, value: value}) do
	+ %Config{}
	+ \|> changeset(%{key: key, value: transform(value)})
	+ \|> Repo.insert()
	+ end
	+
	+ @spec update(Config.t(), map()) :: {:ok, Config} \| {:error, Changeset.t()}
	+ def update(%Config{} = config, %{value: value}) do
	+ config
	+ \|> change(value: transform(value))
	+ \|> Repo.update()
	+ end
	+
	+ @spec update_or_create(map()) :: {:ok, Config.t()} \| {:error, Changeset.t()}
	+ def update_or_create(%{key: key} = params) do
	+ with %Config{} = config <- Config.get_by_key(key) do
	+ Config.update(config, params)
	+ else
	+ nil -> Config.create(params)
	+ end
	+ end
	+
	+ @spec delete(String.t()) :: {:ok, Config.t()} \| {:error, Changeset.t()}
	+ def delete(key) do
	+ with %Config{} = config <- Config.get_by_key(key) do
	+ Repo.delete(config)
	+ else
	+ nil -> {:error, "Config with key #{key} not found"}
	+ end
	+ end
	+
	+ @spec from_binary(binary()) :: term()
	+ def from_binary(value), do: :erlang.binary_to_term(value)
	+
	+ @spec from_binary_to_map(binary()) :: any()
	+ def from_binary_to_map(binary) do
	+ from_binary(binary)
	+ \|> do_convert()
	+ end
	+
	+ defp do_convert([{k, v}] = value) when is_list(value) and length(value) == 1,
	+ do: %{k => do_convert(v)}
	+
	+ defp do_convert(values) when is_list(values), do: for(val <- values, do: do_convert(val))
	+
	+ defp do_convert({k, v} = value) when is_tuple(value),
	+ do: %{k => do_convert(v)}
	+
	+ defp do_convert(value) when is_binary(value) or is_atom(value) or is_map(value),
	+ do: value
	+
	+ @spec transform(any()) :: binary()
	+ def transform(entity) when is_map(entity) do
	+ tuples =
	+ for {k, v} <- entity,
	+ into: [],
	+ do: {if(is_atom(k), do: k, else: String.to_atom(k)), do_transform(v)}
	+
	+ Enum.reject(tuples, fn {_k, v} -> is_nil(v) end)
	+ \|> Enum.sort()
	+ \|> :erlang.term_to_binary()
	+ end
	+
	+ def transform(entity) when is_list(entity) do
	+ list = Enum.map(entity, &do_transform(&1))
	+ :erlang.term_to_binary(list)
	+ end
	+
	+ def transform(entity), do: :erlang.term_to_binary(entity)
	+
	+ defp do_transform(%Regex{} = value) when is_map(value), do: value
	+
	+ defp do_transform(value) when is_map(value) do
	+ values =
	+ for {key, val} <- value,
	+ into: [],
	+ do: {String.to_atom(key), do_transform(val)}
	+
	+ Enum.sort(values)
	+ end
	+
	+ defp do_transform(value) when is_list(value) do
	+ Enum.map(value, &do_transform(&1))
	+ end
	+
	+ defp do_transform(entity) when is_list(entity) and length(entity) == 1, do: hd(entity)
	+
	+ defp do_transform(value) when is_binary(value) do
	+ value = String.trim(value)
	+
	+ case String.length(value) do
	+ 0 ->
	+ nil
	+
	+ _ ->
	+ cond do
	+ String.starts_with?(value, "Pleroma") ->
	+ String.to_existing_atom("Elixir." <> value)
	+
	+ String.starts_with?(value, ":") ->
	+ String.replace(value, ":", "") \|> String.to_existing_atom()
	+
	+ String.starts_with?(value, "i:") ->
	+ String.replace(value, "i:", "") \|> String.to_integer()
	+
	+ true ->
	+ value
	+ end
	+ end
	+ end
	+
	+ defp do_transform(value), do: value
	+end
	diff --git a/lib/pleroma/web/admin_api/views/config_view.ex b/lib/pleroma/web/admin_api/views/config_view.ex
	new file mode 100644
	index 000000000..c8560033e
	--- /dev/null
	+++ b/lib/pleroma/web/admin_api/views/config_view.ex
	@@ -0,0 +1,16 @@
	+defmodule Pleroma.Web.AdminAPI.ConfigView do
	+ use Pleroma.Web, :view
	+
	+ def render("index.json", %{configs: configs}) do
	+ %{
	+ configs: render_many(configs, __MODULE__, "show.json", as: :config)
	+ }
	+ end
	+
	+ def render("show.json", %{config: config}) do
	+ %{
	+ key: config.key,
	+ value: Pleroma.Web.AdminAPI.Config.from_binary_to_map(config.value)
	+ }
	+ end
	+end
	diff --git a/lib/pleroma/web/endpoint.ex b/lib/pleroma/web/endpoint.ex
	index bd76e4295..ddaf88f1d 100644
	--- a/lib/pleroma/web/endpoint.ex
	+++ b/lib/pleroma/web/endpoint.ex
	@@ -1,137 +1,137 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Endpoint do
	use Phoenix.Endpoint, otp_app: :pleroma

	socket("/socket", Pleroma.Web.UserSocket)

	# Serve at "/" the static files from "priv/static" directory.
	#
	# You should set gzip to true if you are running phoenix.digest
	# when deploying your static files in production.
	plug(CORSPlug)
	plug(Pleroma.Plugs.HTTPSecurityPlug)

	plug(Pleroma.Plugs.UploadedMedia)

	@static_cache_control "public, no-cache"

	# InstanceStatic needs to be before Plug.Static to be able to override shipped-static files
	# If you're adding new paths to `only:` you'll need to configure them in InstanceStatic as well
	# Cache-control headers are duplicated in case we turn off etags in the future
	plug(Pleroma.Plugs.InstanceStatic,
	at: "/",
	gzip: true,
	cache_control_for_etags: @static_cache_control,
	headers: %{
	"cache-control" => @static_cache_control
	}
	)

	plug(
	Plug.Static,
	at: "/",
	from: :pleroma,
	only:
	~w(index.html robots.txt static finmoji emoji packs sounds images instance sw.js sw-pleroma.js favicon.png schemas doc),
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	gzip: true,
	cache_control_for_etags: @static_cache_control,
	headers: %{
	"cache-control" => @static_cache_control
	}
	)

	plug(Plug.Static.IndexHtml, at: "/pleroma/admin/")

	plug(Plug.Static,
	at: "/pleroma/admin/",
	from: {:pleroma, "priv/static/adminfe/"}
	)

	# Code reloading can be explicitly enabled under the
	# :code_reloader configuration of your endpoint.
	if code_reloading? do
	plug(Phoenix.CodeReloader)
	end

	plug(TrailingFormatPlug)
	plug(Plug.RequestId)
	plug(Plug.Logger)

	plug(
	Plug.Parsers,
	parsers: [:urlencoded, :multipart, :json],
	pass: ["/"],
	json_decoder: Jason,
	length: Pleroma.Config.get([:instance, :upload_limit]),
	body_reader: {Pleroma.Web.Plugs.DigestPlug, :read_body, []}
	)

	plug(Plug.MethodOverride)
	plug(Plug.Head)

	secure_cookies = Pleroma.Config.get([__MODULE__, :secure_cookie_flag])

	cookie_name =
	if secure_cookies,
	do: "__Host-pleroma_key",
	else: "pleroma_key"

	extra =
	Pleroma.Config.get([__MODULE__, :extra_cookie_attrs])
	\|> Enum.join(";")

	# The session will be stored in the cookie and signed,
	# this means its contents can be read but not tampered with.
	# Set :encryption_salt if you would also like to encrypt it.
	plug(
	Plug.Session,
	store: :cookie,
	key: cookie_name,
	- signing_salt: {Pleroma.Config, :get, [[__MODULE__, :signing_salt], "CqaoopA2"]},
	+ signing_salt: Pleroma.Config.get([__MODULE__, :signing_salt], "CqaoopA2"),
	http_only: true,
	secure: secure_cookies,
	extra: extra
	)

	# Note: the plug and its configuration is compile-time this can't be upstreamed yet
	if proxies = Pleroma.Config.get([__MODULE__, :reverse_proxies]) do
	plug(RemoteIp, proxies: proxies)
	end

	defmodule Instrumenter do
	use Prometheus.PhoenixInstrumenter
	end

	defmodule PipelineInstrumenter do
	use Prometheus.PlugPipelineInstrumenter
	end

	defmodule MetricsExporter do
	use Prometheus.PlugExporter
	end

	plug(PipelineInstrumenter)
	plug(MetricsExporter)

	plug(Pleroma.Web.Router)

	@doc """
	Dynamically loads configuration from the system environment
	on startup.

	It receives the endpoint configuration from the config files
	and must return the updated configuration.
	"""
	def load_from_system_env(config) do
	port = System.get_env("PORT") \|\| raise "expected the PORT environment variable to be set"
	{:ok, Keyword.put(config, :http, [:inet6, port: port])}
	end

	def websocket_url do
	String.replace_leading(url(), "http", "ws")
	end
	end
	diff --git a/lib/pleroma/web/oauth/token.ex b/lib/pleroma/web/oauth/token.ex
	index f412f7eb2..90c304487 100644
	--- a/lib/pleroma/web/oauth/token.ex
	+++ b/lib/pleroma/web/oauth/token.ex
	@@ -1,126 +1,127 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.Token do
	use Ecto.Schema

	import Ecto.Changeset

	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token
	alias Pleroma.Web.OAuth.Token.Query

	- @expires_in Pleroma.Config.get([:oauth2, :token_expires_in], 600)
	@type t :: %__MODULE__{}

	schema "oauth_tokens" do
	field(:token, :string)
	field(:refresh_token, :string)
	field(:scopes, {:array, :string}, default: [])
	field(:valid_until, :naive_datetime_usec)
	belongs_to(:user, User, type: Pleroma.FlakeId)
	belongs_to(:app, App)

	timestamps()
	end

	@doc "Gets token for app by access token"
	@spec get_by_token(App.t(), String.t()) :: {:ok, t()} \| {:error, :not_found}
	def get_by_token(%App{id: app_id} = _app, token) do
	Query.get_by_app(app_id)
	\|> Query.get_by_token(token)
	\|> Repo.find_resource()
	end

	@doc "Gets token for app by refresh token"
	@spec get_by_refresh_token(App.t(), String.t()) :: {:ok, t()} \| {:error, :not_found}
	def get_by_refresh_token(%App{id: app_id} = _app, token) do
	Query.get_by_app(app_id)
	\|> Query.get_by_refresh_token(token)
	\|> Query.preload([:user])
	\|> Repo.find_resource()
	end

	@spec exchange_token(App.t(), Authorization.t()) ::
	{:ok, Token.t()} \| {:error, Changeset.t()}
	def exchange_token(app, auth) do
	with {:ok, auth} <- Authorization.use_token(auth),
	true <- auth.app_id == app.id do
	user = if auth.user_id, do: User.get_cached_by_id(auth.user_id), else: %User{}

	create_token(
	app,
	user,
	%{scopes: auth.scopes}
	)
	end
	end

	defp put_token(changeset) do
	changeset
	\|> change(%{token: Token.Utils.generate_token()})
	\|> validate_required([:token])
	\|> unique_constraint(:token)
	end

	defp put_refresh_token(changeset, attrs) do
	refresh_token = Map.get(attrs, :refresh_token, Token.Utils.generate_token())

	changeset
	\|> change(%{refresh_token: refresh_token})
	\|> validate_required([:refresh_token])
	\|> unique_constraint(:refresh_token)
	end

	defp put_valid_until(changeset, attrs) do
	expires_in =
	- Map.get(attrs, :valid_until, NaiveDateTime.add(NaiveDateTime.utc_now(), @expires_in))
	+ Map.get(attrs, :valid_until, NaiveDateTime.add(NaiveDateTime.utc_now(), expires_in()))

	changeset
	\|> change(%{valid_until: expires_in})
	\|> validate_required([:valid_until])
	end

	@spec create_token(App.t(), User.t(), map()) :: {:ok, Token} \| {:error, Changeset.t()}
	def create_token(%App{} = app, %User{} = user, attrs \\ %{}) do
	%__MODULE__{user_id: user.id, app_id: app.id}
	\|> cast(%{scopes: attrs[:scopes] \|\| app.scopes}, [:scopes])
	\|> validate_required([:scopes, :app_id])
	\|> put_valid_until(attrs)
	\|> put_token()
	\|> put_refresh_token(attrs)
	\|> Repo.insert()
	end

	def delete_user_tokens(%User{id: user_id}) do
	Query.get_by_user(user_id)
	\|> Repo.delete_all()
	end

	def delete_user_token(%User{id: user_id}, token_id) do
	Query.get_by_user(user_id)
	\|> Query.get_by_id(token_id)
	\|> Repo.delete_all()
	end

	def delete_expired_tokens do
	Query.get_expired_tokens()
	\|> Repo.delete_all()
	end

	def get_user_tokens(%User{id: user_id}) do
	Query.get_by_user(user_id)
	\|> Query.preload([:app])
	\|> Repo.all()
	end

	def is_expired?(%__MODULE__{valid_until: valid_until}) do
	NaiveDateTime.diff(NaiveDateTime.utc_now(), valid_until) > 0
	end

	def is_expired?(_), do: false
	+
	+ defp expires_in, do: Pleroma.Config.get([:oauth2, :token_expires_in], 600)
	end
	diff --git a/lib/pleroma/web/oauth/token/response.ex b/lib/pleroma/web/oauth/token/response.ex
	index 64e78b183..2648571ad 100644
	--- a/lib/pleroma/web/oauth/token/response.ex
	+++ b/lib/pleroma/web/oauth/token/response.ex
	@@ -1,32 +1,32 @@
	defmodule Pleroma.Web.OAuth.Token.Response do
	@moduledoc false

	alias Pleroma.User
	alias Pleroma.Web.OAuth.Token.Utils

	- @expires_in Pleroma.Config.get([:oauth2, :token_expires_in], 600)
	-
	@doc false
	def build(%User{} = user, token, opts \\ %{}) do
	%{
	token_type: "Bearer",
	access_token: token.token,
	refresh_token: token.refresh_token,
	- expires_in: @expires_in,
	+ expires_in: expires_in(),
	scope: Enum.join(token.scopes, " "),
	me: user.ap_id
	}
	\|> Map.merge(opts)
	end

	def build_for_client_credentials(token) do
	%{
	token_type: "Bearer",
	access_token: token.token,
	refresh_token: token.refresh_token,
	created_at: Utils.format_created_at(token),
	- expires_in: @expires_in,
	+ expires_in: expires_in(),
	scope: Enum.join(token.scopes, " ")
	}
	end
	+
	+ defp expires_in, do: Pleroma.Config.get([:oauth2, :token_expires_in], 600)
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index 17733a77b..0e3f73226 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,774 +1,777 @@
	# 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)
	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)
	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)
	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", UtilController, :show_password_reset)
	post("/password_reset", UtilController, :password_reset)
	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)

	# TODO: to be removed at version 1.0
	delete("/user", AdminAPIController, :user_delete)
	post("/user", AdminAPIController, :user_create)

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

	# TODO: to be removed at version 1.0
	get("/permission_group/:nickname", AdminAPIController, :right_get)
	get("/permission_group/:nickname/:permission_group", AdminAPIController, :right_get)
	post("/permission_group/:nickname/:permission_group", AdminAPIController, :right_add)
	delete("/permission_group/:nickname/:permission_group", AdminAPIController, :right_delete)

	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)

	# TODO: to be removed at version 1.0
	get("/password_reset", AdminAPIController, :get_password_reset)

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

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

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

	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)

	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_relay 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)
	end

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

	get("/oembed", OEmbed.OEmbedController, :url)
	end

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

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

	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	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
	end

	scope "/relay", Pleroma.Web.ActivityPub do
	pipe_through(:ap_relay)
	get("/", ActivityPubController, :relay)
	end

	scope "/", Pleroma.Web.ActivityPub do
	pipe_through(:activitypub)
	post("/inbox", ActivityPubController, :inbox)
	post("/users/:nickname/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)

	scope [] do
	pipe_through(:oauth_read_or_public)
	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

	defmodule Fallback.RedirectController do
	use Pleroma.Web, :controller
	alias Pleroma.User
	alias Pleroma.Web.Metadata

	def api_not_implemented(conn, _params) do
	conn
	\|> put_status(404)
	\|> json(%{error: "Not implemented"})
	end

	def redirector(conn, _params, code \\ 200) do
	conn
	\|> put_resp_content_type("text/html")
	\|> send_file(code, index_file_path())
	end

	def redirector_with_meta(conn, %{"maybe_nickname_or_id" => maybe_nickname_or_id} = params) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(maybe_nickname_or_id) do
	redirector_with_meta(conn, %{user: user})
	else
	nil ->
	redirector(conn, params)
	end
	end

	def redirector_with_meta(conn, params) do
	{:ok, index_content} = File.read(index_file_path())
	tags = Metadata.build_tags(params)
	response = String.replace(index_content, "<!--server-generated-meta-->", tags)

	conn
	\|> put_resp_content_type("text/html")
	\|> send_resp(200, response)
	end

	def index_file_path do
	Pleroma.Plugs.InstanceStatic.file_path("index.html")
	end

	def registration_page(conn, params) do
	redirector(conn, params)
	end

	def empty(conn, _params) do
	conn
	\|> put_status(204)
	\|> text("")
	end
	end
	diff --git a/priv/repo/migrations/20190518032627_create_config.exs b/priv/repo/migrations/20190518032627_create_config.exs
	new file mode 100644
	index 000000000..1e4e3c689
	--- /dev/null
	+++ b/priv/repo/migrations/20190518032627_create_config.exs
	@@ -0,0 +1,13 @@
	+defmodule Pleroma.Repo.Migrations.CreateConfig do
	+ use Ecto.Migration
	+
	+ def change do
	+ create table(:config) do
	+ add(:key, :string)
	+ add(:value, :binary)
	+ timestamps()
	+ end
	+
	+ create(unique_index(:config, :key))
	+ end
	+end
	diff --git a/test/config/transfer_task_test.exs b/test/config/transfer_task_test.exs
	new file mode 100644
	index 000000000..9b8a8dd45
	--- /dev/null
	+++ b/test/config/transfer_task_test.exs
	@@ -0,0 +1,35 @@
	+defmodule Pleroma.Config.TransferTaskTest do
	+ use Pleroma.DataCase
	+
	+ setup do
	+ dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
	+
	+ Pleroma.Config.put([:instance, :dynamic_configuration], true)
	+
	+ on_exit(fn ->
	+ Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
	+ end)
	+ end
	+
	+ test "transfer config values from db to env" do
	+ refute Application.get_env(:pleroma, :test_key)
	+ Pleroma.Web.AdminAPI.Config.create(%{key: "test_key", value: [live: 2, com: 3]})
	+
	+ Pleroma.Config.TransferTask.start_link()
	+
	+ assert Application.get_env(:pleroma, :test_key) == [live: 2, com: 3]
	+
	+ on_exit(fn ->
	+ Application.delete_env(:pleroma, :test_key)
	+ end)
	+ end
	+
	+ test "non existing atom" do
	+ Pleroma.Web.AdminAPI.Config.create(%{key: "undefined_atom_key", value: [live: 2, com: 3]})
	+
	+ assert ExUnit.CaptureLog.capture_log(fn ->
	+ Pleroma.Config.TransferTask.start_link()
	+ end) =~
	+ "updating env causes error, key: \"undefined_atom_key\", error: %ArgumentError{message: \"argument error\"}"
	+ end
	+end
	diff --git a/test/support/factory.ex b/test/support/factory.ex
	index be6247ca4..5be34660e 100644
	--- a/test/support/factory.ex
	+++ b/test/support/factory.ex
	@@ -1,313 +1,326 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Factory do
	use ExMachina.Ecto, repo: Pleroma.Repo
	alias Pleroma.User

	def participation_factory do
	conversation = insert(:conversation)
	user = insert(:user)

	%Pleroma.Conversation.Participation{
	conversation: conversation,
	user: user,
	read: false
	}
	end

	def conversation_factory do
	%Pleroma.Conversation{
	ap_id: sequence(:ap_id, &"https://some_conversation/#{&1}")
	}
	end

	def user_factory do
	user = %User{
	name: sequence(:name, &"Test テスト User #{&1}"),
	email: sequence(:email, &"user#{&1}@example.com"),
	nickname: sequence(:nickname, &"nick#{&1}"),
	password_hash: Comeonin.Pbkdf2.hashpwsalt("test"),
	bio: sequence(:bio, &"Tester Number #{&1}"),
	info: %{}
	}

	%{
	user
	\| ap_id: User.ap_id(user),
	follower_address: User.ap_followers(user),
	following: [User.ap_id(user)]
	}
	end

	def note_factory(attrs \\ %{}) do
	text = sequence(:text, &"This is :moominmamma: note #{&1}")

	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Note",
	"content" => text,
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"actor" => user.ap_id,
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"likes" => [],
	"like_count" => 0,
	"context" => "2hu",
	"summary" => "2hu",
	"tag" => ["2hu"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	}

	%Pleroma.Object{
	data: merge_attributes(data, Map.get(attrs, :data, %{}))
	}
	end

	def direct_note_factory do
	user2 = insert(:user)

	%Pleroma.Object{data: data} = note_factory()
	%Pleroma.Object{data: Map.merge(data, %{"to" => [user2.ap_id]})}
	end

	def article_factory do
	note_factory()
	\|> Map.put("type", "Article")
	end

	def tombstone_factory do
	data = %{
	"type" => "Tombstone",
	"id" => Pleroma.Web.ActivityPub.Utils.generate_object_id(),
	"formerType" => "Note",
	"deleted" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Object{
	data: data
	}
	end

	def direct_note_activity_factory do
	dm = insert(:direct_note)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => dm.data["actor"],
	"to" => dm.data["to"],
	"object" => dm.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => dm.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def note_activity_factory(attrs \\ %{}) do
	user = attrs[:user] \|\| insert(:user)
	note = attrs[:note] \|\| insert(:note, user: user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"],
	"object" => note.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => note.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def article_activity_factory do
	article = insert(:article)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"type" => "Create",
	"actor" => article.data["actor"],
	"to" => article.data["to"],
	"object" => article.data,
	"published" => DateTime.utc_now() \|> DateTime.to_iso8601(),
	"context" => article.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: data["actor"],
	recipients: data["to"]
	}
	end

	def announce_activity_factory(attrs \\ %{}) do
	note_activity = attrs[:note_activity] \|\| insert(:note_activity)
	user = attrs[:user] \|\| insert(:user)

	data = %{
	"type" => "Announce",
	"actor" => note_activity.actor,
	"object" => note_activity.data["id"],
	"to" => [user.follower_address, note_activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => note_activity.data["context"]
	}

	%Pleroma.Activity{
	data: data,
	actor: user.ap_id,
	recipients: data["to"]
	}
	end

	def like_activity_factory do
	note_activity = insert(:note_activity)
	user = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => user.ap_id,
	"type" => "Like",
	"object" => note_activity.data["object"]["id"],
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data
	}
	end

	def follow_activity_factory do
	follower = insert(:user)
	followed = insert(:user)

	data = %{
	"id" => Pleroma.Web.ActivityPub.Utils.generate_activity_id(),
	"actor" => follower.ap_id,
	"type" => "Follow",
	"object" => followed.ap_id,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601()
	}

	%Pleroma.Activity{
	data: data,
	actor: follower.ap_id
	}
	end

	def websub_subscription_factory do
	%Pleroma.Web.Websub.WebsubServerSubscription{
	topic: "http://example.org",
	callback: "http://example.org/callback",
	secret: "here's a secret",
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 100),
	state: "requested"
	}
	end

	def websub_client_subscription_factory do
	%Pleroma.Web.Websub.WebsubClientSubscription{
	topic: "http://example.org",
	secret: "here's a secret",
	valid_until: nil,
	state: "requested",
	subscribers: []
	}
	end

	def oauth_app_factory do
	%Pleroma.Web.OAuth.App{
	client_name: "Some client",
	redirect_uris: "https://example.com/callback",
	scopes: ["read", "write", "follow", "push"],
	website: "https://example.com",
	client_id: Ecto.UUID.generate(),
	client_secret: "aaa;/&bbb"
	}
	end

	def instance_factory do
	%Pleroma.Instances.Instance{
	host: "domain.com",
	unreachable_since: nil
	}
	end

	def oauth_token_factory do
	oauth_app = insert(:oauth_app)

	%Pleroma.Web.OAuth.Token{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	refresh_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(),
	user: build(:user),
	app_id: oauth_app.id,
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10)
	}
	end

	def oauth_authorization_factory do
	%Pleroma.Web.OAuth.Authorization{
	token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64(padding: false),
	scopes: ["read", "write", "follow", "push"],
	valid_until: NaiveDateTime.add(NaiveDateTime.utc_now(), 60 * 10),
	user: build(:user),
	app: build(:oauth_app)
	}
	end

	def push_subscription_factory do
	%Pleroma.Web.Push.Subscription{
	user: build(:user),
	token: build(:oauth_token),
	endpoint: "https://example.com/example/1234",
	key_auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	key_p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA=",
	data: %{}
	}
	end

	def notification_factory do
	%Pleroma.Notification{
	user: build(:user)
	}
	end

	def scheduled_activity_factory do
	%Pleroma.ScheduledActivity{
	user: build(:user),
	scheduled_at: NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(60), :millisecond),
	params: build(:note) \|> Map.from_struct() \|> Map.get(:data)
	}
	end

	def registration_factory do
	user = insert(:user)

	%Pleroma.Registration{
	user: user,
	provider: "twitter",
	uid: "171799000",
	info: %{
	"name" => "John Doe",
	"email" => "john@doe.com",
	"nickname" => "johndoe",
	"description" => "My bio"
	}
	}
	end
	+
	+ def config_factory do
	+ %Pleroma.Web.AdminAPI.Config{
	+ key: sequence(:key, &"some_key_#{&1}"),
	+ value:
	+ sequence(
	+ :value,
	+ fn key ->
	+ :erlang.term_to_binary(%{another_key: "#{key}somevalue", another: "#{key}somevalue"})
	+ end
	+ )
	+ }
	+ end
	end
	diff --git a/test/tasks/config_test.exs b/test/tasks/config_test.exs
	new file mode 100644
	index 000000000..7d3b1860c
	--- /dev/null
	+++ b/test/tasks/config_test.exs
	@@ -0,0 +1,54 @@
	+defmodule Mix.Tasks.Pleroma.ConfigTest do
	+ use Pleroma.DataCase
	+ alias Pleroma.Repo
	+ alias Pleroma.Web.AdminAPI.Config
	+
	+ setup_all do
	+ Mix.shell(Mix.Shell.Process)
	+ temp_file = "config/temp.migrated.secret.exs"
	+
	+ dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
	+
	+ Pleroma.Config.put([:instance, :dynamic_configuration], true)
	+
	+ on_exit(fn ->
	+ Mix.shell(Mix.Shell.IO)
	+ Application.delete_env(:pleroma, :first_setting)
	+ Application.delete_env(:pleroma, :second_setting)
	+ Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
	+ :ok = File.rm(temp_file)
	+ end)
	+
	+ {:ok, temp_file: temp_file}
	+ end
	+
	+ test "settings are migrated to db" do
	+ assert Repo.all(Config) == []
	+
	+ Application.put_env(:pleroma, :first_setting, key: "value", key2: [Pleroma.Repo])
	+ Application.put_env(:pleroma, :second_setting, key: "value2", key2: [Pleroma.Activity])
	+
	+ Mix.Tasks.Pleroma.Config.run(["migrate_to_db"])
	+
	+ first_db = Config.get_by_key("first_setting")
	+ second_db = Config.get_by_key("second_setting")
	+ refute Config.get_by_key("Pleroma.Repo")
	+
	+ assert Config.from_binary(first_db.value) == [key: "value", key2: [Pleroma.Repo]]
	+ assert Config.from_binary(second_db.value) == [key: "value2", key2: [Pleroma.Activity]]
	+ end
	+
	+ test "settings are migrated to file and deleted from db", %{temp_file: temp_file} do
	+ Config.create(%{key: "setting_first", value: [key: "value", key2: [Pleroma.Activity]]})
	+ Config.create(%{key: "setting_second", value: [key: "valu2", key2: [Pleroma.Repo]]})
	+
	+ Mix.Tasks.Pleroma.Config.run(["migrate_from_db", "temp"])
	+
	+ assert Repo.all(Config) == []
	+ assert File.exists?(temp_file)
	+ {:ok, file} = File.read(temp_file)
	+
	+ assert file =~ "config :pleroma, setting_first:"
	+ assert file =~ "config :pleroma, setting_second:"
	+ end
	+end
	diff --git a/test/tasks/instance.exs b/test/tasks/instance.exs
	index 6917a2376..1875f52a3 100644
	--- a/test/tasks/instance.exs
	+++ b/test/tasks/instance.exs
	@@ -1,62 +1,65 @@
	defmodule Pleroma.InstanceTest do
	use ExUnit.Case, async: true

	setup do
	File.mkdir_p!(tmp_path())
	on_exit(fn -> File.rm_rf(tmp_path()) end)
	:ok
	end

	defp tmp_path do
	"/tmp/generated_files/"
	end

	test "running gen" do
	mix_task = fn ->
	Mix.Tasks.Pleroma.Instance.run([
	"gen",
	"--output",
	tmp_path() <> "generated_config.exs",
	"--output-psql",
	tmp_path() <> "setup.psql",
	"--domain",
	"test.pleroma.social",
	"--instance-name",
	"Pleroma",
	"--admin-email",
	"admin@example.com",
	"--notify-email",
	"notify@example.com",
	"--dbhost",
	"dbhost",
	"--dbname",
	"dbname",
	"--dbuser",
	"dbuser",
	"--dbpass",
	"dbpass",
	"--indexable",
	+ "y",
	+ "--db-configurable",
	"y"
	])
	end

	ExUnit.CaptureIO.capture_io(fn ->
	mix_task.()
	end)

	generated_config = File.read!(tmp_path() <> "generated_config.exs")
	assert generated_config =~ "host: \"test.pleroma.social\""
	assert generated_config =~ "name: \"Pleroma\""
	assert generated_config =~ "email: \"admin@example.com\""
	assert generated_config =~ "notify_email: \"notify@example.com\""
	assert generated_config =~ "hostname: \"dbhost\""
	assert generated_config =~ "database: \"dbname\""
	assert generated_config =~ "username: \"dbuser\""
	assert generated_config =~ "password: \"dbpass\""
	+ assert generated_config =~ "dynamic_configuration: true"
	assert File.read!(tmp_path() <> "setup.psql") == generated_setup_psql()
	end

	defp generated_setup_psql do
	~s(CREATE USER dbuser WITH ENCRYPTED PASSWORD 'dbpass';\nCREATE DATABASE dbname OWNER dbuser;\n\\c dbname;\n--Extensions made by ecto.migrate that need superuser access\nCREATE EXTENSION IF NOT EXISTS citext;\nCREATE EXTENSION IF NOT EXISTS pg_trgm;\nCREATE EXTENSION IF NOT EXISTS \"uuid-ossp\";\n)
	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 43dcf945a..18f64f2b7 100644
	--- a/test/web/admin_api/admin_api_controller_test.exs
	+++ b/test/web/admin_api/admin_api_controller_test.exs
	@@ -1,1295 +1,1467 @@
	# 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.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.CommonAPI
	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"
	})

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

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

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

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

	assert expected == json_response(conn, 200)
	end

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

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

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

	describe "/api/pleroma/admin/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
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	invites_enabled = Pleroma.Config.get([:instance, :invites_enabled])
	Pleroma.Config.put([:instance, :registrations_open], false)
	Pleroma.Config.put([:instance, :invites_enabled], true)

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

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

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post(
	"/api/pleroma/admin/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

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

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

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

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

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/pleroma/admin/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" => []
	},
	%{
	"deactivated" => user.info.deactivated,
	"id" => user.id,
	"nickname" => user.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => false,
	"tags" => ["foo", "bar"]
	}
	]
	\|> 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" => []
	}
	]
	}
	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" => []
	}
	]
	}
	end

	test "search by full nickname", %{conn: conn} do
	user = insert(:user, nickname: "nickname@domain.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?query=nickname@domain.com")

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

	test "search by display name", %{conn: conn} do
	user = insert(:user, name: "Display name")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?name=display")

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

	test "search by email", %{conn: conn} do
	user = insert(:user, email: "email@example.com")
	insert(:user)

	conn = get(conn, "/api/pleroma/admin/users?email=email@example.com")

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

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

	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" => []
	}
	]
	}

	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" => []
	}
	]
	}
	end

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

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

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

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

	test "only local users with no query", %{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" => []
	},
	%{
	"deactivated" => admin.info.deactivated,
	"id" => admin.id,
	"nickname" => admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => true,
	"tags" => []
	},
	%{
	"deactivated" => false,
	"id" => old_admin.id,
	"local" => true,
	"nickname" => old_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"tags" => []
	}
	]
	\|> 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" => []
	},
	%{
	"deactivated" => false,
	"id" => second_admin.id,
	"nickname" => second_admin.nickname,
	"roles" => %{"admin" => true, "moderator" => false},
	"local" => second_admin.local,
	"tags" => []
	}
	]
	\|> 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" => []
	}
	]
	}
	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"]
	},
	%{
	"deactivated" => false,
	"id" => user2.id,
	"nickname" => user2.nickname,
	"roles" => %{"admin" => false, "moderator" => false},
	"local" => user2.local,
	"tags" => ["second"]
	}
	]
	\|> 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" => []
	}
	]
	}
	end
	end

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

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

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

	describe "GET /api/pleroma/admin/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
	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 conn.assigns[:user].nickname in recipients
	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.migrated.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)
	+ :ok = File.rm(temp_file)
	+ end)
	+
	+ dynamic = Pleroma.Config.get([:instance, :dynamic_configuration])
	+
	+ Pleroma.Config.put([:instance, :dynamic_configuration], true)
	+
	+ on_exit(fn ->
	+ Pleroma.Config.put([:instance, :dynamic_configuration], dynamic)
	+ end)
	+
	+ %{conn: assign(conn, :user, admin)}
	+ end
	+
	+ test "create new config setting in db", %{conn: conn} do
	+ conn =
	+ post(conn, "/api/pleroma/admin/config", %{
	+ configs: [
	+ %{key: "key1", value: "value1"},
	+ %{
	+ key: "key2",
	+ value: %{
	+ "nested_1" => "nested_value1",
	+ "nested_2" => [
	+ %{"nested_22" => "nested_value222"},
	+ %{"nested_33" => %{"nested_44" => "nested_444"}}
	+ ]
	+ }
	+ },
	+ %{
	+ key: "key3",
	+ value: [
	+ %{"nested_3" => ":nested_3", "nested_33" => "nested_33"},
	+ %{"nested_4" => ":true"}
	+ ]
	+ },
	+ %{
	+ key: "key4",
	+ value: %{"nested_5" => ":upload", "endpoint" => "https://example.com"}
	+ }
	+ ]
	+ })
	+
	+ assert json_response(conn, 200) == %{
	+ "configs" => [
	+ %{
	+ "key" => "key1",
	+ "value" => "value1"
	+ },
	+ %{
	+ "key" => "key2",
	+ "value" => [
	+ %{"nested_1" => "nested_value1"},
	+ %{
	+ "nested_2" => [
	+ %{"nested_22" => "nested_value222"},
	+ %{"nested_33" => %{"nested_44" => "nested_444"}}
	+ ]
	+ }
	+ ]
	+ },
	+ %{
	+ "key" => "key3",
	+ "value" => [
	+ [%{"nested_3" => "nested_3"}, %{"nested_33" => "nested_33"}],
	+ %{"nested_4" => true}
	+ ]
	+ },
	+ %{
	+ "key" => "key4",
	+ "value" => [%{"endpoint" => "https://example.com"}, %{"nested_5" => "upload"}]
	+ }
	+ ]
	+ }
	+
	+ 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
	+ ]
	+ end
	+
	+ test "update config setting & delete", %{conn: conn} do
	+ config1 = insert(:config, key: "keyaa1")
	+ config2 = insert(:config, key: "keyaa2")
	+
	+ conn =
	+ post(conn, "/api/pleroma/admin/config", %{
	+ configs: [
	+ %{key: config1.key, value: "another_value"},
	+ %{key: config2.key, delete: "true"}
	+ ]
	+ })
	+
	+ assert json_response(conn, 200) == %{
	+ "configs" => [
	+ %{
	+ "key" => config1.key,
	+ "value" => "another_value"
	+ }
	+ ]
	+ }
	+
	+ assert Application.get_env(:pleroma, :keyaa1) == "another_value"
	+ refute Application.get_env(:pleroma, :keyaa2)
	+ end
	+ end
	end
	diff --git a/test/web/admin_api/config_test.exs b/test/web/admin_api/config_test.exs
	new file mode 100644
	index 000000000..a2fedca40
	--- /dev/null
	+++ b/test/web/admin_api/config_test.exs
	@@ -0,0 +1,183 @@
	+defmodule Pleroma.Web.AdminAPI.ConfigTest do
	+ use Pleroma.DataCase, async: true
	+ import Pleroma.Factory
	+ alias Pleroma.Web.AdminAPI.Config
	+
	+ test "get_by_key/1" do
	+ config = insert(:config)
	+ insert(:config)
	+
	+ assert config == Config.get_by_key(config.key)
	+ end
	+
	+ test "create/1" do
	+ {:ok, config} = Config.create(%{key: "some_key", value: "some_value"})
	+ assert config == Config.get_by_key("some_key")
	+ end
	+
	+ test "update/1" do
	+ config = insert(:config)
	+ {:ok, updated} = Config.update(config, %{value: "some_value"})
	+ loaded = Config.get_by_key(config.key)
	+ assert loaded == updated
	+ end
	+
	+ test "update_or_create/1" do
	+ config = insert(:config)
	+ key2 = "another_key"
	+
	+ params = [
	+ %{key: key2, value: "another_value"},
	+ %{key: config.key, value: "new_value"}
	+ ]
	+
	+ assert Repo.all(Config) \|> length() == 1
	+
	+ Enum.each(params, &Config.update_or_create(&1))
	+
	+ assert Repo.all(Config) \|> length() == 2
	+
	+ config1 = Config.get_by_key(config.key)
	+ config2 = Config.get_by_key(key2)
	+
	+ assert config1.value == Config.transform("new_value")
	+ assert config2.value == Config.transform("another_value")
	+ end
	+
	+ test "delete/1" do
	+ config = insert(:config)
	+ {:ok, _} = Config.delete(config.key)
	+ refute Config.get_by_key(config.key)
	+ end
	+
	+ describe "transform/1" do
	+ test "string" do
	+ binary = Config.transform("value as string")
	+ assert binary == :erlang.term_to_binary("value as string")
	+ assert Config.from_binary(binary) == "value as string"
	+ end
	+
	+ test "list of modules" do
	+ binary = Config.transform(["Pleroma.Repo", "Pleroma.Activity"])
	+ assert binary == :erlang.term_to_binary([Pleroma.Repo, Pleroma.Activity])
	+ assert Config.from_binary(binary) == [Pleroma.Repo, Pleroma.Activity]
	+ end
	+
	+ test "list of strings" do
	+ binary = Config.transform(["string1", "string2"])
	+ assert binary == :erlang.term_to_binary(["string1", "string2"])
	+ assert Config.from_binary(binary) == ["string1", "string2"]
	+ end
	+
	+ test "map" do
	+ binary =
	+ Config.transform(%{
	+ "types" => "Pleroma.PostgresTypes",
	+ "telemetry_event" => ["Pleroma.Repo.Instrumenter"],
	+ "migration_lock" => ""
	+ })
	+
	+ assert binary ==
	+ :erlang.term_to_binary(
	+ telemetry_event: [Pleroma.Repo.Instrumenter],
	+ types: Pleroma.PostgresTypes
	+ )
	+
	+ assert Config.from_binary(binary) == [
	+ telemetry_event: [Pleroma.Repo.Instrumenter],
	+ types: Pleroma.PostgresTypes
	+ ]
	+ end
	+
	+ test "complex map with nested integers, lists and atoms" do
	+ binary =
	+ Config.transform(%{
	+ "uploader" => "Pleroma.Uploaders.Local",
	+ "filters" => ["Pleroma.Upload.Filter.Dedupe"],
	+ "link_name" => ":true",
	+ "proxy_remote" => ":false",
	+ "proxy_opts" => %{
	+ "redirect_on_failure" => ":false",
	+ "max_body_length" => "i:1048576",
	+ "http" => %{
	+ "follow_redirect" => ":true",
	+ "pool" => ":upload"
	+ }
	+ }
	+ })
	+
	+ assert binary ==
	+ :erlang.term_to_binary(
	+ filters: [Pleroma.Upload.Filter.Dedupe],
	+ link_name: true,
	+ proxy_opts: [
	+ http: [
	+ follow_redirect: true,
	+ pool: :upload
	+ ],
	+ max_body_length: 1_048_576,
	+ redirect_on_failure: false
	+ ],
	+ proxy_remote: false,
	+ uploader: Pleroma.Uploaders.Local
	+ )
	+
	+ assert Config.from_binary(binary) ==
	+ [
	+ filters: [Pleroma.Upload.Filter.Dedupe],
	+ link_name: true,
	+ proxy_opts: [
	+ http: [
	+ follow_redirect: true,
	+ pool: :upload
	+ ],
	+ max_body_length: 1_048_576,
	+ redirect_on_failure: false
	+ ],
	+ proxy_remote: false,
	+ uploader: Pleroma.Uploaders.Local
	+ ]
	+ end
	+
	+ test "keyword" do
	+ binary =
	+ Config.transform(%{
	+ "level" => ":warn",
	+ "meta" => [":all"],
	+ "webhook_url" => "https://hooks.slack.com/services/YOUR-KEY-HERE"
	+ })
	+
	+ assert binary ==
	+ :erlang.term_to_binary(
	+ level: :warn,
	+ meta: [:all],
	+ webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	+ )
	+
	+ assert Config.from_binary(binary) == [
	+ level: :warn,
	+ meta: [:all],
	+ webhook_url: "https://hooks.slack.com/services/YOUR-KEY-HERE"
	+ ]
	+ end
	+
	+ test "complex map with sigil" do
	+ binary =
	+ Config.transform(%{
	+ federated_timeline_removal: [],
	+ reject: [~r/comp[lL][aA][iI][nN]er/],
	+ replace: []
	+ })
	+
	+ assert binary ==
	+ :erlang.term_to_binary(
	+ federated_timeline_removal: [],
	+ reject: [~r/comp[lL][aA][iI][nN]er/],
	+ replace: []
	+ )
	+
	+ assert Config.from_binary(binary) ==
	+ [federated_timeline_removal: [], reject: [~r/comp[lL][aA][iI][nN]er/], replace: []]
	+ end
	+ end
	+end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 10:06 PM (10 h, 54 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803373
Default Alt Text: (290 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions