No OneTemporary
Actions

Authored By

Unknown

Size

49 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/config/config.exs b/config/config.exs
	index 1401b0a3d..df4c618a7 100644
	--- a/config/config.exs
	+++ b/config/config.exs
	@@ -1,205 +1,212 @@
	# 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,
	+ method: Pleroma.Captcha.Kocaptcha
	+
	+# Kocaptcha is a very simple captcha service, the source code is here: https://github.com/koto-bank/kocaptcha
	+config :pleroma, Pleroma.Captcha.Kocaptcha,
	+ endpoint: "http://localhost:9093"
	+
	# 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, :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/application.ex b/lib/pleroma/application.ex
	index 8705395a4..e15991957 100644
	--- a/lib/pleroma/application.ex
	+++ b/lib/pleroma/application.ex
	@@ -1,101 +1,102 @@
	defmodule Pleroma.Application do
	use Application
	import Supervisor.Spec

	@name "Pleroma"
	@version Mix.Project.config()[:version]
	def name, do: @name
	def version, do: @version
	def named_version(), do: @name <> " " <> @version

	def user_agent() do
	info = "#{Pleroma.Web.base_url()} <#{Pleroma.Config.get([:instance, :email], "")}>"
	named_version() <> "; " <> info
	end

	# See http://elixir-lang.org/docs/stable/elixir/Application.html
	# for more information on OTP Applications
	def start(_type, _args) do
	import Cachex.Spec

	# Define workers and child supervisors to be supervised
	children =
	[
	# Start the Ecto repository
	supervisor(Pleroma.Repo, []),
	worker(Pleroma.Emoji, []),
	+ worker(Pleroma.Captcha, []),
	worker(
	Cachex,
	[
	:user_cache,
	[
	default_ttl: 25000,
	ttl_interval: 1000,
	limit: 2500
	]
	],
	id: :cachex_user
	),
	worker(
	Cachex,
	[
	:object_cache,
	[
	default_ttl: 25000,
	ttl_interval: 1000,
	limit: 2500
	]
	],
	id: :cachex_object
	),
	worker(
	Cachex,
	[
	:idempotency_cache,
	[
	expiration:
	expiration(
	default: :timer.seconds(6 * 60 * 60),
	interval: :timer.seconds(60)
	),
	limit: 2500
	]
	],
	id: :cachex_idem
	),
	worker(Pleroma.Web.Federator.RetryQueue, []),
	worker(Pleroma.Web.Federator, []),
	worker(Pleroma.Stats, []),
	worker(Pleroma.Web.Push, [])
	] ++
	streamer_child() ++
	chat_child() ++
	[
	# Start the endpoint when the application starts
	supervisor(Pleroma.Web.Endpoint, []),
	worker(Pleroma.Gopher.Server, [])
	]

	# See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
	# for other strategies and supported options
	opts = [strategy: :one_for_one, name: Pleroma.Supervisor]
	Supervisor.start_link(children, opts)
	end

	if Mix.env() == :test do
	defp streamer_child(), do: []
	defp chat_child(), do: []
	else
	defp streamer_child() do
	[worker(Pleroma.Web.Streamer, [])]
	end

	defp chat_child() do
	if Pleroma.Config.get([:chat, :enabled]) do
	[worker(Pleroma.Web.ChatChannel.ChatChannelState, [])]
	else
	[]
	end
	end
	end
	end
	diff --git a/lib/pleroma/captcha.ex b/lib/pleroma/captcha.ex
	new file mode 100644
	index 000000000..31f3bc797
	--- /dev/null
	+++ b/lib/pleroma/captcha.ex
	@@ -0,0 +1,68 @@
	+defmodule Pleroma.Captcha do
	+ use GenServer
	+
	+ @ets __MODULE__.Ets
	+ @ets_options [:ordered_set, :private, :named_table, {:read_concurrency, true}]
	+
	+
	+ @doc false
	+ def start_link() do
	+ GenServer.start_link(__MODULE__, [], name: __MODULE__)
	+ end
	+
	+
	+ @doc false
	+ def init(_) do
	+ @ets = :ets.new(@ets, @ets_options)
	+
	+ {:ok, nil}
	+ end
	+
	+ def new() do
	+ GenServer.call(__MODULE__, :new)
	+ end
	+
	+ def validate(token, captcha) do
	+ GenServer.call(__MODULE__, {:validate, token, captcha})
	+ end
	+
	+ @doc false
	+ def handle_call(:new, _from, state) do
	+ method = Pleroma.Config.get!([__MODULE__, :method])
	+
	+ case method do
	+ __MODULE__.Kocaptcha ->
	+ endpoint = Pleroma.Config.get!([method, :endpoint])
	+ case HTTPoison.get(endpoint <> "/new") do
	+ {:error, _} ->
	+ %{error: "Kocaptcha service unavailable"}
	+ {:ok, res} ->
	+ json_resp = Poison.decode!(res.body)
	+
	+ token = json_resp["token"]
	+
	+ true = :ets.insert(@ets, {token, json_resp["md5"]})
	+
	+ {
	+ :reply,
	+ %{type: :kocaptcha, token: token, url: endpoint <> json_resp["url"]},
	+ state
	+ }
	+ end
	+ end
	+ end
	+
	+ @doc false
	+ def handle_call({:validate, token, captcha}, _from, state) do
	+ with false <- is_nil(captcha),
	+ [{^token, saved_md5}] <- :ets.lookup(@ets, token),
	+ true <- (:crypto.hash(:md5, captcha) \|> Base.encode16) == String.upcase(saved_md5) do
	+ # Clear the saved value
	+ :ets.delete(@ets, token)
	+
	+ {:reply, true, state}
	+ else
	+ e -> IO.inspect(e); {:reply, false, state}
	+ end
	+ end
	+end
	diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
	index daff3362c..60342cfb4 100644
	--- a/lib/pleroma/web/router.ex
	+++ b/lib/pleroma/web/router.ex
	@@ -1,473 +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

	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("/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)
	post("/account/password_reset", TwitterAPI.Controller, :password_reset)

	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, ["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

	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, Application.app_dir(:pleroma, "priv/static/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/controllers/util_controller.ex b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	index 2f2b69623..38653f0b8 100644
	--- a/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	+++ b/lib/pleroma/web/twitter_api/controllers/util_controller.ex
	@@ -1,287 +1,291 @@
	defmodule Pleroma.Web.TwitterAPI.UtilController do
	use Pleroma.Web, :controller
	require Logger
	alias Pleroma.Web
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.WebFinger
	alias Pleroma.Web.CommonAPI
	alias Comeonin.Pbkdf2
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.{Repo, PasswordResetToken, User, Emoji}

	def show_password_reset(conn, %{"token" => token}) do
	with %{used: false} = token <- Repo.get_by(PasswordResetToken, %{token: token}),
	%User{} = user <- Repo.get(User, token.user_id) do
	render(conn, "password_reset.html", %{
	token: token,
	user: user
	})
	else
	_e -> render(conn, "invalid_token.html")
	end
	end

	def password_reset(conn, %{"data" => data}) do
	with {:ok, _} <- PasswordResetToken.reset_password(data["token"], data) do
	render(conn, "password_reset_success.html")
	else
	_e -> render(conn, "password_reset_failed.html")
	end
	end

	def help_test(conn, _params) do
	json(conn, "ok")
	end

	def remote_subscribe(conn, %{"nickname" => nick, "profile" => _}) do
	with %User{} = user <- User.get_cached_by_nickname(nick), avatar = User.avatar_url(user) do
	conn
	\|> render("subscribe.html", %{nickname: nick, avatar: avatar, error: false})
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error: "Could not find user"
	})
	end
	end

	def remote_subscribe(conn, %{"user" => %{"nickname" => nick, "profile" => profile}}) do
	with {:ok, %{"subscribe_address" => template}} <- WebFinger.finger(profile),
	%User{ap_id: ap_id} <- User.get_cached_by_nickname(nick) do
	conn
	\|> Phoenix.Controller.redirect(external: String.replace(template, "{uri}", ap_id))
	else
	_e ->
	render(conn, "subscribe.html", %{
	nickname: nick,
	avatar: nil,
	error: "Something went wrong."
	})
	end
	end

	def remote_follow(%{assigns: %{user: user}} = conn, %{"acct" => acct}) do
	{err, followee} = OStatus.find_or_make_user(acct)
	avatar = User.avatar_url(followee)
	name = followee.nickname
	id = followee.id

	if !!user do
	conn
	\|> render("follow.html", %{error: err, acct: acct, avatar: avatar, name: name, id: id})
	else
	conn
	\|> render("follow_login.html", %{
	error: false,
	acct: acct,
	avatar: avatar,
	name: name,
	id: id
	})
	end
	end

	def do_remote_follow(conn, %{
	"authorization" => %{"name" => username, "password" => password, "id" => id}
	}) do
	followee = Repo.get(User, id)
	avatar = User.avatar_url(followee)
	name = followee.nickname

	with %User{} = user <- User.get_cached_by_nickname(username),
	true <- Pbkdf2.checkpw(password, user.password_hash),
	%User{} = _followed <- Repo.get(User, id),
	{:ok, follower} <- User.follow(user, followee),
	{:ok, _activity} <- ActivityPub.follow(follower, followee) do
	conn
	\|> render("followed.html", %{error: false})
	else
	# Was already following user
	{:error, "Could not follow user:" <> _rest} ->
	render(conn, "followed.html", %{error: false})

	_e ->
	conn
	\|> render("follow_login.html", %{
	error: "Wrong username or password",
	id: id,
	name: name,
	avatar: avatar
	})
	end
	end

	def do_remote_follow(%{assigns: %{user: user}} = conn, %{"user" => %{"id" => id}}) do
	with %User{} = followee <- Repo.get(User, id),
	{:ok, follower} <- User.follow(user, followee),
	{:ok, _activity} <- ActivityPub.follow(follower, followee) do
	conn
	\|> render("followed.html", %{error: false})
	else
	# Was already following user
	{:error, "Could not follow user:" <> _rest} ->
	conn
	\|> render("followed.html", %{error: false})

	e ->
	Logger.debug("Remote follow failed with error #{inspect(e)}")

	conn
	\|> render("followed.html", %{error: inspect(e)})
	end
	end

	def config(conn, _params) do
	instance = Pleroma.Config.get(:instance)
	instance_fe = Pleroma.Config.get(:fe)
	instance_chat = Pleroma.Config.get(:chat)

	case get_format(conn) do
	"xml" ->
	response = """
	<config>
	<site>
	<name>#{Keyword.get(instance, :name)}</name>
	<site>#{Web.base_url()}</site>
	<textlimit>#{Keyword.get(instance, :limit)}</textlimit>
	<closed>#{!Keyword.get(instance, :registrations_open)}</closed>
	</site>
	</config>
	"""

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

	_ ->
	vapid_public_key = Keyword.get(Pleroma.Web.Push.vapid_config(), :public_key)

	uploadlimit = %{
	uploadlimit: to_string(Keyword.get(instance, :upload_limit)),
	avatarlimit: to_string(Keyword.get(instance, :avatar_upload_limit)),
	backgroundlimit: to_string(Keyword.get(instance, :background_upload_limit)),
	bannerlimit: to_string(Keyword.get(instance, :banner_upload_limit))
	}

	data = %{
	name: Keyword.get(instance, :name),
	description: Keyword.get(instance, :description),
	server: Web.base_url(),
	textlimit: to_string(Keyword.get(instance, :limit)),
	uploadlimit: uploadlimit,
	closed: if(Keyword.get(instance, :registrations_open), do: "0", else: "1"),
	private: if(Keyword.get(instance, :public, true), do: "0", else: "1"),
	vapidPublicKey: vapid_public_key,
	invitesEnabled: if(Keyword.get(instance, :invites_enabled, false), do: "1", else: "0")
	}

	pleroma_fe = %{
	theme: Keyword.get(instance_fe, :theme),
	background: Keyword.get(instance_fe, :background),
	logo: Keyword.get(instance_fe, :logo),
	logoMask: Keyword.get(instance_fe, :logo_mask),
	logoMargin: Keyword.get(instance_fe, :logo_margin),
	redirectRootNoLogin: Keyword.get(instance_fe, :redirect_root_no_login),
	redirectRootLogin: Keyword.get(instance_fe, :redirect_root_login),
	chatDisabled: !Keyword.get(instance_chat, :enabled),
	showInstanceSpecificPanel: Keyword.get(instance_fe, :show_instance_panel),
	scopeOptionsEnabled: Keyword.get(instance_fe, :scope_options_enabled),
	formattingOptionsEnabled: Keyword.get(instance_fe, :formatting_options_enabled),
	collapseMessageWithSubject: Keyword.get(instance_fe, :collapse_message_with_subject),
	hidePostStats: Keyword.get(instance_fe, :hide_post_stats),
	hideUserStats: Keyword.get(instance_fe, :hide_user_stats),
	scopeCopy: Keyword.get(instance_fe, :scope_copy),
	subjectLineBehavior: Keyword.get(instance_fe, :subject_line_behavior),
	alwaysShowSubjectInput: Keyword.get(instance_fe, :always_show_subject_input)
	}

	managed_config = Keyword.get(instance, :managed_config)

	data =
	if managed_config do
	data \|> Map.put("pleromafe", pleroma_fe)
	else
	data
	end

	json(conn, %{site: data})
	end
	end

	def version(conn, _params) do
	version = Pleroma.Application.named_version()

	case get_format(conn) do
	"xml" ->
	response = "<version>#{version}</version>"

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

	_ ->
	json(conn, version)
	end
	end

	def emoji(conn, _params) do
	json(conn, Enum.into(Emoji.get_all(), %{}))
	end

	def follow_import(conn, %{"list" => %Plug.Upload{} = listfile}) do
	follow_import(conn, %{"list" => File.read!(listfile.path)})
	end

	def follow_import(%{assigns: %{user: user}} = conn, %{"list" => list}) do
	Task.start(fn ->
	String.split(list)
	\|> Enum.map(fn account ->
	with %User{} = follower <- User.get_cached_by_ap_id(user.ap_id),
	%User{} = followed <- User.get_or_fetch(account),
	{:ok, follower} <- User.maybe_direct_follow(follower, followed) do
	ActivityPub.follow(follower, followed)
	else
	err -> Logger.debug("follow_import: following #{account} failed with #{inspect(err)}")
	end
	end)
	end)

	json(conn, "job started")
	end

	def change_password(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
	{:ok, user} ->
	with {:ok, _user} <-
	User.reset_password(user, %{
	password: params["new_password"],
	password_confirmation: params["new_password_confirmation"]
	}) do
	json(conn, %{status: "success"})
	else
	{:error, changeset} ->
	{_, {error, _}} = Enum.at(changeset.errors, 0)
	json(conn, %{error: "New password #{error}."})

	_ ->
	json(conn, %{error: "Unable to change password."})
	end

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

	def delete_account(%{assigns: %{user: user}} = conn, params) do
	case CommonAPI.Utils.confirm_current_password(user, params["password"]) do
	{:ok, user} ->
	Task.start(fn -> User.delete(user) end)
	json(conn, %{status: "success"})

	{:error, msg} ->
	json(conn, %{error: msg})
	end
	end
	+
	+ def captcha(conn, _params) do
	+ json(conn, Pleroma.Captcha.new())
	+ end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index 1e764f24a..c9e8fbcbb 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,300 +1,309 @@
	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.{UserInviteToken, User, Activity, Repo, Object}
	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 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"]
	+ password_confirmation: params["confirm"],
	+ captcha_solution: params["captcha_solution"],
	+ captcha_token: params["captcha_token"]
	}

	- registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	+ # Captcha invalid
	+ if not Pleroma.Captcha.validate(params[:captcha_token], params[:captcha_solution]) do
	+ # I have no idea how this error handling works
	+ {:error, %{error: Jason.encode!(%{captcha: ["Invalid CAPTCHA"]})}}
	+ 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
	+ # 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{info: %{}}, params)
	+ cond do
	+ registrations_open \|\| (!is_nil(token) && !token.used) ->
	+ changeset = User.register_changeset(%User{info: %{}}, params)

	- with {:ok, user} <- Repo.insert(changeset) do
	- !registrations_open && UserInviteToken.mark_as_used(token.token)
	- {:ok, user}
	- else
	- {:error, changeset} ->
	- errors =
	+ with {:ok, user} <- Repo.insert(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
	+ end
	+

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

	- !registrations_open && token.used ->
	- {:error, "Expired 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
	\|> Pleroma.UserEmail.password_reset_email(token_record.token)
	\|> Pleroma.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

File Metadata

Mime Type: text/x-diff
Expires: Sun, Nov 1, 12:08 PM (7 h, 24 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1803010
Default Alt Text: (49 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions