No OneTemporary
Actions

Authored By

Unknown

Size

333 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/config/config.exs b/config/config.exs
	index 9f0f4cd4f..1c55807b7 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,280 +1,281 @@
	# 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

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

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

	# Upload configuration
	config :pleroma, Pleroma.Upload,
	uploader: Pleroma.Uploaders.Local,
	filters: [],
	proxy_remote: false,
	proxy_opts: []

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

	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,
	url: [host: "localhost"],
	http: [
	dispatch: [
	{:_,
	[
	{"/api/v1/streaming", Elixir.Pleroma.Web.MastodonAPI.WebsocketHandler, []},
	{"/socket/websocket", Phoenix.Endpoint.CowboyWebSocket,
	{nil, {Pleroma.Web.Endpoint, Pleroma.Web.UserSocket, websocket_config}}},
	{:_, Plug.Adapters.Cowboy.Handler, {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

	# 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: "$date $time $metadata[$level] $message",
	metadata: [:request_id]

	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

	config :pleroma, :instance,
	name: "Pleroma",
	email: "example@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,
	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: []
	+ autofollowed_nicknames: [],
	+ max_pinned_statuses: 1

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

	config :pleroma, :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, :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, threshold: 10

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

	config :pleroma, :media_proxy, enabled: false

	config :pleroma, :chat, enabled: true

	config :ecto, json_library: Jason

	config :phoenix, :format_encoders, json: Jason

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

	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, max_jobs: 50

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

	# 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/config.md b/docs/config.md
	index 1a9706f5b..7eb2d5671 100644
	--- a/docs/config.md
	+++ b/docs/config.md
	@@ -1,211 +1,212 @@
	# 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.
	* `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", {"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.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.
	+* `api_key` / `password` and / or other adapter-specific settings, per the above documentation.

	An example for Sendgrid adapter:

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

	An example for SMTP adapter:
	```
	config :pleroma, Pleroma.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
	* `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
	* `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.

	## :logger
	* `backends`: `:console` is used to send logs to stdout, `{ExSyslogger, :ex_syslogger}` to log to syslog
	See: [logger’s documentation](https://hexdocs.pm/logger/Logger.html) and [ex_syslogger’s documentation](https://hexdocs.pm/ex_syslogger/)

	## :fe
	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`: Whenether to mask the logo
	* `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
	* `threshold`: Number of mentioned users after which the message gets discarded as spam

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

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

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

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

	You can then do
	```
	curl "http://localhost:4000/api/pleroma/admin/invite_token?admin_token=somerandomtoken"
	```

	## Pleroma.Web.Federator

	* `max_jobs`: The maximum amount of parallel federation jobs running at the same time.

	## Pleroma.Web.Federator.RetryQueue

	* `enabled`: If set to `true`, failed federation jobs will be retried
	* `max_jobs`: The maximum amount of parallel federation jbos running at the same time.
	* `initial_timeout`: The initial timeout in seconds
	* `max_retries`: The maximum number of times a federation job is retried
	diff --git a/lib/pleroma/user/info.ex b/lib/pleroma/user/info.ex
	index 7c79dfcff..fb1791c20 100644
	--- a/lib/pleroma/user/info.ex
	+++ b/lib/pleroma/user/info.ex
	@@ -1,199 +1,222 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.User.Info do
	use Ecto.Schema
	import Ecto.Changeset

	embedded_schema do
	field(:banner, :map, default: %{})
	field(:background, :map, default: %{})
	field(:source_data, :map, default: %{})
	field(:note_count, :integer, default: 0)
	field(:follower_count, :integer, default: 0)
	field(:locked, :boolean, default: false)
	field(:confirmation_pending, :boolean, default: false)
	field(:confirmation_token, :string, default: nil)
	field(:default_scope, :string, default: "public")
	field(:blocks, {:array, :string}, default: [])
	field(:domain_blocks, {:array, :string}, default: [])
	field(:deactivated, :boolean, default: false)
	field(:no_rich_text, :boolean, default: false)
	field(:ap_enabled, :boolean, default: false)
	field(:is_moderator, :boolean, default: false)
	field(:is_admin, :boolean, default: false)
	field(:keys, :string, default: nil)
	field(:settings, :map, default: nil)
	field(:magic_key, :string, default: nil)
	field(:uri, :string, default: nil)
	field(:topic, :string, default: nil)
	field(:hub, :string, default: nil)
	field(:salmon, :string, default: nil)
	field(:hide_network, :boolean, default: false)
	+ field(:pinned_activities, {:array, :integer}, default: [])

	# Found in the wild
	# ap_id -> Where is this used?
	# bio -> Where is this used?
	# avatar -> Where is this used?
	# fqn -> Where is this used?
	# host -> Where is this used?
	# subject _> Where is this used?
	end

	def set_activation_status(info, deactivated) do
	params = %{deactivated: deactivated}

	info
	\|> cast(params, [:deactivated])
	\|> validate_required([:deactivated])
	end

	def add_to_note_count(info, number) do
	set_note_count(info, info.note_count + number)
	end

	def set_note_count(info, number) do
	params = %{note_count: Enum.max([0, number])}

	info
	\|> cast(params, [:note_count])
	\|> validate_required([:note_count])
	end

	def set_follower_count(info, number) do
	params = %{follower_count: Enum.max([0, number])}

	info
	\|> cast(params, [:follower_count])
	\|> validate_required([:follower_count])
	end

	def set_blocks(info, blocks) do
	params = %{blocks: blocks}

	info
	\|> cast(params, [:blocks])
	\|> validate_required([:blocks])
	end

	def add_to_block(info, blocked) do
	set_blocks(info, Enum.uniq([blocked \| info.blocks]))
	end

	def remove_from_block(info, blocked) do
	set_blocks(info, List.delete(info.blocks, blocked))
	end

	def set_domain_blocks(info, domain_blocks) do
	params = %{domain_blocks: domain_blocks}

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

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

	def remove_from_domain_block(info, domain_blocked) do
	set_domain_blocks(info, List.delete(info.domain_blocks, domain_blocked))
	end

	def set_keys(info, keys) do
	params = %{keys: keys}

	info
	\|> cast(params, [:keys])
	\|> validate_required([:keys])
	end

	def remote_user_creation(info, params) do
	info
	\|> cast(params, [
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key,
	:uri,
	:hub,
	:topic,
	:salmon
	])
	end

	def user_upgrade(info, params) do
	info
	\|> cast(params, [
	:ap_enabled,
	:source_data,
	:banner,
	:locked,
	:magic_key
	])
	end

	def profile_update(info, params) do
	info
	\|> cast(params, [
	:locked,
	:no_rich_text,
	:default_scope,
	:banner,
	:hide_network,
	:background
	])
	end

	def confirmation_changeset(info, :confirmed) do
	confirmation_changeset(info, %{
	confirmation_pending: false,
	confirmation_token: nil
	})
	end

	def confirmation_changeset(info, :unconfirmed) do
	confirmation_changeset(info, %{
	confirmation_pending: true,
	confirmation_token: :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	})
	end

	def confirmation_changeset(info, params) do
	cast(info, params, [:confirmation_pending, :confirmation_token])
	end

	def mastodon_profile_update(info, params) do
	info
	\|> cast(params, [
	:locked,
	:banner
	])
	end

	def mastodon_settings_update(info, settings) do
	params = %{settings: settings}

	info
	\|> cast(params, [:settings])
	\|> validate_required([:settings])
	end

	def set_source_data(info, source_data) do
	params = %{source_data: source_data}

	info
	\|> cast(params, [:source_data])
	\|> validate_required([:source_data])
	end

	def admin_api_update(info, params) do
	info
	\|> cast(params, [
	:is_moderator,
	:is_admin
	])
	end
	+
	+ def add_pinnned_activity(info, %Pleroma.Activity{id: id}) do
	+ if id not in info.pinned_activities do
	+ max_pinned_statuses = Pleroma.Config.get([:instance, :max_pinned_statuses], 0)
	+ params = %{pinned_activities: info.pinned_activities ++ [id]}
	+
	+ info
	+ \|> cast(params, [:pinned_activities])
	+ \|> validate_length(:pinned_activities,
	+ max: max_pinned_statuses,
	+ message: "You have already pinned the maximum number of statuses"
	+ )
	+ else
	+ change(info)
	+ end
	+ end
	+
	+ def remove_pinnned_activity(info, %Pleroma.Activity{id: id}) do
	+ params = %{pinned_activities: List.delete(info.pinned_activities, id)}
	+
	+ cast(info, params, [:pinned_activities])
	+ end
	end
	diff --git a/lib/pleroma/web/activity_pub/activity_pub.ex b/lib/pleroma/web/activity_pub/activity_pub.ex
	index b8141146f..9c1eb377f 100644
	--- a/lib/pleroma/web/activity_pub/activity_pub.ex
	+++ b/lib/pleroma/web/activity_pub/activity_pub.ex
	@@ -1,853 +1,861 @@
	# 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, Repo, Object, Upload, User, Notification}
	alias Pleroma.Web.ActivityPub.{Transmogrifier, MRF}
	alias Pleroma.Web.WebFinger
	alias Pleroma.Web.Federator
	alias Pleroma.Web.OStatus
	import Ecto.Query
	import Pleroma.Web.ActivityPub.Utils
	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"] \|\| []
	recipients = to ++ cc
	actor = User.get_cached_by_ap_id(data["actor"])

	recipients
	\|> 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(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}}) do
	limit = Pleroma.Config.get([:instance, :remote_limit])
	String.length(content) <= limit
	end

	defp check_remote_limit(_), do: true

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

	{:ok, activity} =
	Repo.insert(%Activity{
	data: map,
	local: local,
	actor: map["actor"],
	recipients: recipients
	})

	Notification.create_notifications(activity)
	stream_out(activity)
	{:ok, activity}
	else
	%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"] do
	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

	activity.data["object"]
	\|> Map.get("tag", [])
	\|> Enum.filter(fn tag -> is_bitstring(tag) end)
	\|> Enum.map(fn tag -> Pleroma.Web.Streamer.stream("hashtag:" <> tag, activity) end)

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

	if activity.local do
	Pleroma.Web.Streamer.stream("public:local:media", activity)
	end
	end
	else
	if !Enum.member?(activity.data["cc"] \|\| [], public) &&
	!Enum.member?(
	activity.data["to"],
	User.get_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) 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),
	:ok <- maybe_federate(activity),
	{:ok, _actor} <- User.increase_note_count(actor) do
	{: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, "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, "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
	) do
	with true <- is_public?(object),
	announce_data <- make_announce_data(user, object, activity_id),
	{: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)

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

	with {:ok, _} <- Object.delete(object),
	{:ok, activity} <- insert(data, local),
	:ok <- maybe_federate(activity),
	{:ok, _actor} <- User.decrease_note_count(user) 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 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]
	)

	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()
	\|> Repo.all()
	\|> Enum.reverse()
	end

	@valid_visibilities ~w[direct unlisted public private]

	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" => since_id}) do
	from(activity in query, where: activity.id > ^since_id)
	end

	defp restrict_since(query, _), do: query

	defp restrict_tag(query, %{"tag" => tag}) do
	from(
	activity in query,
	where: fragment("? <@ (? #> '{\"object\",\"tag\"}')", ^tag, activity.data)
	)
	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_limit(query, %{"limit" => limit}) do
	from(activity in query, limit: ^limit)
	end

	defp restrict_limit(query, _), do: query

	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_max(query, %{"max_id" => max_id}) do
	from(activity in query, where: activity.id < ^max_id)
	end

	defp restrict_max(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
	restrict_type(query, %{"type" => [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("? <@ (? #> '{\"object\",\"likes\"}')", ^ap_id, activity.data)
	)
	end

	defp restrict_favorited_by(query, _), do: query

	defp restrict_media(query, %{"only_media" => val}) when val == "true" or val == "1" do
	from(
	activity in query,
	where: fragment("not (? #> '{\"object\",\"attachment\"}' = ?)", activity.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

	# Only search through last 100_000 activities by default
	defp restrict_recent(query, %{"whole_db" => true}), do: query

	defp restrict_recent(query, _) do
	since = (Repo.aggregate(Activity, :max, :id) \|\| 0) - 100_000

	from(activity in query, where: activity.id > ^since)
	end

	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 (?->'to' \\?\| ?)", 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
	+
	def fetch_activities_query(recipients, opts \\ %{}) do
	base_query =
	from(
	activity in Activity,
	limit: 20,
	order_by: [fragment("? desc nulls last", activity.id)]
	)

	base_query
	\|> restrict_recipients(recipients, opts["user"])
	\|> restrict_tag(opts)
	\|> restrict_since(opts)
	\|> restrict_local(opts)
	\|> restrict_limit(opts)
	\|> restrict_max(opts)
	\|> restrict_actor(opts)
	\|> restrict_type(opts)
	\|> restrict_favorited_by(opts)
	\|> restrict_recent(opts)
	\|> restrict_blocked(opts)
	\|> restrict_media(opts)
	\|> restrict_visibility(opts)
	\|> restrict_replies(opts)
	\|> restrict_reblogs(opts)
	+ \|> restrict_pinned(opts)
	end

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

	def fetch_activities_bounded(recipients_to, recipients_cc, opts \\ %{}) do
	fetch_activities_query([], opts)
	\|> restrict_to_cc(recipients_to, recipients_cc)
	\|> Repo.all()
	\|> 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
	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_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
	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)

	remote_inboxes =
	(Pleroma.Web.Salmon.remote_users(activity) ++ 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)

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

	Enum.each(remote_inboxes, fn inbox ->
	Federator.enqueue(:publish_single_ap, %{
	inbox: inbox,
	json: json,
	actor: actor,
	id: activity.data["id"]
	})
	end)
	end

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

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

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

	@httpoison.post(
	inbox,
	json,
	[
	{"Content-Type", "application/activity+json"},
	{"signature", signature},
	{"digest", digest}
	]
	)
	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
	Logger.info("Fetching #{id} via AP")

	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.data["object"])}
	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"])}
	e -> e
	end
	end
	end
	end

	def fetch_and_contain_remote_object_from_id(id) do
	Logger.info("Fetching #{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

	def is_public?(%Object{data: %{"type" => "Tombstone"}}) do
	false
	end

	def is_public?(activity) do
	"https://www.w3.org/ns/activitystreams#Public" in (activity.data["to"] ++
	(activity.data["cc"] \|\| []))
	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.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
	def entire_thread_visible_for_user?(
	%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)
	end

	# root
	def entire_thread_visible_for_user?(tail, user), do: visible_for_user?(tail, user)

	# 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/common_api/common_api.ex b/lib/pleroma/web/common_api/common_api.ex
	index bb3c38f00..7ec6aa0ea 100644
	--- a/lib/pleroma/web/common_api/common_api.ex
	+++ b/lib/pleroma/web/common_api/common_api.ex
	@@ -1,167 +1,211 @@
	# 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.{User, Repo, Activity, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Formatter

	import Pleroma.Web.CommonAPI.Utils

	def delete(activity_id, user) do
	with %Activity{data: %{"object" => %{"id" => object_id}}} <- Repo.get(Activity, activity_id),
	%Object{} = object <- Object.normalize(object_id),
	true <- user.info.is_moderator \|\| user.ap_id == object.data["actor"],
	{: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.data["object"]["id"]),
	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.data["object"]["id"]) 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.data["object"]["id"]),
	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.data["object"]["id"]) 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"

	inReplyTo ->
	Pleroma.Web.MastodonAPI.StatusView.get_visibility(inReplyTo.data["object"])
	end
	end

	def get_visibility(_), do: "public"

	defp get_content_type(content_type) do
	if Enum.member?(Pleroma.Config.get([:instance, :allowed_post_formats]), content_type) do
	content_type
	else
	"text/plain"
	end
	end

	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["media_ids"]),
	mentions <- Formatter.parse_mentions(status),
	inReplyTo <- get_replied_to_activity(data["in_reply_to_status_id"]),
	{to, cc} <- to_for_user_and_mentions(user, mentions, inReplyTo, visibility),
	tags <- Formatter.parse_tags(status, data),
	content_html <-
	make_content_html(
	status,
	mentions,
	attachments,
	tags,
	get_content_type(data["content_type"]),
	Enum.member?([true, "true"], data["no_attachment_links"])
	),
	context <- make_context(inReplyTo),
	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,
	inReplyTo,
	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}
	})

	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" => %{
	+ "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
	end
	diff --git a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	index f739e8f7d..e00a3fb87 100644
	--- a/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	+++ b/lib/pleroma/web/mastodon_api/mastodon_api_controller.ex
	@@ -1,1329 +1,1344 @@
	# 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 Pleroma.{Repo, Object, Activity, User, Notification, Stats}
	alias Pleroma.Web

	alias Pleroma.Web.MastodonAPI.{
	StatusView,
	AccountView,
	MastodonView,
	ListView,
	FilterView,
	PushSubscriptionView
	}

	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.OAuth.{Authorization, Token, App}
	alias Pleroma.Web.MediaProxy

	import Ecto.Query
	require Logger

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

	action_fallback(:errors)

	def create_app(conn, params) do
	with cs <- App.register_changeset(%App{}, params) \|> IO.inspect(),
	{:ok, app} <- Repo.insert(cs) \|> IO.inspect() do
	res = %{
	id: app.id \|> to_string,
	name: app.client_name,
	client_id: app.client_id,
	client_secret: app.client_secret,
	redirect_uri: app.redirect_uris,
	website: app.website
	}

	json(conn, res)
	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 user(%{assigns: %{user: for_user}} = conn, %{"id" => id}) do
	with %User{} = user <- Repo.get(User, 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 = Pleroma.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: String.replace(Pleroma.Web.Endpoint.static_url(), "http", "ws")
	},
	stats: Stats.get_stats(),
	thumbnail: Web.base_url() <> "/instance/thumbnail.jpeg",
	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} ->
	url = to_string(URI.merge(Web.base_url(), relative_url))

	%{
	"shortcode" => shortcode,
	"static_url" => url,
	"visible_in_picker" => true,
	"url" => url
	}
	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
	last = List.last(activities)
	first = List.first(activities)

	if last do
	min = last.id
	max = first.id

	{next_url, prev_url} =
	if param do
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{max_id: min})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	param,
	Map.merge(params, %{since_id: max})
	)
	}
	else
	{
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{max_id: min})
	),
	mastodon_api_url(
	Pleroma.Web.Endpoint,
	method,
	Map.merge(params, %{since_id: max})
	)
	}
	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("user", user)

	activities =
	ActivityPub.fetch_activities([user.ap_id \| user.following], 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"]

	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("local_only", local_only)
	\|> Map.put("blocking_user", user)

	activities =
	ActivityPub.fetch_public_activities(params)
	\|> 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 <- Repo.get(User, params["id"]) do
	- # Since Pleroma has no "pinned" posts feature, we'll just set an empty list here
	- activities =
	- if params["pinned"] == "true" do
	- []
	- else
	- ActivityPub.fetch_user_activities(user, reading_user, params)
	- end
	+ 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
	query =
	ActivityPub.fetch_activities_query(
	[user.ap_id],
	Map.merge(params, %{"type" => "Create", visibility: "direct"})
	)

	activities = Repo.all(query)

	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 <- Repo.get(Activity, id),
	true <- ActivityPub.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 <- Repo.get(Activity, 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(),
	descendants:
	StatusView.render(
	"index.json",
	for: user,
	activities: grouped_activities[false] \|\| [],
	as: :activity
	)
	\|> Enum.reverse()
	}

	json(conn, result)
	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"])
	\|> Map.put("no_attachment_links", true)

	idempotency_key =
	case get_req_header(conn, "idempotency-key") do
	[key] -> key
	_ -> Ecto.UUID.generate()
	end

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

	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
	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_activity_by_object_ap_id(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_activity_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_activity_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 notifications(%{assigns: %{user: user}} = conn, params) do
	notifications = Notification.for_user(user, params)

	result =
	Enum.map(notifications, fn x ->
	render_notification(user, x)
	end)
	\|> Enum.filter(& &1)

	conn
	\|> add_link_headers(:notifications, notifications)
	\|> json(result)
	end

	def get_notification(%{assigns: %{user: user}} = conn, %{"id" => id} = _params) do
	with {:ok, notification} <- Notification.get(user, id) do
	json(conn, render_notification(user, notification))
	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 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}}} <- Repo.get(Activity, id) 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}}} <- Repo.get(Activity, id) 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"]

	params =
	params
	\|> Map.put("type", "Create")
	\|> Map.put("local_only", local_only)
	\|> Map.put("blocking_user", user)
	\|> Map.put("tag", String.downcase(params["tag"]))

	activities =
	ActivityPub.fetch_public_activities(params)
	\|> 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}) do
	with %User{} = user <- Repo.get(User, id),
	{:ok, followers} <- User.get_followers(user) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_network -> []
	true -> followers
	end

	conn
	\|> put_view(AccountView)
	\|> render("accounts.json", %{users: followers, as: :user})
	end
	end

	def following(%{assigns: %{user: for_user}} = conn, %{"id" => id}) do
	with %User{} = user <- Repo.get(User, id),
	{:ok, followers} <- User.get_friends(user) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_network -> []
	true -> followers
	end

	conn
	\|> 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 <- Repo.get(User, id),
	{: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.ap_id,
	object: follow_activity.data["id"],
	type: "Accept"
	}) 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 <- Repo.get(User, id),
	%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.ap_id,
	object: follow_activity.data["id"],
	type: "Reject"
	}) 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 <- Repo.get(User, id),
	{: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
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	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, %{"uri" => uri}) do
	with %User{} = followed <- Repo.get_by(User, nickname: uri),
	{:ok, follower} <- User.maybe_direct_follow(follower, followed),
	{:ok, _activity} <- ActivityPub.follow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("account.json", %{user: followed, for: follower})
	else
	{: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 <- Repo.get(User, id),
	{:ok, _activity} <- ActivityPub.unfollow(follower, followed),
	{:ok, follower, _} <- User.unfollow(follower, followed) do
	conn
	\|> put_view(AccountView)
	\|> render("relationship.json", %{user: follower, target: followed})
	end
	end

	def block(%{assigns: %{user: blocker}} = conn, %{"id" => id}) do
	with %User{} = blocked <- Repo.get(User, 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 <- Repo.get(User, 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 status_search(user, query) do
	fetched =
	if Regex.match?(~r/https?:/, query) do
	with {:ok, object} <- ActivityPub.fetch_object_from_id(query),
	%Activity{} = activity <-
	Activity.get_create_activity_by_object_ap_id(object.data["id"]),
	true <- ActivityPub.visible_for_user?(activity, user) do
	[activity]
	else
	_e -> []
	end
	end \|\| []

	q =
	from(
	a in 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,
	^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, params["resolve"] == "true")

	statuses = status_search(user, query)

	tags_path = Web.base_url() <> "/tag/"

	tags =
	String.split(query)
	\|> 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, params["resolve"] == "true")

	statuses = status_search(user, query)

	tags =
	String.split(query)
	\|> 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, params["resolve"] == "true")

	res = AccountView.render("accounts.json", users: accounts, for: user, as: :user)

	json(conn, res)
	end

	def favourites(%{assigns: %{user: user}} = conn, _) do
	params =
	%{}
	\|> Map.put("type", "Create")
	\|> Map.put("favorited_by", user.ap_id)
	\|> Map.put("blocking_user", user)

	activities =
	ActivityPub.fetch_public_activities(params)
	\|> 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 -> json(conn, "error")
	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 <- Repo.get(User, 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 <- Repo.get(Pleroma.User, 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)

	# 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).
	following_to =
	following
	\|> Enum.filter(fn x -> x in user.following end)

	activities =
	ActivityPub.fetch_activities_bounded(following_to, 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 =
	conn
	\|> get_session(:oauth_token)

	if user && token do
	mastodon_emoji = mastodonized_emoji()

	limit = Pleroma.Config.get([:instance, :limit])

	accounts =
	Map.put(%{}, user.id, AccountView.render("account.json", %{user: user, for: 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
	},
	rights: %{
	delete_others_notice: !!user.info.is_moderator,
	admin: !!user.info.is_admin
	},
	compose: %{
	me: "#{user.id}",
	default_privacy: user.info.default_scope,
	default_sensitive: false
	},
	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})
	else
	conn
	\|> 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

	def login(conn, %{"code" => code}) do
	with {:ok, app} <- get_or_make_app(),
	%Authorization{} = auth <- Repo.get_by(Authorization, token: code, app_id: app.id),
	{:ok, token} <- Token.exchange_token(app, auth) do
	conn
	\|> put_session(:oauth_token, token.token)
	\|> redirect(to: "/web/getting-started")
	end
	end

	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: app.scopes
	)

	conn
	\|> redirect(to: path)
	end
	end

	defp get_or_make_app() do
	with %App{} = app <- Repo.get_by(App, client_name: "Mastodon-Local") do
	{:ok, app}
	else
	_e ->
	cs =
	App.register_changeset(%App{}, %{
	client_name: "Mastodon-Local",
	redirect_uris: ".",
	scopes: "read,write,follow"
	})

	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 <- Repo.get(User, 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 render_notification(user, %{id: id, activity: activity, inserted_at: created_at} = _params) do
	actor = User.get_cached_by_ap_id(activity.data["actor"])
	parent_activity = Activity.get_create_activity_by_object_ap_id(activity.data["object"])
	mastodon_type = Activity.mastodon_notification_type(activity)

	response = %{
	id: to_string(id),
	type: mastodon_type,
	created_at: CommonAPI.Utils.to_masto_date(created_at),
	account: AccountView.render("account.json", %{user: actor, for: user})
	}

	case mastodon_type do
	"mention" ->
	response
	\|> Map.merge(%{
	status: StatusView.render("status.json", %{activity: activity, for: user})
	})

	"favourite" ->
	response
	\|> Map.merge(%{
	status: StatusView.render("status.json", %{activity: parent_activity, for: user})
	})

	"reblog" ->
	response
	\|> Map.merge(%{
	status: StatusView.render("status.json", %{activity: parent_activity, for: user})
	})

	"follow" ->
	response

	_ ->
	nil
	end
	end

	def get_filters(%{assigns: %{user: user}} = conn, _) do
	filters = Pleroma.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 = %Pleroma.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} = Pleroma.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 = Pleroma.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 = %Pleroma.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} = Pleroma.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 = %Pleroma.Filter{
	user_id: user.id,
	filter_id: filter_id
	}

	{:ok, _} = Pleroma.Filter.delete(query)
	json(conn, %{})
	end

	def create_push_subscription(%{assigns: %{user: user, token: token}} = conn, params) do
	true = Pleroma.Web.Push.enabled()
	Pleroma.Web.Push.Subscription.delete_if_exists(user, token)
	{:ok, subscription} = Pleroma.Web.Push.Subscription.create(user, token, params)
	view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
	json(conn, view)
	end

	def get_push_subscription(%{assigns: %{user: user, token: token}} = conn, _params) do
	true = Pleroma.Web.Push.enabled()
	subscription = Pleroma.Web.Push.Subscription.get(user, token)
	view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
	json(conn, view)
	end

	def update_push_subscription(
	%{assigns: %{user: user, token: token}} = conn,
	params
	) do
	true = Pleroma.Web.Push.enabled()
	{:ok, subscription} = Pleroma.Web.Push.Subscription.update(user, token, params)
	view = PushSubscriptionView.render("push_subscription.json", subscription: subscription)
	json(conn, view)
	end

	def delete_push_subscription(%{assigns: %{user: user, token: token}} = conn, _params) do
	true = Pleroma.Web.Push.enabled()
	{:ok, _response} = Pleroma.Web.Push.Subscription.delete(user, token)
	json(conn, %{})
	end

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

	def suggestions(%{assigns: %{user: user}} = conn, _) do
	suggestions = Pleroma.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 = Pleroma.Config.get([Pleroma.Web.Endpoint, :url, :host])

	user = user.nickname
	url = String.replace(api, "{{host}}", host) \|> String.replace("{{user}}", user)

	with {:ok, %{status: 200, body: body}} <-
	@httpoison.get(
	url,
	[],
	adapter: [
	timeout: timeout,
	recv_timeout: timeout
	]
	),
	{:ok, data} <- Jason.decode(body) do
	data2 =
	Enum.slice(data, 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(data2)
	else
	e -> Logger.error("Could not retrieve suggestions at fetch #{url}, #{inspect(e)}")
	end
	else
	json(conn, [])
	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
	end
	diff --git a/lib/pleroma/web/mastodon_api/views/status_view.ex b/lib/pleroma/web/mastodon_api/views/status_view.ex
	index 8e8fa8121..db543ffe5 100644
	--- a/lib/pleroma/web/mastodon_api/views/status_view.ex
	+++ b/lib/pleroma/web/mastodon_api/views/status_view.ex
	@@ -1,298 +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.MastodonAPI.StatusView do
	use Pleroma.Web, :view

	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.MediaProxy
	alias Pleroma.Web.MastodonAPI.AccountView
	alias Pleroma.Web.MastodonAPI.StatusView

	# 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

	_ ->
	nil
	end)
	\|> Enum.filter(& &1)
	\|> Activity.create_activity_by_object_id_query()
	\|> Repo.all()
	\|> Enum.reduce(%{}, fn activity, acc ->
	Map.put(acc, activity.data["object"]["id"], activity)
	end)
	end

	def render("index.json", opts) do
	replied_to_activities = get_replied_to_activities(opts.activities)

	opts.activities
	\|> render_many(
	StatusView,
	"status.json",
	Map.put(opts, :replied_to_activities, replied_to_activities)
	)
	\|> Enum.filter(fn x -> not is_nil(x) end)
	end

	def render(
	"status.json",
	%{activity: %{data: %{"type" => "Announce", "object" => object}} = activity} = opts
	) do
	user = User.get_cached_by_ap_id(activity.data["actor"])
	created_at = Utils.to_masto_date(activity.data["published"])

	reblogged = Activity.get_create_activity_by_object_ap_id(object)
	reblogged = render("status.json", Map.put(opts, :activity, reblogged))

	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: false,
	favourited: false,
	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: []
	}
	end

	def render("status.json", %{activity: %{data: %{"object" => object}} = activity} = opts) do
	user = User.get_cached_by_ap_id(activity.data["actor"])

	like_count = object["like_count"] \|\| 0
	announcement_count = object["announcement_count"] \|\| 0

	tags = object["tag"] \|\| []
	sensitive = object["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)

	repeated = opts[:for] && opts[:for].ap_id in (object["announcements"] \|\| [])
	favorited = opts[:for] && opts[:for].ap_id in (object["likes"] \|\| [])

	attachment_data = object["attachment"] \|\| []
	attachments = render_many(attachment_data, StatusView, "attachment.json", as: :attachment)

	created_at = Utils.to_masto_date(object["published"])

	reply_to = get_reply_to(activity, opts)
	reply_to_user = reply_to && User.get_cached_by_ap_id(reply_to.data["actor"])

	content =
	object
	\|> render_content()
	\|> HTML.get_cached_scrubbed_html_for_object(
	User.html_filter_policy(opts[:for]),
	activity,
	__MODULE__
	)

	%{
	id: to_string(activity.id),
	uri: object["id"],
	url: object["external_url"] \|\| object["id"],
	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,
	content: content,
	created_at: created_at,
	reblogs_count: announcement_count,
	replies_count: 0,
	favourites_count: like_count,
	reblogged: present?(repeated),
	favourited: present?(favorited),
	muted: false,
	+ pinned: pinned?(activity, user),
	sensitive: sensitive,
	spoiler_text: object["summary"] \|\| "",
	visibility: get_visibility(object),
	media_attachments: attachments \|> Enum.take(4),
	mentions: mentions,
	tags: build_tags(tags),
	application: %{
	name: "Web",
	website: nil
	},
	language: nil,
	emojis: build_emojis(activity.data["object"]["emoji"])
	}
	end

	def render("status.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"]
	}
	end

	def get_reply_to(activity, %{replied_to_activities: replied_to_activities}) do
	_id = activity.data["object"]["inReplyTo"]
	replied_to_activities[activity.data["object"]["inReplyTo"]]
	end

	def get_reply_to(%{data: %{"object" => object}}, _) do
	if object["inReplyTo"] && object["inReplyTo"] != "" do
	Activity.get_create_activity_by_object_ap_id(object["inReplyTo"])
	else
	nil
	end
	end

	def get_visibility(object) do
	public = "https://www.w3.org/ns/activitystreams#Public"
	to = object["to"] \|\| []
	cc = object["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"

	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"]}"
	else
	_ -> object["content"] \|\| ""
	end
	end

	def render_content(%{"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"]}"
	else
	_ -> object["content"] \|\| ""
	end
	end

	def render_content(object), do: object["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/router.ex b/lib/pleroma/web/router.ex
	index 8df45bf4d..a5f4d8126 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,517 +1,522 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

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

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

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

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

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

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

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

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

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

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

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

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

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_api)
	get("/password_reset/:token", UtilController, :show_password_reset)
	post("/password_reset", UtilController, :password_reset)
	get("/emoji", UtilController, :emoji)
	get("/captcha", UtilController, :captcha)
	end

	scope "/api/pleroma/admin", Pleroma.Web.AdminAPI do
	pipe_through(:admin_api)
	delete("/user", AdminAPIController, :user_delete)
	post("/user", AdminAPIController, :user_create)
	put("/users/tag", AdminAPIController, :tag_users)
	delete("/users/tag", AdminAPIController, :untag_users)

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

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

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

	get("/password_reset", AdminAPIController, :get_password_reset)
	end

	scope "/", Pleroma.Web.TwitterAPI do
	pipe_through(:pleroma_html)
	get("/ostatus_subscribe", UtilController, :remote_follow)
	post("/ostatus_subscribe", UtilController, :do_remote_follow)
	post("/main/ostatus", UtilController, :remote_subscribe)
	end

	scope "/api/pleroma", Pleroma.Web.TwitterAPI do
	pipe_through(:authenticated_api)
	post("/blocks_import", UtilController, :blocks_import)
	post("/follow_import", UtilController, :follow_import)
	post("/change_password", UtilController, :change_password)
	post("/delete_account", UtilController, :delete_account)
	end

	scope "/oauth", Pleroma.Web.OAuth do
	get("/authorize", OAuthController, :authorize)
	post("/authorize", OAuthController, :create_authorization)
	post("/token", OAuthController, :token_exchange)
	post("/revoke", OAuthController, :token_revoke)
	end

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

	patch("/accounts/update_credentials", MastodonAPIController, :update_credentials)
	get("/accounts/verify_credentials", MastodonAPIController, :verify_credentials)
	get("/accounts/relationships", MastodonAPIController, :relationships)
	get("/accounts/search", MastodonAPIController, :account_search)
	post("/accounts/:id/follow", MastodonAPIController, :follow)
	post("/accounts/:id/unfollow", MastodonAPIController, :unfollow)
	post("/accounts/:id/block", MastodonAPIController, :block)
	post("/accounts/:id/unblock", MastodonAPIController, :unblock)
	post("/accounts/:id/mute", MastodonAPIController, :relationship_noop)
	post("/accounts/:id/unmute", MastodonAPIController, :relationship_noop)
	get("/accounts/:id/lists", MastodonAPIController, :account_lists)

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

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

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

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

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

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

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

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

	post("/statuses/:id/reblog", MastodonAPIController, :reblog_status)
	post("/statuses/:id/unreblog", MastodonAPIController, :unreblog_status)
	post("/statuses/:id/favourite", MastodonAPIController, :fav_status)
	post("/statuses/:id/unfavourite", MastodonAPIController, :unfav_status)
	+ post("/statuses/:id/pin", MastodonAPIController, :pin_status)
	+ post("/statuses/:id/unpin", MastodonAPIController, :unpin_status)

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

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

	get("/lists", MastodonAPIController, :get_lists)
	get("/lists/:id", MastodonAPIController, :get_list)
	delete("/lists/:id", MastodonAPIController, :delete_list)
	post("/lists", MastodonAPIController, :create_list)
	put("/lists/:id", MastodonAPIController, :rename_list)
	get("/lists/:id/accounts", MastodonAPIController, :list_accounts)
	post("/lists/:id/accounts", MastodonAPIController, :add_to_list)
	delete("/lists/:id/accounts", MastodonAPIController, :remove_from_list)

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

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

	post("/push/subscription", MastodonAPIController, :create_push_subscription)
	get("/push/subscription", MastodonAPIController, :get_push_subscription)
	put("/push/subscription", MastodonAPIController, :update_push_subscription)
	delete("/push/subscription", MastodonAPIController, :delete_push_subscription)

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

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

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

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

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

	get("/rich_media/parse", RichMediaController, :parse)
	end

	scope "/api/v1", Pleroma.Web.MastodonAPI do
	pipe_through(:api)
	get("/instance", MastodonAPIController, :masto_instance)
	get("/instance/peers", MastodonAPIController, :peers)
	post("/apps", MastodonAPIController, :create_app)
	get("/custom_emojis", MastodonAPIController, :custom_emojis)

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

	get("/statuses/:id", MastodonAPIController, :get_status)
	get("/statuses/:id/context", MastodonAPIController, :get_context)
	get("/statuses/:id/card", MastodonAPIController, :empty_object)
	get("/statuses/:id/favourited_by", MastodonAPIController, :favourited_by)
	get("/statuses/:id/reblogged_by", MastodonAPIController, :reblogged_by)

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

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

	get("/search", MastodonAPIController, :search)
	end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	# XXX: this is really a pleroma API, but we want to keep the pleroma namespace clean
	# for now.
	post("/qvitter/statuses/notifications/read", TwitterAPI.Controller, :notifications_read)

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

	+ post("/statuses/pin/:id", TwitterAPI.Controller, :pin)
	+ post("/statuses/unpin/:id", TwitterAPI.Controller, :unpin)
	+
	get("/pleroma/friend_requests", TwitterAPI.Controller, :friend_requests)
	post("/pleroma/friendships/approve", TwitterAPI.Controller, :approve_friend_request)
	post("/pleroma/friendships/deny", TwitterAPI.Controller, :deny_friend_request)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	get("/users/:nickname/inbox", ActivityPubController, :read_inbox)
	post("/users/:nickname/outbox", ActivityPubController, :update_outbox)
	end

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

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

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

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

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

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

	get("/web/login", MastodonAPIController, :login)
	post("/web/login", MastodonAPIController, :login_post)
	get("/web/*path", MastodonAPIController, :index)
	delete("/auth/sign_out", MastodonAPIController, :logout)
	end

	pipeline :remote_media do
	end

	scope "/proxy/", Pleroma.Web.MediaProxy do
	pipe_through(:remote_media)
	get("/:sig/:url", MediaProxyController, :remote)
	get("/:sig/:url/:filename", MediaProxyController, :remote)
	end

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

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

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

	options("/*path", RedirectController, :empty)
	end
	end

	defmodule Fallback.RedirectController do
	use Pleroma.Web, :controller

	def redirector(conn, _params) do
	conn
	\|> put_resp_content_type("text/html")
	\|> send_file(200, Pleroma.Plugs.InstanceStatic.file_path("index.html"))
	end

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

	def empty(conn, _params) do
	conn
	\|> put_status(204)
	\|> text("")
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/representers/activity_representer.ex b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	index 47154829d..4f8f228ab 100644
	--- a/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	+++ b/lib/pleroma/web/twitter_api/representers/activity_representer.ex
	@@ -1,236 +1,238 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	# THIS MODULE IS DEPRECATED! DON'T USE IT!
	# USE THE Pleroma.Web.TwitterAPI.Views.ActivityView MODULE!
	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter do
	use Pleroma.Web.TwitterAPI.Representers.BaseRepresenter
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.{Activity, User}
	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView}
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Formatter
	alias Pleroma.HTML

	defp user_by_ap_id(user_list, ap_id) do
	Enum.find(user_list, fn %{ap_id: user_id} -> ap_id == user_id end)
	end

	def to_map(
	%Activity{data: %{"type" => "Announce", "actor" => actor, "published" => created_at}} =
	activity,
	%{users: users, announced_activity: announced_activity} = opts
	) do
	user = user_by_ap_id(users, actor)
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} retweeted a status."

	announced_user = user_by_ap_id(users, announced_activity.data["actor"])
	retweeted_status = to_map(announced_activity, Map.merge(%{user: announced_user}, opts))

	%{
	"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" => conversation_id(announced_activity),
	"external_url" => activity.data["id"],
	"activity_type" => "repeat"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Like", "published" => created_at}} = activity,
	%{user: user, liked_activity: liked_activity} = opts
	) do
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} favorited a status."

	%{
	"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,
	"in_reply_to_status_id" => liked_activity.id,
	"external_url" => activity.data["id"],
	"activity_type" => "like"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Follow", "object" => followed_id}} = activity,
	%{user: user} = opts
	) do
	created_at = activity.data["published"] \|\| DateTime.to_iso8601(activity.inserted_at)
	created_at = created_at \|> Utils.date_to_asctime()

	followed = User.get_cached_by_ap_id(followed_id)
	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

	# TODO:
	# Make this more proper. Just a placeholder to not break the frontend.
	def to_map(
	%Activity{
	data: %{"type" => "Undo", "published" => created_at, "object" => undid_activity}
	} = activity,
	%{user: user} = opts
	) do
	created_at = created_at \|> Utils.date_to_asctime()

	text = "#{user.nickname} undid the action at #{undid_activity["id"]}"

	%{
	"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" => "undo"
	}
	end

	def to_map(
	%Activity{data: %{"type" => "Delete", "published" => created_at, "object" => _}} =
	activity,
	%{user: user} = opts
	) do
	created_at = created_at \|> 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 to_map(
	%Activity{data: %{"object" => %{"content" => _content} = object}} = activity,
	%{user: user} = opts
	) do
	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"] \|\| [])
	+ pinned = activity.id in user.info.pinned_activities

	mentions = opts[:mentioned] \|\| []

	attentions =
	activity.recipients
	\|> Enum.map(fn ap_id -> Enum.find(mentions, fn user -> ap_id == user.ap_id end) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(fn user -> UserView.render("show.json", %{user: user, for: opts[:for]}) end)

	conversation_id = conversation_id(activity)

	tags = activity.data["object"]["tag"] \|\| []
	possibly_sensitive = activity.data["object"]["sensitive"] \|\| Enum.member?(tags, "nsfw")

	tags = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	{_summary, content} = ActivityView.render_content(object)

	html =
	HTML.filter_tags(content, User.html_filter_policy(opts[:for]))
	\|> Formatter.emojify(object["emoji"])

	attachments = object["attachment"] \|\| []

	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(object["summary"])

	%{
	"id" => activity.id,
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user, for: opts[:for]}),
	"statusnet_html" => html,
	"text" => HTML.strip_tags(content),
	"is_local" => activity.local,
	"is_post_verb" => true,
	"created_at" => created_at,
	"in_reply_to_status_id" => object["inReplyToStatusId"],
	"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" => attachments \|> ObjectRepresenter.enum_to_list(opts),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => to_boolean(favorited),
	"repeated" => to_boolean(repeated),
	+ "pinned" => pinned,
	"external_url" => object["external_url"] \|\| object["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	"visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object),
	"summary" => summary,
	"summary_html" => summary \|> Formatter.emojify(object["emoji"])
	}
	end

	def conversation_id(activity) do
	with context when not is_nil(context) <- activity.data["context"] do
	TwitterAPI.context_to_conversation_id(context)
	else
	_e -> nil
	end
	end

	defp to_boolean(false) do
	false
	end

	defp to_boolean(nil) do
	false
	end

	defp to_boolean(_) do
	true
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index ecf81d492..7a63724f1 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,330 +1,338 @@
	# 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.{UserInviteToken, User, Activity, Repo, Object}
	alias Pleroma.{UserEmail, Mailer}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.CommonAPI

	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}} <- Repo.get(Activity, 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),
	{: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}
	else
	err -> err
	end
	end

	def unfollow(%User{} = follower, params) do
	with {:ok, %User{} = unfollowed} <- get_user(params),
	{:ok, follower, _follow_activity} <- User.unfollow(follower, unfollowed),
	{:ok, _activity} <- ActivityPub.unfollow(follower, unfollowed) do
	{:ok, follower, unfollowed}
	else
	err -> err
	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_activity_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_activity_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_activity_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_activity_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
	tokenString = 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])

	# no need to query DB if registration is open
	token =
	unless registrations_open \|\| is_nil(tokenString) do
	Repo.get_by(UserInviteToken, %{token: tokenString})
	end

	cond do
	registrations_open \|\| (!is_nil(token) && !token.used) ->
	changeset = User.register_changeset(%User{}, params)

	with {:ok, user} <- User.register(changeset) do
	!registrations_open && UserInviteToken.mark_as_used(token.token)

	{:ok, user}
	else
	{:error, changeset} ->
	errors =
	Ecto.Changeset.traverse_errors(changeset, fn {msg, _opts} -> msg end)
	\|> Jason.encode!()

	{:error, %{error: errors}}
	end

	!registrations_open && is_nil(token) ->
	{:error, "Invalid token"}

	!registrations_open && token.used ->
	{:error, "Expired token"}
	end
	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()
	else
	false ->
	{:error, "bad user identifier"}

	%User{local: false} ->
	{:error, "remote user"}

	nil ->
	{:error, "unknown user"}
	end
	end

	def get_by_id_or_nickname(id_or_nickname) do
	if !is_integer(id_or_nickname) && :error == Integer.parse(id_or_nickname) do
	Repo.get_by(User, nickname: id_or_nickname)
	else
	Repo.get(User, id_or_nickname)
	end
	end

	def get_user(user \\ nil, params) do
	case params do
	%{"user_id" => user_id} ->
	case target = get_by_id_or_nickname(user_id) do
	nil ->
	{:error, "No user with such user_id"}

	_ ->
	{:ok, target}
	end

	%{"screen_name" => nickname} ->
	case target = Repo.get_by(User, nickname: nickname) do
	nil ->
	{:error, "No user with such screen_name"}

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

	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,
	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,
	^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

	# 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

	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/twitter_api_controller.ex b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	index 1e04b8c4b..d5b9d2fb8 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api_controller.ex
	@@ -1,700 +1,724 @@
	# 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.Controller do
	use Pleroma.Web, :controller

	import Pleroma.Web.ControllerHelper, only: [json_response: 3]

	alias Pleroma.Web.TwitterAPI.{TwitterAPI, UserView, ActivityView, NotificationView}
	alias Pleroma.Web.CommonAPI
	alias Pleroma.{Repo, Activity, Object, User, Notification}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Ecto.Changeset

	require Logger

	plug(:only_if_public_instance when action in [:public_timeline, :public_and_external_timeline])
	action_fallback(:errors)

	def verify_credentials(%{assigns: %{user: user}} = conn, _params) do
	token = Phoenix.Token.sign(conn, "user socket", user.id)

	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: user, token: token})
	end

	def status_update(%{assigns: %{user: user}} = conn, %{"status" => _} = status_data) do
	with media_ids <- extract_media_ids(status_data),
	{:ok, activity} <-
	TwitterAPI.create_status(user, Map.put(status_data, "media_ids", media_ids)) do
	conn
	\|> json(ActivityView.render("activity.json", activity: activity, for: user))
	else
	_ -> empty_status_reply(conn)
	end
	end

	def status_update(conn, _status_data) do
	empty_status_reply(conn)
	end

	defp empty_status_reply(conn) do
	bad_request_reply(conn, "Client must provide a 'status' parameter with a value.")
	end

	defp extract_media_ids(status_data) do
	with media_ids when not is_nil(media_ids) <- status_data["media_ids"],
	split_ids <- String.split(media_ids, ","),
	clean_ids <- Enum.reject(split_ids, fn id -> String.length(id) == 0 end) do
	clean_ids
	else
	_e -> []
	end
	end

	def public_and_external_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("blocking_user", user)

	activities = ActivityPub.fetch_public_activities(params)

	conn
	\|> put_view(ActivityView)
	\|> render("index.json", %{activities: activities, for: user})
	end

	def public_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce"])
	\|> Map.put("local_only", true)
	\|> Map.put("blocking_user", user)

	activities = ActivityPub.fetch_public_activities(params)

	conn
	\|> put_view(ActivityView)
	\|> render("index.json", %{activities: activities, for: user})
	end

	def friends_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce", "Follow", "Like"])
	\|> Map.put("blocking_user", user)
	\|> Map.put("user", user)

	activities =
	ActivityPub.fetch_activities([user.ap_id \| user.following], params)
	\|> ActivityPub.contain_timeline(user)

	conn
	\|> put_view(ActivityView)
	\|> render("index.json", %{activities: activities, for: user})
	end

	def show_user(conn, params) do
	for_user = conn.assigns.user

	with {:ok, shown} <- TwitterAPI.get_user(params),
	true <-
	User.auth_active?(shown) \|\|
	(for_user && (for_user.id == shown.id \|\| User.superuser?(for_user))) do
	params =
	if for_user do
	%{user: shown, for: for_user}
	else
	%{user: shown}
	end

	conn
	\|> put_view(UserView)
	\|> render("show.json", params)
	else
	{:error, msg} ->
	bad_request_reply(conn, msg)

	false ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Unconfirmed user"})
	end
	end

	def user_timeline(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.get_user(user, params) do
	{:ok, target_user} ->
	# Twitter and ActivityPub use a different name and sense for this parameter.
	{include_rts, params} = Map.pop(params, "include_rts")

	params =
	case include_rts do
	x when x == "false" or x == "0" -> Map.put(params, "exclude_reblogs", "true")
	_ -> params
	end

	activities = ActivityPub.fetch_user_activities(target_user, user, params)

	conn
	\|> put_view(ActivityView)
	\|> render("index.json", %{activities: activities, for: user})

	{:error, msg} ->
	bad_request_reply(conn, msg)
	end
	end

	def mentions_timeline(%{assigns: %{user: user}} = conn, params) do
	params =
	params
	\|> Map.put("type", ["Create", "Announce", "Follow", "Like"])
	\|> Map.put("blocking_user", user)

	activities = ActivityPub.fetch_activities([user.ap_id], params)

	conn
	\|> put_view(ActivityView)
	\|> render("index.json", %{activities: activities, for: user})
	end

	def dm_timeline(%{assigns: %{user: user}} = conn, params) do
	query =
	ActivityPub.fetch_activities_query(
	[user.ap_id],
	Map.merge(params, %{"type" => "Create", "user" => user, visibility: "direct"})
	)

	activities = Repo.all(query)

	conn
	\|> put_view(ActivityView)
	\|> render("index.json", %{activities: activities, for: user})
	end

	def notifications(%{assigns: %{user: user}} = conn, params) do
	notifications = Notification.for_user(user, params)

	conn
	\|> put_view(NotificationView)
	\|> render("notification.json", %{notifications: notifications, for: user})
	end

	def notifications_read(%{assigns: %{user: user}} = conn, %{"latest_id" => latest_id} = params) do
	Notification.set_read_up_to(user, latest_id)

	notifications = Notification.for_user(user, params)

	conn
	\|> put_view(NotificationView)
	\|> render("notification.json", %{notifications: notifications, for: user})
	end

	def notifications_read(%{assigns: %{user: _user}} = conn, _) do
	bad_request_reply(conn, "You need to specify latest_id")
	end

	def follow(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.follow(user, params) do
	{:ok, user, followed, _activity} ->
	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: followed, for: user})

	{:error, msg} ->
	forbidden_json_reply(conn, msg)
	end
	end

	def block(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.block(user, params) do
	{:ok, user, blocked} ->
	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: blocked, for: user})

	{:error, msg} ->
	forbidden_json_reply(conn, msg)
	end
	end

	def unblock(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.unblock(user, params) do
	{:ok, user, blocked} ->
	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: blocked, for: user})

	{:error, msg} ->
	forbidden_json_reply(conn, msg)
	end
	end

	def delete_post(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {:ok, activity} <- TwitterAPI.delete(user, id) do
	conn
	\|> put_view(ActivityView)
	\|> render("activity.json", %{activity: activity, for: user})
	end
	end

	def unfollow(%{assigns: %{user: user}} = conn, params) do
	case TwitterAPI.unfollow(user, params) do
	{:ok, user, unfollowed} ->
	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: unfollowed, for: user})

	{:error, msg} ->
	forbidden_json_reply(conn, msg)
	end
	end

	def fetch_status(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with %Activity{} = activity <- Repo.get(Activity, id),
	true <- ActivityPub.visible_for_user?(activity, user) do
	conn
	\|> put_view(ActivityView)
	\|> render("activity.json", %{activity: activity, for: user})
	end
	end

	def fetch_conversation(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	id = String.to_integer(id)

	with context when is_binary(context) <- TwitterAPI.conversation_id_to_context(id),
	activities <-
	ActivityPub.fetch_activities_for_context(context, %{
	"blocking_user" => user,
	"user" => user
	}) do
	conn
	\|> put_view(ActivityView)
	\|> render("index.json", %{activities: activities, for: user})
	end
	end

	@doc """
	Updates metadata of uploaded media object.
	Derived from [Twitter API endpoint](https://developer.twitter.com/en/docs/media/upload-media/api-reference/post-media-metadata-create).
	"""
	def update_media(%{assigns: %{user: user}} = conn, %{"media_id" => id} = data) do
	object = Repo.get(Object, id)
	description = get_in(data, ["alt_text", "text"]) \|\| data["name"] \|\| data["description"]

	{conn, status, response_body} =
	cond do
	!object ->
	{halt(conn), :not_found, ""}

	!Object.authorize_mutation(object, user) ->
	{halt(conn), :forbidden, "You can only update your own uploads."}

	!is_binary(description) ->
	{conn, :not_modified, ""}

	true ->
	new_data = Map.put(object.data, "name", description)

	{:ok, _} =
	object
	\|> Object.change(%{data: new_data})
	\|> Repo.update()

	{conn, :no_content, ""}
	end

	conn
	\|> put_status(status)
	\|> json(response_body)
	end

	def upload(%{assigns: %{user: user}} = conn, %{"media" => media}) do
	response = TwitterAPI.upload(media, user)

	conn
	\|> put_resp_content_type("application/atom+xml")
	\|> send_resp(200, response)
	end

	def upload_json(%{assigns: %{user: user}} = conn, %{"media" => media}) do
	response = TwitterAPI.upload(media, user, "json")

	conn
	\|> json_reply(200, response)
	end

	def get_by_id_or_ap_id(id) do
	activity = Repo.get(Activity, id) \|\| Activity.get_create_activity_by_object_ap_id(id)

	if activity.data["type"] == "Create" do
	activity
	else
	Activity.get_create_activity_by_object_ap_id(activity.data["object"])
	end
	end

	def favorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
	{:ok, activity} <- TwitterAPI.fav(user, id) do
	conn
	\|> put_view(ActivityView)
	\|> render("activity.json", %{activity: activity, for: user})
	end
	end

	def unfavorite(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
	{:ok, activity} <- TwitterAPI.unfav(user, id) do
	conn
	\|> put_view(ActivityView)
	\|> render("activity.json", %{activity: activity, for: user})
	end
	end

	def retweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
	{:ok, activity} <- TwitterAPI.repeat(user, id) do
	conn
	\|> put_view(ActivityView)
	\|> render("activity.json", %{activity: activity, for: user})
	end
	end

	def unretweet(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
	{:ok, activity} <- TwitterAPI.unrepeat(user, id) do
	conn
	\|> put_view(ActivityView)
	\|> render("activity.json", %{activity: activity, for: user})
	end
	end

	+ def pin(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	+ with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
	+ {:ok, activity} <- TwitterAPI.pin(user, id) do
	+ conn
	+ \|> put_view(ActivityView)
	+ \|> render("activity.json", %{activity: activity, for: user})
	+ else
	+ {:error, message} -> bad_request_reply(conn, message)
	+ err -> err
	+ end
	+ end
	+
	+ def unpin(%{assigns: %{user: user}} = conn, %{"id" => id}) do
	+ with {_, {:ok, id}} <- {:param_cast, Ecto.Type.cast(:integer, id)},
	+ {:ok, activity} <- TwitterAPI.unpin(user, id) do
	+ conn
	+ \|> put_view(ActivityView)
	+ \|> render("activity.json", %{activity: activity, for: user})
	+ else
	+ {:error, message} -> bad_request_reply(conn, message)
	+ err -> err
	+ end
	+ end
	+
	def register(conn, params) do
	with {:ok, user} <- TwitterAPI.register_user(params) do
	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: user})
	else
	{:error, errors} ->
	conn
	\|> json_reply(400, Jason.encode!(errors))
	end
	end

	def password_reset(conn, params) do
	nickname_or_email = params["email"] \|\| params["nickname"]

	with {:ok, _} <- TwitterAPI.password_reset(nickname_or_email) do
	json_response(conn, :no_content, "")
	end
	end

	def confirm_email(conn, %{"user_id" => uid, "token" => token}) do
	with %User{} = user <- Repo.get(User, uid),
	true <- user.local,
	true <- user.info.confirmation_pending,
	true <- user.info.confirmation_token == token,
	info_change <- User.Info.confirmation_changeset(user.info, :confirmed),
	changeset <- Changeset.change(user) \|> Changeset.put_embed(:info, info_change),
	{:ok, _} <- User.update_and_set_cache(changeset) do
	conn
	\|> redirect(to: "/")
	end
	end

	def resend_confirmation_email(conn, params) do
	nickname_or_email = params["email"] \|\| params["nickname"]

	with %User{} = user <- User.get_by_nickname_or_email(nickname_or_email),
	{:ok, _} <- User.try_send_confirmation_email(user) do
	conn
	\|> json_response(:no_content, "")
	end
	end

	def update_avatar(%{assigns: %{user: user}} = conn, params) do
	{:ok, object} = ActivityPub.upload(params, type: :avatar)
	change = Changeset.change(user, %{avatar: object.data})
	{:ok, user} = User.update_and_set_cache(change)
	CommonAPI.update(user)

	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: user, for: user})
	end

	def update_banner(%{assigns: %{user: user}} = conn, params) do
	with {:ok, object} <- ActivityPub.upload(%{"img" => params["banner"]}, type: :banner),
	new_info <- %{"banner" => object.data},
	info_cng <- User.Info.profile_update(user.info, new_info),
	changeset <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, user} <- User.update_and_set_cache(changeset) do
	CommonAPI.update(user)
	%{"url" => [%{"href" => href} \| _]} = object.data
	response = %{url: href} \|> Jason.encode!()

	conn
	\|> json_reply(200, response)
	end
	end

	def update_background(%{assigns: %{user: user}} = conn, params) do
	with {:ok, object} <- ActivityPub.upload(params, type: :background),
	new_info <- %{"background" => object.data},
	info_cng <- User.Info.profile_update(user.info, new_info),
	changeset <- Ecto.Changeset.change(user) \|> Ecto.Changeset.put_embed(:info, info_cng),
	{:ok, _user} <- User.update_and_set_cache(changeset) do
	%{"url" => [%{"href" => href} \| _]} = object.data
	response = %{url: href} \|> Jason.encode!()

	conn
	\|> json_reply(200, response)
	end
	end

	def external_profile(%{assigns: %{user: current_user}} = conn, %{"profileurl" => uri}) do
	with {:ok, user_map} <- TwitterAPI.get_external_profile(current_user, uri),
	response <- Jason.encode!(user_map) do
	conn
	\|> json_reply(200, response)
	else
	_e ->
	conn
	\|> put_status(404)
	\|> json(%{error: "Can't find user"})
	end
	end

	def followers(%{assigns: %{user: for_user}} = conn, params) do
	with {:ok, user} <- TwitterAPI.get_user(for_user, params),
	{:ok, followers} <- User.get_followers(user) do
	followers =
	cond do
	for_user && user.id == for_user.id -> followers
	user.info.hide_network -> []
	true -> followers
	end

	conn
	\|> put_view(UserView)
	\|> render("index.json", %{users: followers, for: conn.assigns[:user]})
	else
	_e -> bad_request_reply(conn, "Can't get followers")
	end
	end

	def friends(%{assigns: %{user: for_user}} = conn, params) do
	with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
	{:ok, friends} <- User.get_friends(user) do
	friends =
	cond do
	for_user && user.id == for_user.id -> friends
	user.info.hide_network -> []
	true -> friends
	end

	conn
	\|> put_view(UserView)
	\|> render("index.json", %{users: friends, for: conn.assigns[:user]})
	else
	_e -> bad_request_reply(conn, "Can't get friends")
	end
	end

	def blocks(%{assigns: %{user: user}} = conn, _params) do
	with blocked_users <- User.blocked_users(user) do
	conn
	\|> put_view(UserView)
	\|> render("index.json", %{users: blocked_users, for: user})
	end
	end

	def friend_requests(conn, params) do
	with {:ok, user} <- TwitterAPI.get_user(conn.assigns[:user], params),
	{:ok, friend_requests} <- User.get_follow_requests(user) do
	conn
	\|> put_view(UserView)
	\|> render("index.json", %{users: friend_requests, for: conn.assigns[:user]})
	else
	_e -> bad_request_reply(conn, "Can't get friend requests")
	end
	end

	def approve_friend_request(conn, %{"user_id" => uid} = _params) do
	with followed <- conn.assigns[:user],
	uid when is_number(uid) <- String.to_integer(uid),
	%User{} = follower <- Repo.get(User, uid),
	{: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.ap_id,
	object: follow_activity.data["id"],
	type: "Accept"
	}) do
	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: follower, for: followed})
	else
	e -> bad_request_reply(conn, "Can't approve user: #{inspect(e)}")
	end
	end

	def deny_friend_request(conn, %{"user_id" => uid} = _params) do
	with followed <- conn.assigns[:user],
	uid when is_number(uid) <- String.to_integer(uid),
	%User{} = follower <- Repo.get(User, uid),
	%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.ap_id,
	object: follow_activity.data["id"],
	type: "Reject"
	}) do
	conn
	\|> put_view(UserView)
	\|> render("show.json", %{user: follower, for: followed})
	else
	e -> bad_request_reply(conn, "Can't deny user: #{inspect(e)}")
	end
	end

	def friends_ids(%{assigns: %{user: user}} = conn, _params) do
	with {:ok, friends} <- User.get_friends(user) do
	ids =
	friends
	\|> Enum.map(fn x -> x.id end)
	\|> Jason.encode!()

	json(conn, ids)
	else
	_e -> bad_request_reply(conn, "Can't get friends")
	end
	end

	def empty_array(conn, _params) do
	json(conn, Jason.encode!([]))
	end

	def raw_empty_array(conn, _params) do
	json(conn, [])
	end

	defp build_info_cng(user, params) do
	info_params =
	["no_rich_text", "locked", "hide_network"]
	\|> Enum.reduce(%{}, fn key, res ->
	if value = params[key] do
	Map.put(res, key, value == "true")
	else
	res
	end
	end)

	info_params =
	if value = params["default_scope"] do
	Map.put(info_params, "default_scope", value)
	else
	info_params
	end

	User.Info.profile_update(user.info, info_params)
	end

	defp parse_profile_bio(user, params) do
	if bio = params["description"] do
	Map.put(params, "bio", User.parse_bio(bio, user))
	else
	params
	end
	end

	def update_profile(%{assigns: %{user: user}} = conn, params) do
	params = parse_profile_bio(user, params)
	info_cng = build_info_cng(user, params)

	with changeset <- User.update_changeset(user, params),
	changeset <- Ecto.Changeset.put_embed(changeset, :info, info_cng),
	{:ok, user} <- User.update_and_set_cache(changeset) do
	CommonAPI.update(user)

	conn
	\|> put_view(UserView)
	\|> render("user.json", %{user: user, for: user})
	else
	error ->
	Logger.debug("Can't update user: #{inspect(error)}")
	bad_request_reply(conn, "Can't update user")
	end
	end

	def search(%{assigns: %{user: user}} = conn, %{"q" => _query} = params) do
	activities = TwitterAPI.search(user, params)

	conn
	\|> put_view(ActivityView)
	\|> render("index.json", %{activities: activities, for: user})
	end

	def search_user(%{assigns: %{user: user}} = conn, %{"query" => query}) do
	users = User.search(query, true)

	conn
	\|> put_view(UserView)
	\|> render("index.json", %{users: users, for: user})
	end

	defp bad_request_reply(conn, error_message) do
	json = error_json(conn, error_message)
	json_reply(conn, 400, json)
	end

	defp json_reply(conn, status, json) do
	conn
	\|> put_resp_content_type("application/json")
	\|> send_resp(status, json)
	end

	defp forbidden_json_reply(conn, error_message) do
	json = error_json(conn, error_message)
	json_reply(conn, 403, json)
	end

	def only_if_public_instance(%{assigns: %{user: %User{}}} = conn, _), do: conn

	def only_if_public_instance(conn, _) do
	if Keyword.get(Application.get_env(:pleroma, :instance), :public) do
	conn
	else
	conn
	\|> forbidden_json_reply("Invalid credentials.")
	\|> halt()
	end
	end

	defp error_json(conn, error_message) do
	%{"error" => error_message, "request" => conn.request_path} \|> Jason.encode!()
	end

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

	def errors(conn, _) do
	conn
	\|> put_status(500)
	\|> json("Something went wrong")
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/views/activity_view.ex b/lib/pleroma/web/twitter_api/views/activity_view.ex
	index 5f4b74842..108e7bfc5 100644
	--- a/lib/pleroma/web/twitter_api/views/activity_view.ex
	+++ b/lib/pleroma/web/twitter_api/views/activity_view.ex
	@@ -1,353 +1,355 @@
	# 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.Web.CommonAPI.Utils
	alias Pleroma.User
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.Representers.ObjectRepresenter
	alias Pleroma.Activity
	alias Pleroma.HTML
	alias Pleroma.Object
	alias Pleroma.User
	alias Pleroma.Repo
	alias Pleroma.Formatter

	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 -> TwitterAPI.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 ->
	error_user(ap_id)
	end
	end

	defp error_user(ap_id) do
	%User{
	name: ap_id,
	ap_id: ap_id,
	info: %User.Info{},
	nickname: "erroruser@example.com",
	inserted_at: NaiveDateTime.utc_now()
	}
	end

	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)

	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_activity_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_activity_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
	) 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"] \|\| [])
	+ pinned = activity.id in user.info.pinned_activities

	attentions =
	activity.recipients
	\|> 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 = if possibly_sensitive, do: Enum.uniq(["nsfw" \| tags]), else: tags

	{summary, content} = render_content(object)

	html =
	content
	\|> HTML.get_cached_scrubbed_html_for_object(
	User.html_filter_policy(opts[:for]),
	activity,
	__MODULE__
	)
	\|> Formatter.emojify(object["emoji"])

	text =
	if content do
	content
	\|> String.replace(~r/<br\s?\/?>/, "\n")
	\|> HTML.get_cached_stripped_html_for_object(activity, __MODULE__)
	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)

	%{
	"id" => activity.id,
	"uri" => activity.data["object"]["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" => object["inReplyToStatusId"],
	"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),
	"attentions" => attentions,
	"fave_num" => like_count,
	"repeat_num" => announcement_count,
	"favorited" => !!favorited,
	"repeated" => !!repeated,
	+ "pinned" => pinned,
	"external_url" => object["external_url"] \|\| object["id"],
	"tags" => tags,
	"activity_type" => "post",
	"possibly_sensitive" => possibly_sensitive,
	"visibility" => Pleroma.Web.MastodonAPI.StatusView.get_visibility(object),
	"summary" => summary,
	"summary_html" => summary \|> Formatter.emojify(object["emoji"])
	}
	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/test/web/activity_pub/activity_pub_test.exs b/test/web/activity_pub/activity_pub_test.exs
	index 47aa5a56f..eafb96f3a 100644
	--- a/test/web/activity_pub/activity_pub_test.exs
	+++ b/test/web/activity_pub/activity_pub_test.exs
	@@ -1,643 +1,665 @@
	# 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.ActivityPubTest do
	use Pleroma.DataCase
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.ActivityPub.Utils
	alias Pleroma.Web.CommonAPI
	alias Pleroma.{Activity, Object, User}
	alias Pleroma.Builders.ActivityBuilder

	import Pleroma.Factory
	import Tesla.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]
	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
	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 "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 == new_activity
	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"])
	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: %{}
	})

	assert activity.data["to"] == ["user1", "user2"]
	assert activity.actor == user.ap_id
	assert activity.recipients == ["user1", "user2"]
	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})

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

	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_activity_by_object_ap_id(id)
	activity_three = Repo.get(Activity, activity_three.id)

	activities = ActivityPub.fetch_activities([], %{"blocking_user" => user})

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

	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 "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
	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.all_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 Repo.get(Activity, 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 Repo.get(Activity, 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 "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 activity == Utils.fetch_latest_follow(follower, followed)
	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_activity_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_activity_by_object_ap_id(object.data["id"])
	assert activity.data["id"]

	{:ok, object_again} =
	ActivityPub.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} = ActivityPub.fetch_object_from_id(last)

	object = Object.get_by_ap_id(object.data["inReplyTo"])
	assert object
	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 Repo.get(Activity, delete.id) != nil

	assert Repo.get(Object, object.id).data["type"] == "Tombstone"
	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
	})

	assert user1.following == [user3.ap_id <> "/followers", user1.ap_id]

	activities = ActivityPub.fetch_activities([user1.ap_id \| user1.following])

	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
	+
	def data_uri do
	File.read!("test/fixtures/avatar_data_uri")
	end
	end
	diff --git a/test/web/common_api/common_api_test.exs b/test/web/common_api/common_api_test.exs
	index c3674711a..eb69ea4b2 100644
	--- a/test/web/common_api/common_api_test.exs
	+++ b/test/web/common_api/common_api_test.exs
	@@ -1,99 +1,137 @@
	# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.CommonAPI.Test do
	use Pleroma.DataCase
	alias Pleroma.Web.CommonAPI
	alias Pleroma.User
	alias Pleroma.Activity

	import Pleroma.Factory

	test "it de-duplicates tags" do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "#2hu #2HU"})

	assert activity.data["object"]["tag"] == ["2hu"]
	end

	test "it adds emoji when updating profiles" do
	user = insert(:user, %{name: ":karjalanpiirakka:"})

	CommonAPI.update(user)
	user = User.get_cached_by_ap_id(user.ap_id)
	[karjalanpiirakka] = user.info.source_data["tag"]

	assert karjalanpiirakka["name"] == ":karjalanpiirakka:"
	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')"
	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')"
	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)
	+ 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)
	+
	+ assert {:ok, ^activity} = CommonAPI.unpin(activity.id, user)
	+ 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 ce87010c8..b448d13f5 100644
	--- a/test/web/mastodon_api/mastodon_api_controller_test.exs
	+++ b/test/web/mastodon_api/mastodon_api_controller_test.exs
	@@ -1,1474 +1,1554 @@
	# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# 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 Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.{Repo, User, Object, Activity, Notification}
	alias Pleroma.Web.{OStatus, CommonAPI}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.MastodonAPI.FilterView
	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 length(json_response(conn, 200)) == 0

	{: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 Repo.get(Activity, 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 Repo.get(Activity, id)
	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 = Repo.get(Activity, id)
	assert activity.recipients == [user2.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"]

	# 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 "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 = Repo.get(Activity, id)

	assert activity.data["context"] == replied_to.data["context"]
	assert activity.data["object"]["inReplyToStatusId"] == 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 = Repo.get(Activity, 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 "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_by_ap_id(activity.data["actor"])

	conn =
	conn
	\|> assign(:user, author)
	\|> delete("/api/v1/statuses/#{activity.id}")

	assert %{} = json_response(conn, 200)

	refute Repo.get(Activity, 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 Repo.get(Activity, activity.id) == activity
	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><a data-user=\"#{user.id}\" 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><a data-user=\"#{user.id}\" 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
	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}} =
	json_response(conn, 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_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_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 = Repo.get(User, user.id)
	other_user = Repo.get(User, 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: %Pleroma.User.Info{locked: true}})
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, 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 = Repo.get(User, user.id)
	other_user = Repo.get(User, 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)

	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 = Repo.get(User, user.id)
	other_user = Repo.get(User, 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 "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 "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_network", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_network: 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_network, same user requesting", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user, %{info: %{hide_network: 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 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_network", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: 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_network, same user requesting", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: 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 "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 = Repo.get(User, 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 = Repo.get(User, 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 "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 = Repo.get(User, 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 mute endpoints" do
	user = insert(:user)
	other_user = insert(:user)

	["mute", "unmute"]
	\|> Enum.each(fn endpoint ->
	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/v1/accounts/#{other_user.id}/#{endpoint}")

	assert %{"id" => id} = json_response(conn, 200)
	assert id == to_string(other_user.id)
	end)
	end

	test "unimplemented mutes, follow_requests, blocks, domain blocks" do
	user = insert(:user)

	["blocks", "domain_blocks", "mutes", "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"]})

	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)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/v1/favourites")

	assert [status] = json_response(conn, 200)
	assert status["id"] == to_string(activity.id)
	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"] ==
	"I drink <a data-tag=\"cofe\" href=\"http://localhost:4001/tag/cofe\">#cofe</a> with <span><a data-user=\"#{
	user2.id
	}\" href=\"#{user2.ap_id}\">@<span>#{user2.nickname}</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
	end

	test "get instance information", %{conn: conn} do
	insert(:user, %{local: true})
	user = insert(:user, %{local: true})
	insert(:user, %{local: false})

	{:ok, _} = TwitterAPI.create_status(user, %{"status" => "cofe"})

	Pleroma.Stats.update_stats()

	conn =
	conn
	\|> get("/api/v1/instance")

	assert result = json_response(conn, 200)

	assert result["stats"]["user_count"] == 2
	assert result["stats"]["status_count"] == 1
	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
	+ end
	end
	diff --git a/test/web/mastodon_api/status_view_test.exs b/test/web/mastodon_api/status_view_test.exs
	index b953ccd76..1076b5002 100644
	--- a/test/web/mastodon_api/status_view_test.exs
	+++ b/test/web/mastodon_api/status_view_test.exs
	@@ -1,202 +1,203 @@
	# 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.Web.MastodonAPI.{StatusView, AccountView}
	alias Pleroma.User
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Activity
	import Pleroma.Factory
	import Tesla.Mock

	setup do
	mock(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "a note with null content" do
	note = insert(:note_activity)

	data =
	note.data
	\|> put_in(["object", "content"], nil)

	note =
	note
	\|> Map.put(:data, data)

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

	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: note.data["object"]["id"],
	account: AccountView.render("account.json", %{user: user}),
	in_reply_to_id: nil,
	in_reply_to_account_id: 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,
	favourited: false,
	muted: false,
	+ pinned: false,
	sensitive: false,
	spoiler_text: 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
	}
	]
	}

	assert status == expected
	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})

	assert status.mentions == [AccountView.render("mention.json", %{user: user})]
	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
	}

	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(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_activity_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
	end
	diff --git a/test/web/twitter_api/representers/activity_representer_test.exs b/test/web/twitter_api/representers/activity_representer_test.exs
	index d71aaacfe..ef0294140 100644
	--- a/test/web/twitter_api/representers/activity_representer_test.exs
	+++ b/test/web/twitter_api/representers/activity_representer_test.exs
	@@ -1,202 +1,203 @@
	# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.Representers.ActivityRepresenterTest do
	use Pleroma.DataCase
	alias Pleroma.{User, Activity, Object}
	alias Pleroma.Web.TwitterAPI.Representers.{ActivityRepresenter, ObjectRepresenter}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	import Pleroma.Factory

	test "an announce activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	activity_actor = Repo.get_by(User, ap_id: note_activity.data["actor"])
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

	{:ok, announce_activity, _object} = ActivityPub.announce(user, object)
	note_activity = Activity.get_by_ap_id(note_activity.data["id"])

	status =
	ActivityRepresenter.to_map(announce_activity, %{
	users: [user, activity_actor],
	announced_activity: note_activity,
	for: user
	})

	assert status["id"] == announce_activity.id
	assert status["user"] == UserView.render("show.json", %{user: user, for: user})

	retweeted_status =
	ActivityRepresenter.to_map(note_activity, %{user: activity_actor, for: user})

	assert retweeted_status["repeated"] == true
	assert retweeted_status["id"] == note_activity.id
	assert status["statusnet_conversation_id"] == retweeted_status["statusnet_conversation_id"]

	assert status["retweeted_status"] == retweeted_status
	assert status["activity_type"] == "repeat"
	end

	test "a like 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)

	status =
	ActivityRepresenter.to_map(like_activity, %{user: user, liked_activity: note_activity})

	assert status["id"] == like_activity.id
	assert status["in_reply_to_status_id"] == note_activity.id

	note_activity = Activity.get_by_ap_id(note_activity.data["id"])
	activity_actor = Repo.get_by(User, ap_id: note_activity.data["actor"])
	liked_status = ActivityRepresenter.to_map(note_activity, %{user: activity_actor, for: user})
	assert liked_status["favorited"] == true
	assert status["activity_type"] == "like"
	end

	test "an activity" do
	user = insert(:user)
	# {:ok, mentioned_user } = UserBuilder.insert(%{nickname: "shp", ap_id: "shp"})
	mentioned_user = insert(:user, %{nickname: "shp"})

	# {:ok, follower} = UserBuilder.insert(%{following: [User.ap_followers(user)]})
	follower = insert(:user, %{following: [User.ap_followers(user)]})

	object = %Object{
	data: %{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => "image/jpg",
	"href" => "http://example.org/image.jpg"
	}
	],
	"uuid" => 1
	}
	}

	content_html =
	"<script>alert('YAY')</script>Some :2hu: content mentioning <a href='#{mentioned_user.ap_id}'>@shp</shp>"

	content = HtmlSanitizeEx.strip_tags(content_html)
	date = DateTime.from_naive!(~N[2016-05-24 13:26:08.003], "Etc/UTC") \|> DateTime.to_iso8601()

	{:ok, convo_object} = Object.context_mapping("2hu") \|> Repo.insert()

	to = [
	User.ap_followers(user),
	"https://www.w3.org/ns/activitystreams#Public",
	mentioned_user.ap_id
	]

	activity = %Activity{
	id: 1,
	data: %{
	"type" => "Create",
	"id" => "id",
	"to" => to,
	"actor" => User.ap_id(user),
	"object" => %{
	"published" => date,
	"type" => "Note",
	"content" => content_html,
	"summary" => "2hu :2hu:",
	"inReplyToStatusId" => 213_123,
	"attachment" => [
	object
	],
	"external_url" => "some url",
	"like_count" => 5,
	"announcement_count" => 3,
	"context" => "2hu",
	"tag" => ["content", "mentioning", "nsfw"],
	"emoji" => %{
	"2hu" => "corndog.png"
	}
	},
	"published" => date,
	"context" => "2hu"
	},
	local: false,
	recipients: to
	}

	expected_html =
	"<p>2hu <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" /></p>alert('YAY')Some <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" /> content mentioning <a href=\"#{
	mentioned_user.ap_id
	}\">@shp</a>"

	expected_status = %{
	"id" => activity.id,
	"user" => UserView.render("show.json", %{user: user, for: follower}),
	"is_local" => false,
	"statusnet_html" => expected_html,
	"text" => "2hu :2hu:" <> content,
	"is_post_verb" => true,
	"created_at" => "Tue May 24 13:26:08 +0000 2016",
	"in_reply_to_status_id" => 213_123,
	"in_reply_to_screen_name" => nil,
	"in_reply_to_user_id" => nil,
	"in_reply_to_profileurl" => nil,
	"in_reply_to_ostatus_uri" => nil,
	"statusnet_conversation_id" => convo_object.id,
	"attachments" => [
	ObjectRepresenter.to_map(object)
	],
	"attentions" => [
	UserView.render("show.json", %{user: mentioned_user, for: follower})
	],
	"fave_num" => 5,
	"repeat_num" => 3,
	"favorited" => false,
	"repeated" => false,
	+ "pinned" => false,
	"external_url" => "some url",
	"tags" => ["nsfw", "content", "mentioning"],
	"activity_type" => "post",
	"possibly_sensitive" => true,
	"uri" => activity.data["object"]["id"],
	"visibility" => "direct",
	"summary" => "2hu :2hu:",
	"summary_html" =>
	"2hu <img height=\"32px\" width=\"32px\" alt=\"2hu\" title=\"2hu\" src=\"corndog.png\" />"
	}

	assert ActivityRepresenter.to_map(activity, %{
	user: user,
	for: follower,
	mentioned: [mentioned_user]
	}) == expected_status
	end

	test "an undo for a follow" do
	follower = insert(:user)
	followed = insert(:user)

	{:ok, _follow} = ActivityPub.follow(follower, followed)
	{:ok, unfollow} = ActivityPub.unfollow(follower, followed)

	map = ActivityRepresenter.to_map(unfollow, %{user: follower})
	assert map["is_post_verb"] == false
	assert map["activity_type"] == "undo"
	end

	test "a delete activity" do
	object = insert(:note)
	user = User.get_by_ap_id(object.data["actor"])

	{:ok, delete} = ActivityPub.delete(object)

	map = ActivityRepresenter.to_map(delete, %{user: user})

	assert map["is_post_verb"] == false
	assert map["activity_type"] == "delete"
	assert map["uri"] == object.data["id"]
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_controller_test.exs b/test/web/twitter_api/twitter_api_controller_test.exs
	index c41f615ac..7d4c92c66 100644
	--- a/test/web/twitter_api/twitter_api_controller_test.exs
	+++ b/test/web/twitter_api/twitter_api_controller_test.exs
	@@ -1,1697 +1,1772 @@
	# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.ControllerTest do
	use Pleroma.Web.ConnCase
	alias Pleroma.Web.TwitterAPI.Representers.ActivityRepresenter
	alias Pleroma.Builders.{ActivityBuilder, UserBuilder}
	alias Pleroma.{Repo, Activity, User, Object, Notification}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.NotificationView
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Comeonin.Pbkdf2
	alias Ecto.Changeset

	import Pleroma.Factory

	@banner "data:image/gif;base64,R0lGODlhEAAQAMQAAORHHOVSKudfOulrSOp3WOyDZu6QdvCchPGolfO0o/XBs/fNwfjZ0frl3/zy7////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAkAABAALAAAAAAQABAAAAVVICSOZGlCQAosJ6mu7fiyZeKqNKToQGDsM8hBADgUXoGAiqhSvp5QAnQKGIgUhwFUYLCVDFCrKUE1lBavAViFIDlTImbKC5Gm2hB0SlBCBMQiB0UjIQA7"

	describe "POST /api/account/update_profile_banner" do
	test "it updates the banner", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post(authenticated_twitter_api__path(conn, :update_banner), %{"banner" => @banner})
	\|> json_response(200)

	user = refresh_record(user)
	assert user.info.banner["type"] == "Image"
	end
	end

	describe "POST /api/qvitter/update_background_image" do
	test "it updates the background", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post(authenticated_twitter_api__path(conn, :update_background), %{"img" => @banner})
	\|> json_response(200)

	user = refresh_record(user)
	assert user.info.background["type"] == "Image"
	end
	end

	describe "POST /api/account/verify_credentials" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/account/verify_credentials.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	response =
	conn
	\|> with_credentials(user.nickname, "test")
	\|> post("/api/account/verify_credentials.json")
	\|> json_response(200)

	assert response == UserView.render("show.json", %{user: user, token: response["token"]})
	end
	end

	describe "POST /statuses/update.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/statuses/update.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: user} do
	conn_with_creds = conn \|> with_credentials(user.nickname, "test")
	request_path = "/api/statuses/update.json"

	error_response = %{
	"request" => request_path,
	"error" => "Client must provide a 'status' parameter with a value."
	}

	conn =
	conn_with_creds
	\|> post(request_path)

	assert json_response(conn, 400) == error_response

	conn =
	conn_with_creds
	\|> post(request_path, %{status: ""})

	assert json_response(conn, 400) == error_response

	conn =
	conn_with_creds
	\|> post(request_path, %{status: " "})

	assert json_response(conn, 400) == error_response

	# we post with visibility private in order to avoid triggering relay
	conn =
	conn_with_creds
	\|> post(request_path, %{status: "Nice meme.", visibility: "private"})

	assert json_response(conn, 200) ==
	ActivityRepresenter.to_map(Repo.one(Activity), %{user: user})
	end
	end

	describe "GET /statuses/public_timeline.json" do
	setup [:valid_user]

	test "returns statuses", %{conn: conn} do
	user = insert(:user)
	activities = ActivityBuilder.insert_list(30, %{}, %{user: user})
	ActivityBuilder.insert_list(10, %{}, %{user: user})
	since_id = List.last(activities).id

	conn =
	conn
	\|> get("/api/statuses/public_timeline.json", %{since_id: since_id})

	response = json_response(conn, 200)

	assert length(response) == 10
	end

	test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(403)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	test "returns 200 to authenticated request when the instance is not public",
	%{conn: conn, user: user} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> with_credentials(user.nickname, "test")
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(200)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
	conn
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(200)
	end

	test "returns 200 to authenticated request when the instance is public",
	%{conn: conn, user: user} do
	conn
	\|> with_credentials(user.nickname, "test")
	\|> get("/api/statuses/public_timeline.json")
	\|> json_response(200)
	end
	end

	describe "GET /statuses/public_and_external_timeline.json" do
	setup [:valid_user]

	test "returns 403 to unauthenticated request when the instance is not public", %{conn: conn} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(403)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	test "returns 200 to authenticated request when the instance is not public",
	%{conn: conn, user: user} do
	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, false)

	Application.put_env(:pleroma, :instance, instance)

	conn
	\|> with_credentials(user.nickname, "test")
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(200)

	instance =
	Application.get_env(:pleroma, :instance)
	\|> Keyword.put(:public, true)

	Application.put_env(:pleroma, :instance, instance)
	end

	test "returns 200 to unauthenticated request when the instance is public", %{conn: conn} do
	conn
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(200)
	end

	test "returns 200 to authenticated request when the instance is public",
	%{conn: conn, user: user} do
	conn
	\|> with_credentials(user.nickname, "test")
	\|> get("/api/statuses/public_and_external_timeline.json")
	\|> json_response(200)
	end
	end

	describe "GET /statuses/show/:id.json" do
	test "returns one status", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = CommonAPI.post(user, %{"status" => "Hey!"})
	actor = Repo.get_by!(User, ap_id: activity.data["actor"])

	conn =
	conn
	\|> get("/api/statuses/show/#{activity.id}.json")

	response = json_response(conn, 200)

	assert response == ActivityRepresenter.to_map(activity, %{user: actor})
	end
	end

	describe "GET /users/show.json" do
	test "gets user with screen_name", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/users/show.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

	assert response["id"] == user.id
	end

	test "gets user with user_id", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> get("/api/users/show.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert response["id"] == user.id
	end

	test "gets a user for a logged in user", %{conn: conn} do
	user = insert(:user)
	logged_in = insert(:user)

	{:ok, logged_in, user, _activity} = TwitterAPI.follow(logged_in, %{"user_id" => user.id})

	conn =
	conn
	\|> with_credentials(logged_in.nickname, "test")
	\|> get("/api/users/show.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert response["following"] == true
	end
	end

	describe "GET /statusnet/conversation/:id.json" do
	test "returns the statuses in the conversation", %{conn: conn} do
	{:ok, _user} = UserBuilder.insert()
	{: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"})

	conn =
	conn
	\|> get("/api/statusnet/conversation/#{activity.data["context_id"]}.json")

	response = json_response(conn, 200)

	assert length(response) == 2
	end
	end

	describe "GET /statuses/friends_timeline.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/statuses/friends_timeline.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	user = insert(:user)

	activities =
	ActivityBuilder.insert_list(30, %{"to" => [User.ap_followers(user)]}, %{user: user})

	returned_activities =
	ActivityBuilder.insert_list(10, %{"to" => [User.ap_followers(user)]}, %{user: user})

	other_user = insert(:user)
	ActivityBuilder.insert_list(10, %{}, %{user: other_user})
	since_id = List.last(activities).id

	current_user =
	Changeset.change(current_user, following: [User.ap_followers(user)])
	\|> Repo.update!()

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/friends_timeline.json", %{since_id: since_id})

	response = json_response(conn, 200)

	assert length(response) == 10

	assert response ==
	Enum.map(returned_activities, fn activity ->
	ActivityRepresenter.to_map(activity, %{
	user: User.get_cached_by_ap_id(activity.data["actor"]),
	for: current_user
	})
	end)
	end
	end

	describe "GET /statuses/dm_timeline.json" do
	test "it show direct messages", %{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, direct_two} =
	CommonAPI.post(user_two, %{
	"status" => "Hi @#{user_one.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/statuses/dm_timeline.json")

	[status, status_two] = json_response(res_conn, 200)
	assert status["id"] == direct_two.id
	assert status_two["id"] == direct.id
	end
	end

	describe "GET /statuses/mentions.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/statuses/mentions.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: current_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/mentions.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert Enum.at(response, 0) ==
	ActivityRepresenter.to_map(activity, %{
	user: current_user,
	mentioned: [current_user]
	})
	end
	end

	describe "GET /api/qvitter/statuses/notifications.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/qvitter/statuses/notifications.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	other_user = insert(:user)

	{:ok, _activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/statuses/notifications.json")

	response = json_response(conn, 200)

	assert length(response) == 1

	assert response ==
	NotificationView.render("notification.json", %{
	notifications: Notification.for_user(current_user),
	for: current_user
	})
	end
	end

	describe "POST /api/qvitter/statuses/notifications/read" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/qvitter/statuses/notifications/read", %{"latest_id" => 1_234_567})
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials, without any params", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/statuses/notifications/read")

	assert json_response(conn, 400) == %{
	"error" => "You need to specify latest_id",
	"request" => "/api/qvitter/statuses/notifications/read"
	}
	end

	test "with credentials, with params", %{conn: conn, user: current_user} do
	other_user = insert(:user)

	{:ok, _activity} =
	ActivityBuilder.insert(%{"to" => [current_user.ap_id]}, %{user: other_user})

	response_conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/statuses/notifications.json")

	[notification] = response = json_response(response_conn, 200)

	assert length(response) == 1

	assert notification["is_seen"] == 0

	response_conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/statuses/notifications/read", %{"latest_id" => notification["id"]})

	[notification] = response = json_response(response_conn, 200)

	assert length(response) == 1

	assert notification["is_seen"] == 1
	end
	end

	describe "GET /statuses/user_timeline.json" do
	setup [:valid_user]

	test "without any params", %{conn: conn} do
	conn = get(conn, "/api/statuses/user_timeline.json")

	assert json_response(conn, 400) == %{
	"error" => "You need to specify screen_name or user_id",
	"request" => "/api/statuses/user_timeline.json"
	}
	end

	test "with user_id", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn = get(conn, "/api/statuses/user_timeline.json", %{"user_id" => user.id})
	response = json_response(conn, 200)
	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with screen_name", %{conn: conn} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn = get(conn, "/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})
	response = json_response(conn, 200)
	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials", %{conn: conn, user: current_user} do
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: current_user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json")

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: current_user})
	end

	test "with credentials with user_id", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"user_id" => user.id})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials screen_name", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{"screen_name" => user.nickname})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end

	test "with credentials with user_id, excluding RTs", %{conn: conn, user: current_user} do
	user = insert(:user)
	{:ok, activity} = ActivityBuilder.insert(%{"id" => 1, "type" => "Create"}, %{user: user})
	{:ok, _} = ActivityBuilder.insert(%{"id" => 2, "type" => "Announce"}, %{user: user})

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/statuses/user_timeline.json", %{
	"user_id" => user.id,
	"include_rts" => "false"
	})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})

	conn =
	conn
	\|> get("/api/statuses/user_timeline.json", %{"user_id" => user.id, "include_rts" => "0"})

	response = json_response(conn, 200)

	assert length(response) == 1
	assert Enum.at(response, 0) == ActivityRepresenter.to_map(activity, %{user: user})
	end
	end

	describe "POST /friendships/create.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/friendships/create.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	followed = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/friendships/create.json", %{user_id: followed.id})

	current_user = Repo.get(User, current_user.id)
	assert User.ap_followers(followed) in current_user.following

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: followed, for: current_user})
	end
	end

	describe "POST /friendships/destroy.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/friendships/destroy.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	followed = insert(:user)

	{:ok, current_user} = User.follow(current_user, followed)
	assert User.ap_followers(followed) in current_user.following
	ActivityPub.follow(current_user, followed)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/friendships/destroy.json", %{user_id: followed.id})

	current_user = Repo.get(User, current_user.id)
	assert current_user.following == [current_user.ap_id]

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: followed, for: current_user})
	end
	end

	describe "POST /blocks/create.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/blocks/create.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	blocked = insert(:user)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/blocks/create.json", %{user_id: blocked.id})

	current_user = Repo.get(User, current_user.id)
	assert User.blocks?(current_user, blocked)

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: blocked, for: current_user})
	end
	end

	describe "POST /blocks/destroy.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/blocks/destroy.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	blocked = insert(:user)

	{:ok, current_user, blocked} = TwitterAPI.block(current_user, %{"user_id" => blocked.id})
	assert User.blocks?(current_user, blocked)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/blocks/destroy.json", %{user_id: blocked.id})

	current_user = Repo.get(User, current_user.id)
	assert current_user.info.blocks == []

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: blocked, for: current_user})
	end
	end

	describe "GET /help/test.json" do
	test "returns \"ok\"", %{conn: conn} do
	conn = get(conn, "/api/help/test.json")
	assert json_response(conn, 200) == "ok"
	end
	end

	describe "POST /api/qvitter/update_avatar.json" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	conn = post(conn, "/api/qvitter/update_avatar.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	avatar_image = File.read!("test/fixtures/avatar_data_uri")

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/qvitter/update_avatar.json", %{img: avatar_image})

	current_user = Repo.get(User, current_user.id)
	assert is_map(current_user.avatar)

	assert json_response(conn, 200) ==
	UserView.render("show.json", %{user: current_user, for: current_user})
	end
	end

	describe "GET /api/qvitter/mutes.json" do
	setup [:valid_user]

	test "unimplemented mutes without valid credentials", %{conn: conn} do
	conn = get(conn, "/api/qvitter/mutes.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "unimplemented mutes with credentials", %{conn: conn, user: current_user} do
	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> get("/api/qvitter/mutes.json")
	\|> json_response(200)

	assert [] = response
	end
	end

	describe "POST /api/favorites/create/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/favorites/create/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/#{note_activity.id}.json")

	assert json_response(conn, 200)
	end

	test "with credentials, invalid param", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/wrong.json")

	assert json_response(conn, 400)
	end

	test "with credentials, invalid activity", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/create/1.json")

	assert json_response(conn, 500)
	end
	end

	describe "POST /api/favorites/destroy/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/favorites/destroy/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])
	ActivityPub.like(current_user, object)

	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/favorites/destroy/#{note_activity.id}.json")

	assert json_response(conn, 200)
	end
	end

	describe "POST /api/statuses/retweet/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/retweet/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	request_path = "/api/statuses/retweet/#{note_activity.id}.json"

	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	activity = Repo.get(Activity, note_activity.id)
	activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
	end
	end

	describe "POST /api/statuses/unretweet/:id" do
	setup [:valid_user]

	test "without valid credentials", %{conn: conn} do
	note_activity = insert(:note_activity)
	conn = post(conn, "/api/statuses/unretweet/#{note_activity.id}.json")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials", %{conn: conn, user: current_user} do
	note_activity = insert(:note_activity)

	request_path = "/api/statuses/retweet/#{note_activity.id}.json"

	_response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	request_path = String.replace(request_path, "retweet", "unretweet")

	response =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post(request_path)

	activity = Repo.get(Activity, note_activity.id)
	activity_user = Repo.get_by(User, ap_id: note_activity.data["actor"])

	assert json_response(response, 200) ==
	ActivityRepresenter.to_map(activity, %{user: activity_user, for: current_user})
	end
	end

	describe "POST /api/account/register" do
	test "it creates a new user", %{conn: conn} do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	conn =
	conn
	\|> post("/api/account/register", data)

	user = json_response(conn, 200)

	fetched_user = Repo.get_by(User, nickname: "lain")
	assert user == UserView.render("show.json", %{user: fetched_user})
	end

	test "it returns errors on a problem", %{conn: conn} do
	data = %{
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear",
	"confirm" => "bear"
	}

	conn =
	conn
	\|> post("/api/account/register", data)

	errors = json_response(conn, 400)

	assert is_binary(errors["error"])
	end
	end

	describe "POST /api/account/password_reset, with valid parameters" do
	setup %{conn: conn} do
	user = insert(:user)
	conn = post(conn, "/api/account/password_reset?email=#{user.email}")
	%{conn: conn, user: user}
	end

	test "it returns 204", %{conn: conn} do
	assert json_response(conn, :no_content)
	end

	test "it creates a PasswordResetToken record for user", %{user: user} do
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)
	assert token_record
	end

	test "it sends an email to user", %{user: user} do
	token_record = Repo.get_by(Pleroma.PasswordResetToken, user_id: user.id)

	Swoosh.TestAssertions.assert_email_sent(
	Pleroma.UserEmail.password_reset_email(user, token_record.token)
	)
	end
	end

	describe "POST /api/account/password_reset, with invalid parameters" do
	setup [:valid_user]

	test "it returns 500 when user is not found", %{conn: conn, user: user} do
	conn = post(conn, "/api/account/password_reset?email=nonexisting_#{user.email}")
	assert json_response(conn, :internal_server_error)
	end

	test "it returns 500 when user is not local", %{conn: conn, user: user} do
	{:ok, user} = Repo.update(Changeset.change(user, local: false))
	conn = post(conn, "/api/account/password_reset?email=#{user.email}")
	assert json_response(conn, :internal_server_error)
	end
	end

	describe "GET /api/account/confirm_email/:id/:token" do
	setup do
	user = insert(:user)
	info_change = User.Info.confirmation_changeset(user.info, :unconfirmed)

	{:ok, user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> Repo.update()

	assert user.info.confirmation_pending

	[user: user]
	end

	test "it redirects to root url", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")

	assert 302 == conn.status
	end

	test "it confirms the user account", %{conn: conn, user: user} do
	get(conn, "/api/account/confirm_email/#{user.id}/#{user.info.confirmation_token}")

	user = Repo.get(User, user.id)

	refute user.info.confirmation_pending
	refute user.info.confirmation_token
	end

	test "it returns 500 if user cannot be found by id", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/0/#{user.info.confirmation_token}")

	assert 500 == conn.status
	end

	test "it returns 500 if token is invalid", %{conn: conn, user: user} do
	conn = get(conn, "/api/account/confirm_email/#{user.id}/wrong_token")

	assert 500 == conn.status
	end
	end

	describe "POST /api/account/resend_confirmation_email" do
	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

	user = insert(:user)
	info_change = User.Info.confirmation_changeset(user.info, :unconfirmed)

	{:ok, user} =
	user
	\|> Changeset.change()
	\|> Changeset.put_embed(:info, info_change)
	\|> Repo.update()

	assert user.info.confirmation_pending

	[user: user]
	end

	test "it returns 204 No Content", %{conn: conn, user: user} do
	conn
	\|> assign(:user, user)
	\|> post("/api/account/resend_confirmation_email?email=#{user.email}")
	\|> json_response(:no_content)
	end

	test "it sends confirmation email", %{conn: conn, user: user} do
	conn
	\|> assign(:user, user)
	\|> post("/api/account/resend_confirmation_email?email=#{user.email}")

	Swoosh.TestAssertions.assert_email_sent(Pleroma.UserEmail.account_confirmation_email(user))
	end
	end

	describe "GET /api/externalprofile/show" do
	test "it returns the user", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/externalprofile/show", %{profileurl: other_user.ap_id})

	assert json_response(conn, 200) == UserView.render("show.json", %{user: other_user})
	end
	end

	describe "GET /api/statuses/followers" do
	test "it returns a user's followers", %{conn: conn} 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)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/followers")

	expected = UserView.render("index.json", %{users: [follower_one, follower_two], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end

	test "it returns a given user's followers with user_id", %{conn: conn} 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)

	conn =
	conn
	\|> assign(:user, not_follower)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{
	users: [follower_one, follower_two],
	for: not_follower
	})
	)
	)
	end

	test "it returns empty for a hidden network", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: true}})
	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)

	response =
	conn
	\|> assign(:user, not_follower)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})
	\|> json_response(200)

	assert [] == response
	end

	test "it returns the followers for a hidden network if requested by the user themselves", %{
	conn: conn
	} do
	user = insert(:user, %{info: %{hide_network: true}})
	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)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/followers", %{"user_id" => user.id})

	refute [] == json_response(conn, 200)
	end
	end

	describe "GET /api/statuses/blocks" do
	test "it returns the list of users blocked by requester", %{conn: conn} do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, user} = User.block(user, other_user)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/blocks")

	expected = UserView.render("index.json", %{users: [other_user], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end
	end

	describe "GET /api/statuses/friends" do
	test "it returns the logged in user's friends", %{conn: conn} 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)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends")

	expected = UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	result = json_response(conn, 200)
	assert Enum.sort(expected) == Enum.sort(result)
	end

	test "it returns a given user's friends with user_id", %{conn: conn} 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)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	)
	)
	end

	test "it returns empty for a hidden network", %{conn: conn} do
	user = insert(:user, %{info: %{hide_network: true}})
	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)

	conn =
	conn
	\|> assign(:user, not_followed)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})

	assert [] == json_response(conn, 200)
	end

	test "it returns friends for a hidden network if the user themselves request it", %{
	conn: conn
	} do
	user = insert(:user, %{info: %{hide_network: true}})
	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)

	response =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"user_id" => user.id})
	\|> json_response(200)

	refute [] == response
	end

	test "it returns a given user's friends with screen_name", %{conn: conn} 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)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/statuses/friends", %{"screen_name" => user.nickname})

	assert MapSet.equal?(
	MapSet.new(json_response(conn, 200)),
	MapSet.new(
	UserView.render("index.json", %{users: [followed_one, followed_two], for: user})
	)
	)
	end
	end

	describe "GET /friends/ids" do
	test "it returns a user's friends", %{conn: conn} 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)

	conn =
	conn
	\|> assign(:user, user)
	\|> get("/api/friends/ids")

	expected = [followed_one.id, followed_two.id]

	assert MapSet.equal?(
	MapSet.new(Poison.decode!(json_response(conn, 200))),
	MapSet.new(expected)
	)
	end
	end

	describe "POST /api/account/update_profile.json" do
	test "it updates a user's profile", %{conn: conn} do
	user = insert(:user)
	user2 = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"name" => "new name",
	"description" => "hi @#{user2.nickname}"
	})

	user = Repo.get!(User, user.id)
	assert user.name == "new name"

	assert user.bio ==
	"hi <span><a data-user='#{user2.id}' class='mention' href='#{user2.ap_id}'>@<span>#{
	user2.nickname
	}</span></a></span>"

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it sets and un-sets hide_network", %{conn: conn} do
	user = insert(:user)

	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"hide_network" => "true"
	})

	user = Repo.get!(User, user.id)
	assert user.info.hide_network == true

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"hide_network" => "false"
	})

	user = Repo.get!(User, user.id)
	assert user.info.hide_network == false
	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it locks an account", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"locked" => "true"
	})

	user = Repo.get!(User, user.id)
	assert user.info.locked == true

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end

	test "it unlocks an account", %{conn: conn} do
	user = insert(:user)

	conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"locked" => "false"
	})

	user = Repo.get!(User, user.id)
	assert user.info.locked == false

	assert json_response(conn, 200) == UserView.render("user.json", %{user: user, for: user})
	end
	end

	defp valid_user(_context) do
	user = insert(:user)
	[user: user]
	end

	defp with_credentials(conn, username, password) do
	header_content = "Basic " <> Base.encode64("#{username}:#{password}")
	put_req_header(conn, "authorization", header_content)
	end

	describe "GET /api/search.json" do
	test "it returns search results", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about 2hu"})
	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/search.json", %{"q" => "2hu", "page" => "1", "rpp" => "1"})

	assert [status] = json_response(conn, 200)
	assert status["id"] == activity.id
	end
	end

	describe "GET /api/statusnet/tags/timeline/:tag.json" do
	test "it returns the tags timeline", %{conn: conn} do
	user = insert(:user)
	user_two = insert(:user, %{nickname: "shp@shitposter.club"})

	{:ok, activity} = CommonAPI.post(user, %{"status" => "This is about #2hu"})
	{:ok, _} = CommonAPI.post(user_two, %{"status" => "This isn't"})

	conn =
	conn
	\|> get("/api/statusnet/tags/timeline/2hu.json")

	assert [status] = json_response(conn, 200)
	assert status["id"] == activity.id
	end
	end

	test "Convert newlines to <br> in bio", %{conn: conn} do
	user = insert(:user)

	_conn =
	conn
	\|> assign(:user, user)
	\|> post("/api/account/update_profile.json", %{
	"description" => "Hello,\r\nWorld! I\n am a test."
	})

	user = Repo.get!(User, user.id)
	assert user.bio == "Hello,<br>World! I<br> am a test."
	end

	describe "POST /api/pleroma/change_password" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/change_password")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "hi",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials, valid password and new password and confirmation not matching", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "notnewpass"
	})

	assert json_response(conn, 200) == %{
	"error" => "New password does not match confirmation."
	}
	end

	test "with credentials, valid password and invalid new password", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "",
	"new_password_confirmation" => ""
	})

	assert json_response(conn, 200) == %{
	"error" => "New password can't be blank."
	}
	end

	test "with credentials, valid password and matching new password and confirmation", %{
	conn: conn,
	user: current_user
	} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/change_password", %{
	"password" => "test",
	"new_password" => "newpass",
	"new_password_confirmation" => "newpass"
	})

	assert json_response(conn, 200) == %{"status" => "success"}
	fetched_user = Repo.get(User, current_user.id)
	assert Pbkdf2.checkpw("newpass", fetched_user.password_hash) == true
	end
	end

	describe "POST /api/pleroma/delete_account" do
	setup [:valid_user]

	test "without credentials", %{conn: conn} do
	conn = post(conn, "/api/pleroma/delete_account")
	assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	end

	test "with credentials and invalid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "hi"})

	assert json_response(conn, 200) == %{"error" => "Invalid password."}
	end

	test "with credentials and valid password", %{conn: conn, user: current_user} do
	conn =
	conn
	\|> with_credentials(current_user.nickname, "test")
	\|> post("/api/pleroma/delete_account", %{"password" => "test"})

	assert json_response(conn, 200) == %{"status" => "success"}
	# Wait a second for the started task to end
	:timer.sleep(1000)
	end
	end

	describe "GET /api/pleroma/friend_requests" do
	test "it lists friend requests" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

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

	assert [relationship] = json_response(conn, 200)
	assert other_user.id == relationship["id"]
	end
	end

	describe "POST /api/pleroma/friendships/approve" do
	test "it approves a friend request" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/pleroma/friendships/approve", %{"user_id" => to_string(other_user.id)})

	assert relationship = json_response(conn, 200)
	assert other_user.id == relationship["id"]
	assert relationship["follows_you"] == true
	end
	end

	describe "POST /api/pleroma/friendships/deny" do
	test "it denies a friend request" do
	user = insert(:user)
	other_user = insert(:user)

	{:ok, _activity} = ActivityPub.follow(other_user, user)

	user = Repo.get(User, user.id)
	other_user = Repo.get(User, other_user.id)

	assert User.following?(other_user, user) == false

	conn =
	build_conn()
	\|> assign(:user, user)
	\|> post("/api/pleroma/friendships/deny", %{"user_id" => to_string(other_user.id)})

	assert relationship = json_response(conn, 200)
	assert other_user.id == relationship["id"]
	assert relationship["follows_you"] == false
	end
	end

	describe "GET /api/pleroma/search_user" do
	test "it returns users, ordered by similarity", %{conn: conn} do
	user = insert(:user, %{name: "eal"})
	user_two = insert(:user, %{name: "ean"})
	user_three = insert(:user, %{name: "ebn"})

	resp =
	conn
	\|> get(twitter_api_search__path(conn, :search_user), query: "eal")
	\|> json_response(200)

	assert length(resp) == 3
	assert [user.id, user_two.id, user_three.id] == Enum.map(resp, fn %{"id" => id} -> id end)
	end
	end

	describe "POST /api/media/upload" do
	setup context do
	Pleroma.DataCase.ensure_local_uploader(context)
	end

	test "it performs the upload and sets `data[actor]` with AP id of uploader user", %{
	conn: conn
	} do
	user = insert(:user)

	upload_filename = "test/fixtures/image_tmp.jpg"
	File.cp!("test/fixtures/image.jpg", upload_filename)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname(upload_filename),
	filename: "image.jpg"
	}

	response =
	conn
	\|> assign(:user, user)
	\|> put_req_header("content-type", "application/octet-stream")
	\|> post("/api/media/upload", %{
	"media" => file
	})
	\|> json_response(:ok)

	assert response["media_id"]
	object = Repo.get(Object, response["media_id"])
	assert object
	assert object.data["actor"] == User.ap_id(user)
	end
	end

	describe "POST /api/media/metadata/create" do
	setup do
	object = insert(:note)
	user = User.get_by_ap_id(object.data["actor"])
	%{object: object, user: user}
	end

	test "it returns :forbidden status on attempt to modify someone else's upload", %{
	conn: conn,
	object: object
	} do
	initial_description = object.data["name"]
	another_user = insert(:user)

	conn
	\|> assign(:user, another_user)
	\|> post("/api/media/metadata/create", %{"media_id" => object.id})
	\|> json_response(:forbidden)

	object = Repo.get(Object, object.id)
	assert object.data["name"] == initial_description
	end

	test "it updates `data[name]` of referenced Object with provided value", %{
	conn: conn,
	object: object,
	user: user
	} do
	description = "Informative description of the image. Initial value: #{object.data["name"]}}"

	conn
	\|> assign(:user, user)
	\|> post("/api/media/metadata/create", %{
	"media_id" => object.id,
	"alt_text" => %{"text" => description}
	})
	\|> json_response(:no_content)

	object = Repo.get(Object, object.id)
	assert object.data["name"] == description
	end
	end
	+
	+ describe "POST /api/statuses/user_timeline.json?user_id=:user_id&pinned=true" do
	+ test "it returns a list of pinned statuses", %{conn: conn} do
	+ Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
	+
	+ user = insert(:user, %{name: "egor"})
	+ {:ok, %{id: activity_id}} = CommonAPI.post(user, %{"status" => "HI!!!"})
	+ {:ok, _} = CommonAPI.pin(activity_id, user)
	+
	+ resp =
	+ conn
	+ \|> get("/api/statuses/user_timeline.json", %{user_id: user.id, pinned: true})
	+ \|> json_response(200)
	+
	+ assert length(resp) == 1
	+ assert [%{"id" => ^activity_id, "pinned" => true}] = resp
	+ end
	+ end
	+
	+ describe "POST /api/statuses/pin/:id" do
	+ setup do
	+ Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
	+ [user: insert(:user)]
	+ end
	+
	+ test "without valid credentials", %{conn: conn} do
	+ note_activity = insert(:note_activity)
	+ conn = post(conn, "/api/statuses/pin/#{note_activity.id}.json")
	+ assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	+ end
	+
	+ test "with credentials", %{conn: conn, user: user} do
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "test!"})
	+
	+ request_path = "/api/statuses/pin/#{activity.id}.json"
	+
	+ response =
	+ conn
	+ \|> with_credentials(user.nickname, "test")
	+ \|> post(request_path)
	+
	+ user = refresh_record(user)
	+
	+ assert json_response(response, 200) == ActivityRepresenter.to_map(activity, %{user: user})
	+ end
	+ end
	+
	+ describe "POST /api/statuses/unpin/:id" do
	+ setup do
	+ Pleroma.Config.put([:instance, :max_pinned_statuses], 1)
	+ [user: insert(:user)]
	+ end
	+
	+ test "without valid credentials", %{conn: conn} do
	+ note_activity = insert(:note_activity)
	+ conn = post(conn, "/api/statuses/unpin/#{note_activity.id}.json")
	+ assert json_response(conn, 403) == %{"error" => "Invalid credentials."}
	+ end
	+
	+ test "with credentials", %{conn: conn, user: user} do
	+ {:ok, activity} = CommonAPI.post(user, %{"status" => "test!"})
	+ {:ok, activity} = CommonAPI.pin(activity.id, user)
	+
	+ request_path = "/api/statuses/unpin/#{activity.id}.json"
	+
	+ response =
	+ conn
	+ \|> with_credentials(user.nickname, "test")
	+ \|> post(request_path)
	+
	+ user = refresh_record(user)
	+
	+ assert json_response(response, 200) == ActivityRepresenter.to_map(activity, %{user: user})
	+ 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 5294204c6..8b5a16add 100644
	--- a/test/web/twitter_api/views/activity_view_test.exs
	+++ b/test/web/twitter_api/views/activity_view_test.exs
	@@ -1,351 +1,352 @@
	# Pleroma: A lightweight social networking server
	-# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	+# 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.Web.CommonAPI
	alias Pleroma.Web.CommonAPI.Utils
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.UserView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Repo
	alias Pleroma.Activity
	alias Pleroma.User
	alias Pleroma.Web.ActivityPub.ActivityPub

	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 "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 data-tag=\"bike\" href=\"http://localhost:4001/tag/bike\">#Bike</a> log - Commute Tuesday<br /><a href=\"https://pla.bike/posts/20181211/\">https://pla.bike/posts/20181211/</a><br /><a data-tag=\"cycling\" href=\"http://localhost:4001/tag/cycling\">#cycling</a> <a data-tag=\"chscycling\" href=\"http://localhost:4001/tag/chscycling\">#CHScycling</a> <a data-tag=\"commute\" href=\"http://localhost:4001/tag/commute\">#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",
	"status" => "."
	})

	result = ActivityView.render("activity.json", activity: activity)

	expected = ":woollysocks: meow"

	expected_html =
	"<img height=\"32px\" width=\"32px\" alt=\"woollysocks\" title=\"woollysocks\" src=\"http://localhost:4001/finmoji/128px/woollysocks-128.png\" /> 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"})

	result = ActivityView.render("activity.json", activity: activity)

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["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"],
	"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><a data-user=\"#{other_user.id}\" href=\"#{other_user.ap_id}\">@<span>shp</span></a></span>!",
	"tags" => [],
	"text" => "Hey @shp!",
	"uri" => activity.data["object"]["id"],
	"user" => UserView.render("show.json", %{user: user}),
	"visibility" => "direct"
	}

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

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["context"])

	mocks = [
	{
	TwitterAPI,
	[],
	[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(TwitterAPI.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)

	convo_id = TwitterAPI.context_to_conversation_id(activity.data["object"]["context"])

	activity = Repo.get(Activity, 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(
	"https://peertube.moe/videos/watch/df5f464b-be8d-46fb-ad81-2d4c2d1630e3"
	)

	%Activity{} = activity = Activity.get_create_activity_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: Sun, Nov 1, 3:01 PM (13 h, 32 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803121
Default Alt Text: (333 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions