No OneTemporary
Actions

Size

187 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/changelog.d/oban-cancel.change b/changelog.d/oban-cancel.change
	new file mode 100644
	index 000000000..e4512d3bb
	--- /dev/null
	+++ b/changelog.d/oban-cancel.change
	@@ -0,0 +1 @@
	+Changed some jobs to return :cancel on unrecoverable errors that should not be retried
	diff --git a/changelog.d/oban-timeouts.change b/changelog.d/oban-timeouts.change
	new file mode 100644
	index 000000000..33d017c5c
	--- /dev/null
	+++ b/changelog.d/oban-timeouts.change
	@@ -0,0 +1 @@
	+Ensure all Oban jobs have timeouts defined
	diff --git a/config/config.exs b/config/config.exs
	index dd333212c..044f951f6 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,951 +1,951 @@
	# .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 Config module.
	#
	# This configuration file is loaded before any dependency and
	# is restricted to this project.
	import Config

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

	config :pleroma, Pleroma.Repo,
	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,
	filename_display_max_length: 30,
	default_description: nil,
	base_url: nil

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

	config :pleroma, Pleroma.Uploaders.S3,
	bucket: nil,
	bucket_namespace: nil,
	truncated_namespace: nil,
	streaming_enabled: true

	config :ex_aws, :s3,
	# host: "s3.wasabisys.com", # required if not Amazon AWS
	access_key_id: nil,
	secret_access_key: nil,
	# region: "us-east-1", # may be required for Amazon AWS
	scheme: "https://"

	config :pleroma, Pleroma.Uploaders.IPFS,
	post_gateway_url: "http://localhost:5001",
	get_gateway_url: "http://localhost:8080"

	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",
	"hyper",
	"ipfs",
	"ipns",
	"irc",
	"ircs",
	"magnet",
	"mailto",
	"mumble",
	"ssb",
	"xmpp"
	]

	# Configures the endpoint
	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "localhost"],
	http: [
	ip: {127, 0, 0, 1}
	],
	protocol: "https",
	secret_key_base: "aK4Abxf29xU9TTDKre9coZPUgevcVCFQJe/5xP/7Lt4BEif6idBIbjupVbOrbKxl",
	live_view: [signing_salt: "U5ELgdEwTD3n1+D5s0rY0AMg8/y1STxZ3Zvsl3bWh+oBcGrYdil0rXqPMRd3Glcq"],
	signing_salt: "CqaoopA2",
	render_errors: [view: Pleroma.Web.ErrorView, accepts: ~w(json)],
	pubsub_server: Pleroma.PubSub,
	secure_cookie_flag: true,
	extra_cookie_attrs: [
	"SameSite=Lax"
	]

	# Configures Elixir's Logger
	config :logger, backends: [:console]

	config :logger, :console,
	level: :debug,
	format: "\n$time $metadata[$level] $message\n",
	metadata: [:actor, :path, :type, :user]

	config :logger, :ex_syslogger,
	level: :debug,
	ident: "pleroma",
	format: "$metadata[$level] $message",
	metadata: [:actor, :path, :type, :user]

	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,
	user_agent: :default,
	adapter: []

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "Pleroma: An efficient and flexible fediverse server",
	short_description: "",
	background_image: "/images/city.jpg",
	instance_thumbnail: "/instance/thumbnail.jpeg",
	favicon: "/favicon.png",
	limit: 5_000,
	description_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,
	account_approval_required: false,
	federating: true,
	federation_incoming_replies_max_depth: 100,
	federation_reachability_timeout_days: 7,
	allow_relay: true,
	public: true,
	quarantined_instances: [],
	rejected_instances: [],
	static_dir: "instance/static/",
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown",
	"text/bbcode"
	],
	autofollowed_nicknames: [],
	autofollowing_nicknames: [],
	max_pinned_statuses: 1,
	attachment_links: false,
	max_report_comment_size: 1000,
	report_strip_status: true,
	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,
	registration_reason_length: 500,
	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
	]
	],
	show_reactions: true,
	password_reset_token_validity: 60 * 60 * 24,
	profile_directory: true,
	admin_privileges: [
	:users_read,
	:users_manage_invites,
	:users_manage_activation_state,
	:users_manage_tags,
	:users_manage_credentials,
	:users_delete,
	:messages_read,
	:messages_delete,
	:instances_delete,
	:reports_manage_reports,
	:moderation_log_read,
	:announcements_manage_announcements,
	:emoji_manage_emoji,
	:statistics_read
	],
	moderator_privileges: [:messages_delete, :reports_manage_reports],
	max_endorsed_users: 20,
	birthday_required: false,
	birthday_min_age: 0,
	max_media_attachments: 1_000

	config :pleroma, :welcome,
	direct_message: [
	enabled: false,
	sender_nickname: nil,
	message: nil
	],
	chat_message: [
	enabled: false,
	sender_nickname: nil,
	message: nil
	],
	email: [
	enabled: false,
	sender: nil,
	subject: "Welcome to <%= instance_name %>",
	html: "Welcome to <%= instance_name %>",
	text: "Welcome to <%= instance_name %>"
	]

	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.svg",
	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
	}

	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.svg",
	sizes: "144x144",
	purpose: "any",
	type: "image/svg+xml"
	}
	],
	theme_color: "#282c37",
	background_color: "#191b22"

	config :pleroma, :activitypub,
	unfollow_blocked: true,
	outgoing_blocks: true,
	blockers_visible: 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: [],
	followers_only: [],
	accept: [],
	avatar_removal: [],
	banner_removal: [],
	reject_deletes: []

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

	config :pleroma, :mrf_emoji,
	remove_url: [],
	remove_shortcode: [],
	federated_timeline_removal_url: [],
	federated_timeline_removal_shortcode: []

	config :pleroma, :mrf_hashtag,
	sensitive: ["nsfw"],
	reject: [],
	federated_timeline_removal: []

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

	config :pleroma, :mrf_activity_expiration, days: 365

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

	config :pleroma, :mrf_dnsrbl,
	nameserver: "127.0.0.1",
	port: 53,
	zone: "bl.pleroma.com"

	# threshold of 7 days
	config :pleroma, :mrf_object_age,
	threshold: 604_800,
	actions: [:delist, :strip_followers]

	config :pleroma, :mrf_nsfw_api,
	url: "http://127.0.0.1:5000/",
	threshold: 0.7,
	mark_sensitive: true,
	unlist: false,
	reject: false

	config :pleroma, :mrf_follow_bot, follower_nickname: nil

	config :pleroma, :mrf_inline_quote, template: "<bdi>RT:</bdi> {url}"

	config :pleroma, :mrf_force_mention,
	mention_parent: true,
	mention_quoted: true

	config :pleroma, :mrf_antimentionspam, user_age_limit: 30_000

	config :pleroma, :rich_media,
	enabled: true,
	ignore_hosts: [],
	ignore_tld: ["local", "localdomain", "lan"],
	parsers: [
	Pleroma.Web.RichMedia.Parsers.TwitterCard,
	Pleroma.Web.RichMedia.Parsers.OEmbed
	],
	failure_backoff: 60_000,
	ttl_setters: [
	Pleroma.Web.RichMedia.Parser.TTL.AwsSignedUrl,
	Pleroma.Web.RichMedia.Parser.TTL.Opengraph
	],
	max_body: 5_000_000

	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,
	# Note: max_read_duration defaults to Pleroma.ReverseProxy.max_read_duration_default/1
	max_read_duration: 30_000,
	http: [
	follow_redirect: true,
	pool: :media
	]
	],
	whitelist: []

	config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Http,
	method: :purge,
	headers: [],
	options: []

	config :pleroma, Pleroma.Web.MediaProxy.Invalidation.Script,
	script_path: nil,
	url_format: nil

	# Note: media preview proxy depends on media proxy to be enabled
	config :pleroma, :media_preview_proxy,
	enabled: false,
	thumbnail_max_width: 600,
	thumbnail_max_height: 600,
	image_quality: 85,
	min_content_length: 100 * 1024

	config :pleroma, :shout,
	enabled: true,
	limit: 5_000

	config :phoenix, :format_encoders, json: Jason, "activity+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
	],
	unfurl_nsfw: false

	config :pleroma, Pleroma.Web.Preload,
	providers: [
	Pleroma.Web.Preload.Providers.Instance
	]

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

	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",
	"verify_credentials",
	"update_credentials",
	"relationships",
	"search",
	"confirmation_resend",
	"mfa"
	],
	email_blacklist: []

	config :pleroma, Oban,
	repo: Pleroma.Repo,
	log: false,
	queues: [
	activity_expiration: 10,
	federator_incoming: 5,
	federator_outgoing: 5,
	web_push: 50,
	transmogrifier: 20,
	- background: 5,
	+ background: 20,
	search_indexing: [limit: 10, paused: true],
	- slow: 1
	+ slow: 5
	],
	plugins: [Oban.Plugins.Pruner],
	crontab: [
	{"0 0 * * 0", Pleroma.Workers.Cron.DigestEmailsWorker},
	{"0 0 * * *", Pleroma.Workers.Cron.NewUsersDigestWorker}
	]

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

	config :pleroma, Pleroma.Formatter,
	class: false,
	rel: "ugc",
	new_window: false,
	truncate: false,
	strip_prefix: false,
	extra: true,
	validate_tld: :no_scheme

	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"

	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, 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 :pleroma, Pleroma.PromEx,
	disabled: false,
	manual_metrics_start_delay: :no_delay,
	drop_metrics_groups: [],
	grafana: [
	host: System.get_env("GRAFANA_HOST", "http://localhost:3000"),
	auth_token: System.get_env("GRAFANA_TOKEN"),
	upload_dashboards_on_start: false,
	folder_name: "BEAM",
	annotate_app_lifecycle: true
	],
	metrics_server: [
	port: 4021,
	path: "/metrics",
	protocol: :http,
	pool_size: 5,
	cowboy_opts: [],
	auth_strategy: :none
	],
	datasource: "Prometheus"

	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: 3600 * 24 * 365 * 100,
	issue_new_refresh_token: true,
	clean_expired_tokens: false

	config :pleroma, :database, rum_enabled: false

	config :pleroma, :features, improved_hashtag_timeline: :auto

	config :pleroma, :populate_hashtags_table, fault_rate_allowance: 0.01

	config :pleroma, :delete_context_objects, fault_rate_allowance: 0.01

	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.Workers.PurgeExpiredActivity, enabled: true, min_lifetime: 600

	config :pleroma, Pleroma.Web.Plugs.RemoteIp,
	enabled: true,
	headers: ["x-forwarded-for"],
	proxies: [],
	reserved: [
	"127.0.0.0/8",
	"::1/128",
	"fc00::/7",
	"10.0.0.0/8",
	"172.16.0.0/12",
	"192.168.0.0/16"
	]

	config :pleroma, :static_fe, enabled: false

	# Example of frontend configuration
	# This example will make us serve the primary frontend from the
	# frontends directory within your `:pleroma, :instance, static_dir`.
	# e.g., instance/static/frontends/pleroma/develop/
	#
	# With no frontend configuration, the bundled files from the `static` directory will
	# be used.
	#
	# config :pleroma, :frontends,
	# primary: %{"name" => "pleroma-fe", "ref" => "develop"},
	# admin: %{"name" => "admin-fe", "ref" => "stable"},
	# available: %{...}

	config :pleroma, :frontends,
	available: %{
	"kenoma" => %{
	"name" => "kenoma",
	"git" => "https://git.pleroma.social/lambadalambda/kenoma",
	"build_url" =>
	"https://git.pleroma.social/lambadalambda/kenoma/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "master"
	},
	"pleroma-fe" => %{
	"name" => "pleroma-fe",
	"git" => "https://git.pleroma.social/pleroma/pleroma-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/pleroma-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"fedi-fe" => %{
	"name" => "fedi-fe",
	"git" => "https://git.pleroma.social/pleroma/fedi-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/fedi-fe/-/jobs/artifacts/${ref}/download?job=build_release",
	"ref" => "master",
	"custom-http-headers" => [
	{"service-worker-allowed", "/"}
	]
	},
	"admin-fe" => %{
	"name" => "admin-fe",
	"git" => "https://git.pleroma.social/pleroma/admin-fe",
	"build_url" =>
	"https://git.pleroma.social/pleroma/admin-fe/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "develop"
	},
	"soapbox" => %{
	"name" => "soapbox",
	"git" => "https://gitlab.com/soapbox-pub/soapbox",
	"build_url" =>
	"https://gitlab.com/soapbox-pub/soapbox/-/jobs/artifacts/${ref}/download?job=build-production",
	"ref" => "v3.0.0-beta.1",
	"build_dir" => "static"
	},
	"glitch-lily" => %{
	"name" => "glitch-lily",
	"git" => "https://lily-is.land/infra/glitch-lily",
	"build_url" =>
	"https://lily-is.land/infra/glitch-lily/-/jobs/artifacts/${ref}/download?job=build",
	"ref" => "servant",
	"build_dir" => "public"
	}
	}

	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", jit: "off"],
	prepare: :unnamed

	config :pleroma, :connections_pool,
	reclaim_multiplier: 0.1,
	connection_acquisition_wait: 250,
	connection_acquisition_retries: 5,
	max_connections: 250,
	max_idle_time: 30_000,
	retry: 0,
	connect_timeout: 5_000

	config :pleroma, :pools,
	federation: [
	size: 75,
	max_waiting: 20,
	recv_timeout: 10_000
	],
	media: [
	size: 75,
	max_waiting: 20,
	recv_timeout: 15_000
	],
	rich_media: [
	size: 25,
	max_waiting: 20,
	recv_timeout: 15_000
	],
	upload: [
	size: 25,
	max_waiting: 20,
	recv_timeout: 15_000
	],
	default: [
	size: 50,
	max_waiting: 2,
	recv_timeout: 5_000
	]

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

	config :pleroma, :majic_pool, size: 2

	private_instance? = :if_instance_is_private

	config :pleroma, :restrict_unauthenticated,
	timelines: %{local: private_instance?, federated: private_instance?},
	profiles: %{local: private_instance?, remote: private_instance?},
	activities: %{local: private_instance?, remote: private_instance?}

	config :pleroma, Pleroma.Web.ApiSpec.CastAndValidate, strict: false

	config :pleroma, :mrf,
	policies: [
	Pleroma.Web.ActivityPub.MRF.ObjectAgePolicy,
	Pleroma.Web.ActivityPub.MRF.TagPolicy,
	Pleroma.Web.ActivityPub.MRF.InlineQuotePolicy
	],
	transparency: true,
	transparency_exclusions: []

	config :tzdata, :http_client, Pleroma.HTTP.Tzdata

	config :ex_aws, http_client: Pleroma.HTTP.ExAws

	config :web_push_encryption, http_client: Pleroma.HTTP.WebPush

	config :pleroma, :instances_favicons, enabled: false

	config :floki, :html_parser, Floki.HTMLParser.FastHtml

	config :pleroma, Pleroma.Web.Auth.Authenticator, Pleroma.Web.Auth.PleromaAuthenticator

	config :pleroma, Pleroma.User.Backup,
	purge_after_days: 30,
	limit_days: 7,
	dir: nil,
	process_wait_time: 30_000,
	process_chunk_size: 100

	config :pleroma, ConcurrentLimiter, [
	{Pleroma.Search, [max_running: 30, max_waiting: 50]}
	]

	config :pleroma, Pleroma.Web.WebFinger, domain: nil, update_nickname_on_user_fetch: true

	config :pleroma, Pleroma.Search, module: Pleroma.Search.DatabaseSearch

	config :pleroma, Pleroma.Search.Meilisearch,
	url: "http://127.0.0.1:7700/",
	private_key: nil,
	initial_indexing_chunk_size: 100_000

	config :pleroma, Pleroma.Application,
	background_migrators: true,
	internal_fetch: true,
	load_custom_modules: true,
	max_restarts: 3,
	streamer_registry: true

	config :pleroma, Pleroma.Uploaders.Uploader, timeout: 30_000

	config :pleroma, Pleroma.Search.QdrantSearch,
	qdrant_url: "http://127.0.0.1:6333/",
	qdrant_api_key: "",
	openai_url: "http://127.0.0.1:11345",
	# The healthcheck url has to be set to nil when used with the real openai
	# API, as it doesn't have a healthcheck endpoint.
	openai_healthcheck_url: "http://127.0.0.1:11345/health",
	openai_model: "snowflake/snowflake-arctic-embed-xs",
	openai_api_key: "",
	qdrant_index_configuration: %{
	vectors: %{size: 384, distance: "Cosine"}
	}

	# 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/instances/instance.ex b/lib/pleroma/instances/instance.ex
	index c497a4fb7..288555146 100644
	--- a/lib/pleroma/instances/instance.ex
	+++ b/lib/pleroma/instances/instance.ex
	@@ -1,314 +1,314 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Instances.Instance do
	@moduledoc "Instance."

	alias Pleroma.Instances
	alias Pleroma.Instances.Instance
	alias Pleroma.Maps
	alias Pleroma.Repo
	alias Pleroma.User
	- alias Pleroma.Workers.BackgroundWorker
	+ alias Pleroma.Workers.DeleteWorker

	use Ecto.Schema

	import Ecto.Query
	import Ecto.Changeset

	require Logger

	schema "instances" do
	field(:host, :string)
	field(:unreachable_since, :naive_datetime_usec)
	field(:favicon, :string)
	field(:favicon_updated_at, :naive_datetime)

	embeds_one :metadata, Pleroma.Instances.Metadata, primary_key: false do
	field(:software_name, :string)
	field(:software_version, :string)
	field(:software_repository, :string)
	end

	field(:metadata_updated_at, :utc_datetime)

	timestamps()
	end

	defdelegate host(url_or_host), to: Instances

	def changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, __schema__(:fields) -- [:metadata])
	\|> cast_embed(:metadata, with: &metadata_changeset/2)
	\|> validate_required([:host])
	\|> unique_constraint(:host)
	end

	def metadata_changeset(struct, params \\ %{}) do
	struct
	\|> cast(params, [:software_name, :software_version, :software_repository])
	end

	def filter_reachable([]), do: %{}

	def filter_reachable(urls_or_hosts) when is_list(urls_or_hosts) do
	hosts =
	urls_or_hosts
	\|> Enum.map(&(&1 && host(&1)))
	\|> Enum.filter(&(to_string(&1) != ""))

	unreachable_since_by_host =
	Repo.all(
	from(i in Instance,
	where: i.host in ^hosts,
	select: {i.host, i.unreachable_since}
	)
	)
	\|> Map.new(& &1)

	reachability_datetime_threshold = Instances.reachability_datetime_threshold()

	for entry <- Enum.filter(urls_or_hosts, &is_binary/1) do
	host = host(entry)
	unreachable_since = unreachable_since_by_host[host]

	if !unreachable_since \|\|
	NaiveDateTime.compare(unreachable_since, reachability_datetime_threshold) == :gt do
	{entry, unreachable_since}
	end
	end
	\|> Enum.filter(& &1)
	\|> Map.new(& &1)
	end

	def reachable?(url_or_host) when is_binary(url_or_host) do
	!Repo.one(
	from(i in Instance,
	where:
	i.host == ^host(url_or_host) and
	i.unreachable_since <= ^Instances.reachability_datetime_threshold(),
	select: true
	)
	)
	end

	def reachable?(url_or_host) when is_binary(url_or_host), do: true

	def set_reachable(url_or_host) when is_binary(url_or_host) do
	%Instance{host: host(url_or_host)}
	\|> changeset(%{unreachable_since: nil})
	\|> Repo.insert(on_conflict: {:replace, [:unreachable_since]}, conflict_target: :host)
	end

	def set_reachable(_), do: {:error, nil}

	def set_unreachable(url_or_host, unreachable_since \\ nil)

	def set_unreachable(url_or_host, unreachable_since) when is_binary(url_or_host) do
	unreachable_since = parse_datetime(unreachable_since) \|\| NaiveDateTime.utc_now()
	host = host(url_or_host)
	existing_record = Repo.get_by(Instance, %{host: host})

	changes = %{unreachable_since: unreachable_since}

	cond do
	is_nil(existing_record) ->
	%Instance{}
	\|> changeset(Map.put(changes, :host, host))
	\|> Repo.insert()

	existing_record.unreachable_since &&
	NaiveDateTime.compare(existing_record.unreachable_since, unreachable_since) != :gt ->
	{:ok, existing_record}

	true ->
	existing_record
	\|> changeset(changes)
	\|> Repo.update()
	end
	end

	def set_unreachable(_, _), do: {:error, nil}

	def get_consistently_unreachable do
	reachability_datetime_threshold = Instances.reachability_datetime_threshold()

	from(i in Instance,
	where: ^reachability_datetime_threshold > i.unreachable_since,
	order_by: i.unreachable_since,
	select: {i.host, i.unreachable_since}
	)
	\|> Repo.all()
	end

	defp parse_datetime(datetime) when is_binary(datetime) do
	NaiveDateTime.from_iso8601(datetime)
	end

	defp parse_datetime(datetime), do: datetime

	def get_or_update_favicon(%URI{host: host} = instance_uri) do
	existing_record = Repo.get_by(Instance, %{host: host})
	now = NaiveDateTime.utc_now()

	if existing_record && existing_record.favicon_updated_at &&
	NaiveDateTime.diff(now, existing_record.favicon_updated_at) < 86_400 do
	existing_record.favicon
	else
	favicon = scrape_favicon(instance_uri)

	if existing_record do
	existing_record
	\|> changeset(%{favicon: favicon, favicon_updated_at: now})
	\|> Repo.update()
	else
	%Instance{}
	\|> changeset(%{host: host, favicon: favicon, favicon_updated_at: now})
	\|> Repo.insert()
	end

	favicon
	end
	rescue
	e ->
	Logger.warning("Instance.get_or_update_favicon(\"#{host}\") error: #{inspect(e)}")
	nil
	end

	defp scrape_favicon(%URI{} = instance_uri) do
	try do
	with {_, true} <- {:reachable, reachable?(instance_uri.host)},
	{:ok, %Tesla.Env{body: html}} <-
	Pleroma.HTTP.get(to_string(instance_uri), [{"accept", "text/html"}], pool: :media),
	{_, [favicon_rel \| _]} when is_binary(favicon_rel) <-
	{:parse,
	html \|> Floki.parse_document!() \|> Floki.attribute("link[rel=icon]", "href")},
	{_, favicon} when is_binary(favicon) <-
	{:merge, URI.merge(instance_uri, favicon_rel) \|> to_string()} do
	favicon
	else
	{:reachable, false} ->
	Logger.debug(
	"Instance.scrape_favicon(\"#{to_string(instance_uri)}\") ignored unreachable host"
	)

	nil

	_ ->
	nil
	end
	rescue
	e ->
	Logger.warning(
	"Instance.scrape_favicon(\"#{to_string(instance_uri)}\") error: #{inspect(e)}"
	)

	nil
	end
	end

	def get_or_update_metadata(%URI{host: host} = instance_uri) do
	existing_record = Repo.get_by(Instance, %{host: host})
	now = NaiveDateTime.utc_now()

	if existing_record && existing_record.metadata_updated_at &&
	NaiveDateTime.diff(now, existing_record.metadata_updated_at) < 86_400 do
	existing_record.metadata
	else
	metadata = scrape_metadata(instance_uri)

	if existing_record do
	existing_record
	\|> changeset(%{metadata: metadata, metadata_updated_at: now})
	\|> Repo.update()
	else
	%Instance{}
	\|> changeset(%{host: host, metadata: metadata, metadata_updated_at: now})
	\|> Repo.insert()
	end

	metadata
	end
	end

	defp get_nodeinfo_uri(well_known) do
	links = Map.get(well_known, "links", [])

	nodeinfo21 =
	Enum.find(links, &(&1["rel"] == "http://nodeinfo.diaspora.software/ns/schema/2.1"))["href"]

	nodeinfo20 =
	Enum.find(links, &(&1["rel"] == "http://nodeinfo.diaspora.software/ns/schema/2.0"))["href"]

	cond do
	is_binary(nodeinfo21) -> {:ok, nodeinfo21}
	is_binary(nodeinfo20) -> {:ok, nodeinfo20}
	true -> {:error, :no_links}
	end
	end

	defp scrape_metadata(%URI{} = instance_uri) do
	try do
	with {_, true} <- {:reachable, reachable?(instance_uri.host)},
	{:ok, %Tesla.Env{body: well_known_body}} <-
	instance_uri
	\|> URI.merge("/.well-known/nodeinfo")
	\|> to_string()
	\|> Pleroma.HTTP.get([{"accept", "application/json"}]),
	{:ok, well_known_json} <- Jason.decode(well_known_body),
	{:ok, nodeinfo_uri} <- get_nodeinfo_uri(well_known_json),
	{:ok, %Tesla.Env{body: nodeinfo_body}} <-
	Pleroma.HTTP.get(nodeinfo_uri, [{"accept", "application/json"}]),
	{:ok, nodeinfo} <- Jason.decode(nodeinfo_body) do
	# Can extract more metadata from NodeInfo but need to be careful about it's size,
	# can't just dump the entire thing
	software = Map.get(nodeinfo, "software", %{})

	%{
	software_name: software["name"],
	software_version: software["version"]
	}
	\|> Maps.put_if_present(:software_repository, software["repository"])
	else
	{:reachable, false} ->
	Logger.debug(
	"Instance.scrape_metadata(\"#{to_string(instance_uri)}\") ignored unreachable host"
	)

	nil

	_ ->
	nil
	end
	rescue
	e ->
	Logger.warning(
	"Instance.scrape_metadata(\"#{to_string(instance_uri)}\") error: #{inspect(e)}"
	)

	nil
	end
	end

	@doc """
	Deletes all users from an instance in a background task, thus also deleting
	all of those users' activities and notifications.
	"""
	def delete_users_and_activities(host) when is_binary(host) do
	- BackgroundWorker.enqueue("delete_instance", %{"host" => host})
	+ DeleteWorker.enqueue("delete_instance", %{"host" => host})
	end

	def perform(:delete_instance, host) when is_binary(host) do
	User.Query.build(%{nickname: "@#{host}"})
	\|> Repo.chunk_stream(100, :batches)
	\|> Stream.each(fn users ->
	users
	\|> Enum.each(fn user ->
	User.perform(:delete, user)
	end)
	end)
	\|> Stream.run()
	end
	end
	diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
	index 7a8a68931..e28d76a7c 100644
	--- a/lib/pleroma/user.ex
	+++ b/lib/pleroma/user.ex
	@@ -1,2813 +1,2814 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 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
	import Ecto, only: [assoc: 2]
	import Pleroma.Web.Utils.Guards, only: [not_empty_string: 1]

	alias Ecto.Multi
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Conversation.Participation
	alias Pleroma.Delivery
	alias Pleroma.EctoType.ActivityPub.ObjectValidators
	alias Pleroma.Emoji
	alias Pleroma.FollowingRelationship
	alias Pleroma.Formatter
	alias Pleroma.HTML
	alias Pleroma.Keys
	alias Pleroma.MFA
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserRelationship
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Builder
	alias Pleroma.Web.ActivityPub.Pipeline
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils, as: CommonUtils
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.OAuth
	alias Pleroma.Web.RelMe
	alias Pleroma.Workers.BackgroundWorker
	+ alias Pleroma.Workers.DeleteWorker
	alias Pleroma.Workers.UserRefreshWorker

	require Logger
	require Pleroma.Constants

	@type t :: %__MODULE__{}
	@type account_status ::
	:active
	\| :deactivated
	\| :password_reset_pending
	\| :confirmation_pending
	\| :approval_pending
	@primary_key {:id, FlakeId.Ecto.CompatType, autogenerate: true}

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

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

	# AP ID user relationships (blocks, mutes etc.)
	# Format: [rel_type: [outgoing_rel: :outgoing_rel_target, incoming_rel: :incoming_rel_source]]
	@user_relationships_config [
	block: [
	blocker_blocks: :blocked_users,
	blockee_blocks: :blocker_users
	],
	mute: [
	muter_mutes: :muted_users,
	mutee_mutes: :muter_users
	],
	reblog_mute: [
	reblog_muter_mutes: :reblog_muted_users,
	reblog_mutee_mutes: :reblog_muter_users
	],
	notification_mute: [
	notification_muter_mutes: :notification_muted_users,
	notification_mutee_mutes: :notification_muter_users
	],
	# Note: `inverse_subscription` relationship is inverse: subscriber acts as relationship target
	inverse_subscription: [
	subscribee_subscriptions: :subscriber_users,
	subscriber_subscriptions: :subscribee_users
	],
	endorsement: [
	endorser_endorsements: :endorsed_users,
	endorsee_endorsements: :endorser_users
	]
	]

	@cachex Pleroma.Config.get([:cachex, :provider], Cachex)

	schema "users" do
	field(:bio, :string, default: "")
	field(:raw_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(:keys, :string)
	field(:public_key, :string)
	field(:ap_id, :string)
	field(:avatar, :map, default: %{})
	field(:local, :boolean, default: true)
	field(:follower_address, :string)
	field(:following_address, :string)
	field(:featured_address, :string)
	field(:search_rank, :float, virtual: true)
	field(:search_type, :integer, virtual: true)
	field(:tags, {:array, :string}, default: [])
	field(:last_refreshed_at, :naive_datetime_usec)
	field(:last_digest_emailed_at, :naive_datetime)
	field(:banner, :map, default: %{})
	field(:background, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	field(:following_count, :integer, default: 0)
	field(:is_locked, :boolean, default: false)
	field(:is_confirmed, :boolean, default: true)
	field(:password_reset_pending, :boolean, default: false)
	field(:is_approved, :boolean, default: true)
	field(:registration_reason, :string, default: nil)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:domain_blocks, {:array, :string}, default: [])
	field(:is_active, :boolean, default: true)
	field(:no_rich_text, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:show_role, :boolean, default: true)
	field(:uri, ObjectValidators.Uri, default: nil)
	field(:hide_followers_count, :boolean, default: false)
	field(:hide_follows_count, :boolean, default: false)
	field(:hide_followers, :boolean, default: false)
	field(:hide_follows, :boolean, default: false)
	field(:hide_favorites, :boolean, default: true)
	field(:email_notifications, :map, default: %{"digest" => false})
	field(:mascot, :map, default: nil)
	field(:emoji, :map, default: %{})
	field(:pleroma_settings_store, :map, default: %{})
	field(:fields, {:array, :map}, default: [])
	field(:raw_fields, {:array, :map}, default: [])
	field(:is_discoverable, :boolean, default: false)
	field(:invisible, :boolean, default: false)
	field(:allow_following_move, :boolean, default: true)
	field(:skip_thread_containment, :boolean, default: false)
	field(:actor_type, :string, default: "Person")
	field(:also_known_as, {:array, ObjectValidators.ObjectID}, default: [])
	field(:inbox, :string)
	field(:shared_inbox, :string)
	field(:accepts_chat_messages, :boolean, default: nil)
	field(:last_active_at, :naive_datetime)
	field(:disclose_client, :boolean, default: true)
	field(:pinned_objects, :map, default: %{})
	field(:is_suggested, :boolean, default: false)
	field(:last_status_at, :naive_datetime)
	field(:birthday, :date)
	field(:show_birthday, :boolean, default: false)
	field(:language, :string)

	embeds_one(
	:notification_settings,
	Pleroma.User.NotificationSetting,
	on_replace: :update
	)

	has_many(:notifications, Notification)
	has_many(:registrations, Registration)
	has_many(:deliveries, Delivery)

	has_many(:outgoing_relationships, UserRelationship, foreign_key: :source_id)
	has_many(:incoming_relationships, UserRelationship, foreign_key: :target_id)

	for {relationship_type,
	[
	{outgoing_relation, outgoing_relation_target},
	{incoming_relation, incoming_relation_source}
	]} <- @user_relationships_config do
	# Definitions of `has_many` relations: :blocker_blocks, :muter_mutes, :reblog_muter_mutes,
	# :notification_muter_mutes, :subscribee_subscriptions, :endorser_endorsements
	has_many(outgoing_relation, UserRelationship,
	foreign_key: :source_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blockee_blocks, :mutee_mutes, :reblog_mutee_mutes,
	# :notification_mutee_mutes, :subscriber_subscriptions, :endorsee_endorsements
	has_many(incoming_relation, UserRelationship,
	foreign_key: :target_id,
	where: [relationship_type: relationship_type]
	)

	# Definitions of `has_many` relations: :blocked_users, :muted_users, :reblog_muted_users,
	# :notification_muted_users, :subscriber_users, :endorsed_users
	has_many(outgoing_relation_target, through: [outgoing_relation, :target])

	# Definitions of `has_many` relations: :blocker_users, :muter_users, :reblog_muter_users,
	# :notification_muter_users, :subscribee_users, :endorser_users
	has_many(incoming_relation_source, through: [incoming_relation, :source])
	end

	# `:blocks` is deprecated (replaced with `blocked_users` relation)
	field(:blocks, {:array, :string}, default: [])
	# `:mutes` is deprecated (replaced with `muted_users` relation)
	field(:mutes, {:array, :string}, default: [])
	# `:muted_reblogs` is deprecated (replaced with `reblog_muted_users` relation)
	field(:muted_reblogs, {:array, :string}, default: [])
	# `:muted_notifications` is deprecated (replaced with `notification_muted_users` relation)
	field(:muted_notifications, {:array, :string}, default: [])
	# `:subscribers` is deprecated (replaced with `subscriber_users` relation)
	field(:subscribers, {:array, :string}, default: [])

	embeds_one(
	:multi_factor_authentication_settings,
	MFA.Settings,
	on_replace: :delete
	)

	timestamps()
	end

	for {_relationship_type, [{_outgoing_relation, outgoing_relation_target}, _]} <-
	@user_relationships_config do
	# `def blocked_users_relation/2`, `def muted_users_relation/2`,
	# `def reblog_muted_users_relation/2`, `def notification_muted_users/2`,
	# `def subscriber_users/2`, `def endorsed_users_relation/2`
	def unquote(:"#{outgoing_relation_target}_relation")(user, restrict_deactivated? \\ false) do
	target_users_query = assoc(user, unquote(outgoing_relation_target))

	if restrict_deactivated? do
	target_users_query
	\|> User.Query.build(%{deactivated: false})
	else
	target_users_query
	end
	end

	# `def blocked_users/2`, `def muted_users/2`, `def reblog_muted_users/2`,
	# `def notification_muted_users/2`, `def subscriber_users/2`, `def endorsed_users/2`
	def unquote(outgoing_relation_target)(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> Repo.all()
	end

	# `def blocked_users_ap_ids/2`, `def muted_users_ap_ids/2`, `def reblog_muted_users_ap_ids/2`,
	# `def notification_muted_users_ap_ids/2`, `def subscriber_users_ap_ids/2`,
	# `def endorsed_users_ap_ids/2`
	def unquote(:"#{outgoing_relation_target}_ap_ids")(user, restrict_deactivated? \\ false) do
	__MODULE__
	\|> apply(unquote(:"#{outgoing_relation_target}_relation"), [
	user,
	restrict_deactivated?
	])
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end
	end

	def cached_blocked_users_ap_ids(user) do
	@cachex.fetch!(:user_cache, "blocked_users_ap_ids:#{user.ap_id}", fn _ ->
	blocked_users_ap_ids(user)
	end)
	end

	def cached_muted_users_ap_ids(user) do
	@cachex.fetch!(:user_cache, "muted_users_ap_ids:#{user.ap_id}", fn _ ->
	muted_users_ap_ids(user)
	end)
	end

	defdelegate following_count(user), to: FollowingRelationship
	defdelegate following(user), to: FollowingRelationship
	defdelegate following?(follower, followed), to: FollowingRelationship
	defdelegate following_ap_ids(user), to: FollowingRelationship
	defdelegate get_follow_requests(user), to: FollowingRelationship
	defdelegate search(query, opts \\ []), to: User.Search

	@doc """
	Dumps Flake Id to SQL-compatible format (16-byte UUID).
	E.g. "9pQtDGXuq4p3VlcJEm" -> <<0, 0, 1, 110, 179, 218, 42, 92, 213, 41, 44, 227, 95, 213, 0, 0>>
	"""
	def binary_id(source_id) when is_binary(source_id) do
	with {:ok, dumped_id} <- FlakeId.Ecto.CompatType.dump(source_id) do
	dumped_id
	else
	_ -> source_id
	end
	end

	def binary_id(source_ids) when is_list(source_ids) do
	Enum.map(source_ids, &binary_id/1)
	end

	def binary_id(%User{} = user), do: binary_id(user.id)

	@doc "Returns status account"
	@spec account_status(User.t()) :: account_status()
	def account_status(%User{is_active: false}), do: :deactivated
	def account_status(%User{password_reset_pending: true}), do: :password_reset_pending
	def account_status(%User{local: true, is_approved: false}), do: :approval_pending
	def account_status(%User{local: true, is_confirmed: false}), do: :confirmation_pending
	def account_status(%User{}), do: :active

	@spec visible_for(User.t(), User.t() \| nil) ::
	:visible
	\| :invisible
	\| :restricted_unauthenticated
	\| :deactivated
	\| :confirmation_pending
	def visible_for(user, for_user \\ nil)

	def visible_for(%User{invisible: true}, _), do: :invisible

	def visible_for(%User{id: user_id}, %User{id: user_id}), do: :visible

	def visible_for(%User{} = user, nil) do
	if restrict_unauthenticated?(user) do
	:restrict_unauthenticated
	else
	visible_account_status(user)
	end
	end

	def visible_for(%User{} = user, for_user) do
	if privileged?(for_user, :users_manage_activation_state) do
	:visible
	else
	visible_account_status(user)
	end
	end

	def visible_for(_, _), do: :invisible

	defp restrict_unauthenticated?(%User{local: true}) do
	Config.restrict_unauthenticated_access?(:profiles, :local)
	end

	defp restrict_unauthenticated?(%User{local: _}) do
	Config.restrict_unauthenticated_access?(:profiles, :remote)
	end

	defp visible_account_status(user) do
	status = account_status(user)

	if status in [:active, :password_reset_pending] do
	:visible
	else
	status
	end
	end

	@spec privileged?(User.t(), atom()) :: boolean()
	def privileged?(%User{is_admin: false, is_moderator: false}, _), do: false

	def privileged?(
	%User{local: true, is_admin: is_admin, is_moderator: is_moderator},
	privilege_tag
	),
	do:
	privileged_for?(privilege_tag, is_admin, :admin_privileges) or
	privileged_for?(privilege_tag, is_moderator, :moderator_privileges)

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

	defp privileged_for?(privilege_tag, true, config_role_key),
	do: privilege_tag in Config.get([:instance, config_role_key])

	defp privileged_for?(_, _, _), do: false

	@spec privileges(User.t()) :: [atom()]
	def privileges(%User{local: false}) do
	[]
	end

	def privileges(%User{is_moderator: false, is_admin: false}) do
	[]
	end

	def privileges(%User{local: true, is_moderator: true, is_admin: true}) do
	(Config.get([:instance, :moderator_privileges]) ++ Config.get([:instance, :admin_privileges]))
	\|> Enum.uniq()
	end

	def privileges(%User{local: true, is_moderator: true, is_admin: false}) do
	Config.get([:instance, :moderator_privileges])
	end

	def privileges(%User{local: true, is_moderator: false, is_admin: true}) do
	Config.get([:instance, :admin_privileges])
	end

	@spec invisible?(User.t()) :: boolean()
	def invisible?(%User{invisible: true}), do: true
	def invisible?(_), do: false

	def avatar_url(user, options \\ []) do
	case user.avatar do
	%{"url" => [%{"href" => href} \| _]} ->
	href

	_ ->
	unless options[:no_default] do
	Config.get([:assets, :default_user_avatar], "#{Endpoint.url()}/images/avi.png")
	end
	end
	end

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

	# Should probably be renamed or removed
	@spec ap_id(User.t()) :: String.t()
	def ap_id(%User{nickname: nickname}), do: "#{Endpoint.url()}/users/#{nickname}"

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

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

	@spec ap_featured_collection(User.t()) :: String.t()
	def ap_featured_collection(%User{featured_address: fa}) when is_binary(fa), do: fa

	def ap_featured_collection(%User{} = user), do: "#{ap_id(user)}/collections/featured"

	defp truncate_fields_param(params) do
	if Map.has_key?(params, :fields) do
	Map.put(params, :fields, Enum.map(params[:fields], &truncate_field/1))
	else
	params
	end
	end

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

	defp fix_follower_address(%{follower_address: _, following_address: _} = params), do: params

	defp fix_follower_address(%{nickname: nickname} = params),
	do: Map.put(params, :follower_address, ap_followers(%User{nickname: nickname}))

	defp fix_follower_address(params), do: params

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

	name =
	case params[:name] do
	name when is_binary(name) and byte_size(name) > 0 -> name
	_ -> params[:nickname]
	end

	params =
	params
	\|> Map.put(:name, name)
	\|> Map.put_new(:last_refreshed_at, NaiveDateTime.utc_now())
	\|> truncate_if_exists(:name, name_limit)
	\|> truncate_if_exists(:bio, bio_limit)
	\|> truncate_fields_param()
	\|> fix_follower_address()

	struct
	\|> cast(
	params,
	[
	:bio,
	:emoji,
	:ap_id,
	:inbox,
	:shared_inbox,
	:nickname,
	:public_key,
	:avatar,
	:banner,
	:is_locked,
	:last_refreshed_at,
	:uri,
	:follower_address,
	:following_address,
	:featured_address,
	:hide_followers,
	:hide_follows,
	:hide_followers_count,
	:hide_follows_count,
	:follower_count,
	:fields,
	:following_count,
	:is_discoverable,
	:invisible,
	:actor_type,
	:also_known_as,
	:accepts_chat_messages,
	:pinned_objects,
	:birthday,
	:show_birthday
	]
	)
	\|> cast(params, [:name], empty_values: [])
	\|> validate_required([:ap_id])
	\|> validate_required([:name], trim: false)
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, @email_regex)
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, max: name_limit)
	\|> validate_fields(true)
	\|> validate_non_local()
	end

	defp validate_non_local(cng) do
	local? = get_field(cng, :local)

	if local? do
	cng
	\|> add_error(:local, "User is local, can't update with this changeset.")
	else
	cng
	end
	end

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

	struct
	\|> cast(
	params,
	[
	:bio,
	:raw_bio,
	:name,
	:emoji,
	:avatar,
	:public_key,
	:inbox,
	:shared_inbox,
	:is_locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_follows,
	:hide_followers,
	:hide_followers_count,
	:hide_follows_count,
	:hide_favorites,
	:allow_following_move,
	:also_known_as,
	:background,
	:show_role,
	:skip_thread_containment,
	:fields,
	:raw_fields,
	:pleroma_settings_store,
	:is_discoverable,
	:actor_type,
	:accepts_chat_messages,
	:disclose_client,
	:birthday,
	:show_birthday
	]
	)
	\|> validate_min_age()
	\|> unique_constraint(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_inclusion(:actor_type, Pleroma.Constants.allowed_user_actor_types())
	\|> put_fields()
	\|> put_emoji()
	\|> put_change_if_present(:bio, &{:ok, parse_bio(&1, struct)})
	\|> put_change_if_present(:avatar, &put_upload(&1, :avatar))
	\|> put_change_if_present(:banner, &put_upload(&1, :banner))
	\|> put_change_if_present(:background, &put_upload(&1, :background))
	\|> put_change_if_present(
	:pleroma_settings_store,
	&{:ok, Map.merge(struct.pleroma_settings_store, &1)}
	)
	\|> validate_fields(false)
	end

	defp put_fields(changeset) do
	if raw_fields = get_change(changeset, :raw_fields) do
	old_fields = changeset.data.raw_fields

	raw_fields =
	raw_fields
	\|> Enum.filter(fn %{"name" => n} -> n != "" end)
	\|> Enum.map(fn field ->
	previous =
	old_fields
	\|> Enum.find(fn %{"value" => value} -> field["value"] == value end)

	if previous && Map.has_key?(previous, "verified_at") do
	field
	\|> Map.put("verified_at", previous["verified_at"])
	else
	field
	end
	end)

	fields =
	raw_fields
	\|> Enum.map(fn f -> Map.update!(f, "value", &parse_fields(&1)) end)

	changeset
	\|> put_change(:raw_fields, raw_fields)
	\|> put_change(:fields, fields)
	else
	changeset
	end
	end

	defp parse_fields(value) do
	value
	\|> Formatter.linkify(mentions_format: :full)
	\|> elem(0)
	end

	defp put_emoji(changeset) do
	emojified_fields = [:bio, :name, :raw_fields]

	if Enum.any?(changeset.changes, fn {k, _} -> k in emojified_fields end) do
	bio = Emoji.Formatter.get_emoji_map(get_field(changeset, :bio))
	name = Emoji.Formatter.get_emoji_map(get_field(changeset, :name))

	emoji = Map.merge(bio, name)

	emoji =
	changeset
	\|> get_field(:raw_fields)
	\|> Enum.reduce(emoji, fn x, acc ->
	Map.merge(acc, Emoji.Formatter.get_emoji_map(x["name"] <> x["value"]))
	end)

	put_change(changeset, :emoji, emoji)
	else
	changeset
	end
	end

	defp put_change_if_present(changeset, map_field, value_function) do
	with {:ok, value} <- fetch_change(changeset, map_field),
	{:ok, new_value} <- value_function.(value) do
	put_change(changeset, map_field, new_value)
	else
	{:error, :file_too_large} ->
	Ecto.Changeset.validate_change(changeset, map_field, fn map_field, _value ->
	[{map_field, "file is too large"}]
	end)

	_ ->
	changeset
	end
	end

	defp put_upload(value, type) do
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: type) do
	{:ok, object.data}
	end
	end

	def update_as_admin_changeset(struct, params) do
	struct
	\|> update_changeset(params)
	\|> cast(params, [:email])
	\|> delete_change(:also_known_as)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_inclusion(:actor_type, ["Person", "Service"])
	end

	@spec update_as_admin(User.t(), map()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def update_as_admin(user, params) do
	params = Map.put(params, "password_confirmation", params["password"])
	changeset = update_as_admin_changeset(user, params)

	if params["password"] do
	reset_password(user, changeset, params)
	else
	User.update_and_set_cache(changeset)
	end
	end

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

	@spec reset_password(User.t(), map()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def reset_password(%User{} = user, params) do
	reset_password(user, user, params)
	end

	def reset_password(%User{id: user_id} = user, struct, params) do
	multi =
	Multi.new()
	\|> Multi.update(:user, password_update_changeset(struct, params))
	\|> Multi.delete_all(:tokens, OAuth.Token.Query.get_by_user(user_id))
	\|> Multi.delete_all(:auth, OAuth.Authorization.delete_by_user_query(user))

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

	def update_password_reset_pending(user, value) do
	user
	\|> change()
	\|> put_change(:password_reset_pending, value)
	\|> update_and_set_cache()
	end

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

	@spec force_password_reset(User.t()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def force_password_reset(user), do: update_password_reset_pending(user, true)

	# Used to auto-register LDAP accounts which won't have a password hash stored locally
	def register_changeset_ldap(struct, params = %{password: password})
	when is_nil(password) do
	params = Map.put_new(params, :accepts_chat_messages, true)

	params =
	if Map.has_key?(params, :email) do
	Map.put_new(params, :email, params[:email])
	else
	params
	end

	struct
	\|> cast(params, [
	:name,
	:nickname,
	:email,
	:accepts_chat_messages
	])
	\|> validate_required([:name, :nickname])
	\|> unique_constraint(:nickname)
	\|> validate_not_restricted_nickname(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_and_featured_address()
	\|> put_private_key()
	end

	def register_changeset(struct, params \\ %{}, opts \\ []) do
	bio_limit = Config.get([:instance, :user_bio_length], 5000)
	name_limit = Config.get([:instance, :user_name_length], 100)
	reason_limit = Config.get([:instance, :registration_reason_length], 500)
	params = Map.put_new(params, :accepts_chat_messages, true)

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

	approved? =
	if is_nil(opts[:approved]) do
	!Config.get([:instance, :account_approval_required])
	else
	opts[:approved]
	end

	struct
	\|> confirmation_changeset(set_confirmation: confirmed?)
	\|> approval_changeset(set_approval: approved?)
	\|> cast(params, [
	:bio,
	:raw_bio,
	:email,
	:name,
	:nickname,
	:password,
	:password_confirmation,
	:emoji,
	:accepts_chat_messages,
	:registration_reason,
	:birthday,
	:language
	])
	\|> validate_required([:name, :nickname, :password, :password_confirmation])
	\|> validate_confirmation(:password)
	\|> unique_constraint(:email)
	\|> validate_format(:email, @email_regex)
	\|> validate_email_not_in_blacklisted_domain(:email)
	\|> unique_constraint(:nickname)
	\|> validate_not_restricted_nickname(:nickname)
	\|> validate_format(:nickname, local_nickname_regex())
	\|> validate_length(:bio, max: bio_limit)
	\|> validate_length(:name, min: 1, max: name_limit)
	\|> validate_length(:registration_reason, max: reason_limit)
	\|> maybe_validate_required_email(opts[:external])
	\|> maybe_validate_required_birthday
	\|> validate_min_age()
	\|> put_password_hash
	\|> put_ap_id()
	\|> unique_constraint(:ap_id)
	\|> put_following_and_follower_and_featured_address()
	\|> put_private_key()
	end

	def validate_not_restricted_nickname(changeset, field) do
	validate_change(changeset, field, fn _, value ->
	valid? =
	Config.get([User, :restricted_nicknames])
	\|> Enum.all?(fn restricted_nickname ->
	String.downcase(value) != String.downcase(restricted_nickname)
	end)

	if valid?, do: [], else: [nickname: "Invalid nickname"]
	end)
	end

	def validate_email_not_in_blacklisted_domain(changeset, field) do
	validate_change(changeset, field, fn _, value ->
	valid? =
	Config.get([User, :email_blacklist])
	\|> Enum.all?(fn blacklisted_domain ->
	blacklisted_domain_downcase = String.downcase(blacklisted_domain)

	!String.ends_with?(String.downcase(value), [
	"@" <> blacklisted_domain_downcase,
	"." <> blacklisted_domain_downcase
	])
	end)

	if valid?, do: [], else: [email: "Invalid email"]
	end)
	end

	def maybe_validate_required_email(changeset, true), do: changeset

	def maybe_validate_required_email(changeset, _) do
	if Config.get([:instance, :account_activation_required]) do
	validate_required(changeset, [:email])
	else
	changeset
	end
	end

	defp maybe_validate_required_birthday(changeset) do
	if Config.get([:instance, :birthday_required]) do
	validate_required(changeset, [:birthday])
	else
	changeset
	end
	end

	defp validate_min_age(changeset) do
	changeset
	\|> validate_change(:birthday, fn :birthday, birthday ->
	valid? =
	Date.utc_today()
	\|> Date.diff(birthday) >=
	Config.get([:instance, :birthday_min_age])

	if valid?, do: [], else: [birthday: "Invalid age"]
	end)
	end

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

	defp put_following_and_follower_and_featured_address(changeset) do
	user = %User{nickname: get_field(changeset, :nickname)}
	followers = ap_followers(user)
	following = ap_following(user)
	featured = ap_featured_collection(user)

	changeset
	\|> put_change(:follower_address, followers)
	\|> put_change(:following_address, following)
	\|> put_change(:featured_address, featured)
	end

	defp put_private_key(changeset) do
	{:ok, pem} = Keys.generate_rsa_pem()
	put_change(changeset, :keys, pem)
	end

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

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

	follow_all(user, autofollowed_users)
	end

	defp autofollowing_users(user) do
	candidates = Config.get([:instance, :autofollowing_nicknames])

	User.Query.build(%{nickname: candidates, local: true, deactivated: false})
	\|> Repo.all()
	\|> Enum.each(&follow(&1, user, :follow_accept))

	{:ok, :success}
	end

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

	def post_register_action(%User{is_confirmed: false} = user) do
	with {:ok, _} <- maybe_send_confirmation_email(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{is_approved: false} = user) do
	with {:ok, _} <- send_user_approval_email(user),
	{:ok, _} <- send_admin_approval_emails(user) do
	{:ok, user}
	end
	end

	def post_register_action(%User{is_approved: true, is_confirmed: true} = user) do
	with {:ok, user} <- autofollow_users(user),
	{:ok, _} <- autofollowing_users(user),
	{:ok, user} <- set_cache(user),
	{:ok, _} <- maybe_send_registration_email(user),
	{:ok, _} <- maybe_send_welcome_email(user),
	{:ok, _} <- maybe_send_welcome_message(user),
	{:ok, _} <- maybe_send_welcome_chat_message(user) do
	{:ok, user}
	end
	end

	defp send_user_approval_email(%User{email: email} = user) when is_binary(email) do
	user
	\|> Pleroma.Emails.UserEmail.approval_pending_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	end

	defp send_user_approval_email(_user) do
	{:ok, :skipped}
	end

	defp send_admin_approval_emails(user) do
	all_superusers()
	\|> Enum.filter(fn user -> not is_nil(user.email) end)
	\|> Enum.each(fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.new_unapproved_registration(user)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, :enqueued}
	end

	defp maybe_send_welcome_message(user) do
	if User.WelcomeMessage.enabled?() do
	User.WelcomeMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_chat_message(user) do
	if User.WelcomeChatMessage.enabled?() do
	User.WelcomeChatMessage.post_message(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_email(%User{email: email} = user) when is_binary(email) do
	if User.WelcomeEmail.enabled?() do
	User.WelcomeEmail.send_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	defp maybe_send_welcome_email(_), do: {:ok, :noop}

	@spec maybe_send_confirmation_email(User.t()) :: {:ok, :enqueued \| :noop}
	def maybe_send_confirmation_email(%User{is_confirmed: false, email: email} = user)
	when is_binary(email) do
	if Config.get([:instance, :account_activation_required]) do
	send_confirmation_email(user)
	{:ok, :enqueued}
	else
	{:ok, :noop}
	end
	end

	def maybe_send_confirmation_email(_), do: {:ok, :noop}

	@spec send_confirmation_email(User.t()) :: User.t()
	def send_confirmation_email(%User{} = user) do
	user
	\|> Pleroma.Emails.UserEmail.account_confirmation_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	user
	end

	@spec maybe_send_registration_email(User.t()) :: {:ok, :enqueued \| :noop}
	defp maybe_send_registration_email(%User{email: email} = user) when is_binary(email) do
	with false <- User.WelcomeEmail.enabled?(),
	false <- Config.get([:instance, :account_activation_required], false),
	false <- Config.get([:instance, :account_approval_required], false) do
	user
	\|> Pleroma.Emails.UserEmail.successful_registration_email()
	\|> Pleroma.Emails.Mailer.deliver_async()

	{:ok, :enqueued}
	else
	_ ->
	{:ok, :noop}
	end
	end

	defp maybe_send_registration_email(_), do: {:ok, :noop}

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

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

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

	def needs_update?(_), do: true

	@spec maybe_direct_follow(User.t(), User.t()) ::
	{:ok, User.t(), User.t()} \| {:error, String.t()}

	# "Locked" (self-locked) users demand explicit authorization of follow requests
	def maybe_direct_follow(%User{} = follower, %User{local: true, is_locked: true} = followed) do
	follow(follower, followed, :follow_pending)
	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
	{:ok, follower, followed}
	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
	followeds
	\|> Enum.reject(fn followed -> blocks?(follower, followed) \|\| blocks?(followed, follower) end)
	\|> Enum.each(&follow(follower, &1, :follow_accept))

	set_cache(follower)
	end

	def follow(%User{} = follower, %User{} = followed, state \\ :follow_accept) do
	deny_follow_blocked = Config.get([:user, :deny_follow_blocked])

	cond do
	not followed.is_active ->
	{:error, "Could not follow user: #{followed.nickname} is deactivated."}

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

	true ->
	FollowingRelationship.follow(follower, followed, state)
	end
	end

	def unfollow(%User{ap_id: ap_id}, %User{ap_id: ap_id}) do
	{:error, "Not subscribed!"}
	end

	@spec unfollow(User.t(), User.t()) :: {:ok, User.t(), Activity.t()} \| {:error, String.t()}
	def unfollow(%User{} = follower, %User{} = followed) do
	case do_unfollow(follower, followed) do
	{:ok, follower, followed} ->
	{:ok, follower, Utils.fetch_latest_follow(follower, followed)}

	error ->
	error
	end
	end

	@spec do_unfollow(User.t(), User.t()) :: {:ok, User.t(), User.t()} \| {:error, String.t()}
	defp do_unfollow(%User{} = follower, %User{} = followed) do
	case get_follow_state(follower, followed) do
	state when state in [:follow_pending, :follow_accept] ->
	FollowingRelationship.unfollow(follower, followed)

	nil ->
	{:error, "Not subscribed!"}
	end
	end

	@doc "Returns follow state as Pleroma.FollowingRelationship.State value"
	def get_follow_state(%User{} = follower, %User{} = following) do
	following_relationship = FollowingRelationship.get(follower, following)
	get_follow_state(follower, following, following_relationship)
	end

	def get_follow_state(
	%User{} = follower,
	%User{} = following,
	following_relationship
	) do
	case {following_relationship, following.local} do
	{nil, false} ->
	case Utils.fetch_latest_follow(follower, following) do
	%Activity{data: %{"state" => state}} when state in ["pending", "accept"] ->
	FollowingRelationship.state_to_enum(state)

	_ ->
	nil
	end

	{%{state: state}, _} ->
	state

	{nil, _} ->
	nil
	end
	end

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

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

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

	def get_by_uri(uri) do
	Repo.get_by(User, uri: uri)
	end

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

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

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

	get_cached_by_nickname(nickname)
	end

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

	def set_cache(%User{} = user) do
	@cachex.put(:user_cache, "ap_id:#{user.ap_id}", user)
	@cachex.put(:user_cache, "nickname:#{user.nickname}", user)
	@cachex.put(:user_cache, "friends_ap_ids:#{user.nickname}", get_user_friends_ap_ids(user))
	{:ok, user}
	end

	def update_and_set_cache(struct, params) do
	struct
	\|> update_changeset(params)
	\|> update_and_set_cache()
	end

	def update_and_set_cache(changeset) do
	with {:ok, user} <- Repo.update(changeset, stale_error_field: :id) do
	if get_change(changeset, :raw_fields) do
	BackgroundWorker.enqueue("verify_fields_links", %{"user_id" => user.id})
	end

	set_cache(user)
	end
	end

	def get_user_friends_ap_ids(user) do
	from(u in User.get_friends_query(user), select: u.ap_id)
	\|> Repo.all()
	end

	@spec get_cached_user_friends_ap_ids(User.t()) :: [String.t()]
	def get_cached_user_friends_ap_ids(user) do
	@cachex.fetch!(:user_cache, "friends_ap_ids:#{user.ap_id}", fn _ ->
	get_user_friends_ap_ids(user)
	end)
	end

	def invalidate_cache(user) do
	@cachex.del(:user_cache, "ap_id:#{user.ap_id}")
	@cachex.del(:user_cache, "nickname:#{user.nickname}")
	@cachex.del(:user_cache, "friends_ap_ids:#{user.ap_id}")
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	@cachex.del(:user_cache, "muted_users_ap_ids:#{user.ap_id}")
	end

	@spec get_cached_by_ap_id(String.t()) :: User.t() \| nil
	def get_cached_by_ap_id(ap_id) do
	key = "ap_id:#{ap_id}"

	with {:ok, nil} <- @cachex.get(:user_cache, key),
	user when not is_nil(user) <- get_by_ap_id(ap_id),
	{:ok, true} <- @cachex.put(:user_cache, key, user) do
	user
	else
	{:ok, user} -> user
	nil -> nil
	end
	end

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

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

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

	get_cached_by_ap_id(ap_id)
	end

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

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

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

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

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

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

	true ->
	nil
	end
	end

	@spec get_by_nickname(String.t()) :: User.t() \| nil
	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 fetch_by_nickname(nickname), do: ActivityPub.make_user_from_nickname(nickname)

	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
	{:ok, user}
	else
	_e -> {:error, "not found " <> nickname}
	end
	end
	end

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

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

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

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

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

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

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

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

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

	def get_friends(%User{} = user, page \\ nil) do
	user
	\|> get_friends_query(page)
	\|> Repo.all()
	end

	def get_friends_ap_ids(%User{} = user) do
	user
	\|> get_friends_query(nil)
	\|> select([u], u.ap_id)
	\|> Repo.all()
	end

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

	@spec get_familiar_followers_query(User.t(), User.t(), pos_integer() \| nil) :: Ecto.Query.t()
	def get_familiar_followers_query(%User{} = user, %User{} = current_user, nil) do
	friends =
	get_friends_query(current_user)
	\|> where([u], not u.hide_follows)
	\|> select([u], u.id)

	User.Query.build(%{is_active: true})
	\|> where([u], u.id not in ^[user.id, current_user.id])
	\|> join(:inner, [u], r in FollowingRelationship,
	as: :followers_relationships,
	on: r.following_id == ^user.id and r.follower_id == u.id
	)
	\|> where([followers_relationships: r], r.state == ^:follow_accept)
	\|> where([followers_relationships: r], r.follower_id in subquery(friends))
	end

	def get_familiar_followers_query(%User{} = user, %User{} = current_user, page) do
	user
	\|> get_familiar_followers_query(current_user, nil)
	\|> User.Query.paginate(page, 20)
	end

	@spec get_familiar_followers_query(User.t(), User.t()) :: Ecto.Query.t()
	def get_familiar_followers_query(%User{} = user, %User{} = current_user),
	do: get_familiar_followers_query(user, current_user, nil)

	@spec get_familiar_followers(User.t(), User.t(), pos_integer() \| nil) :: {:ok, list(User.t())}
	def get_familiar_followers(%User{} = user, %User{} = current_user, page \\ nil) do
	user
	\|> get_familiar_followers_query(current_user, page)
	\|> Repo.all()
	end

	def increase_note_count(%User{} = user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], inc: [note_count: 1])
	\|> 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: [
	note_count: fragment("greatest(0, note_count - 1)")
	]
	)
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

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

	user
	\|> cast(%{note_count: note_count}, [:note_count])
	\|> update_and_set_cache()
	end

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

	user
	end
	end

	def fetch_follow_information(user) do
	with {:ok, info} <- ActivityPub.fetch_follow_information_for_user(user) do
	user
	\|> follow_information_changeset(info)
	\|> update_and_set_cache()
	end
	end

	defp follow_information_changeset(user, params) do
	user
	\|> cast(params, [
	:hide_followers,
	:hide_follows,
	:follower_count,
	:following_count,
	:hide_followers_count,
	:hide_follows_count
	])
	end

	@spec update_follower_count(User.t()) :: {:ok, User.t()}
	def update_follower_count(%User{} = user) do
	if user.local or !Config.get([:instance, :external_user_synchronization]) do
	follower_count = FollowingRelationship.follower_count(user)

	user
	\|> follow_information_changeset(%{follower_count: follower_count})
	\|> update_and_set_cache
	else
	{:ok, maybe_fetch_follow_information(user)}
	end
	end

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

	def update_following_count(%User{local: true} = user) do
	following_count = FollowingRelationship.following_count(user)

	user
	\|> follow_information_changeset(%{following_count: following_count})
	\|> update_and_set_cache()
	end

	@spec get_users_from_set([String.t()], keyword()) :: [User.t()]
	def get_users_from_set(ap_ids, opts \\ []) do
	local_only = Keyword.get(opts, :local_only, true)
	criteria = %{ap_id: ap_ids, is_active: true}
	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, actor: actor}) do
	to = [actor \| to]

	query = User.Query.build(%{recipients_from_activity: to, local: true, is_active: true})

	query
	\|> Repo.all()
	end

	@spec mute(User.t(), User.t(), map()) ::
	{:ok, list(UserRelationship.t())} \| {:error, String.t()}
	def mute(%User{} = muter, %User{} = mutee, params \\ %{}) do
	notifications? = Map.get(params, :notifications, true)
	duration = Map.get(params, :duration, 0)

	expires_at =
	if duration > 0 do
	DateTime.utc_now()
	\|> DateTime.add(duration)
	else
	nil
	end

	with {:ok, user_mute} <- UserRelationship.create_mute(muter, mutee, expires_at),
	{:ok, user_notification_mute} <-
	(notifications? &&
	UserRelationship.create_notification_mute(
	muter,
	mutee,
	expires_at
	)) \|\|
	{:ok, nil} do
	if duration > 0 do
	Pleroma.Workers.MuteExpireWorker.enqueue(
	"unmute_user",
	%{"muter_id" => muter.id, "mutee_id" => mutee.id},
	scheduled_at: expires_at
	)
	end

	@cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")

	{:ok, Enum.filter([user_mute, user_notification_mute], & &1)}
	end
	end

	def unmute(%User{} = muter, %User{} = mutee) do
	with {:ok, user_mute} <- UserRelationship.delete_mute(muter, mutee),
	{:ok, user_notification_mute} <-
	UserRelationship.delete_notification_mute(muter, mutee) do
	@cachex.del(:user_cache, "muted_users_ap_ids:#{muter.ap_id}")
	{:ok, [user_mute, user_notification_mute]}
	end
	end

	def unmute(muter_id, mutee_id) do
	with {:muter, %User{} = muter} <- {:muter, User.get_by_id(muter_id)},
	{:mutee, %User{} = mutee} <- {:mutee, User.get_by_id(mutee_id)} do
	unmute(muter, mutee)
	else
	{who, result} = error ->
	Logger.warning(
	"User.unmute/2 failed. #{who}: #{result}, muter_id: #{muter_id}, mutee_id: #{mutee_id}"
	)

	{:error, error}
	end
	end

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

	if blocks?(target, subscriber) and deny_follow_blocked do
	{:error, "Could not subscribe: #{target.nickname} is blocking you"}
	else
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.create_inverse_subscription(target, subscriber)
	end
	end

	def subscribe(%User{} = subscriber, %{ap_id: ap_id}) do
	with %User{} = subscribee <- get_cached_by_ap_id(ap_id) do
	subscribe(subscriber, subscribee)
	end
	end

	def unsubscribe(%User{} = unsubscriber, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.delete_inverse_subscription(target, unsubscriber)
	end

	def unsubscribe(%User{} = unsubscriber, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unsubscribe(unsubscriber, user)
	end
	end

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

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

	blocker =
	case CommonAPI.reject_follow_request(blocker, blocked) do
	{:ok, %User{} = updated_blocker} -> updated_blocker
	nil -> blocker
	end

	unsubscribe(blocked, blocker)

	unfollowing_blocked = Config.get([:activitypub, :unfollow_blocked], true)
	if unfollowing_blocked && following?(blocked, blocker), do: unfollow(blocked, blocker)

	{:ok, blocker} = update_follower_count(blocker)
	{:ok, blocker, _} = Participation.mark_all_as_read(blocker, blocked)
	add_to_block(blocker, blocked)
	end

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

	def unblock(%User{} = blocker, %User{} = blocked) do
	remove_from_block(blocker, blocked)
	end

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

	def endorse(%User{} = endorser, %User{} = target) do
	with max_endorsed_users <- Pleroma.Config.get([:instance, :max_endorsed_users], 0),
	endorsed_users <-
	User.endorsed_users_relation(endorser)
	\|> Repo.aggregate(:count, :id) do
	cond do
	endorsed_users >= max_endorsed_users ->
	{:error, "You have already pinned the maximum number of users"}

	not following?(endorser, target) ->
	{:error, "Could not endorse: You are not following #{target.nickname}"}

	true ->
	UserRelationship.create_endorsement(endorser, target)
	end
	end
	end

	def endorse(%User{} = endorser, %{ap_id: ap_id}) do
	with %User{} = endorsed <- get_cached_by_ap_id(ap_id) do
	endorse(endorser, endorsed)
	end
	end

	def unendorse(%User{} = unendorser, %User{} = target) do
	UserRelationship.delete_endorsement(unendorser, target)
	end

	def unendorse(%User{} = unendorser, %{ap_id: ap_id}) do
	with %User{} = user <- get_cached_by_ap_id(ap_id) do
	unendorse(unendorser, user)
	end
	end

	def mutes?(nil, _), do: false
	def mutes?(%User{} = user, %User{} = target), do: mutes_user?(user, target)

	def mutes_user?(%User{} = user, %User{} = target) do
	UserRelationship.mute_exists?(user, target)
	end

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

	def muted_notifications?(%User{} = user, %User{} = target),
	do: UserRelationship.notification_mute_exists?(user, target)

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

	def blocks?(%User{} = user, %User{} = target) do
	blocks_user?(user, target) \|\|
	(blocks_domain?(user, target) and not User.following?(user, target))
	end

	def blocks_user?(%User{} = user, %User{} = target) do
	UserRelationship.block_exists?(user, target)
	end

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

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

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

	def subscribed_to?(%User{} = user, %User{} = target) do
	# Note: the relationship is inverse: subscriber acts as relationship target
	UserRelationship.inverse_subscription_exists?(target, user)
	end

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

	def endorses?(%User{} = user, %User{} = target) do
	UserRelationship.endorsement_exists?(user, target)
	end

	@doc """
	Returns map of outgoing (blocked, muted etc.) relationships' user AP IDs by relation type.
	E.g. `outgoing_relationships_ap_ids(user, [:block])` -> `%{block: ["https://some.site/users/userapid"]}`
	"""
	@spec outgoing_relationships_ap_ids(User.t(), list(atom())) :: %{atom() => list(String.t())}
	def outgoing_relationships_ap_ids(_user, []), do: %{}

	def outgoing_relationships_ap_ids(nil, _relationship_types), do: %{}

	def outgoing_relationships_ap_ids(%User{} = user, relationship_types)
	when is_list(relationship_types) do
	db_result =
	user
	\|> assoc(:outgoing_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :target))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> select([user_rel, u], [user_rel.relationship_type, fragment("array_agg(?)", u.ap_id)])
	\|> group_by([user_rel, u], user_rel.relationship_type)
	\|> Repo.all()
	\|> Enum.into(%{}, fn [k, v] -> {k, v} end)

	Enum.into(
	relationship_types,
	%{},
	fn rel_type -> {rel_type, db_result[rel_type] \|\| []} end
	)
	end

	def incoming_relationships_ungrouped_ap_ids(user, relationship_types, ap_ids \\ nil)

	def incoming_relationships_ungrouped_ap_ids(_user, [], _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(nil, _relationship_types, _ap_ids), do: []

	def incoming_relationships_ungrouped_ap_ids(%User{} = user, relationship_types, ap_ids)
	when is_list(relationship_types) do
	user
	\|> assoc(:incoming_relationships)
	\|> join(:inner, [user_rel], u in assoc(user_rel, :source))
	\|> where([user_rel, u], user_rel.relationship_type in ^relationship_types)
	\|> maybe_filter_on_ap_id(ap_ids)
	\|> select([user_rel, u], u.ap_id)
	\|> distinct(true)
	\|> Repo.all()
	end

	defp maybe_filter_on_ap_id(query, ap_ids) when is_list(ap_ids) do
	where(query, [user_rel, u], u.ap_id in ^ap_ids)
	end

	defp maybe_filter_on_ap_id(query, _ap_ids), do: query

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

	@spec set_activation([User.t()], boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_activation(users, status) when is_list(users) do
	Repo.transaction(fn ->
	for user <- users do
	{:ok, user} = set_activation(user, status)
	user
	end
	end)
	end

	@spec set_activation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_activation(%User{} = user, status) do
	with {:ok, user} <- set_activation_status(user, status) do
	user
	\|> get_followers()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&set_cache(update_following_count(&1)))

	# Only update local user counts, remote will be update during the next pull.
	user
	\|> get_friends()
	\|> Enum.filter(& &1.local)
	\|> Enum.each(&do_unfollow(user, &1))

	{:ok, user}
	end
	end

	def approve(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- approve(user), do: user
	end)
	end)
	end

	def approve(%User{is_approved: false} = user) do
	with chg <- change(user, is_approved: true),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def approve(%User{} = user), do: {:ok, user}

	def confirm(users) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- confirm(user), do: user
	end)
	end)
	end

	def confirm(%User{is_confirmed: false} = user) do
	with chg <- confirmation_changeset(user, set_confirmation: true),
	{:ok, user} <- update_and_set_cache(chg) do
	post_register_action(user)
	{:ok, user}
	end
	end

	def confirm(%User{} = user), do: {:ok, user}

	def set_suggestion(users, is_suggested) when is_list(users) do
	Repo.transaction(fn ->
	Enum.map(users, fn user ->
	with {:ok, user} <- set_suggestion(user, is_suggested), do: user
	end)
	end)
	end

	def set_suggestion(%User{is_suggested: is_suggested} = user, is_suggested), do: {:ok, user}

	def set_suggestion(%User{} = user, is_suggested) when is_boolean(is_suggested) do
	user
	\|> change(is_suggested: is_suggested)
	\|> update_and_set_cache()
	end

	def update_notification_settings(%User{} = user, settings) do
	user
	\|> cast(%{notification_settings: settings}, [])
	\|> cast_embed(:notification_settings)
	\|> validate_required([:notification_settings])
	\|> update_and_set_cache()
	end

	@spec purge_user_changeset(User.t()) :: Ecto.Changeset.t()
	def purge_user_changeset(user) do
	# "Right to be forgotten"
	# https://gdpr.eu/right-to-be-forgotten/
	change(user, %{
	bio: "",
	raw_bio: nil,
	email: nil,
	name: nil,
	password_hash: nil,
	avatar: %{},
	tags: [],
	last_refreshed_at: nil,
	last_digest_emailed_at: nil,
	banner: %{},
	background: %{},
	note_count: 0,
	follower_count: 0,
	following_count: 0,
	is_locked: false,
	password_reset_pending: false,
	registration_reason: nil,
	confirmation_token: nil,
	domain_blocks: [],
	is_active: false,
	is_moderator: false,
	is_admin: false,
	mascot: nil,
	emoji: %{},
	pleroma_settings_store: %{},
	fields: [],
	raw_fields: [],
	is_discoverable: false,
	also_known_as: []
	# id: preserved
	# ap_id: preserved
	# nickname: preserved
	})
	end

	# Purge doesn't delete the user from the database.
	# It just nulls all its fields and deactivates it.
	# See `User.purge_user_changeset/1` above.
	defp purge(%User{} = user) do
	user
	\|> purge_user_changeset()
	\|> update_and_set_cache()
	end

	def delete(users) when is_list(users) do
	for user <- users, do: delete(user)
	end

	def delete(%User{} = user) do
	# Purge the user immediately
	purge(user)
	- BackgroundWorker.enqueue("delete_user", %{"user_id" => user.id})
	+ DeleteWorker.enqueue("delete_user", %{"user_id" => user.id})
	end

	# Actually delete the user from the DB
	defp delete_from_db(%User{} = user) do
	invalidate_cache(user)
	Repo.delete(user)
	end

	# If the user never finalized their account, it's safe to delete them.
	defp maybe_delete_from_db(%User{local: true, is_confirmed: false} = user),
	do: delete_from_db(user)

	defp maybe_delete_from_db(%User{local: true, is_approved: false} = user),
	do: delete_from_db(user)

	defp maybe_delete_from_db(user), do: {:ok, user}

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

	@spec perform(atom(), User.t()) :: {:ok, User.t()}
	def perform(:delete, %User{} = user) do
	# Purge the user again, in case perform/2 is called directly
	purge(user)

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

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

	delete_user_activities(user)
	delete_notifications_from_user_activities(user)
	delete_outgoing_pending_follow_requests(user)

	maybe_delete_from_db(user)
	end

	def perform(:verify_fields_links, user) do
	profile_urls = [user.ap_id]

	fields =
	user.raw_fields
	\|> Enum.map(&verify_field_link(&1, profile_urls))

	changeset =
	user
	\|> update_changeset(%{raw_fields: fields})

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

	def perform(:set_activation_async, user, status), do: set_activation(user, status)

	defp verify_field_link(field, profile_urls) do
	verified_at =
	with %{"value" => value} <- field,
	{:verified_at, nil} <- {:verified_at, Map.get(field, "verified_at")},
	%{scheme: scheme, userinfo: nil, host: host}
	when not_empty_string(host) and scheme in ["http", "https"] <-
	URI.parse(value),
	{:not_idn, true} <-
	{:not_idn, match?(^host, to_string(:idna.encode(to_charlist(host))))},
	"me" <- Pleroma.Web.RelMe.maybe_put_rel_me(value, profile_urls) do
	CommonUtils.to_masto_date(NaiveDateTime.utc_now())
	else
	{:verified_at, value} when not_empty_string(value) ->
	value

	_ ->
	nil
	end

	Map.put(field, "verified_at", verified_at)
	end

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

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

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

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

	Repo.all(query)
	end

	def delete_notifications_from_user_activities(%User{ap_id: ap_id}) do
	Notification
	\|> join(:inner, [n], activity in assoc(n, :activity))
	\|> where([n, a], fragment("? = ?", a.actor, ^ap_id))
	\|> Repo.delete_all()
	end

	def delete_user_activities(%User{ap_id: ap_id} = user) do
	ap_id
	\|> Activity.Queries.by_actor()
	\|> Repo.chunk_stream(50, :batches)
	\|> Stream.each(fn activities ->
	Enum.each(activities, fn activity -> delete_activity(activity, user) end)
	end)
	\|> Stream.run()
	end

	defp delete_activity(%{data: %{"type" => "Create", "object" => object}} = activity, user) do
	with {_, %Object{}} <- {:find_object, Object.get_by_ap_id(object)},
	{:ok, delete_data, _} <- Builder.delete(user, object) do
	Pipeline.common_pipeline(delete_data, local: user.local)
	else
	{:find_object, nil} ->
	# We have the create activity, but not the object, it was probably pruned.
	# Insert a tombstone and try again
	with {:ok, tombstone_data, _} <- Builder.tombstone(user.ap_id, object),
	{:ok, _tombstone} <- Object.create(tombstone_data) do
	delete_activity(activity, user)
	end

	e ->
	Logger.error("Could not delete #{object} created by #{activity.data["ap_id"]}")
	Logger.error("Error: #{inspect(e)}")
	end
	end

	defp delete_activity(%{data: %{"type" => type}} = activity, user)
	when type in ["Like", "Announce"] do
	{:ok, undo, _} = Builder.undo(user, activity)
	Pipeline.common_pipeline(undo, local: user.local)
	end

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

	defp delete_outgoing_pending_follow_requests(user) do
	user
	\|> FollowingRelationship.outgoing_pending_follow_requests_query()
	\|> Repo.delete_all()
	end

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

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

	def fetch_by_ap_id(ap_id), do: ActivityPub.make_user_from_ap_id(ap_id)

	@spec get_or_fetch_by_ap_id(String.t()) :: {:ok, User.t()} \| {:error, any()}
	def get_or_fetch_by_ap_id(ap_id) do
	with cached_user = %User{} <- get_cached_by_ap_id(ap_id),
	_ <- maybe_refresh(cached_user) do
	{:ok, cached_user}
	else
	_ -> fetch_by_ap_id(ap_id)
	end
	end

	defp maybe_refresh(user) do
	if needs_update?(user) do
	UserRefreshWorker.new(%{"ap_id" => user.ap_id})
	\|> Oban.insert()
	end
	end

	@doc """
	Creates an internal service actor by URI if missing.
	Optionally takes nickname for addressing.
	"""
	@spec get_or_create_service_actor_by_ap_id(String.t(), String.t()) :: User.t() \| nil
	def get_or_create_service_actor_by_ap_id(uri, nickname) do
	{_, user} =
	case get_cached_by_ap_id(uri) do
	nil ->
	with {:error, %{errors: errors}} <- create_service_actor(uri, nickname) do
	Logger.error("Cannot create service actor: #{uri}/.\n#{inspect(errors)}")
	{:error, nil}
	end

	%User{invisible: false} = user ->
	set_invisible(user)

	user ->
	{:ok, user}
	end

	user
	end

	@spec set_invisible(User.t()) :: {:ok, User.t()}
	defp set_invisible(user) do
	user
	\|> change(%{invisible: true})
	\|> update_and_set_cache()
	end

	@spec create_service_actor(String.t(), String.t()) ::
	{:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	defp create_service_actor(uri, nickname) do
	%User{
	invisible: true,
	local: true,
	ap_id: uri,
	nickname: nickname,
	follower_address: uri <> "/followers"
	}
	\|> change
	\|> put_private_key()
	\|> unique_constraint(:nickname)
	\|> Repo.insert()
	\|> set_cache()
	end

	def public_key(%{public_key: public_key_pem}) when is_binary(public_key_pem) do
	key =
	public_key_pem
	\|> :public_key.pem_decode()
	\|> hd()
	\|> :public_key.pem_entry_decode()

	{:ok, key}
	end

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

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

	@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("https://" <> _host = uri), do: get_or_fetch_by_ap_id(uri)
	def get_or_fetch(nickname), do: get_or_fetch_by_nickname(nickname)

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

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

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

	def parse_bio(_), do: ""

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

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

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

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

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

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

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

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

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

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

	updated_user
	end

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

	defp local_nickname_regex do
	if 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(%User{} = user) do
	if String.contains?(user.nickname, "@") do
	user.nickname
	else
	host = Pleroma.Web.WebFinger.host()
	user.nickname <> "@" <> host
	end
	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,
	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, is_active: true})
	\|> Repo.all()
	end

	@spec all_users_with_privilege(atom()) :: [User.t()]
	def all_users_with_privilege(privilege) do
	User.Query.build(%{is_privileged: privilege}) \|> Repo.all()
	end

	def muting_reblogs?(%User{} = user, %User{} = target) do
	UserRelationship.reblog_mute_exists?(user, target)
	end

	def showing_reblogs?(%User{} = user, %User{} = target) do
	not muting_reblogs?(user, target)
	end

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

	## Examples

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

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

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

	## Examples

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

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

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

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

	updated_user
	end

	@spec set_confirmation(User.t(), boolean()) :: {:ok, User.t()} \| {:error, Ecto.Changeset.t()}
	def set_confirmation(%User{} = user, bool) do
	user
	\|> confirmation_changeset(set_confirmation: bool)
	\|> update_and_set_cache()
	end

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

	def get_mascot(%{mascot: mascot}) when is_nil(mascot) do
	# use instance-default
	config = Config.get([:assets, :mascots])
	default_mascot = 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 get_ap_ids_by_nicknames(nicknames) do
	from(u in User,
	where: u.nickname in ^nicknames,
	order_by: fragment("array_position(?, ?)", ^nicknames, u.nickname),
	select: u.ap_id
	)
	\|> Repo.all()
	end

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

	defp put_password_hash(changeset), do: changeset

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

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

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

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

	def alias_users(user) do
	user.also_known_as
	\|> Enum.map(&User.get_cached_by_ap_id/1)
	\|> Enum.filter(fn user -> user != nil end)
	end

	def add_alias(user, new_alias_user) do
	current_aliases = user.also_known_as \|\| []
	new_alias_ap_id = new_alias_user.ap_id

	if new_alias_ap_id in current_aliases do
	{:ok, user}
	else
	user
	\|> cast(%{also_known_as: current_aliases ++ [new_alias_ap_id]}, [:also_known_as])
	\|> update_and_set_cache()
	end
	end

	def delete_alias(user, alias_user) do
	current_aliases = user.also_known_as \|\| []
	alias_ap_id = alias_user.ap_id

	if alias_ap_id in current_aliases do
	user
	\|> cast(%{also_known_as: current_aliases -- [alias_ap_id]}, [:also_known_as])
	\|> update_and_set_cache()
	else
	{:error, :no_such_alias}
	end
	end

	# Internal function; public one is `deactivate/2`
	defp set_activation_status(user, status) do
	user
	\|> cast(%{is_active: status}, [:is_active])
	\|> update_and_set_cache()
	end

	def update_banner(user, banner) do
	user
	\|> cast(%{banner: banner}, [:banner])
	\|> update_and_set_cache()
	end

	def update_background(user, background) do
	user
	\|> cast(%{background: background}, [:background])
	\|> update_and_set_cache()
	end

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

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

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

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

	defp valid_field?(_), do: false

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

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

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

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

	@doc "Signs user out of all applications"
	def global_sign_out(user) do
	OAuth.Authorization.delete_user_authorizations(user)
	OAuth.Token.delete_user_tokens(user)
	end

	def mascot_update(user, url) do
	user
	\|> cast(%{mascot: url}, [:mascot])
	\|> validate_required([:mascot])
	\|> update_and_set_cache()
	end

	@spec confirmation_changeset(User.t(), keyword()) :: Ecto.Changeset.t()
	def confirmation_changeset(user, set_confirmation: confirmed?) do
	params =
	if confirmed? do
	%{
	is_confirmed: true,
	confirmation_token: nil
	}
	else
	%{
	is_confirmed: false,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	}
	end

	cast(user, params, [:is_confirmed, :confirmation_token])
	end

	@spec approval_changeset(Ecto.Changeset.t(), keyword()) :: Ecto.Changeset.t()
	def approval_changeset(changeset, set_approval: approved?) do
	cast(changeset, %{is_approved: approved?}, [:is_approved])
	end

	@spec add_pinned_object_id(User.t(), String.t()) :: {:ok, User.t()} \| {:error, term()}
	def add_pinned_object_id(%User{} = user, object_id) do
	if !user.pinned_objects[object_id] do
	params = %{pinned_objects: Map.put(user.pinned_objects, object_id, NaiveDateTime.utc_now())}

	user
	\|> cast(params, [:pinned_objects])
	\|> validate_change(:pinned_objects, fn :pinned_objects, pinned_objects ->
	max_pinned_statuses = Config.get([:instance, :max_pinned_statuses], 0)

	if Enum.count(pinned_objects) <= max_pinned_statuses do
	[]
	else
	[pinned_objects: "You have already pinned the maximum number of statuses"]
	end
	end)
	else
	change(user)
	end
	\|> update_and_set_cache()
	end

	@spec remove_pinned_object_id(User.t(), String.t()) :: {:ok, t()} \| {:error, term()}
	def remove_pinned_object_id(%User{} = user, object_id) do
	user
	\|> cast(
	%{pinned_objects: Map.delete(user.pinned_objects, object_id)},
	[:pinned_objects]
	)
	\|> update_and_set_cache()
	end

	def update_email_notifications(user, settings) do
	email_notifications =
	user.email_notifications
	\|> Map.merge(settings)
	\|> Map.take(["digest"])

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

	user
	\|> cast(params, fields)
	\|> validate_required(fields)
	\|> update_and_set_cache()
	end

	defp set_domain_blocks(user, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

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

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

	def unblock_domain(user, domain_blocked) do
	set_domain_blocks(user, List.delete(user.domain_blocks, domain_blocked))
	end

	@spec add_to_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:error, Ecto.Changeset.t()}
	defp add_to_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.create_block(user, blocked) do
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	@spec remove_from_block(User.t(), User.t()) ::
	{:ok, UserRelationship.t()} \| {:ok, nil} \| {:error, Ecto.Changeset.t()}
	defp remove_from_block(%User{} = user, %User{} = blocked) do
	with {:ok, relationship} <- UserRelationship.delete_block(user, blocked) do
	@cachex.del(:user_cache, "blocked_users_ap_ids:#{user.ap_id}")
	{:ok, relationship}
	end
	end

	def set_invisible(user, invisible) do
	params = %{invisible: invisible}

	user
	\|> cast(params, [:invisible])
	\|> validate_required([:invisible])
	\|> update_and_set_cache()
	end

	def sanitize_html(%User{} = user) do
	sanitize_html(user, nil)
	end

	# User data that mastodon isn't filtering (treated as plaintext):
	# - field name
	# - display name
	def sanitize_html(%User{} = user, filter) do
	fields =
	Enum.map(user.fields, fn %{"name" => name, "value" => value} = fields ->
	%{
	"name" => name,
	"value" => HTML.filter_tags(value, Pleroma.HTML.Scrubber.LinksOnly),
	"verified_at" => Map.get(fields, "verified_at")
	}
	end)

	user
	\|> Map.put(:bio, HTML.filter_tags(user.bio, filter))
	\|> Map.put(:fields, fields)
	end

	def get_host(%User{ap_id: ap_id} = _user) do
	URI.parse(ap_id).host
	end

	def update_last_active_at(%__MODULE__{local: true} = user) do
	user
	\|> cast(%{last_active_at: NaiveDateTime.utc_now()}, [:last_active_at])
	\|> update_and_set_cache()
	end

	def update_last_active_at(user), do: user

	def active_user_count(days \\ 30) do
	active_after = Timex.shift(NaiveDateTime.utc_now(), days: -days)

	__MODULE__
	\|> where([u], u.last_active_at >= ^active_after)
	\|> where([u], u.local == true)
	\|> Repo.aggregate(:count)
	end

	def update_last_status_at(user) do
	User
	\|> where(id: ^user.id)
	\|> update([u], set: [last_status_at: fragment("NOW()")])
	\|> select([u], u)
	\|> Repo.update_all([])
	\|> case do
	{1, [user]} -> set_cache(user)
	_ -> {:error, user}
	end
	end

	def get_friends_birthdays_query(%User{} = user, day, month) do
	User.Query.build(%{
	friends: user,
	deactivated: false,
	birthday_day: day,
	birthday_month: month
	})
	end
	end
	diff --git a/lib/pleroma/workers/background_worker.ex b/lib/pleroma/workers/background_worker.ex
	index dbf40ee1b..d74cc08f1 100644
	--- a/lib/pleroma/workers/background_worker.ex
	+++ b/lib/pleroma/workers/background_worker.ex
	@@ -1,54 +1,44 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.BackgroundWorker do
	- alias Pleroma.Instances.Instance
	alias Pleroma.User

	use Pleroma.Workers.WorkerHelper, queue: "background"

	@impl Oban.Worker

	def perform(%Job{args: %{"op" => "user_activation", "user_id" => user_id, "status" => status}}) do
	user = User.get_cached_by_id(user_id)
	User.perform(:set_activation_async, user, status)
	end

	- def perform(%Job{args: %{"op" => "delete_user", "user_id" => user_id}}) do
	- user = User.get_cached_by_id(user_id)
	- User.perform(:delete, user)
	- end
	-
	def perform(%Job{args: %{"op" => "force_password_reset", "user_id" => user_id}}) do
	user = User.get_cached_by_id(user_id)
	User.perform(:force_password_reset, user)
	end

	def perform(%Job{args: %{"op" => op, "user_id" => user_id, "identifiers" => identifiers}})
	when op in ["blocks_import", "follow_import", "mutes_import"] do
	user = User.get_cached_by_id(user_id)
	{:ok, User.Import.perform(String.to_existing_atom(op), user, identifiers)}
	end

	def perform(%Job{
	args: %{"op" => "move_following", "origin_id" => origin_id, "target_id" => target_id}
	}) do
	origin = User.get_cached_by_id(origin_id)
	target = User.get_cached_by_id(target_id)

	Pleroma.FollowingRelationship.move_following(origin, target)
	end

	def perform(%Job{args: %{"op" => "verify_fields_links", "user_id" => user_id}}) do
	user = User.get_by_id(user_id)
	User.perform(:verify_fields_links, user)
	end

	- def perform(%Job{args: %{"op" => "delete_instance", "host" => host}}) do
	- Instance.perform(:delete_instance, host)
	- end
	-
	@impl Oban.Worker
	- def timeout(_job), do: :timer.seconds(900)
	+ def timeout(_job), do: :timer.seconds(5)
	end
	diff --git a/lib/pleroma/workers/cron/digest_emails_worker.ex b/lib/pleroma/workers/cron/digest_emails_worker.ex
	index 0292bbb3b..17e92d10b 100644
	--- a/lib/pleroma/workers/cron/digest_emails_worker.ex
	+++ b/lib/pleroma/workers/cron/digest_emails_worker.ex
	@@ -1,61 +1,64 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.Cron.DigestEmailsWorker do
	@moduledoc """
	The worker to send digest emails.
	"""

	use Oban.Worker, queue: "mailer"

	alias Pleroma.Config
	alias Pleroma.Emails
	alias Pleroma.Repo
	alias Pleroma.User

	import Ecto.Query

	require Logger

	@impl Oban.Worker
	def perform(_job) do
	config = Config.get([:email_notifications, :digest])

	if config[:active] do
	negative_interval = -Map.fetch!(config, :interval)
	inactivity_threshold = Map.fetch!(config, :inactivity_threshold)
	inactive_users_query = User.list_inactive_users_query(inactivity_threshold)

	now = NaiveDateTime.truncate(NaiveDateTime.utc_now(), :second)

	from(u in inactive_users_query,
	where: fragment(~s(? ->'digest' @> 'true'), u.email_notifications),
	where: not is_nil(u.email),
	where: u.last_digest_emailed_at < datetime_add(^now, ^negative_interval, "day"),
	select: u
	)
	\|> Repo.all()
	\|> send_emails
	end

	:ok
	end

	def send_emails(users) do
	Enum.each(users, &send_email/1)
	end

	@doc """
	Send digest email to the given user.
	Updates `last_digest_emailed_at` field for the user and returns the updated user.
	"""
	@spec send_email(User.t()) :: User.t()
	def send_email(user) do
	with %Swoosh.Email{} = email <- Emails.UserEmail.digest_email(user) do
	Emails.Mailer.deliver_async(email)
	end

	User.touch_last_digest_emailed_at(user)
	end
	+
	+ @impl Oban.Worker
	+ def timeout(_job), do: :timer.seconds(5)
	end
	diff --git a/lib/pleroma/workers/cron/new_users_digest_worker.ex b/lib/pleroma/workers/cron/new_users_digest_worker.ex
	index d2abb2d3b..1f57aad4a 100644
	--- a/lib/pleroma/workers/cron/new_users_digest_worker.ex
	+++ b/lib/pleroma/workers/cron/new_users_digest_worker.ex
	@@ -1,63 +1,66 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.Cron.NewUsersDigestWorker do
	alias Pleroma.Activity
	alias Pleroma.Repo
	alias Pleroma.User

	import Ecto.Query

	use Pleroma.Workers.WorkerHelper, queue: "background"

	@impl Oban.Worker
	def perform(_job) do
	if Pleroma.Config.get([Pleroma.Emails.NewUsersDigestEmail, :enabled]) do
	today = NaiveDateTime.utc_now() \|> Timex.beginning_of_day()

	a_day_ago =
	today
	\|> Timex.shift(days: -1)
	\|> Timex.beginning_of_day()

	users_and_statuses =
	%{
	local: true,
	order_by: :inserted_at
	}
	\|> User.Query.build()
	\|> where([u], u.inserted_at >= ^a_day_ago and u.inserted_at < ^today)
	\|> Repo.all()
	\|> Enum.map(fn user ->
	latest_status =
	Activity
	\|> Activity.Queries.by_actor(user.ap_id)
	\|> Activity.Queries.by_type("Create")
	\|> Activity.with_preloaded_object()
	\|> order_by(desc: :inserted_at)
	\|> limit(1)
	\|> Repo.one()

	total_statuses =
	Activity
	\|> Activity.Queries.by_actor(user.ap_id)
	\|> Activity.Queries.by_type("Create")
	\|> Repo.aggregate(:count, :id)

	{user, total_statuses, latest_status}
	end)

	if users_and_statuses != [] do
	%{is_admin: true}
	\|> User.Query.build()
	\|> where([u], not is_nil(u.email))
	\|> Repo.all()
	\|> Enum.map(&Pleroma.Emails.NewUsersDigestEmail.new_users(&1, users_and_statuses))
	\|> Enum.each(&Pleroma.Emails.Mailer.deliver/1)
	end
	end

	:ok
	end
	+
	+ @impl Oban.Worker
	+ def timeout(_job), do: :timer.seconds(5)
	end
	diff --git a/lib/pleroma/workers/delete_worker.ex b/lib/pleroma/workers/delete_worker.ex
	new file mode 100644
	index 000000000..97003fb69
	--- /dev/null
	+++ b/lib/pleroma/workers/delete_worker.ex
	@@ -0,0 +1,24 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Pleroma.Workers.DeleteWorker do
	+ alias Pleroma.Instances.Instance
	+ alias Pleroma.User
	+
	+ use Pleroma.Workers.WorkerHelper, queue: "slow"
	+
	+ @impl Oban.Worker
	+
	+ def perform(%Job{args: %{"op" => "delete_user", "user_id" => user_id}}) do
	+ user = User.get_cached_by_id(user_id)
	+ User.perform(:delete, user)
	+ end
	+
	+ def perform(%Job{args: %{"op" => "delete_instance", "host" => host}}) do
	+ Instance.perform(:delete_instance, host)
	+ end
	+
	+ @impl Oban.Worker
	+ def timeout(_job), do: :timer.seconds(900)
	+end
	diff --git a/lib/pleroma/workers/purge_expired_activity.ex b/lib/pleroma/workers/purge_expired_activity.ex
	index a65593b6e..f48e34042 100644
	--- a/lib/pleroma/workers/purge_expired_activity.ex
	+++ b/lib/pleroma/workers/purge_expired_activity.ex
	@@ -1,75 +1,77 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.PurgeExpiredActivity do
	@moduledoc """
	Worker which purges expired activity.
	"""
	-
	- use Oban.Worker, queue: :slow, max_attempts: 1, unique: [period: :infinity]
	+ @queue :background
	+ use Oban.Worker, queue: @queue, max_attempts: 1, unique: [period: :infinity]

	import Ecto.Query

	alias Pleroma.Activity

	@spec enqueue(map()) ::
	{:ok, Oban.Job.t()}
	\| {:error, :expired_activities_disabled}
	\| {:error, :expiration_too_close}
	def enqueue(args) do
	with true <- enabled?() do
	{scheduled_at, args} = Map.pop(args, :expires_at)

	args
	\|> new(scheduled_at: scheduled_at)
	\|> Oban.insert()
	end
	end

	@impl true
	def perform(%Oban.Job{args: %{"activity_id" => id}}) do
	with %Activity{} = activity <- find_activity(id),
	%Pleroma.User{} = user <- find_user(activity.object.data["actor"]) do
	Pleroma.Web.CommonAPI.delete(activity.id, user)
	end
	end

	@impl Oban.Worker
	def timeout(_job), do: :timer.seconds(5)

	defp enabled? do
	with false <- Pleroma.Config.get([__MODULE__, :enabled], false) do
	{:error, :expired_activities_disabled}
	end
	end

	defp find_activity(id) do
	with nil <- Activity.get_by_id_with_object(id) do
	- {:error, :activity_not_found}
	+ {:cancel, :activity_not_found}
	end
	end

	defp find_user(ap_id) do
	with nil <- Pleroma.User.get_by_ap_id(ap_id) do
	- {:error, :user_not_found}
	+ {:cancel, :user_not_found}
	end
	end

	def get_expiration(id) do
	+ queue = Atom.to_string(@queue)
	+
	from(j in Oban.Job,
	where: j.state == "scheduled",
	- where: j.queue == "slow",
	+ where: j.queue == ^queue,
	where: fragment("?->>'activity_id' = ?", j.args, ^id)
	)
	\|> Pleroma.Repo.one()
	end

	@spec expires_late_enough?(DateTime.t()) :: boolean()
	def expires_late_enough?(scheduled_at) do
	now = DateTime.utc_now()
	diff = DateTime.diff(scheduled_at, now, :millisecond)
	min_lifetime = Pleroma.Config.get([__MODULE__, :min_lifetime], 600)
	diff > :timer.seconds(min_lifetime)
	end
	end
	diff --git a/lib/pleroma/workers/rich_media_worker.ex b/lib/pleroma/workers/rich_media_worker.ex
	index f18ac658a..ecc980a28 100644
	--- a/lib/pleroma/workers/rich_media_worker.ex
	+++ b/lib/pleroma/workers/rich_media_worker.ex
	@@ -1,19 +1,22 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.RichMediaWorker do
	alias Pleroma.Web.RichMedia.Backfill
	alias Pleroma.Web.RichMedia.Card

	use Oban.Worker, queue: :background, max_attempts: 3, unique: [period: 300]

	@impl Oban.Worker
	def perform(%Job{args: %{"op" => "expire", "url" => url} = _args}) do
	Card.delete(url)
	end

	def perform(%Job{args: %{"op" => "backfill", "url" => _url} = args}) do
	Backfill.run(args)
	end
	+
	+ @impl Oban.Worker
	+ def timeout(_job), do: :timer.seconds(5)
	end
	diff --git a/lib/pleroma/workers/search_indexing_worker.ex b/lib/pleroma/workers/search_indexing_worker.ex
	index 8476a2be5..8969ae378 100644
	--- a/lib/pleroma/workers/search_indexing_worker.ex
	+++ b/lib/pleroma/workers/search_indexing_worker.ex
	@@ -1,23 +1,26 @@
	defmodule Pleroma.Workers.SearchIndexingWorker do
	use Pleroma.Workers.WorkerHelper, queue: "search_indexing"

	@impl Oban.Worker

	alias Pleroma.Config.Getting, as: Config

	def perform(%Job{args: %{"op" => "add_to_index", "activity" => activity_id}}) do
	activity = Pleroma.Activity.get_by_id_with_object(activity_id)

	search_module = Config.get([Pleroma.Search, :module])

	search_module.add_to_index(activity)
	end

	def perform(%Job{args: %{"op" => "remove_from_index", "object" => object_id}}) do
	object = Pleroma.Object.get_by_id(object_id)

	search_module = Config.get([Pleroma.Search, :module])

	search_module.remove_from_index(object)
	end
	+
	+ @impl Oban.Worker
	+ def timeout(_job), do: :timer.seconds(5)
	end
	diff --git a/lib/pleroma/workers/user_refresh_worker.ex b/lib/pleroma/workers/user_refresh_worker.ex
	index f43170c8f..0c04fb237 100644
	--- a/lib/pleroma/workers/user_refresh_worker.ex
	+++ b/lib/pleroma/workers/user_refresh_worker.ex
	@@ -1,14 +1,17 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.UserRefreshWorker do
	use Oban.Worker, queue: :background, max_attempts: 1, unique: [period: 300]

	alias Pleroma.User

	@impl true
	def perform(%Job{args: %{"ap_id" => ap_id}}) do
	User.fetch_by_ap_id(ap_id)
	end
	+
	+ @impl Oban.Worker
	+ def timeout(_job), do: :timer.seconds(5)
	end
	diff --git a/mix.lock b/mix.lock
	index 495f20cbc..c7d71bc84 100644
	--- a/mix.lock
	+++ b/mix.lock
	@@ -1,151 +1,151 @@
	%{
	"accept": {:hex, :accept, "0.3.5", "b33b127abca7cc948bbe6caa4c263369abf1347cfa9d8e699c6d214660f10cd1", [:rebar3], [], "hexpm", "11b18c220bcc2eab63b5470c038ef10eb6783bcb1fcdb11aa4137defa5ac1bb8"},
	"bandit": {:hex, :bandit, "1.5.5", "df28f1c41f745401fe9e85a6882033f5f3442ab6d30c8a2948554062a4ab56e0", [:mix], [{:hpax, "~> 0.2.0", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.0", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "f21579a29ea4bc08440343b2b5f16f7cddf2fea5725d31b72cf973ec729079e1"},
	"base62": {:hex, :base62, "1.2.2", "85c6627eb609317b70f555294045895ffaaeb1758666ab9ef9ca38865b11e629", [:mix], [{:custom_base, "~> 0.2.1", [hex: :custom_base, repo: "hexpm", optional: false]}], "hexpm", "d41336bda8eaa5be197f1e4592400513ee60518e5b9f4dcf38f4b4dae6f377bb"},
	"bbcode_pleroma": {:hex, :bbcode_pleroma, "0.2.0", "d36f5bca6e2f62261c45be30fa9b92725c0655ad45c99025cb1c3e28e25803ef", [:mix], [{:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "19851074419a5fedb4ef49e1f01b30df504bb5dbb6d6adfc135238063bebd1c3"},
	"bcrypt_elixir": {:hex, :bcrypt_elixir, "2.3.1", "5114d780459a04f2b4aeef52307de23de961b69e13a5cd98a911e39fda13f420", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "42182d5f46764def15bf9af83739e3bf4ad22661b1c34fc3e88558efced07279"},
	"benchee": {:hex, :benchee, "1.3.0", "f64e3b64ad3563fa9838146ddefb2d2f94cf5b473bdfd63f5ca4d0657bf96694", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.0", [hex: :statistex, repo: "hexpm", optional: false]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "34f4294068c11b2bd2ebf2c59aac9c7da26ffa0068afdf3419f1b176e16c5f81"},
	"blurhash": {:hex, :rinpatch_blurhash, "0.1.0", "01a888b0f5f1f382ab52e4396f01831cbe8486ea5828604c90f4dac533d39a4b", [:mix], [{:mogrify, "~> 0.8.0", [hex: :mogrify, repo: "hexpm", optional: true]}], "hexpm", "19911a5dcbb0acb9710169a72f702bce6cb048822b12de566ccd82b2cc42b907"},
	"bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},
	"cachex": {:hex, :cachex, "3.6.0", "14a1bfbeee060dd9bec25a5b6f4e4691e3670ebda28c8ba2884b12fe30b36bf8", [:mix], [{:eternal, "~> 1.2", [hex: :eternal, repo: "hexpm", optional: false]}, {:jumper, "~> 1.0", [hex: :jumper, repo: "hexpm", optional: false]}, {:sleeplocks, "~> 1.1", [hex: :sleeplocks, repo: "hexpm", optional: false]}, {:unsafe, "~> 1.0", [hex: :unsafe, repo: "hexpm", optional: false]}], "hexpm", "ebf24e373883bc8e0c8d894a63bbe102ae13d918f790121f5cfe6e485cc8e2e2"},
	"calendar": {:hex, :calendar, "1.0.0", "f52073a708528482ec33d0a171954ca610fe2bd28f1e871f247dc7f1565fa807", [:mix], [{:tzdata, "~> 0.5.20 or ~> 0.1.201603 or ~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "990e9581920c82912a5ee50e62ff5ef96da6b15949a2ee4734f935fdef0f0a6f"},
	"captcha": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/elixir-captcha.git", "6630c42aaaab124e697b4e513190c89d8b64e410", [ref: "6630c42aaaab124e697b4e513190c89d8b64e410"]},
	"castore": {:hex, :castore, "0.1.22", "4127549e411bedd012ca3a308dede574f43819fe9394254ca55ab4895abfa1a2", [:mix], [], "hexpm", "c17576df47eb5aa1ee40cc4134316a99f5cad3e215d5c77b8dd3cfef12a22cac"},
	"cc_precompiler": {:hex, :cc_precompiler, "0.1.9", "e8d3364f310da6ce6463c3dd20cf90ae7bbecbf6c5203b98bf9b48035592649b", [:mix], [{:elixir_make, "~> 0.7", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "9dcab3d0f3038621f1601f13539e7a9ee99843862e66ad62827b0c42b2f58a54"},
	"certifi": {:hex, :certifi, "2.12.0", "2d1cca2ec95f59643862af91f001478c9863c2ac9cb6e2f89780bfd8de987329", [:rebar3], [], "hexpm", "ee68d85df22e554040cdb4be100f33873ac6051387baf6a8f6ce82272340ff1c"},
	"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
	"comeonin": {:hex, :comeonin, "5.4.0", "246a56ca3f41d404380fc6465650ddaa532c7f98be4bda1b4656b3a37cc13abe", [:mix], [], "hexpm", "796393a9e50d01999d56b7b8420ab0481a7538d0caf80919da493b4a6e51faf1"},
	"concurrent_limiter": {:hex, :concurrent_limiter, "0.1.1", "43ae1dc23edda1ab03dd66febc739c4ff710d047bb4d735754909f9a474ae01c", [:mix], [{:telemetry, "~> 0.3", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "53968ff238c0fbb4d7ed76ddb1af0be6f3b2f77909f6796e249e737c505a16eb"},
	"connection": {:hex, :connection, "1.1.0", "ff2a49c4b75b6fb3e674bfc5536451607270aac754ffd1bdfe175abe4a6d7a68", [:mix], [], "hexpm", "722c1eb0a418fbe91ba7bd59a47e28008a189d47e37e0e7bb85585a016b2869c"},
	"cors_plug": {:hex, :cors_plug, "2.0.3", "316f806d10316e6d10f09473f19052d20ba0a0ce2a1d910ddf57d663dac402ae", [:mix], [{:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "ee4ae1418e6ce117fc42c2ba3e6cbdca4e95ecd2fe59a05ec6884ca16d469aea"},
	"covertool": {:hex, :covertool, "2.0.6", "4a291b4e3449025b0595d8f44c8d7635d4f48f033be2ce88d22a329f36f94a91", [:rebar3], [], "hexpm", "5db3fcd82180d8ea4ad857d4d1ab21a8d31b5aee0d60d2f6c0f9e25a411d1e21"},
	"cowboy": {:hex, :cowboy, "2.12.0", "f276d521a1ff88b2b9b4c54d0e753da6c66dd7be6c9fca3d9418b561828a3731", [:make, :rebar3], [{:cowlib, "2.13.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, "1.8.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "8a7abe6d183372ceb21caa2709bec928ab2b72e18a3911aa1771639bef82651e"},
	"cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"},
	"cowlib": {:hex, :cowlib, "2.13.0", "db8f7505d8332d98ef50a3ef34b34c1afddec7506e4ee4dd4a3a266285d282ca", [:make, :rebar3], [], "hexpm", "e1e1284dc3fc030a64b1ad0d8382ae7e99da46c3246b815318a4b848873800a4"},
	"credo": {:hex, :credo, "1.7.3", "05bb11eaf2f2b8db370ecaa6a6bda2ec49b2acd5e0418bc106b73b07128c0436", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "35ea675a094c934c22fb1dca3696f3c31f2728ae6ef5a53b5d648c11180a4535"},
	"crontab": {:hex, :crontab, "1.1.8", "2ce0e74777dfcadb28a1debbea707e58b879e6aa0ffbf9c9bb540887bce43617", [:mix], [{:ecto, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm"},
	"custom_base": {:hex, :custom_base, "0.2.1", "4a832a42ea0552299d81652aa0b1f775d462175293e99dfbe4d7dbaab785a706", [:mix], [], "hexpm", "8df019facc5ec9603e94f7270f1ac73ddf339f56ade76a721eaa57c1493ba463"},
	- "db_connection": {:hex, :db_connection, "2.6.0", "77d835c472b5b67fc4f29556dee74bf511bbafecdcaf98c27d27fa5918152086", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "c2f992d15725e721ec7fbc1189d4ecdb8afef76648c746a8e1cad35e3b8a35f3"},
	+ "db_connection": {:hex, :db_connection, "2.7.0", "b99faa9291bb09892c7da373bb82cba59aefa9b36300f6145c5f201c7adf48ec", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "dcf08f31b2701f857dfc787fbad78223d61a32204f217f15e881dd93e4bdd3ff"},
	"decimal": {:hex, :decimal, "2.1.1", "5611dca5d4b2c3dd497dec8f68751f1f1a54755e8ed2a966c2633cf885973ad6", [:mix], [], "hexpm", "53cfe5f497ed0e7771ae1a475575603d77425099ba5faef9394932b35020ffcc"},
	"deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
	"dialyxir": {:hex, :dialyxir, "1.4.3", "edd0124f358f0b9e95bfe53a9fcf806d615d8f838e2202a9f430d59566b6b53b", [:mix], [{:erlex, ">= 0.2.6", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "bf2cfb75cd5c5006bec30141b131663299c661a864ec7fbbc72dfa557487a986"},
	"earmark": {:hex, :earmark, "1.4.46", "8c7287bd3137e99d26ae4643e5b7ef2129a260e3dcf41f251750cb4563c8fb81", [:mix], [], "hexpm", "798d86db3d79964e759ddc0c077d5eb254968ed426399fbf5a62de2b5ff8910a"},
	"earmark_parser": {:hex, :earmark_parser, "1.4.39", "424642f8335b05bb9eb611aa1564c148a8ee35c9c8a8bba6e129d51a3e3c6769", [:mix], [], "hexpm", "06553a88d1f1846da9ef066b87b57c6f605552cfbe40d20bd8d59cc6bde41944"},
	"eblurhash": {:git, "https://github.com/zotonic/eblurhash.git", "bc37ceb426ef021ee9927fb249bb93f7059194ab", [ref: "bc37ceb426ef021ee9927fb249bb93f7059194ab"]},
	"ecto": {:hex, :ecto, "3.11.2", "e1d26be989db350a633667c5cda9c3d115ae779b66da567c68c80cfb26a8c9ee", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "3c38bca2c6f8d8023f2145326cc8a80100c3ffe4dcbd9842ff867f7fc6156c65"},
	"ecto_enum": {:hex, :ecto_enum, "1.4.0", "d14b00e04b974afc69c251632d1e49594d899067ee2b376277efd8233027aec8", [:mix], [{:ecto, ">= 3.0.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "> 3.0.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:mariaex, ">= 0.0.0", [hex: :mariaex, repo: "hexpm", optional: true]}, {:postgrex, ">= 0.0.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "8fb55c087181c2b15eee406519dc22578fa60dd82c088be376d0010172764ee4"},
	"ecto_psql_extras": {:hex, :ecto_psql_extras, "0.7.15", "0fc29dbae0e444a29bd6abeee4cf3c4c037e692a272478a234a1cc765077dbb1", [:mix], [{:ecto_sql, "~> 3.7", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16.0 or ~> 0.17.0", [hex: :postgrex, repo: "hexpm", optional: false]}, {:table_rex, "~> 3.1.1 or ~> 4.0.0", [hex: :table_rex, repo: "hexpm", optional: false]}], "hexpm", "b6127f3a5c6fc3d84895e4768cc7c199f22b48b67d6c99b13fbf4a374e73f039"},
	- "ecto_sql": {:hex, :ecto_sql, "3.11.2", "c7cc7f812af571e50b80294dc2e535821b3b795ce8008d07aa5f336591a185a8", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.11.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6.0", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "73c07f995ac17dbf89d3cfaaf688fcefabcd18b7b004ac63b0dc4ef39499ed6b"},
	+ "ecto_sql": {:hex, :ecto_sql, "3.11.3", "4eb7348ff8101fbc4e6bbc5a4404a24fecbe73a3372d16569526b0cf34ebc195", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.11.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.6", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.16 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e5f36e3d736b99c7fee3e631333b8394ade4bafe9d96d35669fca2d81c2be928"},
	"eimp": {:hex, :eimp, "1.0.14", "fc297f0c7e2700457a95a60c7010a5f1dcb768a083b6d53f49cd94ab95a28f22", [:rebar3], [{:p1_utils, "1.0.18", [hex: :p1_utils, repo: "hexpm", optional: false]}], "hexpm", "501133f3112079b92d9e22da8b88bf4f0e13d4d67ae9c15c42c30bd25ceb83b6"},
	"elixir_make": {:hex, :elixir_make, "0.7.8", "505026f266552ee5aabca0b9f9c229cbb496c689537c9f922f3eb5431157efc7", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:certifi, "~> 2.0", [hex: :certifi, repo: "hexpm", optional: true]}], "hexpm", "7a71945b913d37ea89b06966e1342c85cfe549b15e6d6d081e8081c493062c07"},
	"erlex": {:hex, :erlex, "0.2.6", "c7987d15e899c7a2f34f5420d2a2ea0d659682c06ac607572df55a43753aa12e", [:mix], [], "hexpm", "2ed2e25711feb44d52b17d2780eabf998452f6efda104877a3881c2f8c0c0c75"},
	"esbuild": {:hex, :esbuild, "0.5.0", "d5bb08ff049d7880ee3609ed5c4b864bd2f46445ea40b16b4acead724fb4c4a3", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}], "hexpm", "f183a0b332d963c4cfaf585477695ea59eef9a6f2204fdd0efa00e099694ffe5"},
	"eternal": {:hex, :eternal, "1.2.2", "d1641c86368de99375b98d183042dd6c2b234262b8d08dfd72b9eeaafc2a1abd", [:mix], [], "hexpm", "2c9fe32b9c3726703ba5e1d43a1d255a4f3f2d8f8f9bc19f094c7cb1a7a9e782"},
	"ex_aws": {:hex, :ex_aws, "2.1.9", "dc4865ecc20a05190a34a0ac5213e3e5e2b0a75a0c2835e923ae7bfeac5e3c31", [:mix], [{:configparser_ex, "~> 4.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:jsx, "~> 3.0", [hex: :jsx, repo: "hexpm", optional: true]}, {:sweet_xml, "~> 0.6", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "3e6c776703c9076001fbe1f7c049535f042cb2afa0d2cbd3b47cbc4e92ac0d10"},
	"ex_aws_s3": {:hex, :ex_aws_s3, "2.5.3", "422468e5c3e1a4da5298e66c3468b465cfd354b842e512cb1f6fbbe4e2f5bdaf", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "4f09dd372cc386550e484808c5ac5027766c8d0cd8271ccc578b82ee6ef4f3b8"},
	"ex_const": {:hex, :ex_const, "0.2.4", "d06e540c9d834865b012a17407761455efa71d0ce91e5831e86881b9c9d82448", [:mix], [], "hexpm", "96fd346610cc992b8f896ed26a98be82ac4efb065a0578f334a32d60a3ba9767"},
	"ex_doc": {:hex, :ex_doc, "0.31.1", "8a2355ac42b1cc7b2379da9e40243f2670143721dd50748bf6c3b1184dae2089", [:mix], [{:earmark_parser, "~> 1.4.39", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.1", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1", [hex: :makeup_erlang, repo: "hexpm", optional: false]}], "hexpm", "3178c3a407c557d8343479e1ff117a96fd31bafe52a039079593fb0524ef61b0"},
	"ex_machina": {:hex, :ex_machina, "2.7.0", "b792cc3127fd0680fecdb6299235b4727a4944a09ff0fa904cc639272cd92dc7", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm", "419aa7a39bde11894c87a615c4ecaa52d8f107bbdd81d810465186f783245bf8"},
	"ex_syslogger": {:hex, :ex_syslogger, "1.5.2", "72b6aa2d47a236e999171f2e1ec18698740f40af0bd02c8c650bf5f1fd1bac79", [:mix], [{:poison, ">= 1.5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:syslog, "~> 1.1.0", [hex: :syslog, repo: "hexpm", optional: false]}], "hexpm", "ab9fab4136dbc62651ec6f16fa4842f10cf02ab4433fa3d0976c01be99398399"},
	"exile": {:hex, :exile, "0.10.0", "b69e2d27a9af670b0f0a0898addca0eda78f6f5ba95ccfbc9bc6ccdd04925436", [:make, :mix], [{:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "c62ee8fee565b5ac4a898d0dcd58d2b04fb5eec1655af1ddcc9eb582c6732c33"},
	"expo": {:hex, :expo, "0.5.1", "249e826a897cac48f591deba863b26c16682b43711dd15ee86b92f25eafd96d9", [:mix], [], "hexpm", "68a4233b0658a3d12ee00d27d37d856b1ba48607e7ce20fd376958d0ba6ce92b"},
	"fast_html": {:hex, :fast_html, "2.2.0", "6c5ef1be087a4ed613b0379c13f815c4d11742b36b67bb52cee7859847c84520", [:make, :mix], [{:elixir_make, "~> 0.4", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}], "hexpm", "064c4f23b4a6168f9187dac8984b056f2c531bb0787f559fd6a8b34b38aefbae"},
	"fast_sanitize": {:hex, :fast_sanitize, "0.2.3", "67b93dfb34e302bef49fec3aaab74951e0f0602fd9fa99085987af05bd91c7a5", [:mix], [{:fast_html, "~> 2.0", [hex: :fast_html, repo: "hexpm", optional: false]}, {:plug, "~> 1.8", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "e8ad286d10d0386e15d67d0ee125245ebcfbc7d7290b08712ba9013c8c5e56e2"},
	"file_system": {:hex, :file_system, "0.2.10", "fb082005a9cd1711c05b5248710f8826b02d7d1784e7c3451f9c1231d4fc162d", [:mix], [], "hexpm", "41195edbfb562a593726eda3b3e8b103a309b733ad25f3d642ba49696bf715dc"},
	"finch": {:hex, :finch, "0.18.0", "944ac7d34d0bd2ac8998f79f7a811b21d87d911e77a786bc5810adb75632ada4", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.3", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2.6 or ~> 1.0", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "69f5045b042e531e53edc2574f15e25e735b522c37e2ddb766e15b979e03aa65"},
	"flake_id": {:hex, :flake_id, "0.1.0", "7716b086d2e405d09b647121a166498a0d93d1a623bead243e1f74216079ccb3", [:mix], [{:base62, "~> 1.2", [hex: :base62, repo: "hexpm", optional: false]}, {:ecto, ">= 2.0.0", [hex: :ecto, repo: "hexpm", optional: true]}], "hexpm", "31fc8090fde1acd267c07c36ea7365b8604055f897d3a53dd967658c691bd827"},
	"floki": {:hex, :floki, "0.35.2", "87f8c75ed8654b9635b311774308b2760b47e9a579dabf2e4d5f1e1d42c39e0b", [:mix], [], "hexpm", "6b05289a8e9eac475f644f09c2e4ba7e19201fd002b89c28c1293e7bd16773d9"},
	"gen_smtp": {:hex, :gen_smtp, "0.15.0", "9f51960c17769b26833b50df0b96123605a8024738b62db747fece14eb2fbfcc", [:rebar3], [], "hexpm", "29bd14a88030980849c7ed2447b8db6d6c9278a28b11a44cafe41b791205440f"},
	"gettext": {:hex, :gettext, "0.24.0", "6f4d90ac5f3111673cbefc4ebee96fe5f37a114861ab8c7b7d5b30a1108ce6d8", [:mix], [{:expo, "~> 0.5.1", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "bdf75cdfcbe9e4622dd18e034b227d77dd17f0f133853a1c73b97b3d6c770e8b"},
	"gun": {:hex, :gun, "2.0.1", "160a9a5394800fcba41bc7e6d421295cf9a7894c2252c0678244948e3336ad73", [:make, :rebar3], [{:cowlib, "2.12.1", [hex: :cowlib, repo: "hexpm", optional: false]}], "hexpm", "a10bc8d6096b9502205022334f719cc9a08d9adcfbfc0dbee9ef31b56274a20b"},
	"hackney": {:hex, :hackney, "1.18.2", "d7ff544ddae5e1cb49e9cf7fa4e356d7f41b283989a1c304bfc47a8cc1cf966f", [:rebar3], [{:certifi, "~>2.12.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~>6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~>1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~>1.1", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.4.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~>1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "af94d5c9f97857db257090a4a10e5426ecb6f4918aa5cc666798566ae14b65fd"},
	"hpax": {:hex, :hpax, "0.2.0", "5a58219adcb75977b2edce5eb22051de9362f08236220c9e859a47111c194ff5", [:mix], [], "hexpm", "bea06558cdae85bed075e6c036993d43cd54d447f76d8190a8db0dc5893fa2f1"},
	"html_entities": {:hex, :html_entities, "0.5.2", "9e47e70598da7de2a9ff6af8758399251db6dbb7eebe2b013f2bbd2515895c3c", [:mix], [], "hexpm", "c53ba390403485615623b9531e97696f076ed415e8d8058b1dbaa28181f4fdcc"},
	"http_signatures": {:hex, :http_signatures, "0.1.2", "ed1cc7043abcf5bb4f30d68fb7bad9d618ec1a45c4ff6c023664e78b67d9c406", [:mix], [], "hexpm", "f08aa9ac121829dae109d608d83c84b940ef2f183ae50f2dd1e9a8bc619d8be7"},
	"httpoison": {:hex, :httpoison, "1.8.2", "9eb9c63ae289296a544842ef816a85d881d4a31f518a0fec089aaa744beae290", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "2bb350d26972e30c96e2ca74a1aaf8293d61d0742ff17f01e0279fef11599921"},
	"idna": {:hex, :idna, "6.1.1", "8a63070e9f7d0c62eb9d9fcb360a7de382448200fbbd1b106cc96d3d8099df8d", [:rebar3], [{:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "92376eb7894412ed19ac475e4a86f7b413c1b9fbb5bd16dccd57934157944cea"},
	"inet_cidr": {:hex, :inet_cidr, "1.0.8", "d26bb7bdbdf21ae401ead2092bf2bb4bf57fe44a62f5eaa5025280720ace8a40", [:mix], [], "hexpm", "d5b26da66603bb56c933c65214c72152f0de9a6ea53618b56d63302a68f6a90e"},
	- "jason": {:hex, :jason, "1.4.1", "af1504e35f629ddcdd6addb3513c3853991f694921b1b9368b0bd32beb9f1b63", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "fbb01ecdfd565b56261302f7e1fcc27c4fb8f32d56eab74db621fc154604a7a1"},
	+ "jason": {:hex, :jason, "1.4.3", "d3f984eeb96fe53b85d20e0b049f03e57d075b5acda3ac8d465c969a2536c17b", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "9a90e868927f7c777689baa16d86f4d0e086d968db5c05d917ccff6d443e58a3"},
	"joken": {:hex, :joken, "2.6.0", "b9dd9b6d52e3e6fcb6c65e151ad38bf4bc286382b5b6f97079c47ade6b1bcc6a", [:mix], [{:jose, "~> 1.11.5", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "5a95b05a71cd0b54abd35378aeb1d487a23a52c324fa7efdffc512b655b5aaa7"},
	"jose": {:hex, :jose, "1.11.6", "613fda82552128aa6fb804682e3a616f4bc15565a048dabd05b1ebd5827ed965", [:mix, :rebar3], [], "hexpm", "6275cb75504f9c1e60eeacb771adfeee4905a9e182103aa59b53fed651ff9738"},
	"jumper": {:hex, :jumper, "1.0.2", "68cdcd84472a00ac596b4e6459a41b3062d4427cbd4f1e8c8793c5b54f1406a7", [:mix], [], "hexpm", "9b7782409021e01ab3c08270e26f36eb62976a38c1aa64b2eaf6348422f165e1"},
	"linkify": {:hex, :linkify, "0.5.3", "5f8143d8f61f5ff08d3aeeff47ef6509492b4948d8f08007fbf66e4d2246a7f2", [:mix], [], "hexpm", "3ef35a1377d47c25506e07c1c005ea9d38d700699d92ee92825f024434258177"},
	"logger_backends": {:hex, :logger_backends, "1.0.0", "09c4fad6202e08cb0fbd37f328282f16539aca380f512523ce9472b28edc6bdf", [:mix], [], "hexpm", "1faceb3e7ec3ef66a8f5746c5afd020e63996df6fd4eb8cdb789e5665ae6c9ce"},
	"majic": {:hex, :majic, "1.0.0", "37e50648db5f5c2ff0c9fb46454d034d11596c03683807b9fb3850676ffdaab3", [:make, :mix], [{:elixir_make, "~> 0.6.1", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:mime, "~> 1.0", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 0.2", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "7905858f76650d49695f14ea55cd9aaaee0c6654fa391671d4cf305c275a0a9e"},
	"makeup": {:hex, :makeup, "1.0.5", "d5a830bc42c9800ce07dd97fa94669dfb93d3bf5fcf6ea7a0c67b2e0e4a7f26c", [:mix], [{:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "cfa158c02d3f5c0c665d0af11512fed3fba0144cf1aadee0f2ce17747fba2ca9"},
	"makeup_elixir": {:hex, :makeup_elixir, "0.14.1", "4f0e96847c63c17841d42c08107405a005a2680eb9c7ccadfd757bd31dabccfb", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "f2438b1a80eaec9ede832b5c41cd4f373b38fd7aa33e3b22d9db79e640cbde11"},
	"makeup_erlang": {:hex, :makeup_erlang, "0.1.3", "d684f4bac8690e70b06eb52dad65d26de2eefa44cd19d64a8095e1417df7c8fd", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "b78dc853d2e670ff6390b605d807263bf606da3c82be37f9d7f68635bd886fc9"},
	"meck": {:hex, :meck, "0.9.2", "85ccbab053f1db86c7ca240e9fc718170ee5bda03810a6292b5306bf31bae5f5", [:rebar3], [], "hexpm", "81344f561357dc40a8344afa53767c32669153355b626ea9fcbc8da6b3045826"},
	"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},
	"mime": {:hex, :mime, "1.6.0", "dabde576a497cef4bbdd60aceee8160e02a6c89250d6c0b29e56c0dfb00db3d2", [:mix], [], "hexpm", "31a1a8613f8321143dde1dafc36006a17d28d02bdfecb9e95a880fa7aabd19a7"},
	"mimerl": {:hex, :mimerl, "1.3.0", "d0cd9fc04b9061f82490f6581e0128379830e78535e017f7780f37fea7545726", [:rebar3], [], "hexpm", "a1e15a50d1887217de95f0b9b0793e32853f7c258a5cd227650889b38839fe9d"},
	"mint": {:hex, :mint, "1.6.1", "065e8a5bc9bbd46a41099dfea3e0656436c5cbcb6e741c80bd2bad5cd872446f", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "4fc518dcc191d02f433393a72a7ba3f6f94b101d094cb6bf532ea54c89423780"},
	"mochiweb": {:hex, :mochiweb, "2.18.0", "eb55f1db3e6e960fac4e6db4e2db9ec3602cc9f30b86cd1481d56545c3145d2e", [:rebar3], [], "hexpm"},
	"mock": {:hex, :mock, "0.3.8", "7046a306b71db2488ef54395eeb74df0a7f335a7caca4a3d3875d1fc81c884dd", [:mix], [{:meck, "~> 0.9.2", [hex: :meck, repo: "hexpm", optional: false]}], "hexpm", "7fa82364c97617d79bb7d15571193fc0c4fe5afd0c932cef09426b3ee6fe2022"},
	"mogrify": {:hex, :mogrify, "0.8.0", "3506f3ca3f7b95a155f3b4ef803b5db176f5a0633723e3fe85e0d6399e3b11c8", [:mix], [], "hexpm", "2278d245f07056ea3b586e98801e933695147066fa4cf563f552c1b4f0ff8ad9"},
	"mox": {:hex, :mox, "1.1.0", "0f5e399649ce9ab7602f72e718305c0f9cdc351190f72844599545e4996af73c", [:mix], [], "hexpm", "d44474c50be02d5b72131070281a5d3895c0e7a95c780e90bc0cfe712f633a13"},
	"nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"},
	"nimble_parsec": {:hex, :nimble_parsec, "0.6.0", "32111b3bf39137144abd7ba1cce0914533b2d16ef35e8abc5ec8be6122944263", [:mix], [], "hexpm", "27eac315a94909d4dc68bc07a4a83e06c8379237c5ea528a9acff4ca1c873c52"},
	"nimble_pool": {:hex, :nimble_pool, "0.2.6", "91f2f4c357da4c4a0a548286c84a3a28004f68f05609b4534526871a22053cde", [:mix], [], "hexpm", "1c715055095d3f2705c4e236c18b618420a35490da94149ff8b580a2144f653f"},
	"nodex": {:git, "https://git.pleroma.social/pleroma/nodex", "cb6730f943cfc6aad674c92161be23a8411f15d1", [ref: "cb6730f943cfc6aad674c92161be23a8411f15d1"]},
	- "oban": {:hex, :oban, "2.17.10", "c3e5bd739b5c3fdc38eba1d43ab270a8c6ca4463bb779b7705c69400b0d87678", [:mix], [{:ecto_sql, "~> 3.10", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:ecto_sqlite3, "~> 0.9", [hex: :ecto_sqlite3, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "4afd027b8e2bc3c399b54318b4f46ee8c40251fb55a285cb4e38b5363f0ee7c4"},
	+ "oban": {:hex, :oban, "2.17.12", "33fb0cbfb92b910d48dd91a908590fe3698bb85eacec8cd0d9bc6aa13dddd6d6", [:mix], [{:ecto_sql, "~> 3.10", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:ecto_sqlite3, "~> 0.9", [hex: :ecto_sqlite3, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7a647d6cd6bb300073db17faabce22d80ae135da3baf3180a064fa7c4fa046e3"},
	"octo_fetch": {:hex, :octo_fetch, "0.4.0", "074b5ecbc08be10b05b27e9db08bc20a3060142769436242702931c418695b19", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~> 1.1", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm", "cf8be6f40cd519d7000bb4e84adcf661c32e59369ca2827c4e20042eda7a7fc6"},
	"open_api_spex": {:hex, :open_api_spex, "3.18.2", "8c855e83bfe8bf81603d919d6e892541eafece3720f34d1700b58024dadde247", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0 or ~> 4.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "aa3e6dcfc0ad6a02596b2172662da21c9dd848dac145ea9e603f54e3d81b8d2b"},
	"parse_trans": {:hex, :parse_trans, "3.4.1", "6e6aa8167cb44cc8f39441d05193be6e6f4e7c2946cb2759f015f8c56b76e5ff", [:rebar3], [], "hexpm", "620a406ce75dada827b82e453c19cf06776be266f5a67cff34e1ef2cbb60e49a"},
	"pbkdf2_elixir": {:hex, :pbkdf2_elixir, "1.2.1", "9cbe354b58121075bd20eb83076900a3832324b7dd171a6895fab57b6bb2752c", [:mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}], "hexpm", "d3b40a4a4630f0b442f19eca891fcfeeee4c40871936fed2f68e1c4faa30481f"},
	"phoenix": {:hex, :phoenix, "1.7.14", "a7d0b3f1bc95987044ddada111e77bd7f75646a08518942c72a8440278ae7825", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "c7859bc56cc5dfef19ecfc240775dae358cbaa530231118a9e014df392ace61a"},
	"phoenix_ecto": {:hex, :phoenix_ecto, "4.4.3", "86e9878f833829c3f66da03d75254c155d91d72a201eb56ae83482328dc7ca93", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "d36c401206f3011fefd63d04e8ef626ec8791975d9d107f9a0817d426f61ac07"},
	"phoenix_html": {:hex, :phoenix_html, "3.3.4", "42a09fc443bbc1da37e372a5c8e6755d046f22b9b11343bf885067357da21cb3", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "0249d3abec3714aff3415e7ee3d9786cb325be3151e6c4b3021502c585bf53fb"},
	"phoenix_live_dashboard": {:hex, :phoenix_live_dashboard, "0.8.3", "7ff51c9b6609470f681fbea20578dede0e548302b0c8bdf338b5a753a4f045bf", [:mix], [{:ecto, "~> 3.6.2 or ~> 3.7", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_mysql_extras, "~> 0.5", [hex: :ecto_mysql_extras, repo: "hexpm", optional: true]}, {:ecto_psql_extras, "~> 0.7", [hex: :ecto_psql_extras, repo: "hexpm", optional: true]}, {:ecto_sqlite3_extras, "~> 1.1.7 or ~> 1.2.0", [hex: :ecto_sqlite3_extras, repo: "hexpm", optional: true]}, {:mime, "~> 1.6 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 0.19 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "f9470a0a8bae4f56430a23d42f977b5a6205fdba6559d76f932b876bfaec652d"},
	"phoenix_live_reload": {:hex, :phoenix_live_reload, "1.3.3", "3a53772a6118d5679bf50fc1670505a290e32a1d195df9e069d8c53ab040c054", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "766796676e5f558dbae5d1bdb066849673e956005e3730dfd5affd7a6da4abac"},
	"phoenix_live_view": {:hex, :phoenix_live_view, "0.19.5", "6e730595e8e9b8c5da230a814e557768828fd8dfeeb90377d2d8dbb52d4ec00a", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b2eaa0dd3cfb9bd7fb949b88217df9f25aed915e986a28ad5c8a0d054e7ca9d3"},
	"phoenix_pubsub": {:hex, :phoenix_pubsub, "2.1.3", "3168d78ba41835aecad272d5e8cd51aa87a7ac9eb836eabc42f6e57538e3731d", [:mix], [], "hexpm", "bba06bc1dcfd8cb086759f0edc94a8ba2bc8896d5331a1e2c2902bf8e36ee502"},
	"phoenix_swoosh": {:hex, :phoenix_swoosh, "1.2.1", "b74ccaa8046fbc388a62134360ee7d9742d5a8ae74063f34eb050279de7a99e1", [:mix], [{:finch, "~> 0.8", [hex: :finch, repo: "hexpm", optional: true]}, {:hackney, "~> 1.10", [hex: :hackney, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_html, "~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_view, "~> 1.0 or ~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: false]}, {:swoosh, "~> 1.5", [hex: :swoosh, repo: "hexpm", optional: false]}], "hexpm", "4000eeba3f9d7d1a6bf56d2bd56733d5cadf41a7f0d8ffe5bb67e7d667e204a2"},
	"phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
	"phoenix_view": {:hex, :phoenix_view, "2.0.4", "b45c9d9cf15b3a1af5fb555c674b525391b6a1fe975f040fb4d913397b31abf4", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "4e992022ce14f31fe57335db27a28154afcc94e9983266835bb3040243eb620b"},
	"plug": {:hex, :plug, "1.16.1", "40c74619c12f82736d2214557dedec2e9762029b2438d6d175c5074c933edc9d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a13ff6b9006b03d7e33874945b2755253841b238c34071ed85b0e86057f8cddc"},
	"plug_cowboy": {:hex, :plug_cowboy, "2.7.1", "87677ffe3b765bc96a89be7960f81703223fe2e21efa42c125fcd0127dd9d6b2", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "02dbd5f9ab571b864ae39418db7811618506256f6d13b4a45037e5fe78dc5de3"},
	"plug_crypto": {:hex, :plug_crypto, "2.1.0", "f44309c2b06d249c27c8d3f65cfe08158ade08418cf540fd4f72d4d6863abb7b", [:mix], [], "hexpm", "131216a4b030b8f8ce0f26038bc4421ae60e4bb95c5cf5395e1421437824c4fa"},
	"plug_static_index_html": {:hex, :plug_static_index_html, "1.0.0", "840123d4d3975585133485ea86af73cb2600afd7f2a976f9f5fd8b3808e636a0", [:mix], [{:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "79fd4fcf34d110605c26560cbae8f23c603ec4158c08298bd4360fdea90bb5cf"},
	"poison": {:hex, :poison, "3.1.0", "d9eb636610e096f86f25d9a46f35a9facac35609a7591b3be3326e99a0484665", [:mix], [], "hexpm", "fec8660eb7733ee4117b85f55799fd3833eb769a6df71ccf8903e8dc5447cfce"},
	"poolboy": {:hex, :poolboy, "1.5.2", "392b007a1693a64540cead79830443abf5762f5d30cf50bc95cb2c1aaafa006b", [:rebar3], [], "hexpm", "dad79704ce5440f3d5a3681c8590b9dc25d1a561e8f5a9c995281012860901e3"},
	"postgrex": {:hex, :postgrex, "0.17.5", "0483d054938a8dc069b21bdd636bf56c487404c241ce6c319c1f43588246b281", [:mix], [{:db_connection, "~> 2.1", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "50b8b11afbb2c4095a3ba675b4f055c416d0f3d7de6633a595fc131a828a67eb"},
	"pot": {:hex, :pot, "1.0.2", "13abb849139fdc04ab8154986abbcb63bdee5de6ed2ba7e1713527e33df923dd", [:rebar3], [], "hexpm", "78fe127f5a4f5f919d6ea5a2a671827bd53eb9d37e5b4128c0ad3df99856c2e0"},
	"prom_ex": {:hex, :prom_ex, "1.9.0", "63e6dda6c05cdeec1f26c48443dcc38ffd2118b3665ae8d2bd0e5b79f2aea03e", [:mix], [{:absinthe, ">= 1.6.0", [hex: :absinthe, repo: "hexpm", optional: true]}, {:broadway, ">= 1.0.2", [hex: :broadway, repo: "hexpm", optional: true]}, {:ecto, ">= 3.5.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:finch, "~> 0.15", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.2", [hex: :jason, repo: "hexpm", optional: false]}, {:oban, ">= 2.4.0", [hex: :oban, repo: "hexpm", optional: true]}, {:octo_fetch, "~> 0.3", [hex: :octo_fetch, repo: "hexpm", optional: false]}, {:phoenix, ">= 1.5.0", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, ">= 0.14.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, ">= 1.12.1", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, "~> 2.5 or ~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: false]}, {:telemetry, ">= 1.0.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}, {:telemetry_metrics_prometheus_core, "~> 1.0", [hex: :telemetry_metrics_prometheus_core, repo: "hexpm", optional: false]}, {:telemetry_poller, "~> 1.0", [hex: :telemetry_poller, repo: "hexpm", optional: false]}], "hexpm", "01f3d4f69ec93068219e686cc65e58a29c42bea5429a8ff4e2121f19db178ee6"},
	"prometheus": {:hex, :prometheus, "4.10.0", "792adbf0130ff61b5fa8826f013772af24b6e57b984445c8d602c8a0355704a1", [:mix, :rebar3], [{:quantile_estimator, "~> 0.2.1", [hex: :quantile_estimator, repo: "hexpm", optional: false]}], "hexpm", "2a99bb6dce85e238c7236fde6b0064f9834dc420ddbd962aac4ea2a3c3d59384"},
	"prometheus_ecto": {:hex, :prometheus_ecto, "1.4.3", "3dd4da1812b8e0dbee81ea58bb3b62ed7588f2eae0c9e97e434c46807ff82311", [:mix], [{:ecto, "~> 2.0 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "8d66289f77f913b37eda81fd287340c17e61a447549deb28efc254532b2bed82"},
	"prometheus_ex": {:git, "https://github.com/lanodan/prometheus.ex.git", "31f7fbe4b71b79ba27efc2a5085746c4011ceb8f", [branch: "fix/elixir-1.14"]},
	"prometheus_phoenix": {:hex, :prometheus_phoenix, "1.3.0", "c4b527e0b3a9ef1af26bdcfbfad3998f37795b9185d475ca610fe4388fdd3bb5", [:mix], [{:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.3 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}], "hexpm", "c4d1404ac4e9d3d963da601db2a7d8ea31194f0017057fabf0cfb9bf5a6c8c75"},
	"prometheus_phx": {:git, "https://git.pleroma.social/pleroma/elixir-libraries/prometheus-phx.git", "9cd8f248c9381ffedc799905050abce194a97514", [branch: "no-logging"]},
	"prometheus_plugs": {:hex, :prometheus_plugs, "1.1.5", "25933d48f8af3a5941dd7b621c889749894d8a1082a6ff7c67cc99dec26377c5", [:mix], [{:accept, "~> 0.1", [hex: :accept, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}, {:prometheus_ex, "~> 1.1 or ~> 2.0 or ~> 3.0", [hex: :prometheus_ex, repo: "hexpm", optional: false]}, {:prometheus_process_collector, "~> 1.1", [hex: :prometheus_process_collector, repo: "hexpm", optional: true]}], "hexpm", "0273a6483ccb936d79ca19b0ab629aef0dba958697c94782bb728b920dfc6a79"},
	"quantile_estimator": {:hex, :quantile_estimator, "0.2.1", "ef50a361f11b5f26b5f16d0696e46a9e4661756492c981f7b2229ef42ff1cd15", [:rebar3], [], "hexpm", "282a8a323ca2a845c9e6f787d166348f776c1d4a41ede63046d72d422e3da946"},
	"ranch": {:hex, :ranch, "1.8.0", "8c7a100a139fd57f17327b6413e4167ac559fbc04ca7448e9be9057311597a1d", [:make, :rebar3], [], "hexpm", "49fbcfd3682fab1f5d109351b61257676da1a2fdbe295904176d5e521a2ddfe5"},
	"recon": {:hex, :recon, "2.5.4", "05dd52a119ee4059fa9daa1ab7ce81bc7a8161a2f12e9d42e9d551ffd2ba901c", [:mix, :rebar3], [], "hexpm", "e9ab01ac7fc8572e41eb59385efeb3fb0ff5bf02103816535bacaedf327d0263"},
	"remote_ip": {:git, "https://git.pleroma.social/pleroma/remote_ip.git", "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8", [ref: "b647d0deecaa3acb140854fe4bda5b7e1dc6d1c8"]},
	"rustler": {:hex, :rustler, "0.30.0", "cefc49922132b072853fa9b0ca4dc2ffcb452f68fb73b779042b02d545e097fb", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:toml, "~> 0.6", [hex: :toml, repo: "hexpm", optional: false]}], "hexpm", "9ef1abb6a7dda35c47cfc649e6a5a61663af6cf842a55814a554a84607dee389"},
	"sleeplocks": {:hex, :sleeplocks, "1.1.2", "d45aa1c5513da48c888715e3381211c859af34bee9b8290490e10c90bb6ff0ca", [:rebar3], [], "hexpm", "9fe5d048c5b781d6305c1a3a0f40bb3dfc06f49bf40571f3d2d0c57eaa7f59a5"},
	"ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.7", "354c321cf377240c7b8716899e182ce4890c5938111a1296add3ec74cf1715df", [:make, :mix, :rebar3], [], "hexpm", "fe4c190e8f37401d30167c8c405eda19469f34577987c76dde613e838bbc67f8"},
	"statistex": {:hex, :statistex, "1.0.0", "f3dc93f3c0c6c92e5f291704cf62b99b553253d7969e9a5fa713e5481cd858a5", [:mix], [], "hexpm", "ff9d8bee7035028ab4742ff52fc80a2aa35cece833cf5319009b52f1b5a86c27"},
	"sweet_xml": {:hex, :sweet_xml, "0.7.4", "a8b7e1ce7ecd775c7e8a65d501bc2cd933bff3a9c41ab763f5105688ef485d08", [:mix], [], "hexpm", "e7c4b0bdbf460c928234951def54fe87edf1a170f6896675443279e2dbeba167"},
	"swoosh": {:hex, :swoosh, "1.16.9", "20c6a32ea49136a4c19f538e27739bb5070558c0fa76b8a95f4d5d5ca7d319a1", [:mix], [{:bandit, ">= 1.0.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:cowboy, "~> 1.1 or ~> 2.4", [hex: :cowboy, repo: "hexpm", optional: true]}, {:ex_aws, "~> 2.1", [hex: :ex_aws, repo: "hexpm", optional: true]}, {:finch, "~> 0.6", [hex: :finch, repo: "hexpm", optional: true]}, {:gen_smtp, "~> 0.13 or ~> 1.0", [hex: :gen_smtp, repo: "hexpm", optional: true]}, {:hackney, "~> 1.9", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mail, "~> 0.2", [hex: :mail, repo: "hexpm", optional: true]}, {:mime, "~> 1.1 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mua, "~> 0.2.0", [hex: :mua, repo: "hexpm", optional: true]}, {:multipart, "~> 0.4", [hex: :multipart, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, ">= 1.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:req, "~> 0.5 or ~> 1.0", [hex: :req, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "878b1a7a6c10ebbf725a3349363f48f79c5e3d792eb621643b0d276a38acc0a6"},
	"syslog": {:hex, :syslog, "1.1.0", "6419a232bea84f07b56dc575225007ffe34d9fdc91abe6f1b2f254fd71d8efc2", [:rebar3], [], "hexpm", "4c6a41373c7e20587be33ef841d3de6f3beba08519809329ecc4d27b15b659e1"},
	"table_rex": {:hex, :table_rex, "4.0.0", "3c613a68ebdc6d4d1e731bc973c233500974ec3993c99fcdabb210407b90959b", [:mix], [], "hexpm", "c35c4d5612ca49ebb0344ea10387da4d2afe278387d4019e4d8111e815df8f55"},
	"telemetry": {:hex, :telemetry, "1.0.0", "0f453a102cdf13d506b7c0ab158324c337c41f1cc7548f0bc0e130bbf0ae9452", [:rebar3], [], "hexpm", "73bc09fa59b4a0284efb4624335583c528e07ec9ae76aca96ea0673850aec57a"},
	"telemetry_metrics": {:hex, :telemetry_metrics, "0.6.2", "2caabe9344ec17eafe5403304771c3539f3b6e2f7fb6a6f602558c825d0d0bfb", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "9b43db0dc33863930b9ef9d27137e78974756f5f198cae18409970ed6fa5b561"},
	"telemetry_metrics_prometheus_core": {:hex, :telemetry_metrics_prometheus_core, "1.2.0", "b583c3f18508f5c5561b674d16cf5d9afd2ea3c04505b7d92baaeac93c1b8260", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "9cba950e1c4733468efbe3f821841f34ac05d28e7af7798622f88ecdbbe63ea3"},
	"telemetry_poller": {:hex, :telemetry_poller, "1.0.0", "db91bb424e07f2bb6e73926fcafbfcbcb295f0193e0a00e825e589a0a47e8453", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b3a24eafd66c3f42da30fc3ca7dda1e9d546c12250a2d60d7b81d264fbec4f6e"},
	"tesla": {:hex, :tesla, "1.11.0", "81b2b10213dddb27105ec6102d9eb0cc93d7097a918a0b1594f2dfd1a4601190", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:exjsx, ">= 3.0.0", [hex: :exjsx, repo: "hexpm", optional: true]}, {:finch, "~> 0.13", [hex: :finch, repo: "hexpm", optional: true]}, {:fuse, "~> 2.4", [hex: :fuse, repo: "hexpm", optional: true]}, {:gun, ">= 1.0.0", [hex: :gun, repo: "hexpm", optional: true]}, {:hackney, "~> 1.6", [hex: :hackney, repo: "hexpm", optional: true]}, {:ibrowse, "4.4.2", [hex: :ibrowse, repo: "hexpm", optional: true]}, {:jason, ">= 1.0.0", [hex: :jason, repo: "hexpm", optional: true]}, {:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.0", [hex: :mint, repo: "hexpm", optional: true]}, {:msgpax, "~> 2.3", [hex: :msgpax, repo: "hexpm", optional: true]}, {:poison, ">= 1.0.0", [hex: :poison, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "b83ab5d4c2d202e1ea2b7e17a49f788d49a699513d7c4f08f2aef2c281be69db"},
	"thousand_island": {:hex, :thousand_island, "1.3.5", "6022b6338f1635b3d32406ff98d68b843ba73b3aa95cfc27154223244f3a6ca5", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "2be6954916fdfe4756af3239fb6b6d75d0b8063b5df03ba76fd8a4c87849e180"},
	"timex": {:hex, :timex, "3.7.7", "3ed093cae596a410759104d878ad7b38e78b7c2151c6190340835515d4a46b8a", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.10", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 1.0", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "0ec4b09f25fe311321f9fc04144a7e3affe48eb29481d7a5583849b6c4dfa0a7"},
	"toml": {:hex, :toml, "0.7.0", "fbcd773caa937d0c7a02c301a1feea25612720ac3fa1ccb8bfd9d30d822911de", [:mix], [], "hexpm", "0690246a2478c1defd100b0c9b89b4ea280a22be9a7b313a8a058a2408a2fa70"},
	"trailing_format_plug": {:hex, :trailing_format_plug, "0.0.7", "64b877f912cf7273bed03379936df39894149e35137ac9509117e59866e10e45", [:mix], [{:plug, "> 0.12.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "bd4fde4c15f3e993a999e019d64347489b91b7a9096af68b2bdadd192afa693f"},
	"tzdata": {:hex, :tzdata, "1.0.5", "69f1ee029a49afa04ad77801febaf69385f3d3e3d1e4b56b9469025677b89a28", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "55519aa2a99e5d2095c1e61cc74c9be69688f8ab75c27da724eb8279ff402a5a"},
	"ueberauth": {:hex, :ueberauth, "0.10.7", "5a31cbe11e7ce5c7484d745dc9e1f11948e89662f8510d03c616de03df581ebd", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "0bccf73e2ffd6337971340832947ba232877aa8122dba4c95be9f729c8987377"},
	"unicode_util_compat": {:hex, :unicode_util_compat, "0.7.0", "bc84380c9ab48177092f43ac89e4dfa2c6d62b40b8bd132b1059ecc7232f9a78", [:rebar3], [], "hexpm", "25eee6d67df61960cf6a794239566599b09e17e668d3700247bc498638152521"},
	"unsafe": {:hex, :unsafe, "1.0.2", "23c6be12f6c1605364801f4b47007c0c159497d0446ad378b5cf05f1855c0581", [:mix], [], "hexpm", "b485231683c3ab01a9cd44cb4a79f152c6f3bb87358439c6f68791b85c2df675"},
	"vix": {:hex, :vix, "0.26.0", "027f10b6969b759318be84bd0bd8c88af877445e4e41cf96a0460392cea5399c", [:make, :mix], [{:castore, "~> 1.0 or ~> 0.1", [hex: :castore, repo: "hexpm", optional: false]}, {:cc_precompiler, "~> 0.2 or ~> 0.1.4", [hex: :cc_precompiler, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.8 or ~> 0.7.3", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:kino, "~> 0.7", [hex: :kino, repo: "hexpm", optional: true]}], "hexpm", "71b0a79ae7f199cacfc8e679b0e4ba25ee47dc02e182c5b9097efb29fbe14efd"},
	"web_push_encryption": {:hex, :web_push_encryption, "0.3.1", "76d0e7375142dfee67391e7690e89f92578889cbcf2879377900b5620ee4708d", [:mix], [{:httpoison, "~> 1.0", [hex: :httpoison, repo: "hexpm", optional: false]}, {:jose, "~> 1.11.1", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "4f82b2e57622fb9337559058e8797cb0df7e7c9790793bdc4e40bc895f70e2a2"},
	"websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
	"websock_adapter": {:hex, :websock_adapter, "0.5.6", "0437fe56e093fd4ac422de33bf8fc89f7bc1416a3f2d732d8b2c8fd54792fe60", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "e04378d26b0af627817ae84c92083b7e97aca3121196679b73c73b99d0d133ea"},
	"websockex": {:hex, :websockex, "0.4.3", "92b7905769c79c6480c02daacaca2ddd49de936d912976a4d3c923723b647bf0", [:mix], [], "hexpm", "95f2e7072b85a3a4cc385602d42115b73ce0b74a9121d0d6dbbf557645ac53e4"},
	}
	diff --git a/test/pleroma/workers/purge_expired_activity_test.exs b/test/pleroma/workers/purge_expired_activity_test.exs
	index 0372f54ca..040ff6a51 100644
	--- a/test/pleroma/workers/purge_expired_activity_test.exs
	+++ b/test/pleroma/workers/purge_expired_activity_test.exs
	@@ -1,59 +1,59 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Workers.PurgeExpiredActivityTest do
	use Pleroma.DataCase, async: true
	use Oban.Testing, repo: Pleroma.Repo

	import Pleroma.Factory

	alias Pleroma.Workers.PurgeExpiredActivity

	test "enqueue job" do
	activity = insert(:note_activity)

	assert {:ok, _} =
	PurgeExpiredActivity.enqueue(%{
	activity_id: activity.id,
	expires_at: DateTime.add(DateTime.utc_now(), 3601)
	})

	assert_enqueued(
	worker: Pleroma.Workers.PurgeExpiredActivity,
	args: %{activity_id: activity.id}
	)

	assert {:ok, _} =
	perform_job(Pleroma.Workers.PurgeExpiredActivity, %{activity_id: activity.id})

	assert %Oban.Job{} = Pleroma.Workers.PurgeExpiredActivity.get_expiration(activity.id)
	end

	test "error if user was not found" do
	activity = insert(:note_activity)

	assert {:ok, _} =
	PurgeExpiredActivity.enqueue(%{
	activity_id: activity.id,
	expires_at: DateTime.add(DateTime.utc_now(), 3601)
	})

	user = Pleroma.User.get_by_ap_id(activity.actor)
	Pleroma.Repo.delete(user)

	- assert {:error, :user_not_found} =
	+ assert {:cancel, :user_not_found} =
	perform_job(Pleroma.Workers.PurgeExpiredActivity, %{activity_id: activity.id})
	end

	test "error if actiivity was not found" do
	assert {:ok, _} =
	PurgeExpiredActivity.enqueue(%{
	activity_id: "some_id",
	expires_at: DateTime.add(DateTime.utc_now(), 3601)
	})

	- assert {:error, :activity_not_found} =
	+ assert {:cancel, :activity_not_found} =
	perform_job(Pleroma.Workers.PurgeExpiredActivity, %{activity_id: "some_if"})
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Nov 25, 7:44 AM (1 d, 11 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 39728
Default Alt Text: (187 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions