No OneTemporary
Actions

Authored By

Unknown

Size

55 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/config/config.exs b/config/config.exs
	index ad4b79f54..5477c0c0e 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,209 +1,207 @@
	# 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

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

	# Configures the endpoint
	config :pleroma, Pleroma.Web.Endpoint,
	url: [host: "localhost"],
	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 :mime, :types, %{
	"application/xml" => ["xml"],
	"application/xrd+xml" => ["xrd+xml"],
	"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: 5000,
	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,
	allowed_post_formats: [
	"text/plain",
	"text/html",
	"text/markdown"
	],
	finmoji_enabled: true,
	mrf_transparency: true

	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_simple,
	media_removal: [],
	media_nsfw: [],
	federated_timeline_removal: [],
	reject: [],
	accept: []

	config :pleroma, :media_proxy,
	enabled: false,
	# base_url: "https://cache.pleroma.social",
	proxy_opts: [
	# inline_content_types: [] \| false \| true,
	# http: [:insecure]
	]

	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, :metadata,
	- oembed: false,
	- opengraph: true
	+config :pleroma, :metadata, opengraph: true

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

	# Import environment specific config. This must remain at the bottom
	# of this file so it overrides the configuration defined above.
	import_config "#{Mix.env()}.exs"
	diff --git a/lib/pleroma/formatter.ex b/lib/pleroma/formatter.ex
	index b63f592fb..1d5dc0c99 100644
	--- a/lib/pleroma/formatter.ex
	+++ b/lib/pleroma/formatter.ex
	@@ -1,182 +1,184 @@
	defmodule Pleroma.Formatter do
	alias Pleroma.User
	alias Pleroma.Web.MediaProxy
	alias Pleroma.HTML
	alias Pleroma.Emoji

	@tag_regex ~r/\#\w+/u
	def parse_tags(text, data \\ %{}) do
	Regex.scan(@tag_regex, text)
	\|> Enum.map(fn ["#" <> tag = full_tag] -> {full_tag, String.downcase(tag)} end)
	\|> (fn map ->
	if data["sensitive"] in [true, "True", "true", "1"],
	do: [{"#nsfw", "nsfw"}] ++ map,
	else: map
	end).()
	end

	def parse_mentions(text) do
	# Modified from https://www.w3.org/TR/html5/forms.html#valid-e-mail-address
	regex =
	~r/@[a-zA-Z0-9.!#$%&'+\/=?^_`{\|}~-]@?[a-zA-Z0-9_-](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*/u

	Regex.scan(regex, text)
	\|> List.flatten()
	\|> Enum.uniq()
	\|> Enum.map(fn "@" <> match = full_match ->
	{full_match, User.get_cached_by_nickname(match)}
	end)
	\|> Enum.filter(fn {_match, user} -> user end)
	end

	def emojify(text) do
	emojify(text, Emoji.get_all())
	end

	def emojify(text, nil), do: text

	def emojify(text, emoji) do
	Enum.reduce(emoji, text, fn {emoji, file}, text ->
	emoji = HTML.strip_tags(emoji)
	file = HTML.strip_tags(file)

	String.replace(
	text,
	":#{emoji}:",
	"<img height='32px' width='32px' alt='#{emoji}' title='#{emoji}' src='#{
	MediaProxy.url(file)
	}' />"
	)
	\|> HTML.filter_tags()
	end)
	end

	def get_emoji(text) when is_binary(text) do
	Enum.filter(Emoji.get_all(), fn {emoji, _} -> String.contains?(text, ":#{emoji}:") end)
	end

	def get_emoji(_), do: []

	@link_regex ~r/[0-9a-z+\-\.]+:[0-9a-z$-_.+!*'(),]+/ui

	@uri_schemes Application.get_env(:pleroma, :uri_schemes, [])
	@valid_schemes Keyword.get(@uri_schemes, :valid_schemes, [])

	# TODO: make it use something other than @link_regex
	def html_escape(text, "text/html") do
	HTML.filter_tags(text)
	end

	def html_escape(text, "text/plain") do
	Regex.split(@link_regex, text, include_captures: true)
	\|> Enum.map_every(2, fn chunk ->
	{:safe, part} = Phoenix.HTML.html_escape(chunk)
	part
	end)
	\|> Enum.join("")
	end

	@doc "changes scheme:... urls to html links"
	def add_links({subs, text}) do
	links =
	text
	\|> String.split([" ", "\t", "<br>"])
	\|> Enum.filter(fn word -> String.starts_with?(word, @valid_schemes) end)
	\|> Enum.filter(fn word -> Regex.match?(@link_regex, word) end)
	\|> Enum.map(fn url -> {Ecto.UUID.generate(), url} end)
	\|> Enum.sort_by(fn {_, url} -> -String.length(url) end)

	uuid_text =
	links
	\|> Enum.reduce(text, fn {uuid, url}, acc -> String.replace(acc, url, uuid) end)

	subs =
	subs ++
	Enum.map(links, fn {uuid, url} ->
	{uuid, "<a href=\"#{url}\">#{url}</a>"}
	end)

	{subs, uuid_text}
	end

	@doc "Adds the links to mentioned users"
	def add_user_links({subs, text}, mentions) do
	mentions =
	mentions
	\|> Enum.sort_by(fn {name, _} -> -String.length(name) end)
	\|> Enum.map(fn {name, user} -> {name, user, Ecto.UUID.generate()} end)

	uuid_text =
	mentions
	\|> Enum.reduce(text, fn {match, _user, uuid}, text ->
	String.replace(text, match, uuid)
	end)

	subs =
	subs ++
	Enum.map(mentions, fn {match, %User{id: id, ap_id: ap_id, info: info}, uuid} ->
	ap_id =
	if is_binary(info.source_data["url"]) do
	info.source_data["url"]
	else
	ap_id
	end

	short_match = String.split(match, "@") \|> tl() \|> hd()

	{uuid,
	"<span><a data-user='#{id}' class='mention' href='#{ap_id}'>@<span>#{short_match}</span></a></span>"}
	end)

	{subs, uuid_text}
	end

	@doc "Adds the hashtag links"
	def add_hashtag_links({subs, text}, tags) do
	tags =
	tags
	\|> Enum.sort_by(fn {name, _} -> -String.length(name) end)
	\|> Enum.map(fn {name, short} -> {name, short, Ecto.UUID.generate()} end)

	uuid_text =
	tags
	\|> Enum.reduce(text, fn {match, _short, uuid}, text ->
	String.replace(text, match, uuid)
	end)

	subs =
	subs ++
	Enum.map(tags, fn {tag_text, tag, uuid} ->
	url =
	"<a data-tag='#{tag}' href='#{Pleroma.Web.base_url()}/tag/#{tag}' rel='tag'>#{
	tag_text
	}</a>"

	{uuid, url}
	end)

	{subs, uuid_text}
	end

	def finalize({subs, text}) do
	Enum.reduce(subs, text, fn {uuid, replacement}, result_text ->
	String.replace(result_text, uuid, replacement)
	end)
	end

	def truncate(text, opts \\ []) do
	- max_length = opts[:max_length] \|\| 200
	- omission = opts[:omission] \|\| "..."
	+ max_length = opts[:max_length] \|\| 200
	+ omission = opts[:omission] \|\| "..."

	cond do
	not String.valid?(text) ->
	text
	+
	String.length(text) < max_length ->
	text
	+
	true ->
	length_with_omission = max_length - String.length(omission)

	"#{String.slice(text, 0, length_with_omission)}#{omission}"
	end
	end
	end
	diff --git a/lib/pleroma/web/oembed/activity_representer.ex b/lib/pleroma/web/oembed/activity_representer.ex
	deleted file mode 100644
	index 0e65090ee..000000000
	--- a/lib/pleroma/web/oembed/activity_representer.ex
	+++ /dev/null
	@@ -1,25 +0,0 @@
	-defmodule Pleroma.Web.OEmbed.ActivityRepresenter do
	- alias Pleroma.{Activity, User, Object}
	- alias Pleroma.Web.OStatus.UserRepresenter
	-
	- def to_simple_form(%{data: %{"object" => %{"type" => "Note"}}} = activity, user, with_author) do
	- h = fn str -> [to_charlist(str)] end
	-
	- content = if activity.data["object"]["content"] do
	- [{:content, [], h.(activity.data["object"]["content"])}]
	- else
	- []
	- end
	-
	- [
	- {:version, ["1.0"]},
	- {:type, ["link"]},
	- ] ++ content
	-
	- end
	-
	- def wrap_with_entry(simple_form) do
	- [ { :oembed, [], simple_form } ]
	- end
	-
	-end
	diff --git a/lib/pleroma/web/oembed/oembed.ex b/lib/pleroma/web/oembed/oembed.ex
	deleted file mode 100644
	index a52aa6004..000000000
	--- a/lib/pleroma/web/oembed/oembed.ex
	+++ /dev/null
	@@ -1,23 +0,0 @@
	-defmodule Pleroma.Web.OEmbed do
	- alias Pleroma.{Repo, Object, Activity, User}
	- alias Pleroma.Formatter
	-
	- def recognize_path(url) do
	- details = Regex.named_captures(~r/.+\/(?<route>.+)\/(?<id>\w+).*$/, url)
	-
	- case details do
	- %{ "route" => "notice", "id" => id } ->
	- %{type: :activity, entity: Repo.get(Activity, id) }
	- %{ "route" => "users", "id" => nickname } ->
	- %{type: :user, entity: User.get_by_nickname(nickname) }
	- _ ->
	- { :error, "no matching route"}
	- end
	- end
	-
	- def truncated_content(activity) do
	- content = activity.data['object']['content']
	- IO.puts(content)
	- Formatter.truncate(content)
	- end
	-end
	diff --git a/lib/pleroma/web/oembed/oembed_controller.ex b/lib/pleroma/web/oembed/oembed_controller.ex
	deleted file mode 100644
	index d63d3c58c..000000000
	--- a/lib/pleroma/web/oembed/oembed_controller.ex
	+++ /dev/null
	@@ -1,31 +0,0 @@
	-defmodule Pleroma.Web.OEmbed.OEmbedController do
	- use Pleroma.Web, :controller
	-
	- alias Pleroma.Web.OEmbed
	- alias Pleroma.Web.OEmbed.{NoteView, ActivityRepresenter}
	- alias Pleroma.Web.MediaProxy
	- alias Pleroma.Repo
	- alias Pleroma.User
	-
	- def url(conn, %{ "url" => url} ) do
	- case format = get_format(conn) do
	- _ ->
	- result = OEmbed.recognize_path(url)
	- render_oembed(conn, format, result)
	- end
	- end
	-
	- def render_oembed(conn, format \\ "json", result)
	- def render_oembed(conn, "json", result) do
	- conn
	- \|> put_resp_content_type("application/json")
	- \|> json(NoteView.render("note.json", result))
	- end
	-
	- def render_oembed(conn, "xml", result) do
	- conn
	- \|> put_resp_content_type("application/xml")
	- \|> NoteView.render("note.json", result)
	-
	- end
	-end
	diff --git a/lib/pleroma/web/oembed/views/note_view.ex b/lib/pleroma/web/oembed/views/note_view.ex
	deleted file mode 100644
	index ecdabc04b..000000000
	--- a/lib/pleroma/web/oembed/views/note_view.ex
	+++ /dev/null
	@@ -1,21 +0,0 @@
	-defmodule Pleroma.Web.OEmbed.NoteView do
	- use Pleroma.Web, :view
	- alias Pleroma.{User, Activity}
	- alias Pleroma.Web.OEmbed
	-
	- def render("note.json", %{type: type, entity: activity }) do
	- oembed_data(activity)
	- end
	-
	- def oembed_data(activity) do
	- with %User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]),
	- image = User.avatar_url(user) \|> MediaProxy.url() do
	- %{
	- version: "1.0",
	- type: "link",
	- title: OEmbed.truncated_content(activity),
	- provider_url: "https://pleroma.site",
	- thumbnail_url: image,
	- }
	- end
	-end
	diff --git a/lib/pleroma/web/ostatus/metadata.ex b/lib/pleroma/web/ostatus/metadata.ex
	index 4f319b360..792b4a4bd 100644
	--- a/lib/pleroma/web/ostatus/metadata.ex
	+++ b/lib/pleroma/web/ostatus/metadata.ex
	@@ -1,92 +1,75 @@
	defmodule Pleroma.Web.Metadata do
	alias Phoenix.HTML
	- alias Pleroma.{Web, Formatter}
	- alias Pleroma.{User, Activity}
	+ alias Pleroma.{Formatter, User}
	alias Pleroma.Web.MediaProxy

	- def build_tags(request_url, params) do
	- Enum.concat([
	- if(meta_enabled?(:opengraph), do: opengraph_tags(params), else: []),
	- if(meta_enabled?(:oembed), do: oembed_links(request_url), else: [])
	- ])
	+ def build_tags(params) do
	+ if(meta_enabled?(:opengraph), do: opengraph_tags(params), else: [])
	\|> Enum.map(&to_tag/1)
	\|> Enum.map(&HTML.safe_to_string/1)
	\|> Enum.join("\n")
	end

	def meta_enabled?(type) do
	config = Pleroma.Config.get(:metadata, [])
	Keyword.get(config, type, false)
	end

	# opengraph for single status
	defp opengraph_tags(%{activity: activity, user: user}) do
	with truncated_content = Formatter.truncate(activity.data["object"]["content"]) do
	[
	{:meta,
	- [
	- property: "og:title",
	- content: "#{user.name} (@#{user.nickname}@#{pleroma_domain()}) post ##{activity.id}"
	- ], []},
	+ [
	+ property: "og:title",
	+ content: "#{user.name} (@#{user.nickname}@#{pleroma_domain()}) post ##{activity.id}"
	+ ], []},
	{:meta, [property: "og:url", content: activity.data["id"]], []},
	- {:meta, [property: "og:description", content: truncated_content],
	- []},
	+ {:meta, [property: "og:description", content: truncated_content], []},
	{:meta, [property: "og:image", content: user_avatar_url(user)], []},
	{:meta, [property: "og:image:width", content: 120], []},
	{:meta, [property: "og:image:height", content: 120], []},
	{:meta, [property: "twitter:card", content: "summary"], []}
	]
	end
	end

	# opengraph for user card
	defp opengraph_tags(%{user: user}) do
	with truncated_bio = Formatter.truncate(user.bio) do
	[
	{:meta,
	- [
	- property: "og:title",
	- content: "#{user.name} (@#{user.nickname}@#{pleroma_domain()}) profile"
	- ], []},
	+ [
	+ property: "og:title",
	+ content: "#{user.name} (@#{user.nickname}@#{pleroma_domain()}) profile"
	+ ], []},
	{:meta, [property: "og:url", content: User.profile_url(user)], []},
	{:meta, [property: "og:description", content: truncated_bio], []},
	{:meta, [property: "og:image", content: user_avatar_url(user)], []},
	{:meta, [property: "og:image:width", content: 120], []},
	{:meta, [property: "og:image:height", content: 120], []},
	{:meta, [property: "twitter:card", content: "summary"], []}
	]
	end
	end

	- defp oembed_links(url) do
	- Enum.map(["xml", "json"], fn format ->
	- href = HTML.raw(oembed_path(url, format))
	- { :link, [ type: ["application/#{format}+oembed"], href: href, rel: 'alternate'], [] }
	- end)
	- end
	-
	def to_tag(data) do
	with {name, attrs, _content = []} <- data do
	HTML.Tag.tag(name, attrs)
	else
	{name, attrs, content} ->
	HTML.Tag.content_tag(name, content, attrs)

	_ ->
	raise ArgumentError, message: "make_tag invalid args"
	end
	end

	- defp oembed_path(url, format) do
	- query = URI.encode_query(%{url: url, format: format})
	- "#{Web.base_url()}/oembed?#{query}"
	- end
	-
	defp user_avatar_url(user) do
	User.avatar_url(user) \|> MediaProxy.url()
	end

	def pleroma_domain do
	Pleroma.Config.get([:instance, :domain], "UNKNOWN_DOMAIN")
	end
	-end
	\ No newline at end of file
	+end
	diff --git a/lib/pleroma/web/ostatus/ostatus.ex b/lib/pleroma/web/ostatus/ostatus.ex
	index ba44b2e99..c6440c20e 100644
	--- a/lib/pleroma/web/ostatus/ostatus.ex
	+++ b/lib/pleroma/web/ostatus/ostatus.ex
	@@ -1,388 +1,388 @@
	defmodule Pleroma.Web.OStatus do
	@httpoison Application.get_env(:pleroma, :httpoison)

	import Ecto.Query
	import Pleroma.Web.XML
	require Logger

	- alias Pleroma.{Repo, User, Web, Object, Activity, Formatter}
	+ alias Pleroma.{Repo, User, Web, Object, Activity}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.{WebFinger, Websub}
	alias Pleroma.Web.OStatus.{FollowHandler, UnfollowHandler, NoteHandler, DeleteHandler}
	alias Pleroma.Web.ActivityPub.Transmogrifier

	def is_representable?(%Activity{data: data}) do
	object = Object.normalize(data["object"])

	cond do
	is_nil(object) ->
	false

	object.data["type"] == "Note" ->
	true

	true ->
	false
	end
	end

	def feed_path(user) do
	"#{user.ap_id}/feed.atom"
	end

	def pubsub_path(user) do
	"#{Web.base_url()}/push/hub/#{user.nickname}"
	end

	def salmon_path(user) do
	"#{user.ap_id}/salmon"
	end

	def remote_follow_path do
	"#{Web.base_url()}/ostatus_subscribe?acct={uri}"
	end

	def handle_incoming(xml_string) do
	with doc when doc != :error <- parse_document(xml_string) do
	entries = :xmerl_xpath.string('//entry', doc)

	activities =
	Enum.map(entries, fn entry ->
	{:xmlObj, :string, object_type} =
	:xmerl_xpath.string('string(/entry/activity:object-type[1])', entry)

	{:xmlObj, :string, verb} = :xmerl_xpath.string('string(/entry/activity:verb[1])', entry)
	Logger.debug("Handling #{verb}")

	try do
	case verb do
	'http://activitystrea.ms/schema/1.0/delete' ->
	with {:ok, activity} <- DeleteHandler.handle_delete(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/follow' ->
	with {:ok, activity} <- FollowHandler.handle(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/unfollow' ->
	with {:ok, activity} <- UnfollowHandler.handle(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/share' ->
	with {:ok, activity, retweeted_activity} <- handle_share(entry, doc),
	do: [activity, retweeted_activity]

	'http://activitystrea.ms/schema/1.0/favorite' ->
	with {:ok, activity, favorited_activity} <- handle_favorite(entry, doc),
	do: [activity, favorited_activity]

	_ ->
	case object_type do
	'http://activitystrea.ms/schema/1.0/note' ->
	with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity

	'http://activitystrea.ms/schema/1.0/comment' ->
	with {:ok, activity} <- NoteHandler.handle_note(entry, doc), do: activity

	_ ->
	Logger.error("Couldn't parse incoming document")
	nil
	end
	end
	rescue
	e ->
	Logger.error("Error occured while handling activity")
	Logger.error(xml_string)
	Logger.error(inspect(e))
	nil
	end
	end)
	\|> Enum.filter(& &1)

	{:ok, activities}
	else
	_e -> {:error, []}
	end
	end

	def make_share(entry, doc, retweeted_activity) do
	with {:ok, actor} <- find_make_or_update_user(doc),
	%Object{} = object <- Object.normalize(retweeted_activity.data["object"]),
	id when not is_nil(id) <- string_from_xpath("/entry/id", entry),
	{:ok, activity, _object} = ActivityPub.announce(actor, object, id, false) do
	{:ok, activity}
	end
	end

	def handle_share(entry, doc) do
	with {:ok, retweeted_activity} <- get_or_build_object(entry),
	{:ok, activity} <- make_share(entry, doc, retweeted_activity) do
	{:ok, activity, retweeted_activity}
	else
	e -> {:error, e}
	end
	end

	def make_favorite(entry, doc, favorited_activity) do
	with {:ok, actor} <- find_make_or_update_user(doc),
	%Object{} = object <- Object.normalize(favorited_activity.data["object"]),
	id when not is_nil(id) <- string_from_xpath("/entry/id", entry),
	{:ok, activity, _object} = ActivityPub.like(actor, object, id, false) do
	{:ok, activity}
	end
	end

	def get_or_build_object(entry) do
	with {:ok, activity} <- get_or_try_fetching(entry) do
	{:ok, activity}
	else
	_e ->
	with [object] <- :xmerl_xpath.string('/entry/activity:object', entry) do
	NoteHandler.handle_note(object, object)
	end
	end
	end

	def get_or_try_fetching(entry) do
	Logger.debug("Trying to get entry from db")

	with id when not is_nil(id) <- string_from_xpath("//activity:object[1]/id", entry),
	%Activity{} = activity <- Activity.get_create_activity_by_object_ap_id(id) do
	{:ok, activity}
	else
	_ ->
	Logger.debug("Couldn't get, will try to fetch")

	with href when not is_nil(href) <-
	string_from_xpath("//activity:object[1]/link[@type=\"text/html\"]/@href", entry),
	{:ok, [favorited_activity]} <- fetch_activity_from_url(href) do
	{:ok, favorited_activity}
	else
	e -> Logger.debug("Couldn't find href: #{inspect(e)}")
	end
	end
	end

	def handle_favorite(entry, doc) do
	with {:ok, favorited_activity} <- get_or_try_fetching(entry),
	{:ok, activity} <- make_favorite(entry, doc, favorited_activity) do
	{:ok, activity, favorited_activity}
	else
	e -> {:error, e}
	end
	end

	def get_attachments(entry) do
	:xmerl_xpath.string('/entry/link[@rel="enclosure"]', entry)
	\|> Enum.map(fn enclosure ->
	with href when not is_nil(href) <- string_from_xpath("/link/@href", enclosure),
	type when not is_nil(type) <- string_from_xpath("/link/@type", enclosure) do
	%{
	"type" => "Attachment",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => type,
	"href" => href
	}
	]
	}
	end
	end)
	\|> Enum.filter(& &1)
	end

	@doc """
	Gets the content from a an entry.
	"""
	def get_content(entry) do
	string_from_xpath("//content", entry)
	end

	@doc """
	Get the cw that mastodon uses.
	"""
	def get_cw(entry) do
	with cw when not is_nil(cw) <- string_from_xpath("/*/summary", entry) do
	cw
	else
	_e -> nil
	end
	end

	def get_tags(entry) do
	:xmerl_xpath.string('//category', entry)
	\|> Enum.map(fn category -> string_from_xpath("/category/@term", category) end)
	\|> Enum.filter(& &1)
	\|> Enum.map(&String.downcase/1)
	end

	def maybe_update(doc, user) do
	if "true" == string_from_xpath("//author[1]/ap_enabled", doc) do
	Transmogrifier.upgrade_user_from_ap_id(user.ap_id)
	else
	maybe_update_ostatus(doc, user)
	end
	end

	def maybe_update_ostatus(doc, user) do
	old_data = %{
	avatar: user.avatar,
	bio: user.bio,
	name: user.name
	}

	with false <- user.local,
	avatar <- make_avatar_object(doc),
	bio <- string_from_xpath("//author[1]/summary", doc),
	name <- string_from_xpath("//author[1]/poco:displayName", doc),
	new_data <- %{
	avatar: avatar \|\| old_data.avatar,
	name: name \|\| old_data.name,
	bio: bio \|\| old_data.bio
	},
	false <- new_data == old_data do
	change = Ecto.Changeset.change(user, new_data)
	User.update_and_set_cache(change)
	else
	_ ->
	{:ok, user}
	end
	end

	def find_make_or_update_user(doc) do
	uri = string_from_xpath("//author/uri[1]", doc)

	with {:ok, user} <- find_or_make_user(uri) do
	maybe_update(doc, user)
	end
	end

	def find_or_make_user(uri) do
	query = from(user in User, where: user.ap_id == ^uri)

	user = Repo.one(query)

	if is_nil(user) do
	make_user(uri)
	else
	{:ok, user}
	end
	end

	def make_user(uri, update \\ false) do
	with {:ok, info} <- gather_user_info(uri) do
	data = %{
	name: info["name"],
	nickname: info["nickname"] <> "@" <> info["host"],
	ap_id: info["uri"],
	info: info,
	avatar: info["avatar"],
	bio: info["bio"]
	}

	with false <- update,
	%User{} = user <- User.get_by_ap_id(data.ap_id) do
	{:ok, user}
	else
	_e -> User.insert_or_update_user(data)
	end
	end
	end

	# TODO: Just takes the first one for now.
	def make_avatar_object(author_doc, rel \\ "avatar") do
	href = string_from_xpath("//author[1]/link[@rel=\"#{rel}\"]/@href", author_doc)
	type = string_from_xpath("//author[1]/link[@rel=\"#{rel}\"]/@type", author_doc)

	if href do
	%{
	"type" => "Image",
	"url" => [
	%{
	"type" => "Link",
	"mediaType" => type,
	"href" => href
	}
	]
	}
	else
	nil
	end
	end

	def gather_user_info(username) do
	with {:ok, webfinger_data} <- WebFinger.finger(username),
	{:ok, feed_data} <- Websub.gather_feed_data(webfinger_data["topic"]) do
	{:ok, Map.merge(webfinger_data, feed_data) \|> Map.put("fqn", username)}
	else
	e ->
	Logger.debug(fn -> "Couldn't gather info for #{username}" end)
	{:error, e}
	end
	end

	# Regex-based 'parsing' so we don't have to pull in a full html parser
	# It's a hack anyway. Maybe revisit this in the future
	@mastodon_regex ~r/<link href='(.*)' rel='alternate' type='application\/atom\+xml'>/
	@gs_regex ~r/<link title=.* href="(.*)" type="application\/atom\+xml" rel="alternate">/
	@gs_classic_regex ~r/<link rel="alternate" href="(.)" type="application\/atom\+xml" title=.>/
	def get_atom_url(body) do
	cond do
	Regex.match?(@mastodon_regex, body) ->
	[[_, match]] = Regex.scan(@mastodon_regex, body)
	{:ok, match}

	Regex.match?(@gs_regex, body) ->
	[[_, match]] = Regex.scan(@gs_regex, body)
	{:ok, match}

	Regex.match?(@gs_classic_regex, body) ->
	[[_, match]] = Regex.scan(@gs_classic_regex, body)
	{:ok, match}

	true ->
	Logger.debug(fn -> "Couldn't find Atom link in #{inspect(body)}" end)
	{:error, "Couldn't find the Atom link"}
	end
	end

	def fetch_activity_from_atom_url(url) do
	with true <- String.starts_with?(url, "http"),
	{:ok, %{body: body, status: code}} when code in 200..299 <-
	@httpoison.get(
	url,
	[{:Accept, "application/atom+xml"}]
	) do
	Logger.debug("Got document from #{url}, handling...")
	handle_incoming(body)
	else
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	e
	end
	end

	def fetch_activity_from_html_url(url) do
	Logger.debug("Trying to fetch #{url}")

	with true <- String.starts_with?(url, "http"),
	{:ok, %{body: body}} <- @httpoison.get(url, []),
	{:ok, atom_url} <- get_atom_url(body) do
	fetch_activity_from_atom_url(atom_url)
	else
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	e
	end
	end

	def fetch_activity_from_url(url) do
	with {:ok, [_ \| _] = activities} <- fetch_activity_from_atom_url(url) do
	{:ok, activities}
	else
	_e -> fetch_activity_from_html_url(url)
	end
	rescue
	e ->
	Logger.debug("Couldn't get #{url}: #{inspect(e)}")
	{:error, "Couldn't get #{url}: #{inspect(e)}"}
	end
	end
	diff --git a/lib/pleroma/web/ostatus/ostatus_controller.ex b/lib/pleroma/web/ostatus/ostatus_controller.ex
	index fbd25c5f5..55dbcab93 100644
	--- a/lib/pleroma/web/ostatus/ostatus_controller.ex
	+++ b/lib/pleroma/web/ostatus/ostatus_controller.ex
	@@ -1,199 +1,197 @@
	defmodule Pleroma.Web.OStatus.OStatusController do
	use Pleroma.Web, :controller

	alias Pleroma.{User, Activity, Object}
	alias Pleroma.Web.OStatus.{FeedRepresenter, ActivityRepresenter}
	alias Pleroma.Repo
	alias Pleroma.Web.{OStatus, Federator}
	alias Pleroma.Web.XML
	alias Pleroma.Web.ActivityPub.ObjectView
	alias Pleroma.Web.ActivityPub.ActivityPubController
	alias Pleroma.Web.ActivityPub.ActivityPub

	plug(Pleroma.Web.FederatingPlug when action in [:salmon_incoming])
	action_fallback(:errors)

	def feed_redirect(conn, %{"nickname" => nickname}) do
	- format = get_format(conn)
	- IO.puts(format)
	- case format do
	+ case get_format(conn) do
	"html" ->
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	Fallback.RedirectController.redirector_with_meta(conn, %{user: user})
	end

	"activity+json" ->
	ActivityPubController.call(conn, :user)

	_ ->
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	redirect(conn, external: OStatus.feed_path(user))
	else
	nil -> {:error, :not_found}
	end
	end
	end

	def feed(conn, %{"nickname" => nickname} = params) do
	with %User{} = user <- User.get_cached_by_nickname(nickname) do
	query_params =
	Map.take(params, ["max_id"])
	\|> Map.merge(%{"whole_db" => true, "actor_id" => user.ap_id})

	activities =
	ActivityPub.fetch_public_activities(query_params)
	\|> Enum.reverse()

	response =
	user
	\|> FeedRepresenter.to_simple_form(activities, [user])
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	conn
	\|> put_resp_content_type("application/atom+xml")
	\|> send_resp(200, response)
	else
	nil -> {:error, :not_found}
	end
	end

	defp decode_or_retry(body) do
	with {:ok, magic_key} <- Pleroma.Web.Salmon.fetch_magic_key(body),
	{:ok, doc} <- Pleroma.Web.Salmon.decode_and_validate(magic_key, body) do
	{:ok, doc}
	else
	_e ->
	with [decoded \| _] <- Pleroma.Web.Salmon.decode(body),
	doc <- XML.parse_document(decoded),
	uri when not is_nil(uri) <- XML.string_from_xpath("/entry/author[1]/uri", doc),
	{:ok, _} <- Pleroma.Web.OStatus.make_user(uri, true),
	{:ok, magic_key} <- Pleroma.Web.Salmon.fetch_magic_key(body),
	{:ok, doc} <- Pleroma.Web.Salmon.decode_and_validate(magic_key, body) do
	{:ok, doc}
	end
	end
	end

	def salmon_incoming(conn, _) do
	{:ok, body, _conn} = read_body(conn)
	{:ok, doc} = decode_or_retry(body)

	Federator.enqueue(:incoming_doc, doc)

	conn
	\|> send_resp(200, "")
	end

	def object(conn, %{"uuid" => uuid}) do
	if get_format(conn) == "activity+json" do
	ActivityPubController.call(conn, :object)
	else
	with id <- o_status_url(conn, :object, uuid),
	{_, %Activity{} = activity} <-
	{:activity, Activity.get_create_activity_by_object_ap_id(id)},
	{_, true} <- {:public?, ActivityPub.is_public?(activity)},
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	case get_format(conn) do
	"html" -> redirect(conn, to: "/notice/#{activity.id}")
	_ -> represent_activity(conn, nil, activity, user)
	end
	else
	{:public?, false} ->
	{:error, :not_found}

	{:activity, nil} ->
	{:error, :not_found}

	e ->
	e
	end
	end
	end

	def activity(conn, %{"uuid" => uuid}) do
	with id <- o_status_url(conn, :activity, uuid),
	{_, %Activity{} = activity} <- {:activity, Activity.normalize(id)},
	{_, true} <- {:public?, ActivityPub.is_public?(activity)},
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	case format = get_format(conn) do
	"html" -> redirect(conn, to: "/notice/#{activity.id}")
	_ -> represent_activity(conn, format, activity, user)
	end
	else
	{:public?, false} ->
	{:error, :not_found}

	{:activity, nil} ->
	{:error, :not_found}

	e ->
	e
	end
	end

	def notice(conn, %{"id" => id}) do
	with {_, %Activity{} = activity} <- {:activity, Repo.get(Activity, id)},
	{_, true} <- {:public?, ActivityPub.is_public?(activity)},
	%User{} = user <- User.get_cached_by_ap_id(activity.data["actor"]) do
	case format = get_format(conn) do
	"html" ->
	Fallback.RedirectController.redirector_with_meta(conn, %{activity: activity, user: user})

	_ ->
	represent_activity(conn, format, activity, user)
	end
	else
	{:public?, false} ->
	{:error, :not_found}

	{:activity, nil} ->
	{:error, :not_found}

	e ->
	e
	end
	end

	defp represent_activity(
	conn,
	"activity+json",
	%Activity{data: %{"type" => "Create"}} = activity,
	_user
	) do
	object = Object.normalize(activity.data["object"])

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

	defp represent_activity(_conn, "activity+json", _, _) do
	{:error, :not_found}
	end

	defp represent_activity(conn, _, activity, user) do
	response =
	activity
	\|> ActivityRepresenter.to_simple_form(user, true)
	\|> ActivityRepresenter.wrap_with_entry()
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

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

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

	def errors(conn, _) do
	conn
	\|> put_status(500)
	\|> text("Something went wrong")
	end
	end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index ad26093ac..914cd6a6d 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,474 +1,474 @@
	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.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

	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)
	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)
	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("/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("/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/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/show/:id", TwitterAPI.Controller, :fetch_status)
	get("/statusnet/conversation/:id", TwitterAPI.Controller, :fetch_conversation)

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

	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)

	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, ["html", "xml", "atom", "activity+json"])
	end

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

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

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

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

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

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

	pipeline :activitypub do
	plug(:accepts, ["activity+json"])
	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

	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

	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
	alias Pleroma.Web.Metadata

	def redirector(conn, _params) do
	conn
	\|> put_resp_content_type("text/html")
	\|> send_file(200, Application.app_dir(:pleroma, "priv/static/index.html"))
	end

	def redirector_with_meta(conn, params) do
	- {:ok, index_content } = File.read(Application.app_dir(:pleroma, "priv/static/index.html"))
	- tags = Metadata.build_tags(request_url(conn), params)
	+ {:ok, index_content} = File.read(Application.app_dir(:pleroma, "priv/static/index.html"))
	+ tags = Metadata.build_tags(params)
	response = String.replace(index_content, "<!--server-generated-meta-->", tags)

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

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

	def empty(conn, _params) do
	conn
	\|> put_status(204)
	\|> text("")
	end
	end
	diff --git a/test/web/oembed/oembed_test.exs b/test/web/oembed/oembed_test.exs
	deleted file mode 100644
	index 16c2c3598..000000000
	--- a/test/web/oembed/oembed_test.exs
	+++ /dev/null
	@@ -1,23 +0,0 @@
	-defmodule Pleroma.Web.OEmbedTest do
	- use Pleroma.DataCase
	- alias Pleroma.Web.OEmbed
	- alias Pleroma.Web.XML
	- alias Pleroma.{Object, Repo, User, Activity}
	- import Pleroma.Factory
	- import ExUnit.CaptureLog
	-
	- setup_all do
	- :ok
	- end
	-
	- test 'recognizes notices in given url' do
	- url = "https://pleroma.site/notice/5"
	- assert { :activity, _ } = OEmbed.recognize_path(url)
	- end
	-
	- test 'recognizes user card in given url' do
	- url = "https://pleroma.site/users/raeno"
	- assert { :user, _ } = OEmbed.recognize_path(url)
	- end
	-
	-end

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 6:40 AM (11 h, 32 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1802695
Default Alt Text: (55 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions