No OneTemporary
Actions

Size

73 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/config/config.exs b/config/config.exs
	index d15998715..1539b15c6 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,688 +1,681 @@
	# .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: true,
	seconds_valid: 300,
	method: Pleroma.Captcha.Native

	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: false,
	proxy_remote: false,
	proxy_opts: [
	redirect_on_failure: false,
	max_body_length: 25 * 1_048_576,
	http: [
	follow_redirect: true,
	pool: :upload
	]
	],
	filename_display_max_length: 30

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

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

	config :pleroma, :emoji,
	shortcode_globs: ["/emoji/custom/*/.png"],
	pack_extensions: [".png", ".gif"],
	groups: [
	Custom: ["/emoji/.png", "/emoji//.png"]
	],
	default_manifest: "https://git.pleroma.social/pleroma/emoji-index/raw/master/index.json",
	shared_pack_cache_seconds_per_file: 60

	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: [
	ip: {127, 0, 0, 1},
	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,
	level: :debug,
	format: "\n$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.Gun
	# Configures http settings, upstream proxy etc.
	config :pleroma, :http,
	proxy_url: nil,
	send_user_agent: true,
	user_agent: :default,
	adapter: []

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	background_image: "/images/city.jpg",
	limit: 5_000,
	chat_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,
	invites_enabled: false,
	account_activation_required: false,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	federation_publisher_modules: [
	Pleroma.Web.ActivityPub.Publisher
	],
	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,
	mrf_transparency_exclusions: [],
	autofollowed_nicknames: [],
	max_pinned_statuses: 1,
	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,
	user_bio_length: 5000,
	user_name_length: 100,
	max_account_fields: 10,
	max_remote_account_fields: 20,
	account_field_name_length: 512,
	account_field_value_length: 2048,
	external_user_synchronization: true,
	extended_nickname_format: true,
	- cleanup_attachments: false,
	- multi_factor_authentication: [
	- totp: [
	- # digits 6 or 8
	- digits: 6,
	- period: 30
	- ],
	- backup_codes: [
	- number: 5,
	- length: 16
	- ]
	- ]
	+ cleanup_attachments: false

	config :pleroma, :feed,
	post_title: %{
	max_length: 100,
	omission: "..."
	}

	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.Scrubber.Default,
	Pleroma.HTML.Transform.MediaProxy
	]

	config :pleroma, :frontend_configurations,
	pleroma_fe: %{
	alwaysShowSubjectInput: true,
	background: "/images/city.jpg",
	collapseMessageWithSubject: false,
	disableChat: false,
	greentext: false,
	hideFilteredStatuses: false,
	hideMutedPosts: false,
	hidePostStats: false,
	hideSitename: false,
	hideUserStats: false,
	loginMethod: "password",
	logo: "/static/logo.png",
	logoMargin: ".1em",
	logoMask: true,
	minimalScopesMode: false,
	noAttachmentLinks: false,
	nsfwCensorImage: "",
	postContentType: "text/plain",
	redirectRootLogin: "/main/friends",
	redirectRootNoLogin: "/main/all",
	scopeCopy: true,
	sidebarRight: false,
	showFeaturesPanel: true,
	showInstanceSpecificPanel: false,
	subjectLineBehavior: "email",
	theme: "pleroma-dark",
	webPushNotifications: false
	},
	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, :manifest,
	icons: [
	%{
	src: "/static/logo.png",
	type: "image/png"
	}
	],
	theme_color: "#282c37",
	background_color: "#191b22"

	config :pleroma, :activitypub,
	unfollow_blocked: true,
	outgoing_blocks: true,
	follow_handshake_timeout: 500,
	note_replies_output_limit: 5,
	sign_object_fetches: true,
	authorized_fetch_mode: false

	config :pleroma, :streamer,
	workers: 3,
	overflow_workers: 2

	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: [],
	- reject_deletes: []
	+ banner_removal: []

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

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

	config :pleroma, :mrf_vocabulary,
	accept: [],
	reject: []

	config :pleroma, :mrf_object_age,
	threshold: 172_800,
	actions: [:delist, :strip_followers]

	config :pleroma, :rich_media,
	enabled: true,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"],
	parsers: [
	Pleroma.Web.RichMedia.Parsers.TwitterCard,
	Pleroma.Web.RichMedia.Parsers.OGP,
	Pleroma.Web.RichMedia.Parsers.OEmbed
	],
	ttl_setters: [Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl]

	config :pleroma, :media_proxy,
	enabled: false,
	invalidation: [
	enabled: false,
	provider: Pleroma.Web.MediaProxy.Invalidation.Script
	],
	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 :phoenix, :json_library, Jason

	config :phoenix, :filter_parameters, ["password", "confirm"]

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

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

	+config :pleroma, Pleroma.Web.Preload,
	+ providers: [
	+ Pleroma.Web.Preload.Providers.Instance,
	+ Pleroma.Web.Preload.Providers.User,
	+ Pleroma.Web.Preload.Providers.Timelines
	+ ]
	+
	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, Oban,
	repo: Pleroma.Repo,
	verbose: false,
	prune: {:maxlen, 1500},
	queues: [
	activity_expiration: 10,
	federator_incoming: 50,
	federator_outgoing: 50,
	web_push: 50,
	mailer: 10,
	transmogrifier: 20,
	scheduled_activities: 10,
	background: 5,
	remote_fetcher: 2,
	attachments_cleanup: 5,
	new_users_digest: 1
	],
	crontab: [
	{"0 0 * * *", Pleroma.Workers.Cron.ClearOauthTokenWorker},
	{"0 * * * *", Pleroma.Workers.Cron.StatsWorker},
	{"* * * * *", Pleroma.Workers.Cron.PurgeExpiredActivitiesWorker},
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker}
	]

	config :pleroma, :workers,
	retries: [
	federator_incoming: 5,
	federator_outgoing: 5
	]

	config :auto_linker,
	opts: [
	extra: true,
	# TODO: Set to :no_scheme when it works properly
	validate_tld: true,
	class: false,
	strip_prefix: false,
	new_window: false,
	rel: "ugc"
	]

	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,
	enforce_oauth_admin_scope_usage: true,
	oauth_consumer_strategies: oauth_consumer_strategies

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

	config :pleroma, Pleroma.Emails.UserEmail,
	logo: nil,
	styling: %{
	link_color: "#d8a070",
	background_color: "#2C3645",
	content_background_color: "#1B2635",
	header_color: "#d8a070",
	text_color: "#b9b9ba",
	text_muted_color: "#b9b9ba"
	}

	config :pleroma, Pleroma.Emails.NewUsersDigestEmail, enabled: false

	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, :email_notifications,
	digest: %{
	active: false,
	interval: 7,
	inactivity_threshold: 7
	}

	config :pleroma, :oauth2,
	token_expires_in: 600,
	issue_new_refresh_token: true,
	clean_expired_tokens: false

	config :pleroma, :database, rum_enabled: false

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

	config :http_signatures,
	adapter: Pleroma.Signature

	config :pleroma, :rate_limit,
	authentication: {60_000, 15},
	timeline: {500, 3},
	search: [{1000, 10}, {1000, 30}],
	app_account_creation: {1_800_000, 25},
	relations_actions: {10_000, 10},
	relation_id_action: {60_000, 2},
	statuses_actions: {10_000, 15},
	status_id_action: {60_000, 3},
	password_reset: {1_800_000, 5},
	account_confirmation_resend: {8_640_000, 5},
	ap_routes: {60_000, 15}

	config :pleroma, Pleroma.ActivityExpiration, enabled: true

	config :pleroma, Pleroma.Plugs.RemoteIp, enabled: true

	config :pleroma, :static_fe, enabled: false

	config :pleroma, :web_cache_ttl,
	activity_pub: nil,
	activity_pub_question: 30_000

	config :pleroma, :modules, runtime_dir: "instance/modules"

	config :pleroma, configurable_from_database: false

	config :pleroma, Pleroma.Repo,
	parameters: [gin_fuzzy_search_limit: "500"],
	prepare: :unnamed

	config :pleroma, :connections_pool,
	checkin_timeout: 250,
	max_connections: 250,
	retry: 1,
	retry_timeout: 1000,
	await_up_timeout: 5_000

	config :pleroma, :pools,
	federation: [
	size: 50,
	max_overflow: 10,
	timeout: 150_000
	],
	media: [
	size: 50,
	max_overflow: 10,
	timeout: 150_000
	],
	upload: [
	size: 25,
	max_overflow: 5,
	timeout: 300_000
	],
	default: [
	size: 10,
	max_overflow: 2,
	timeout: 10_000
	]

	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, :restrict_unauthenticated,
	timelines: %{local: false, federated: false},
	profiles: %{local: false, remote: false},
	activities: %{local: false, remote: false}

	-config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: false
	-
	# 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/lib/pleroma/web/fallback_redirect_controller.ex b/lib/pleroma/web/fallback_redirect_controller.ex
	index 0d9d578fc..932fb8d7e 100644
	--- a/lib/pleroma/web/fallback_redirect_controller.ex
	+++ b/lib/pleroma/web/fallback_redirect_controller.ex
	@@ -1,79 +1,107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Fallback.RedirectController do
	use Pleroma.Web, :controller
	-
	require Logger
	-
	alias Pleroma.User
	alias Pleroma.Web.Metadata
	+ alias Pleroma.Web.Preload

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

	- def redirector(conn, _params, code \\ 200)
	-
	- # redirect to admin section
	- # /pleroma/admin -> /pleroma/admin/
	- #
	- def redirector(conn, %{"path" => ["pleroma", "admin"]} = _, _code) do
	- redirect(conn, to: "/pleroma/admin/")
	- end
	-
	- def redirector(conn, _params, code) do
	+ 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 =
	- try do
	- Metadata.build_tags(params)
	- rescue
	- e ->
	- Logger.error(
	- "Metadata rendering for #{conn.request_path} failed.\n" <>
	- Exception.format(:error, e, __STACKTRACE__)
	- )
	-
	- ""
	- end
	+ tags = build_tags(conn, params)
	+ preloads = preload_data(conn, params)

	- response = String.replace(index_content, "<!--server-generated-meta-->", tags)
	+ response =
	+ index_content
	+ \|> String.replace("<!--server-generated-meta-->", tags)
	+ \|> String.replace("<!--server-generated-initial-data-->", preloads)

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

	- def index_file_path do
	- Pleroma.Plugs.InstanceStatic.file_path("index.html")
	+ def redirector_with_preload(conn, %{"path" => ["pleroma", "admin"]}) do
	+ redirect(conn, to: "/pleroma/admin/")
	+ end
	+
	+ def redirector_with_preload(conn, params) do
	+ {:ok, index_content} = File.read(index_file_path())
	+ preloads = preload_data(conn, params)
	+
	+ response =
	+ index_content
	+ \|> String.replace("<!--server-generated-initial-data-->", preloads)
	+
	+ conn
	+ \|> put_resp_content_type("text/html")
	+ \|> send_resp(200, response)
	end

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

	def empty(conn, _params) do
	conn
	\|> put_status(204)
	\|> text("")
	end
	+
	+ defp index_file_path do
	+ Pleroma.Plugs.InstanceStatic.file_path("index.html")
	+ end
	+
	+ defp build_tags(conn, params) do
	+ try do
	+ Metadata.build_tags(params)
	+ rescue
	+ e ->
	+ Logger.error(
	+ "Metadata rendering for #{conn.request_path} failed.\n" <>
	+ Exception.format(:error, e, __STACKTRACE__)
	+ )
	+
	+ ""
	+ end
	+ end
	+
	+ defp preload_data(conn, params) do
	+ try do
	+ Preload.build_tags(conn, params)
	+ rescue
	+ e ->
	+ Logger.error(
	+ "Preloading for #{conn.request_path} failed.\n" <>
	+ Exception.format(:error, e, __STACKTRACE__)
	+ )
	+
	+ ""
	+ end
	+ end
	end
	diff --git a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex b/lib/pleroma/web/nodeinfo/nodeinfo.ex
	similarity index 63%
	copy from lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	copy to lib/pleroma/web/nodeinfo/nodeinfo.ex
	index 721b599d4..d26b7c938 100644
	--- a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	+++ b/lib/pleroma/web/nodeinfo/nodeinfo.ex
	@@ -1,130 +1,130 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	-defmodule Pleroma.Web.Nodeinfo.NodeinfoController do
	- use Pleroma.Web, :controller
	-
	+defmodule Pleroma.Web.Nodeinfo.Nodeinfo do
	alias Pleroma.Config
	alias Pleroma.Stats
	alias Pleroma.User
	- alias Pleroma.Web
	+ alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.Federator.Publisher
	- alias Pleroma.Web.MastodonAPI.InstanceView
	-
	- def schemas(conn, _params) do
	- response = %{
	- links: [
	- %{
	- rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
	- href: Web.base_url() <> "/nodeinfo/2.0.json"
	- },
	- %{
	- rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
	- href: Web.base_url() <> "/nodeinfo/2.1.json"
	- }
	- ]
	- }
	-
	- json(conn, response)
	- end

	# returns a nodeinfo 2.0 map, since 2.1 just adds a repository field
	# under software.
	- def raw_nodeinfo do
	+ def get_nodeinfo("2.0") do
	stats = Stats.get_stats()

	+ quarantined = Config.get([:instance, :quarantined_instances], [])
	+
	staff_accounts =
	User.all_superusers()
	\|> Enum.map(fn u -> u.ap_id end)

	- features = InstanceView.features()
	- federation = InstanceView.federation()
	+ federation_response =
	+ if Config.get([:instance, :mrf_transparency]) do
	+ {:ok, data} = MRF.describe()
	+
	+ data
	+ \|> Map.merge(%{quarantined_instances: quarantined})
	+ else
	+ %{}
	+ end
	+ \|> Map.put(:enabled, Config.get([:instance, :federating]))
	+
	+ features =
	+ [
	+ "pleroma_api",
	+ "mastodon_api",
	+ "mastodon_api_streaming",
	+ "polls",
	+ "pleroma_explicit_addressing",
	+ "shareable_emoji_packs",
	+ "multifetch",
	+ "pleroma:api/v1/notifications:include_types_filter",
	+ if Config.get([:media_proxy, :enabled]) do
	+ "media_proxy"
	+ end,
	+ if Config.get([:gopher, :enabled]) do
	+ "gopher"
	+ end,
	+ if Config.get([:chat, :enabled]) do
	+ "chat"
	+ end,
	+ if Config.get([:instance, :allow_relay]) do
	+ "relay"
	+ end,
	+ if Config.get([:instance, :safe_dm_mentions]) do
	+ "safe_dm_mentions"
	+ end,
	+ "pleroma_emoji_reactions"
	+ ]
	+ \|> Enum.filter(& &1)

	%{
	version: "2.0",
	software: %{
	name: Pleroma.Application.name() \|> String.downcase(),
	version: Pleroma.Application.version()
	},
	protocols: Publisher.gather_nodeinfo_protocol_names(),
	services: %{
	inbound: [],
	outbound: []
	},
	openRegistrations: Config.get([:instance, :registrations_open]),
	usage: %{
	users: %{
	total: Map.get(stats, :user_count, 0)
	},
	localPosts: Map.get(stats, :status_count, 0)
	},
	metadata: %{
	nodeName: Config.get([:instance, :name]),
	nodeDescription: Config.get([:instance, :description]),
	private: !Config.get([:instance, :public], true),
	suggestions: %{
	enabled: false
	},
	staffAccounts: staff_accounts,
	- federation: federation,
	+ federation: federation_response,
	pollLimits: Config.get([:instance, :poll_limits]),
	postFormats: Config.get([:instance, :allowed_post_formats]),
	uploadLimits: %{
	general: Config.get([:instance, :upload_limit]),
	avatar: Config.get([:instance, :avatar_upload_limit]),
	banner: Config.get([:instance, :banner_upload_limit]),
	background: Config.get([:instance, :background_upload_limit])
	},
	fieldsLimits: %{
	maxFields: Config.get([:instance, :max_account_fields]),
	maxRemoteFields: Config.get([:instance, :max_remote_account_fields]),
	nameLength: Config.get([:instance, :account_field_name_length]),
	valueLength: Config.get([:instance, :account_field_value_length])
	},
	accountActivationRequired: Config.get([:instance, :account_activation_required], false),
	invitesEnabled: Config.get([:instance, :invites_enabled], false),
	mailerEnabled: Config.get([Pleroma.Emails.Mailer, :enabled], false),
	features: features,
	restrictedNicknames: Config.get([Pleroma.User, :restricted_nicknames]),
	skipThreadContainment: Config.get([:instance, :skip_thread_containment], false)
	}
	}
	end

	- # Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.0/schema.json
	- # and https://github.com/jhass/nodeinfo/blob/master/schemas/2.1/schema.json
	- def nodeinfo(conn, %{"version" => "2.0"}) do
	- conn
	- \|> put_resp_header(
	- "content-type",
	- "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.0#; charset=utf-8"
	- )
	- \|> json(raw_nodeinfo())
	- end
	-
	- def nodeinfo(conn, %{"version" => "2.1"}) do
	- raw_response = raw_nodeinfo()
	+ def get_nodeinfo("2.1") do
	+ raw_response = get_nodeinfo("2.0")

	updated_software =
	raw_response
	\|> Map.get(:software)
	\|> Map.put(:repository, Pleroma.Application.repository())

	- response =
	- raw_response
	- \|> Map.put(:software, updated_software)
	- \|> Map.put(:version, "2.1")
	-
	- conn
	- \|> put_resp_header(
	- "content-type",
	- "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.1#; charset=utf-8"
	- )
	- \|> json(response)
	+ raw_response
	+ \|> Map.put(:software, updated_software)
	+ \|> Map.put(:version, "2.1")
	end

	- def nodeinfo(conn, _) do
	- render_error(conn, :not_found, "Nodeinfo schema version not handled")
	+ def get_nodeinfo(_version) do
	+ {:error, :missing}
	end
	end
	diff --git a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	index 721b599d4..8c7a9e565 100644
	--- a/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	+++ b/lib/pleroma/web/nodeinfo/nodeinfo_controller.ex
	@@ -1,130 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Nodeinfo.NodeinfoController do
	use Pleroma.Web, :controller

	- alias Pleroma.Config
	- alias Pleroma.Stats
	- alias Pleroma.User
	alias Pleroma.Web
	- alias Pleroma.Web.Federator.Publisher
	- alias Pleroma.Web.MastodonAPI.InstanceView
	+ alias Pleroma.Web.Nodeinfo.Nodeinfo

	def schemas(conn, _params) do
	response = %{
	links: [
	%{
	rel: "http://nodeinfo.diaspora.software/ns/schema/2.0",
	href: Web.base_url() <> "/nodeinfo/2.0.json"
	},
	%{
	rel: "http://nodeinfo.diaspora.software/ns/schema/2.1",
	href: Web.base_url() <> "/nodeinfo/2.1.json"
	}
	]
	}

	json(conn, response)
	end

	- # returns a nodeinfo 2.0 map, since 2.1 just adds a repository field
	- # under software.
	- def raw_nodeinfo do
	- stats = Stats.get_stats()
	-
	- staff_accounts =
	- User.all_superusers()
	- \|> Enum.map(fn u -> u.ap_id end)
	-
	- features = InstanceView.features()
	- federation = InstanceView.federation()
	-
	- %{
	- version: "2.0",
	- software: %{
	- name: Pleroma.Application.name() \|> String.downcase(),
	- version: Pleroma.Application.version()
	- },
	- protocols: Publisher.gather_nodeinfo_protocol_names(),
	- services: %{
	- inbound: [],
	- outbound: []
	- },
	- openRegistrations: Config.get([:instance, :registrations_open]),
	- usage: %{
	- users: %{
	- total: Map.get(stats, :user_count, 0)
	- },
	- localPosts: Map.get(stats, :status_count, 0)
	- },
	- metadata: %{
	- nodeName: Config.get([:instance, :name]),
	- nodeDescription: Config.get([:instance, :description]),
	- private: !Config.get([:instance, :public], true),
	- suggestions: %{
	- enabled: false
	- },
	- staffAccounts: staff_accounts,
	- federation: federation,
	- pollLimits: Config.get([:instance, :poll_limits]),
	- postFormats: Config.get([:instance, :allowed_post_formats]),
	- uploadLimits: %{
	- general: Config.get([:instance, :upload_limit]),
	- avatar: Config.get([:instance, :avatar_upload_limit]),
	- banner: Config.get([:instance, :banner_upload_limit]),
	- background: Config.get([:instance, :background_upload_limit])
	- },
	- fieldsLimits: %{
	- maxFields: Config.get([:instance, :max_account_fields]),
	- maxRemoteFields: Config.get([:instance, :max_remote_account_fields]),
	- nameLength: Config.get([:instance, :account_field_name_length]),
	- valueLength: Config.get([:instance, :account_field_value_length])
	- },
	- accountActivationRequired: Config.get([:instance, :account_activation_required], false),
	- invitesEnabled: Config.get([:instance, :invites_enabled], false),
	- mailerEnabled: Config.get([Pleroma.Emails.Mailer, :enabled], false),
	- features: features,
	- restrictedNicknames: Config.get([Pleroma.User, :restricted_nicknames]),
	- skipThreadContainment: Config.get([:instance, :skip_thread_containment], false)
	- }
	- }
	- end
	-
	# Schema definition: https://github.com/jhass/nodeinfo/blob/master/schemas/2.0/schema.json
	# and https://github.com/jhass/nodeinfo/blob/master/schemas/2.1/schema.json
	- def nodeinfo(conn, %{"version" => "2.0"}) do
	- conn
	- \|> put_resp_header(
	- "content-type",
	- "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.0#; charset=utf-8"
	- )
	- \|> json(raw_nodeinfo())
	- end
	-
	- def nodeinfo(conn, %{"version" => "2.1"}) do
	- raw_response = raw_nodeinfo()
	-
	- updated_software =
	- raw_response
	- \|> Map.get(:software)
	- \|> Map.put(:repository, Pleroma.Application.repository())
	-
	- response =
	- raw_response
	- \|> Map.put(:software, updated_software)
	- \|> Map.put(:version, "2.1")
	-
	- conn
	- \|> put_resp_header(
	- "content-type",
	- "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.1#; charset=utf-8"
	- )
	- \|> json(response)
	- end
	-
	- def nodeinfo(conn, _) do
	- render_error(conn, :not_found, "Nodeinfo schema version not handled")
	+ def nodeinfo(conn, %{"version" => version}) do
	+ case Nodeinfo.get_nodeinfo(version) do
	+ {:error, :missing} ->
	+ render_error(conn, :not_found, "Nodeinfo schema version not handled")
	+
	+ node_info ->
	+ conn
	+ \|> put_resp_header(
	+ "content-type",
	+ "application/json; profile=http://nodeinfo.diaspora.software/ns/schema/2.0#; charset=utf-8"
	+ )
	+ \|> json(node_info)
	+ end
	end
	end
	diff --git a/lib/pleroma/web/preload.ex b/lib/pleroma/web/preload.ex
	new file mode 100644
	index 000000000..c2211c597
	--- /dev/null
	+++ b/lib/pleroma/web/preload.ex
	@@ -0,0 +1,30 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.Preload do
	+ alias Phoenix.HTML
	+ require Logger
	+
	+ def build_tags(_conn, params) do
	+ preload_data =
	+ Enum.reduce(Pleroma.Config.get([__MODULE__, :providers], []), %{}, fn parser, acc ->
	+ Map.merge(acc, parser.generate_terms(params))
	+ end)
	+
	+ rendered_html =
	+ preload_data
	+ \|> Jason.encode!()
	+ \|> build_script_tag()
	+ \|> HTML.safe_to_string()
	+
	+ rendered_html
	+ end
	+
	+ def build_script_tag(content) do
	+ HTML.Tag.content_tag(:script, HTML.raw(content),
	+ id: "initial-results",
	+ type: "application/json"
	+ )
	+ end
	+end
	diff --git a/lib/pleroma/web/preload/instance.ex b/lib/pleroma/web/preload/instance.ex
	new file mode 100644
	index 000000000..0b6fd3313
	--- /dev/null
	+++ b/lib/pleroma/web/preload/instance.ex
	@@ -0,0 +1,49 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.Preload.Providers.Instance do
	+ alias Pleroma.Web.MastodonAPI.InstanceView
	+ alias Pleroma.Web.Nodeinfo.Nodeinfo
	+ alias Pleroma.Web.Preload.Providers.Provider
	+
	+ @behaviour Provider
	+ @instance_url :"/api/v1/instance"
	+ @panel_url :"/instance/panel.html"
	+ @nodeinfo_url :"/nodeinfo/2.0"
	+
	+ @impl Provider
	+ def generate_terms(_params) do
	+ %{}
	+ \|> build_info_tag()
	+ \|> build_panel_tag()
	+ \|> build_nodeinfo_tag()
	+ end
	+
	+ defp build_info_tag(acc) do
	+ info_data = InstanceView.render("show.json", %{})
	+
	+ Map.put(acc, @instance_url, info_data)
	+ end
	+
	+ defp build_panel_tag(acc) do
	+ instance_path = Path.join(:code.priv_dir(:pleroma), "static/instance/panel.html")
	+
	+ if File.exists?(instance_path) do
	+ panel_data = File.read!(instance_path)
	+ Map.put(acc, @panel_url, panel_data)
	+ else
	+ acc
	+ end
	+ end
	+
	+ defp build_nodeinfo_tag(acc) do
	+ case Nodeinfo.get_nodeinfo("2.0") do
	+ {:error, _} ->
	+ acc
	+
	+ nodeinfo_data ->
	+ Map.put(acc, @nodeinfo_url, nodeinfo_data)
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/preload/provider.ex b/lib/pleroma/web/preload/provider.ex
	new file mode 100644
	index 000000000..7ef595a34
	--- /dev/null
	+++ b/lib/pleroma/web/preload/provider.ex
	@@ -0,0 +1,7 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.Preload.Providers.Provider do
	+ @callback generate_terms(map()) :: map()
	+end
	diff --git a/lib/pleroma/web/preload/timelines.ex b/lib/pleroma/web/preload/timelines.ex
	new file mode 100644
	index 000000000..dbd7db407
	--- /dev/null
	+++ b/lib/pleroma/web/preload/timelines.ex
	@@ -0,0 +1,42 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.Preload.Providers.Timelines do
	+ alias Pleroma.Web.ActivityPub.ActivityPub
	+ alias Pleroma.Web.MastodonAPI.StatusView
	+ alias Pleroma.Web.Preload.Providers.Provider
	+
	+ @behaviour Provider
	+ @public_url :"/api/v1/timelines/public"
	+
	+ @impl Provider
	+ def generate_terms(_params) do
	+ build_public_tag(%{})
	+ end
	+
	+ def build_public_tag(acc) do
	+ if Pleroma.Config.get([:restrict_unauthenticated, :timelines, :federated], true) do
	+ acc
	+ else
	+ Map.put(acc, @public_url, public_timeline(nil))
	+ end
	+ end
	+
	+ defp public_timeline(user) do
	+ activities =
	+ create_timeline_params(user)
	+ \|> Map.put("local_only", false)
	+ \|> ActivityPub.fetch_public_activities()
	+
	+ StatusView.render("index.json", activities: activities, for: user, as: :activity)
	+ end
	+
	+ defp create_timeline_params(user) do
	+ %{}
	+ \|> Map.put("type", ["Create", "Announce"])
	+ \|> Map.put("blocking_user", user)
	+ \|> Map.put("muting_user", user)
	+ \|> Map.put("user", user)
	+ end
	+end
	diff --git a/lib/pleroma/web/preload/user.ex b/lib/pleroma/web/preload/user.ex
	new file mode 100644
	index 000000000..3a244845b
	--- /dev/null
	+++ b/lib/pleroma/web/preload/user.ex
	@@ -0,0 +1,25 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.Preload.Providers.User do
	+ alias Pleroma.Web.MastodonAPI.AccountView
	+ alias Pleroma.Web.Preload.Providers.Provider
	+
	+ @behaviour Provider
	+ @account_url :"/api/v1/accounts"
	+
	+ @impl Provider
	+ def generate_terms(%{user: user}) do
	+ build_accounts_tag(%{}, user)
	+ end
	+
	+ def generate_terms(_params), do: %{}
	+
	+ def build_accounts_tag(acc, nil), do: acc
	+
	+ def build_accounts_tag(acc, user) do
	+ account_data = AccountView.render("show.json", %{user: user, for: user})
	+ Map.put(acc, @account_url, account_data)
	+ end
	+end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index e493a4153..a1ef2633d 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,723 +1,723 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 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)
	plug(Pleroma.Plugs.UserEnabledPlug)
	end

	pipeline :expect_authentication do
	plug(Pleroma.Plugs.ExpectAuthenticatedCheckPlug)
	end

	pipeline :expect_public_instance_or_authentication do
	plug(Pleroma.Plugs.ExpectPublicOrAuthenticatedCheckPlug)
	end

	pipeline :authenticate do
	plug(Pleroma.Plugs.OAuthPlug)
	plug(Pleroma.Plugs.BasicAuthDecoderPlug)
	plug(Pleroma.Plugs.UserFetcherPlug)
	plug(Pleroma.Plugs.SessionAuthenticationPlug)
	plug(Pleroma.Plugs.LegacyAuthenticationPlug)
	plug(Pleroma.Plugs.AuthenticationPlug)
	end

	pipeline :after_auth do
	plug(Pleroma.Plugs.UserEnabledPlug)
	plug(Pleroma.Plugs.SetUserSessionIdPlug)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

	pipeline :base_api do
	plug(:accepts, ["json"])
	plug(:fetch_session)
	plug(:authenticate)
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :api do
	plug(:expect_public_instance_or_authentication)
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :authenticated_api do
	plug(:expect_authentication)
	plug(:base_api)
	plug(:after_auth)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :admin_api do
	plug(:expect_authentication)
	plug(:base_api)
	plug(Pleroma.Plugs.AdminSecretAuthenticationPlug)
	plug(:after_auth)
	plug(Pleroma.Plugs.EnsureAuthenticatedPlug)
	plug(Pleroma.Plugs.UserIsAdminPlug)
	plug(Pleroma.Plugs.IdempotencyPlug)
	end

	pipeline :mastodon_html do
	plug(:browser)
	plug(:authenticate)
	plug(:after_auth)
	end

	pipeline :pleroma_html do
	plug(:browser)
	plug(:authenticate)
	plug(Pleroma.Plugs.EnsureUserKeyPlug)
	end

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

	pipeline :config do
	plug(:accepts, ["json", "xml"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	end

	pipeline :pleroma_api do
	plug(:accepts, ["html", "json"])
	plug(OpenApiSpex.Plug.PutApiSpec, module: Pleroma.Web.ApiSpec)
	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

	pipeline :http_signature do
	plug(Pleroma.Web.Plugs.HTTPSignaturePlug)
	plug(Pleroma.Web.Plugs.MappedSignatureToIdentityPlug)
	end

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

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

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

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

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

	put("/users/disable_mfa", AdminAPIController, :disable_mfa)
	delete("/users", AdminAPIController, :user_delete)
	post("/users", AdminAPIController, :users_create)
	patch("/users/:nickname/toggle_activation", AdminAPIController, :user_toggle_activation)
	patch("/users/activate", AdminAPIController, :user_activate)
	patch("/users/deactivate", AdminAPIController, :user_deactivate)
	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)

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

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

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

	post("/users/permission_group/:permission_group", AdminAPIController, :right_add_multiple)

	delete(
	"/users/permission_group/:permission_group",
	AdminAPIController,
	:right_delete_multiple
	)

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

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

	get("/users/:nickname/password_reset", AdminAPIController, :get_password_reset)
	patch("/users/force_password_reset", AdminAPIController, :force_password_reset)
	get("/users/:nickname/credentials", AdminAPIController, :show_user_credentials)
	patch("/users/:nickname/credentials", AdminAPIController, :update_user_credentials)

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

	get("/instances/:instance/statuses", AdminAPIController, :list_instance_statuses)

	patch("/users/confirm_email", AdminAPIController, :confirm_email)
	patch("/users/resend_confirmation_email", AdminAPIController, :resend_confirmation_email)

	get("/reports", AdminAPIController, :list_reports)
	get("/reports/:id", AdminAPIController, :report_show)
	patch("/reports", AdminAPIController, :reports_update)
	post("/reports/:id/notes", AdminAPIController, :report_notes_create)
	delete("/reports/:report_id/notes/:id", AdminAPIController, :report_notes_delete)

	get("/statuses/:id", StatusController, :show)
	put("/statuses/:id", StatusController, :update)
	delete("/statuses/:id", StatusController, :delete)
	get("/statuses", StatusController, :index)

	get("/config", AdminAPIController, :config_show)
	post("/config", AdminAPIController, :config_update)
	get("/config/descriptions", AdminAPIController, :config_descriptions)
	get("/need_reboot", AdminAPIController, :need_reboot)
	get("/restart", AdminAPIController, :restart)

	get("/moderation_log", AdminAPIController, :list_log)

	post("/reload_emoji", AdminAPIController, :reload_emoji)
	get("/stats", AdminAPIController, :stats)

	get("/oauth_app", AdminAPIController, :oauth_app_list)
	post("/oauth_app", AdminAPIController, :oauth_app_create)
	patch("/oauth_app/:id", AdminAPIController, :oauth_app_update)
	delete("/oauth_app/:id", AdminAPIController, :oauth_app_delete)
	end

	scope "/api/pleroma/emoji", Pleroma.Web.PleromaAPI do
	# Modifying packs
	scope "/packs" do
	pipe_through(:admin_api)

	get("/import", EmojiPackController, :import_from_filesystem)
	get("/remote", EmojiPackController, :remote)
	post("/download", EmojiPackController, :download)

	post("/:name", EmojiPackController, :create)
	patch("/:name", EmojiPackController, :update)
	delete("/:name", EmojiPackController, :delete)

	post("/:name/files", EmojiPackController, :add_file)
	patch("/:name/files", EmojiPackController, :update_file)
	delete("/:name/files", EmojiPackController, :delete_file)
	end

	# Pack info / downloading
	scope "/packs" do
	pipe_through(:api)
	get("/", EmojiPackController, :index)
	get("/:name", EmojiPackController, :show)
	get("/:name/archive", EmojiPackController, :archive)
	end
	end

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

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

	post("/ostatus_subscribe", RemoteFollowController, :do_follow)
	end

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

	post("/change_email", UtilController, :change_email)
	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)

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

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

	get("/accounts/mfa", TwoFactorAuthenticationController, :settings)
	get("/accounts/mfa/backup_codes", TwoFactorAuthenticationController, :backup_codes)
	get("/accounts/mfa/setup/:method", TwoFactorAuthenticationController, :setup)
	post("/accounts/mfa/confirm/:method", TwoFactorAuthenticationController, :confirm)
	delete("/accounts/mfa/:method", TwoFactorAuthenticationController, :disable)
	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)

	post("/mfa/challenge", MFAController, :challenge)
	post("/mfa/verify", MFAController, :verify, as: :mfa_verify)
	get("/mfa", MFAController, :show)

	scope [] do
	pipe_through(:browser)

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

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

	get("/statuses/:id/reactions/:emoji", EmojiReactionController, :index)
	get("/statuses/:id/reactions", EmojiReactionController, :index)
	end

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

	get("/conversations/:id/statuses", ConversationController, :statuses)
	get("/conversations/:id", ConversationController, :show)
	post("/conversations/read", ConversationController, :mark_as_read)
	patch("/conversations/:id", ConversationController, :update)

	put("/statuses/:id/reactions/:emoji", EmojiReactionController, :create)
	delete("/statuses/:id/reactions/:emoji", EmojiReactionController, :delete)
	post("/notifications/read", NotificationController, :mark_as_read)

	patch("/accounts/update_avatar", AccountController, :update_avatar)
	patch("/accounts/update_banner", AccountController, :update_banner)
	patch("/accounts/update_background", AccountController, :update_background)

	get("/mascot", MascotController, :show)
	put("/mascot", MascotController, :update)

	post("/scrobble", ScrobbleController, :create)
	end

	scope [] do
	pipe_through(:api)
	get("/accounts/:id/favourites", AccountController, :favourites)
	end

	scope [] do
	pipe_through(:authenticated_api)

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

	post("/accounts/confirmation_resend", AccountController, :confirmation_resend)
	end

	scope "/api/v1/pleroma", Pleroma.Web.PleromaAPI do
	pipe_through(:api)
	get("/accounts/:id/scrobbles", ScrobbleController, :index)
	end

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

	get("/accounts/verify_credentials", AccountController, :verify_credentials)
	patch("/accounts/update_credentials", AccountController, :update_credentials)

	get("/accounts/relationships", AccountController, :relationships)
	get("/accounts/:id/lists", AccountController, :lists)
	get("/accounts/:id/identity_proofs", AccountController, :identity_proofs)
	get("/endorsements", AccountController, :endorsements)
	get("/blocks", AccountController, :blocks)
	get("/mutes", AccountController, :mutes)

	post("/follows", AccountController, :follow_by_uri)
	post("/accounts/:id/follow", AccountController, :follow)
	post("/accounts/:id/unfollow", AccountController, :unfollow)
	post("/accounts/:id/block", AccountController, :block)
	post("/accounts/:id/unblock", AccountController, :unblock)
	post("/accounts/:id/mute", AccountController, :mute)
	post("/accounts/:id/unmute", AccountController, :unmute)

	get("/apps/verify_credentials", AppController, :verify_credentials)

	get("/conversations", ConversationController, :index)
	post("/conversations/:id/read", ConversationController, :mark_as_read)

	get("/domain_blocks", DomainBlockController, :index)
	post("/domain_blocks", DomainBlockController, :create)
	delete("/domain_blocks", DomainBlockController, :delete)

	get("/filters", FilterController, :index)

	post("/filters", FilterController, :create)
	get("/filters/:id", FilterController, :show)
	put("/filters/:id", FilterController, :update)
	delete("/filters/:id", FilterController, :delete)

	get("/follow_requests", FollowRequestController, :index)
	post("/follow_requests/:id/authorize", FollowRequestController, :authorize)
	post("/follow_requests/:id/reject", FollowRequestController, :reject)

	get("/lists", ListController, :index)
	get("/lists/:id", ListController, :show)
	get("/lists/:id/accounts", ListController, :list_accounts)

	delete("/lists/:id", ListController, :delete)
	post("/lists", ListController, :create)
	put("/lists/:id", ListController, :update)
	post("/lists/:id/accounts", ListController, :add_to_list)
	delete("/lists/:id/accounts", ListController, :remove_from_list)

	get("/markers", MarkerController, :index)
	post("/markers", MarkerController, :upsert)

	post("/media", MediaController, :create)
	get("/media/:id", MediaController, :show)
	put("/media/:id", MediaController, :update)

	get("/notifications", NotificationController, :index)
	get("/notifications/:id", NotificationController, :show)

	post("/notifications/:id/dismiss", NotificationController, :dismiss)
	post("/notifications/clear", NotificationController, :clear)
	delete("/notifications/destroy_multiple", NotificationController, :destroy_multiple)
	# Deprecated: was removed in Mastodon v3, use `/notifications/:id/dismiss` instead
	post("/notifications/dismiss", NotificationController, :dismiss_via_body)

	post("/polls/:id/votes", PollController, :vote)

	post("/reports", ReportController, :create)

	get("/scheduled_statuses", ScheduledActivityController, :index)
	get("/scheduled_statuses/:id", ScheduledActivityController, :show)

	put("/scheduled_statuses/:id", ScheduledActivityController, :update)
	delete("/scheduled_statuses/:id", ScheduledActivityController, :delete)

	# Unlike `GET /api/v1/accounts/:id/favourites`, demands authentication
	get("/favourites", StatusController, :favourites)
	get("/bookmarks", StatusController, :bookmarks)

	post("/statuses", StatusController, :create)
	delete("/statuses/:id", StatusController, :delete)
	post("/statuses/:id/reblog", StatusController, :reblog)
	post("/statuses/:id/unreblog", StatusController, :unreblog)
	post("/statuses/:id/favourite", StatusController, :favourite)
	post("/statuses/:id/unfavourite", StatusController, :unfavourite)
	post("/statuses/:id/pin", StatusController, :pin)
	post("/statuses/:id/unpin", StatusController, :unpin)
	post("/statuses/:id/bookmark", StatusController, :bookmark)
	post("/statuses/:id/unbookmark", StatusController, :unbookmark)
	post("/statuses/:id/mute", StatusController, :mute_conversation)
	post("/statuses/:id/unmute", StatusController, :unmute_conversation)

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

	get("/suggestions", SuggestionController, :index)

	get("/timelines/home", TimelineController, :home)
	get("/timelines/direct", TimelineController, :direct)
	get("/timelines/list/:list_id", TimelineController, :list)
	end

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

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

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

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

	get("/accounts/:id/statuses", AccountController, :statuses)
	get("/accounts/:id/followers", AccountController, :followers)
	get("/accounts/:id/following", AccountController, :following)
	get("/accounts/:id", AccountController, :show)

	post("/accounts", AccountController, :create)

	get("/instance", InstanceController, :show)
	get("/instance/peers", InstanceController, :peers)

	post("/apps", AppController, :create)

	get("/statuses", StatusController, :index)
	get("/statuses/:id", StatusController, :show)
	get("/statuses/:id/context", StatusController, :context)
	get("/statuses/:id/card", StatusController, :card)
	get("/statuses/:id/favourited_by", StatusController, :favourited_by)
	get("/statuses/:id/reblogged_by", StatusController, :reblogged_by)

	get("/custom_emojis", CustomEmojiController, :index)

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

	get("/timelines/public", TimelineController, :public)
	get("/timelines/tag/:tag", TimelineController, :hashtag)

	get("/polls/:id", PollController, :show)
	end

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

	post("/media", MediaController, :create2)
	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)

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

	scope "/api" do
	pipe_through(:base_api)

	get("/openapi", OpenApiSpex.Plug.RenderSpec, [])
	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)

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

	pipeline :ostatus do
	plug(:accepts, ["html", "xml", "rss", "atom", "activity+json", "json"])
	plug(Pleroma.Plugs.StaticFEPlug)
	end

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

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

	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)

	# Mastodon compatibility routes
	get("/users/:nickname/statuses/:id", OStatus.OStatusController, :object)
	get("/users/:nickname/statuses/:id/activity", OStatus.OStatusController, :activity)

	get("/users/:nickname/feed", Feed.UserController, :feed, as: :user_feed)
	get("/users/:nickname", Feed.UserController, :feed_redirect, as: :user_feed)

	get("/tags/:tag", Feed.TagController, :feed, as: :tag_feed)
	end

	scope "/", Pleroma.Web do
	pipe_through(:browser)
	get("/mailer/unsubscribe/:token", Mailer.SubscriptionController, :unsubscribe)
	end

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

	get("/users/:nickname/outbox", ActivityPubController, :outbox)
	end

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

	# Server to Server (S2S) AP interactions
	pipeline :activitypub do
	plug(:ap_service_actor)
	plug(:http_signature)
	end

	# Client to Server (C2S) AP interactions
	pipeline :activitypub_client do
	plug(:ap_service_actor)
	plug(:fetch_session)
	plug(:authenticate)
	plug(:after_auth)
	end

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

	get("/api/ap/whoami", ActivityPubController, :whoami)
	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)

	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	post("/api/ap/upload_media", ActivityPubController, :upload_media)

	# The following two are S2S as well, see `ActivityPub.fetch_follow_information_for_user/1`:
	get("/users/:nickname/followers", ActivityPubController, :followers)
	get("/users/:nickname/following", ActivityPubController, :following)
	end

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

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

	get("/", ActivityPubController, :relay)

	scope [] do
	pipe_through(:http_signature)
	post("/inbox", ActivityPubController, :inbox)
	end

	get("/following", ActivityPubController, :relay_following)
	get("/followers", ActivityPubController, :relay_followers)
	end

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

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

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

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

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

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

	get("/web/manifest.json", MastoFEController, :manifest)
	end

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

	get("/web/login", MastodonAPI.AuthController, :login)
	delete("/auth/sign_out", MastodonAPI.AuthController, :logout)

	post("/auth/password", MastodonAPI.AuthController, :password_reset)

	get("/web/*path", MastoFEController, :index)
	end

	scope "/proxy/", Pleroma.Web.MediaProxy do
	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

	# Test-only routes needed to test action dispatching and plug chain execution
	if Pleroma.Config.get(:env) == :test do
	@test_actions [
	:do_oauth_check,
	:fallback_oauth_check,
	:skip_oauth_check,
	:fallback_oauth_skip_publicity_check,
	:skip_oauth_skip_publicity_check,
	:missing_oauth_check_definition
	]

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

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	end

	scope "/test/authenticated_api", Pleroma.Tests do
	pipe_through(:authenticated_api)

	for action <- @test_actions do
	get("/#{action}", AuthTestController, action)
	end
	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)
	+ get("/*path", RedirectController, :redirector_with_preload)

	options("/*path", RedirectController, :empty)
	end
	end
	diff --git a/test/plugs/instance_static_test.exs b/test/plugs/instance_static_test.exs
	index b8f070d6a..be2613ad0 100644
	--- a/test/plugs/instance_static_test.exs
	+++ b/test/plugs/instance_static_test.exs
	@@ -1,43 +1,43 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.RuntimeStaticPlugTest do
	use Pleroma.Web.ConnCase

	@dir "test/tmp/instance_static"

	setup do
	File.mkdir_p!(@dir)
	on_exit(fn -> File.rm_rf(@dir) end)
	end

	setup do: clear_config([:instance, :static_dir], @dir)

	test "overrides index" do
	bundled_index = get(build_conn(), "/")
	- assert html_response(bundled_index, 200) == File.read!("priv/static/index.html")
	+ refute html_response(bundled_index, 200) == "hello world"

	File.write!(@dir <> "/index.html", "hello world")

	index = get(build_conn(), "/")
	assert html_response(index, 200) == "hello world"
	end

	test "overrides any file in static/static" do
	bundled_index = get(build_conn(), "/static/terms-of-service.html")

	assert html_response(bundled_index, 200) ==
	File.read!("priv/static/static/terms-of-service.html")

	File.mkdir!(@dir <> "/static")
	File.write!(@dir <> "/static/terms-of-service.html", "plz be kind")

	index = get(build_conn(), "/static/terms-of-service.html")
	assert html_response(index, 200) == "plz be kind"

	File.write!(@dir <> "/static/kaniini.html", "<h1>rabbit hugs as a service</h1>")
	index = get(build_conn(), "/static/kaniini.html")
	assert html_response(index, 200) == "<h1>rabbit hugs as a service</h1>"
	end
	end
	diff --git a/test/web/fallback_test.exs b/test/web/fallback_test.exs
	index 3919ef93a..3b7a51d5e 100644
	--- a/test/web/fallback_test.exs
	+++ b/test/web/fallback_test.exs
	@@ -1,56 +1,70 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.FallbackTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory

	- test "GET /registration/:token", %{conn: conn} do
	- assert conn
	- \|> get("/registration/foo")
	- \|> html_response(200) =~ "<!--server-generated-meta-->"
	+ describe "neither preloaded data nor metadata attached to" do
	+ test "GET /registration/:token", %{conn: conn} do
	+ response = get(conn, "/registration/foo")
	+
	+ assert html_response(response, 200) =~ "<!--server-generated-meta-->"
	+ assert html_response(response, 200) =~ "<!--server-generated-initial-data-->"
	+ end
	end

	- test "GET /:maybe_nickname_or_id", %{conn: conn} do
	- user = insert(:user)
	+ describe "preloaded data and metadata attached to" do
	+ test "GET /:maybe_nickname_or_id", %{conn: conn} do
	+ user = insert(:user)
	+ user_missing = get(conn, "/foo")
	+ user_present = get(conn, "/#{user.nickname}")

	- assert conn
	- \|> get("/foo")
	- \|> html_response(200) =~ "<!--server-generated-meta-->"
	+ assert html_response(user_missing, 200) =~ "<!--server-generated-meta-->"
	+ refute html_response(user_present, 200) =~ "<!--server-generated-meta-->"

	- refute conn
	- \|> get("/" <> user.nickname)
	- \|> html_response(200) =~ "<!--server-generated-meta-->"
	+ assert html_response(user_missing, 200) =~ "<!--server-generated-initial-data-->"
	+ refute html_response(user_present, 200) =~ "<!--server-generated-initial-data-->"
	+ end
	+ end
	+
	+ describe "preloaded data only attached to" do
	+ test "GET /*path", %{conn: conn} do
	+ public_page = get(conn, "/main/public")
	+
	+ assert html_response(public_page, 200) =~ "<!--server-generated-meta-->"
	+ refute html_response(public_page, 200) =~ "<!--server-generated-initial-data-->"
	+ end
	end

	test "GET /api*path", %{conn: conn} do
	assert conn
	\|> get("/api/foo")
	\|> json_response(404) == %{"error" => "Not implemented"}
	end

	test "GET /pleroma/admin -> /pleroma/admin/", %{conn: conn} do
	assert redirected_to(get(conn, "/pleroma/admin")) =~ "/pleroma/admin/"
	end

	test "GET /*path", %{conn: conn} do
	assert conn
	\|> get("/foo")
	\|> html_response(200) =~ "<!--server-generated-meta-->"

	assert conn
	\|> get("/foo/bar")
	\|> html_response(200) =~ "<!--server-generated-meta-->"
	end

	test "OPTIONS /*path", %{conn: conn} do
	assert conn
	\|> options("/foo")
	\|> response(204) == ""

	assert conn
	\|> options("/foo/bar")
	\|> response(204) == ""
	end
	end
	diff --git a/test/web/preload/instance_test.exs b/test/web/preload/instance_test.exs
	new file mode 100644
	index 000000000..52f9bab3b
	--- /dev/null
	+++ b/test/web/preload/instance_test.exs
	@@ -0,0 +1,37 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.Preload.Providers.InstanceTest do
	+ use Pleroma.DataCase
	+ alias Pleroma.Web.Preload.Providers.Instance
	+
	+ setup do: {:ok, Instance.generate_terms(nil)}
	+
	+ test "it renders the info", %{"/api/v1/instance": info} do
	+ assert %{
	+ description: description,
	+ email: "admin@example.com",
	+ registrations: true
	+ } = info
	+
	+ assert String.equivalent?(description, "A Pleroma instance, an alternative fediverse server")
	+ end
	+
	+ test "it renders the panel", %{"/instance/panel.html": panel} do
	+ assert String.contains?(
	+ panel,
	+ "<p>Welcome to <a href=\"https://pleroma.social\" target=\"_blank\">Pleroma!</a></p>"
	+ )
	+ end
	+
	+ test "it renders the node_info", %{"/nodeinfo/2.0": nodeinfo} do
	+ %{
	+ metadata: metadata,
	+ version: "2.0"
	+ } = nodeinfo
	+
	+ assert metadata.private == false
	+ assert metadata.suggestions == %{enabled: false}
	+ end
	+end
	diff --git a/test/web/preload/timeline_test.exs b/test/web/preload/timeline_test.exs
	new file mode 100644
	index 000000000..00b10d0ab
	--- /dev/null
	+++ b/test/web/preload/timeline_test.exs
	@@ -0,0 +1,74 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.Preload.Providers.TimelineTest do
	+ use Pleroma.DataCase
	+ import Pleroma.Factory
	+
	+ alias Pleroma.Web.CommonAPI
	+ alias Pleroma.Web.Preload.Providers.Timelines
	+
	+ @public_url :"/api/v1/timelines/public"
	+
	+ describe "unauthenticated timeliness when restricted" do
	+ setup do
	+ svd_config = Pleroma.Config.get([:restrict_unauthenticated, :timelines])
	+ Pleroma.Config.put([:restrict_unauthenticated, :timelines], %{local: true, federated: true})
	+
	+ on_exit(fn ->
	+ Pleroma.Config.put([:restrict_unauthenticated, :timelines], svd_config)
	+ end)
	+
	+ :ok
	+ end
	+
	+ test "return nothing" do
	+ tl_data = Timelines.generate_terms(%{})
	+
	+ refute Map.has_key?(tl_data, "/api/v1/timelines/public")
	+ end
	+ end
	+
	+ describe "unauthenticated timeliness when unrestricted" do
	+ setup do
	+ svd_config = Pleroma.Config.get([:restrict_unauthenticated, :timelines])
	+
	+ Pleroma.Config.put([:restrict_unauthenticated, :timelines], %{
	+ local: false,
	+ federated: false
	+ })
	+
	+ on_exit(fn ->
	+ Pleroma.Config.put([:restrict_unauthenticated, :timelines], svd_config)
	+ end)
	+
	+ {:ok, user: insert(:user)}
	+ end
	+
	+ test "returns the timeline when not restricted" do
	+ assert Timelines.generate_terms(%{})
	+ \|> Map.has_key?(@public_url)
	+ end
	+
	+ test "returns public items", %{user: user} do
	+ {:ok, _} = CommonAPI.post(user, %{"status" => "it's post 1!"})
	+ {:ok, _} = CommonAPI.post(user, %{"status" => "it's post 2!"})
	+ {:ok, _} = CommonAPI.post(user, %{"status" => "it's post 3!"})
	+
	+ assert Timelines.generate_terms(%{})
	+ \|> Map.fetch!(@public_url)
	+ \|> Enum.count() == 3
	+ end
	+
	+ test "does not return non-public items", %{user: user} do
	+ {:ok, _} = CommonAPI.post(user, %{"status" => "it's post 1!", "visibility" => "unlisted"})
	+ {:ok, _} = CommonAPI.post(user, %{"status" => "it's post 2!", "visibility" => "direct"})
	+ {:ok, _} = CommonAPI.post(user, %{"status" => "it's post 3!"})
	+
	+ assert Timelines.generate_terms(%{})
	+ \|> Map.fetch!(@public_url)
	+ \|> Enum.count() == 1
	+ end
	+ end
	+end
	diff --git a/test/web/preload/user_test.exs b/test/web/preload/user_test.exs
	new file mode 100644
	index 000000000..99232cdfa
	--- /dev/null
	+++ b/test/web/preload/user_test.exs
	@@ -0,0 +1,33 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Web.Preload.Providers.UserTest do
	+ use Pleroma.DataCase
	+ import Pleroma.Factory
	+ alias Pleroma.Web.Preload.Providers.User
	+
	+ describe "returns empty when user doesn't exist" do
	+ test "nil user specified" do
	+ refute User.generate_terms(%{user: nil})
	+ \|> Map.has_key?("/api/v1/accounts")
	+ end
	+
	+ test "missing user specified" do
	+ refute User.generate_terms(%{user: :not_a_user})
	+ \|> Map.has_key?("/api/v1/accounts")
	+ end
	+ end
	+
	+ describe "specified user exists" do
	+ setup do
	+ user = insert(:user)
	+
	+ {:ok, User.generate_terms(%{user: user})}
	+ end
	+
	+ test "account is rendered", %{"/api/v1/accounts": accounts} do
	+ assert %{acct: user, username: user} = accounts
	+ end
	+ end
	+end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 1:45 PM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723533
Default Alt Text: (73 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions