No OneTemporary
Actions

Size

63 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/mix/tasks/pleroma/user.ex b/lib/mix/tasks/pleroma/user.ex
	index 00a933292..887f45029 100644
	--- a/lib/mix/tasks/pleroma/user.ex
	+++ b/lib/mix/tasks/pleroma/user.ex
	@@ -1,427 +1,429 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.User do
	use Mix.Task
	import Ecto.Changeset
	alias Mix.Tasks.Pleroma.Common
	alias Pleroma.User
	alias Pleroma.UserInviteToken

	@shortdoc "Manages Pleroma users"
	@moduledoc """
	Manages Pleroma users.

	## Create a new user.

	mix pleroma.user new NICKNAME EMAIL [OPTION...]

	Options:
	- `--name NAME` - the user's name (i.e., "Lain Iwakura")
	- `--bio BIO` - the user's bio
	- `--password PASSWORD` - the user's password
	- `--moderator`/`--no-moderator` - whether the user is a moderator
	- `--admin`/`--no-admin` - whether the user is an admin
	- `-y`, `--assume-yes`/`--no-assume-yes` - whether to assume yes to all questions

	## Generate an invite link.

	mix pleroma.user invite [OPTION...]

	Options:
	- `--expire_date DATE` - last day on which token is active (e.g. "2019-04-05")
	- `--max_use NUMBER` - maximum numbers of token use

	## Generated invites list

	mix pleroma.user invites_list

	## Revoke invite

	mix pleroma.user invite_revoke TOKEN OR TOKEN_ID

	## Delete the user's account.

	mix pleroma.user rm NICKNAME

	## Delete the user's activities.

	mix pleroma.user delete_activities NICKNAME

	## Deactivate or activate the user's account.

	mix pleroma.user toggle_activated NICKNAME

	## Unsubscribe local users from user's account and deactivate it

	mix pleroma.user unsubscribe NICKNAME

	## Create a password reset link.

	mix pleroma.user reset_password NICKNAME

	## Set the value of the given user's settings.

	mix pleroma.user set NICKNAME [OPTION...]

	Options:
	- `--locked`/`--no-locked` - whether the user's account is locked
	- `--moderator`/`--no-moderator` - whether the user is a moderator
	- `--admin`/`--no-admin` - whether the user is an admin

	## Add tags to a user.

	mix pleroma.user tag NICKNAME TAGS

	## Delete tags from a user.

	mix pleroma.user untag NICKNAME TAGS
	"""
	def run(["new", nickname, email \| rest]) do
	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	name: :string,
	bio: :string,
	password: :string,
	moderator: :boolean,
	admin: :boolean,
	assume_yes: :boolean
	],
	aliases: [
	y: :assume_yes
	]
	)

	name = Keyword.get(options, :name, nickname)
	bio = Keyword.get(options, :bio, "")

	{password, generated_password?} =
	case Keyword.get(options, :password) do
	nil ->
	{:crypto.strong_rand_bytes(16) \|> Base.encode64(), true}

	password ->
	{password, false}
	end

	moderator? = Keyword.get(options, :moderator, false)
	admin? = Keyword.get(options, :admin, false)
	assume_yes? = Keyword.get(options, :assume_yes, false)

	Mix.shell().info("""
	A user will be created with the following information:
	- nickname: #{nickname}
	- email: #{email}
	- password: #{
	if(generated_password?, do: "[generated; a reset link will be created]", else: password)
	}
	- name: #{name}
	- bio: #{bio}
	- moderator: #{if(moderator?, do: "true", else: "false")}
	- admin: #{if(admin?, do: "true", else: "false")}
	""")

	proceed? = assume_yes? or Mix.shell().yes?("Continue?")

	unless not proceed? do
	Common.start_pleroma()

	params = %{
	nickname: nickname,
	email: email,
	password: password,
	password_confirmation: password,
	name: name,
	bio: bio
	}

	changeset = User.register_changeset(%User{}, params, confirmed: true)
	{:ok, _user} = User.register(changeset)

	Mix.shell().info("User #{nickname} created")

	if moderator? do
	run(["set", nickname, "--moderator"])
	end

	if admin? do
	run(["set", nickname, "--admin"])
	end

	if generated_password? do
	run(["reset_password", nickname])
	end
	else
	Mix.shell().info("User will not be created.")
	end
	end

	def run(["rm", nickname]) do
	Common.start_pleroma()

	with %User{local: true} = user <- User.get_by_nickname(nickname) do
	User.delete(user)
	Mix.shell().info("User #{nickname} deleted.")
	else
	_ ->
	Mix.shell().error("No local user #{nickname}")
	end
	end

	def run(["toggle_activated", nickname]) do
	Common.start_pleroma()

	with %User{} = user <- User.get_by_nickname(nickname) do
	{:ok, user} = User.deactivate(user, !user.info.deactivated)

	Mix.shell().info(
	"Activation status of #{nickname}: #{if(user.info.deactivated, do: "de", else: "")}activated"
	)
	else
	_ ->
	Mix.shell().error("No user #{nickname}")
	end
	end

	def run(["reset_password", nickname]) do
	Common.start_pleroma()

	with %User{local: true} = user <- User.get_by_nickname(nickname),
	{:ok, token} <- Pleroma.PasswordResetToken.create_token(user) do
	Mix.shell().info("Generated password reset token for #{user.nickname}")

	IO.puts(
	"URL: #{
	Pleroma.Web.Router.Helpers.util_url(
	Pleroma.Web.Endpoint,
	:show_password_reset,
	token.token
	)
	}"
	)
	else
	_ ->
	Mix.shell().error("No local user #{nickname}")
	end
	end

	def run(["unsubscribe", nickname]) do
	Common.start_pleroma()

	with %User{} = user <- User.get_by_nickname(nickname) do
	Mix.shell().info("Deactivating #{user.nickname}")
	User.deactivate(user)

	{:ok, friends} = User.get_friends(user)

	Enum.each(friends, fn friend ->
	user = User.get_by_id(user.id)

	Mix.shell().info("Unsubscribing #{friend.nickname} from #{user.nickname}")
	User.unfollow(user, friend)
	end)

	:timer.sleep(500)

	user = User.get_by_id(user.id)

	if Enum.empty?(user.following) do
	Mix.shell().info("Successfully unsubscribed all followers from #{user.nickname}")
	end
	else
	_ ->
	Mix.shell().error("No user #{nickname}")
	end
	end

	def run(["set", nickname \| rest]) do
	Common.start_pleroma()

	{options, [], []} =
	OptionParser.parse(
	rest,
	strict: [
	moderator: :boolean,
	admin: :boolean,
	locked: :boolean
	]
	)

	with %User{local: true} = user <- User.get_by_nickname(nickname) do
	user =
	case Keyword.get(options, :moderator) do
	nil -> user
	value -> set_moderator(user, value)
	end

	user =
	case Keyword.get(options, :locked) do
	nil -> user
	value -> set_locked(user, value)
	end

	_user =
	case Keyword.get(options, :admin) do
	nil -> user
	value -> set_admin(user, value)
	end
	else
	_ ->
	Mix.shell().error("No local user #{nickname}")
	end
	end

	def run(["tag", nickname \| tags]) do
	Common.start_pleroma()

	with %User{} = user <- User.get_by_nickname(nickname) do
	user = user \|> User.tag(tags)

	Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}")
	else
	_ ->
	Mix.shell().error("Could not change user tags for #{nickname}")
	end
	end

	def run(["untag", nickname \| tags]) do
	Common.start_pleroma()

	with %User{} = user <- User.get_by_nickname(nickname) do
	user = user \|> User.untag(tags)

	Mix.shell().info("Tags of #{user.nickname}: #{inspect(tags)}")
	else
	_ ->
	Mix.shell().error("Could not change user tags for #{nickname}")
	end
	end

	def run(["invite" \| rest]) do
	{options, [], []} =
	OptionParser.parse(rest,
	strict: [
	expire_date: :string,
	max_use: :integer
	]
	)

	expire_at =
	with expire_date when expire_date != nil <- Keyword.get(options, :expire_date) do
	Date.from_iso8601!(expire_date)
	end

	options = Keyword.put(options, :expire_at, expire_at)
	-
	+ options = Enum.into(options, %{})
	Common.start_pleroma()

	- with {:ok, token} <- UserInviteToken.create_token(options) do
	+ with {:ok, invite} <- UserInviteToken.create_invite(options) do
	Mix.shell().info(
	- "Generated user invite token " <> String.replace(token.token_type, "_", " ")
	+ "Generated user invite token " <> String.replace(invite.invite_type, "_", " ")
	)

	url =
	Pleroma.Web.Router.Helpers.redirect_url(
	Pleroma.Web.Endpoint,
	:registration_page,
	- token.token
	+ invite.token
	)

	IO.puts(url)
	else
	_ ->
	Mix.shell().error("Could not create invite token.")
	end
	end

	def run(["invites_list"]) do
	Common.start_pleroma()

	Mix.shell().info("Invites list:")

	UserInviteToken.list_invites()
	\|> Enum.each(fn invite ->
	expire_date =
	case invite.expire_at do
	nil -> nil
	date -> " \| Expire date: #{Date.to_string(date)}"
	end

	using_info =
	case invite.max_use do
	nil -> nil
	max_use -> " \| Max use: #{max_use} Left use: #{max_use - invite.uses}"
	end

	Mix.shell().info(
	"ID: #{invite.id} \| Token: #{invite.token} \| Token type: #{invite.token_type} \| Used: #{
	invite.used
	}#{expire_date}#{using_info}"
	)
	end)
	end

	def run(["invite_revoke", token]) do
	Common.start_pleroma()

	- with {:ok, _} <- UserInviteToken.mark_as_used(token) do
	+ invite = UserInviteToken.find_by_token!(token)
	+
	+ with {:ok, _} <- UserInviteToken.update_invite(invite, %{used: true}) do
	Mix.shell().info("Invite for token #{token} was revoked.")
	else
	_ -> Mix.shell().error("No invite found with token #{token}")
	end
	end

	def run(["delete_activities", nickname]) do
	Common.start_pleroma()

	with %User{local: true} = user <- User.get_by_nickname(nickname) do
	User.delete_user_activities(user)
	Mix.shell().info("User #{nickname} statuses deleted.")
	else
	_ ->
	Mix.shell().error("No local user #{nickname}")
	end
	end

	defp set_moderator(user, value) do
	info_cng = User.Info.admin_api_update(user.info, %{is_moderator: value})

	user_cng =
	Ecto.Changeset.change(user)
	\|> put_embed(:info, info_cng)

	{:ok, user} = User.update_and_set_cache(user_cng)

	Mix.shell().info("Moderator status of #{user.nickname}: #{user.info.is_moderator}")
	user
	end

	defp set_admin(user, value) do
	info_cng = User.Info.admin_api_update(user.info, %{is_admin: value})

	user_cng =
	Ecto.Changeset.change(user)
	\|> put_embed(:info, info_cng)

	{:ok, user} = User.update_and_set_cache(user_cng)

	Mix.shell().info("Admin status of #{user.nickname}: #{user.info.is_admin}")
	user
	end

	defp set_locked(user, value) do
	info_cng = User.Info.user_upgrade(user.info, %{locked: value})

	user_cng =
	Ecto.Changeset.change(user)
	\|> put_embed(:info, info_cng)

	{:ok, user} = User.update_and_set_cache(user_cng)

	Mix.shell().info("Locked status of #{user.nickname}: #{user.info.locked}")
	user
	end
	end
	diff --git a/lib/pleroma/user_invite_token.ex b/lib/pleroma/user_invite_token.ex
	index 3ed39ddd3..4efdbdc32 100644
	--- a/lib/pleroma/user_invite_token.ex
	+++ b/lib/pleroma/user_invite_token.ex
	@@ -1,122 +1,117 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.UserInviteToken do
	use Ecto.Schema

	import Ecto.Changeset
	import Ecto.Query
	alias Pleroma.Repo
	alias Pleroma.UserInviteToken

	@type token :: String.t()

	schema "user_invite_tokens" do
	field(:token, :string)
	field(:used, :boolean, default: false)
	field(:max_use, :integer)
	field(:expire_at, :date)
	- field(:uses, :integer)
	- field(:token_type)
	+ field(:uses, :integer, default: 0)
	+ field(:invite_type, :string)

	timestamps()
	end

	- def create_token(options \\ []) do
	+ @spec create_invite(map()) :: UserInviteToken.t()
	+ def create_invite(params \\ %{}) do
	+ %UserInviteToken{}
	+ \|> cast(params, ~w(max_use expire_at)a)
	+ \|> add_token()
	+ \|> assign_type()
	+ \|> Repo.insert()
	+ end
	+
	+ defp add_token(changeset) do
	token = :crypto.strong_rand_bytes(32) \|> Base.url_encode64()
	+ put_change(changeset, :token, token)
	+ end

	- max_use = options[:max_use]
	- expire_at = options[:expire_at]
	+ defp assign_type(%{changes: %{max_use: _max_use, expire_at: _expire_at}} = changeset) do
	+ put_change(changeset, :invite_type, "reusable_date_limited")
	+ end

	- token =
	- %UserInviteToken{
	- used: false,
	- token: token,
	- max_use: max_use,
	- expire_at: expire_at,
	- uses: 0
	- }
	- \|> token_type()
	+ defp assign_type(%{changes: %{expire_at: _expire_at}} = changeset) do
	+ put_change(changeset, :invite_type, "date_limited")
	+ end

	- Repo.insert(token)
	+ defp assign_type(%{changes: %{max_use: _max_use}} = changeset) do
	+ put_change(changeset, :invite_type, "reusable")
	end

	+ defp assign_type(changeset), do: put_change(changeset, :invite_type, "one_time")
	+
	+ @spec list_invites() :: [UserInviteToken.t()]
	def list_invites do
	query = from(u in UserInviteToken, order_by: u.id)
	Repo.all(query)
	end

	- def used_changeset(struct) do
	- struct
	- \|> cast(%{}, [])
	- \|> put_change(:used, true)
	+ @spec update_invite!(UserInviteToken.t(), map()) :: UserInviteToken.t() \| no_return()
	+ def update_invite!(invite, changes) do
	+ change(invite, changes) \|> Repo.update!()
	end

	- @spec mark_as_used(token()) :: {:ok, UserInviteToken.t()} \| {:error, token()}
	- def mark_as_used(token) do
	- with %{used: false} = token <- Repo.get_by(UserInviteToken, %{token: token}),
	- {:ok, token} <- Repo.update(used_changeset(token)) do
	- {:ok, token}
	- else
	- _e -> {:error, token}
	- end
	+ @spec update_invite(UserInviteToken.t(), map()) ::
	+ {:ok, UserInviteToken.t()} \| {:error, Changeset.t()}
	+ def update_invite(invite, changes) do
	+ change(invite, changes) \|> Repo.update()
	end

	- defp token_type(%{expire_at: nil, max_use: nil} = token), do: %{token \| token_type: "one_time"}
	+ @spec find_by_token!(token()) :: UserInviteToken.t() \| no_return()
	+ def find_by_token!(token), do: Repo.get_by!(UserInviteToken, token: token)

	- defp token_type(%{expire_at: _expire_at, max_use: nil} = token),
	- do: %{token \| token_type: "date_limited"}
	-
	- defp token_type(%{expire_at: nil, max_use: _max_use} = token),
	- do: %{token \| token_type: "reusable"}
	-
	- defp token_type(%{expire_at: _expire_at, max_use: _max_use} = token),
	- do: %{token \| token_type: "reusable_date_limited"}
	-
	- @spec valid_token?(UserInviteToken.t()) :: boolean()
	- def valid_token?(%{token_type: "one_time"} = token) do
	- not token.used
	+ @spec valid_invite?(UserInviteToken.t()) :: boolean()
	+ def valid_invite?(%{invite_type: "one_time"} = invite) do
	+ not invite.used
	end

	- def valid_token?(%{token_type: "date_limited"} = token) do
	- not_overdue_date?(token) and not token.used
	+ def valid_invite?(%{invite_type: "date_limited"} = invite) do
	+ not_overdue_date?(invite) and not invite.used
	end

	- def valid_token?(%{token_type: "reusable"} = token) do
	- token.uses < token.max_use and not token.used
	+ def valid_invite?(%{invite_type: "reusable"} = invite) do
	+ invite.uses < invite.max_use and not invite.used
	end

	- def valid_token?(%{token_type: "reusable_date_limited"} = token) do
	- not_overdue_date?(token) and token.uses < token.max_use and not token.used
	+ def valid_invite?(%{invite_type: "reusable_date_limited"} = invite) do
	+ not_overdue_date?(invite) and invite.uses < invite.max_use and not invite.used
	end

	- defp not_overdue_date?(%{expire_at: expire_at} = token) do
	+ defp not_overdue_date?(%{expire_at: expire_at} = invite) do
	Date.compare(Date.utc_today(), expire_at) in [:lt, :eq] \|\|
	- (Repo.update!(change(token, used: true)) && false)
	+ (update_invite!(invite, %{used: true}) && false)
	end

	- def update_usage(%{token_type: "date_limited"}), do: nil
	-
	- def update_usage(%{token_type: "one_time"} = token) do
	- UserInviteToken.mark_as_used(token.token)
	- end
	+ @spec update_usage!(UserInviteToken.t()) :: nil \| UserInviteToken.t() \| no_return()
	+ def update_usage!(%{invite_type: "date_limited"}), do: nil

	- def update_usage(%{token_type: token_type} = token)
	- when token_type == "reusable" or token_type == "reusable_date_limited" do
	- new_uses = token.uses + 1
	+ def update_usage!(%{invite_type: "one_time"} = invite),
	+ do: update_invite!(invite, %{used: true})

	+ def update_usage!(%{invite_type: invite_type} = invite)
	+ when invite_type == "reusable" or invite_type == "reusable_date_limited" do
	changes = %{
	- uses: new_uses
	+ uses: invite.uses + 1
	}

	changes =
	- if new_uses >= token.max_use do
	+ if changes.uses >= invite.max_use do
	Map.put(changes, :used, true)
	else
	changes
	end

	- change(token, changes) \|> Repo.update!()
	+ update_invite!(invite, changes)
	end
	end
	diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
	index a578fbbf4..402fd195f 100644
	--- a/lib/pleroma/web/twitter_api/twitter_api.ex
	+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
	@@ -1,302 +1,302 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
	alias Pleroma.Activity
	alias Pleroma.Mailer
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserEmail
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.CommonAPI
	alias Pleroma.Web.TwitterAPI.UserView

	import Ecto.Query

	def create_status(%User{} = user, %{"status" => _} = data) do
	CommonAPI.post(user, data)
	end

	def delete(%User{} = user, id) do
	with %Activity{data: %{"type" => _type}} <- Activity.get_by_id(id),
	{:ok, activity} <- CommonAPI.delete(id, user) do
	{:ok, activity}
	end
	end

	def follow(%User{} = follower, params) do
	with {:ok, %User{} = followed} <- get_user(params) do
	CommonAPI.follow(follower, followed)
	end
	end

	def unfollow(%User{} = follower, params) do
	with {:ok, %User{} = unfollowed} <- get_user(params),
	{:ok, follower} <- CommonAPI.unfollow(follower, unfollowed) do
	{:ok, follower, unfollowed}
	end
	end

	def block(%User{} = blocker, params) do
	with {:ok, %User{} = blocked} <- get_user(params),
	{:ok, blocker} <- User.block(blocker, blocked),
	{:ok, _activity} <- ActivityPub.block(blocker, blocked) do
	{:ok, blocker, blocked}
	else
	err -> err
	end
	end

	def unblock(%User{} = blocker, params) do
	with {:ok, %User{} = blocked} <- get_user(params),
	{:ok, blocker} <- User.unblock(blocker, blocked),
	{:ok, _activity} <- ActivityPub.unblock(blocker, blocked) do
	{:ok, blocker, blocked}
	else
	err -> err
	end
	end

	def repeat(%User{} = user, ap_id_or_id) do
	with {:ok, _announce, %{data: %{"id" => id}}} <- CommonAPI.repeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def unrepeat(%User{} = user, ap_id_or_id) do
	with {:ok, _unannounce, %{data: %{"id" => id}}} <- CommonAPI.unrepeat(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def pin(%User{} = user, ap_id_or_id) do
	CommonAPI.pin(ap_id_or_id, user)
	end

	def unpin(%User{} = user, ap_id_or_id) do
	CommonAPI.unpin(ap_id_or_id, user)
	end

	def fav(%User{} = user, ap_id_or_id) do
	with {:ok, _fav, %{data: %{"id" => id}}} <- CommonAPI.favorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def unfav(%User{} = user, ap_id_or_id) do
	with {:ok, _unfav, _fav, %{data: %{"id" => id}}} <- CommonAPI.unfavorite(ap_id_or_id, user),
	%Activity{} = activity <- Activity.get_create_by_object_ap_id(id) do
	{:ok, activity}
	end
	end

	def upload(%Plug.Upload{} = file, %User{} = user, format \\ "xml") do
	{:ok, object} = ActivityPub.upload(file, actor: User.ap_id(user))

	url = List.first(object.data["url"])
	href = url["href"]
	type = url["mediaType"]

	case format do
	"xml" ->
	# Fake this as good as possible...
	"""
	<?xml version="1.0" encoding="UTF-8"?>
	<rsp stat="ok" xmlns:atom="http://www.w3.org/2005/Atom">
	<mediaid>#{object.id}</mediaid>
	<media_id>#{object.id}</media_id>
	<media_id_string>#{object.id}</media_id_string>
	<media_url>#{href}</media_url>
	<mediaurl>#{href}</mediaurl>
	<atom:link rel="enclosure" href="#{href}" type="#{type}"></atom:link>
	</rsp>
	"""

	"json" ->
	%{
	media_id: object.id,
	media_id_string: "#{object.id}}",
	media_url: href,
	size: 0
	}
	\|> Jason.encode!()
	end
	end

	def register_user(params) do
	- token_string = params["token"]
	+ token = params["token"]

	params = %{
	nickname: params["nickname"],
	name: params["fullname"],
	bio: User.parse_bio(params["bio"]),
	email: params["email"],
	password: params["password"],
	password_confirmation: params["confirm"],
	captcha_solution: params["captcha_solution"],
	captcha_token: params["captcha_token"],
	captcha_answer_data: params["captcha_answer_data"]
	}

	captcha_enabled = Pleroma.Config.get([Pleroma.Captcha, :enabled])
	# true if captcha is disabled or enabled and valid, false otherwise
	captcha_ok =
	if !captcha_enabled do
	:ok
	else
	Pleroma.Captcha.validate(
	params[:captcha_token],
	params[:captcha_solution],
	params[:captcha_answer_data]
	)
	end

	# Captcha invalid
	if captcha_ok != :ok do
	{:error, error} = captcha_ok
	# I have no idea how this error handling works
	{:error, %{error: Jason.encode!(%{captcha: [error]})}}
	else
	registrations_open = Pleroma.Config.get([:instance, :registrations_open])
	- registration_process(registrations_open, params, token_string)
	+ registration_process(registrations_open, params, token)
	end
	end

	- defp registration_process(_registration_open = true, params, _token_string) do
	+ defp registration_process(_registration_open = true, params, _token) do
	create_user(params)
	end

	- defp registration_process(registration_open, params, token_string)
	+ defp registration_process(registration_open, params, token)
	when registration_open == false or is_nil(registration_open) do
	- token =
	- unless is_nil(token_string) do
	- Repo.get_by(UserInviteToken, %{token: token_string})
	+ invite =
	+ unless is_nil(token) do
	+ Repo.get_by(UserInviteToken, %{token: token})
	end

	- valid_token? = token && UserInviteToken.valid_token?(token)
	+ valid_invite? = invite && UserInviteToken.valid_invite?(invite)

	- case token do
	+ case invite do
	nil ->
	{:error, "Invalid token"}

	- token when valid_token? ->
	- UserInviteToken.update_usage(token)
	+ invite when valid_invite? ->
	+ UserInviteToken.update_usage!(invite)
	create_user(params)

	_ ->
	{:error, "Expired token"}
	end
	end

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

	case User.register(changeset) do
	{:ok, user} ->
	{:ok, user}

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

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

	def password_reset(nickname_or_email) do
	with true <- is_binary(nickname_or_email),
	%User{local: true} = user <- User.get_by_nickname_or_email(nickname_or_email),
	{:ok, token_record} <- Pleroma.PasswordResetToken.create_token(user) do
	user
	\|> UserEmail.password_reset_email(token_record.token)
	\|> Mailer.deliver_async()
	else
	false ->
	{:error, "bad user identifier"}

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

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

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

	_ ->
	{:ok, target}
	end

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

	_ ->
	if user do
	{:ok, user}
	else
	{:error, "You need to specify screen_name or user_id"}
	end
	end
	end

	defp parse_int(string, default)

	defp parse_int(string, default) when is_binary(string) do
	with {n, _} <- Integer.parse(string) do
	n
	else
	_e -> default
	end
	end

	defp parse_int(_, default), do: default

	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

	def get_external_profile(for_user, uri) do
	with %User{} = user <- User.get_or_fetch(uri) do
	{:ok, UserView.render("show.json", %{user: user, for: for_user})}
	else
	_e ->
	{:error, "Couldn't find user"}
	end
	end
	end
	diff --git a/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs b/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs
	index abdd5e277..46fa1cb32 100644
	--- a/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs
	+++ b/priv/repo/migrations/20190404050946_add_fields_to_user_invite_tokens.exs
	@@ -1,12 +1,12 @@
	defmodule Pleroma.Repo.Migrations.AddFieldsToUserInviteTokens do
	use Ecto.Migration

	def change do
	alter table(:user_invite_tokens) do
	add(:expire_at, :date)
	add(:uses, :integer, default: 0)
	add(:max_use, :integer)
	- add(:token_type, :string, default: "one_time")
	+ add(:invite_type, :string, default: "one_time")
	end
	end
	end
	diff --git a/test/tasks/user_test.exs b/test/tasks/user_test.exs
	index c55711b04..c9e5dd625 100644
	--- a/test/tasks/user_test.exs
	+++ b/test/tasks/user_test.exs
	@@ -1,340 +1,340 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Mix.Tasks.Pleroma.UserTest do
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory
	import ExUnit.CaptureIO

	setup_all do
	Mix.shell(Mix.Shell.Process)

	on_exit(fn ->
	Mix.shell(Mix.Shell.IO)
	end)

	:ok
	end

	describe "running new" do
	test "user is created" do
	# just get random data
	unsaved = build(:user)

	# prepare to answer yes
	send(self(), {:mix_shell_input, :yes?, true})

	Mix.Tasks.Pleroma.User.run([
	"new",
	unsaved.nickname,
	unsaved.email,
	"--name",
	unsaved.name,
	"--bio",
	unsaved.bio,
	"--password",
	"test",
	"--moderator",
	"--admin"
	])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_received {:mix_shell, :yes?, [message]}
	assert message =~ "Continue"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "created"

	user = User.get_by_nickname(unsaved.nickname)
	assert user.name == unsaved.name
	assert user.email == unsaved.email
	assert user.bio == unsaved.bio
	assert user.info.is_moderator
	assert user.info.is_admin
	end

	test "user is not created" do
	unsaved = build(:user)

	# prepare to answer no
	send(self(), {:mix_shell_input, :yes?, false})

	Mix.Tasks.Pleroma.User.run(["new", unsaved.nickname, unsaved.email])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "user will be created"

	assert_received {:mix_shell, :yes?, [message]}
	assert message =~ "Continue"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "will not be created"

	refute User.get_by_nickname(unsaved.nickname)
	end
	end

	describe "running rm" do
	test "user is deleted" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["rm", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " deleted"

	user = User.get_by_nickname(user.nickname)
	assert user.info.deactivated
	end

	test "no user to delete" do
	Mix.Tasks.Pleroma.User.run(["rm", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running toggle_activated" do
	test "user is deactivated" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " deactivated"

	user = User.get_by_nickname(user.nickname)
	assert user.info.deactivated
	end

	test "user is activated" do
	user = insert(:user, info: %{deactivated: true})

	Mix.Tasks.Pleroma.User.run(["toggle_activated", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ " activated"

	user = User.get_by_nickname(user.nickname)
	refute user.info.deactivated
	end

	test "no user to toggle" do
	Mix.Tasks.Pleroma.User.run(["toggle_activated", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running unsubscribe" do
	test "user is unsubscribed" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	Mix.Tasks.Pleroma.User.run(["unsubscribe", user.nickname])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Deactivating"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Unsubscribing"

	# Note that the task has delay :timer.sleep(500)
	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Successfully unsubscribed"

	user = User.get_by_nickname(user.nickname)
	assert Enum.empty?(user.following)
	assert user.info.deactivated
	end

	test "no user to unsubscribe" do
	Mix.Tasks.Pleroma.User.run(["unsubscribe", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No user"
	end
	end

	describe "running set" do
	test "All statuses set" do
	user = insert(:user)

	Mix.Tasks.Pleroma.User.run(["set", user.nickname, "--moderator", "--admin", "--locked"])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* true/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* true/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* true/

	user = User.get_by_nickname(user.nickname)
	assert user.info.is_moderator
	assert user.info.locked
	assert user.info.is_admin
	end

	test "All statuses unset" do
	user = insert(:user, info: %{is_moderator: true, locked: true, is_admin: true})

	Mix.Tasks.Pleroma.User.run([
	"set",
	user.nickname,
	"--no-moderator",
	"--no-admin",
	"--no-locked"
	])

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Moderator status .* false/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Locked status .* false/

	assert_received {:mix_shell, :info, [message]}
	assert message =~ ~r/Admin status .* false/

	user = User.get_by_nickname(user.nickname)
	refute user.info.is_moderator
	refute user.info.locked
	refute user.info.is_admin
	end

	test "no user to set status" do
	Mix.Tasks.Pleroma.User.run(["set", "nonexistent", "--moderator"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running reset_password" do
	test "password reset token is generated" do
	user = insert(:user)

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["reset_password", user.nickname])
	end) =~ "URL:"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated"
	end

	test "no user to reset password" do
	Mix.Tasks.Pleroma.User.run(["reset_password", "nonexistent"])

	assert_received {:mix_shell, :error, [message]}
	assert message =~ "No local user"
	end
	end

	describe "running invite" do
	test "invite token is generated" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run(["invite"])
	end) =~ "http"

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token one time"
	end

	test "token is generated with expire_at" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--expire-date",
	Date.to_string(Date.utc_today())
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token date limited"
	end

	test "token is generated with max use" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--max-use",
	"5"
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token reusable"
	end

	test "token is generated with max use and expire date" do
	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite",
	"--max-use",
	"5",
	"--expire-date",
	Date.to_string(Date.utc_today())
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Generated user invite token reusable date limited"
	end
	end

	describe "running invites_list" do
	test "invites are listed" do
	- {:ok, invite} = Pleroma.UserInviteToken.create_token()
	+ {:ok, invite} = Pleroma.UserInviteToken.create_invite()

	{:ok, invite2} =
	- Pleroma.UserInviteToken.create_token(expire_at: Date.utc_today(), max_use: 15)
	+ Pleroma.UserInviteToken.create_invite(%{expire_at: Date.utc_today(), max_use: 15})

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invites_list"
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert_received {:mix_shell, :info, [message2]}
	assert_received {:mix_shell, :info, [message3]}
	assert message =~ "Invites list:"
	assert message2 =~ invite.token_type
	assert message3 =~ invite2.token_type
	end
	end

	describe "running invite revoke" do
	test "invite is revoked" do
	- {:ok, invite} = Pleroma.UserInviteToken.create_token(expire_at: Date.utc_today())
	+ {:ok, invite} = Pleroma.UserInviteToken.create_invite(%{expire_at: Date.utc_today()})

	assert capture_io(fn ->
	Mix.Tasks.Pleroma.User.run([
	"invite_revoke",
	invite.token
	])
	end)

	assert_received {:mix_shell, :info, [message]}
	assert message =~ "Invite for token #{invite.token} was revoked."
	end
	end

	describe "running delete_activities" do
	test "activities are deleted" do
	%{nickname: nickname} = insert(:user)

	assert :ok == Mix.Tasks.Pleroma.User.run(["delete_activities", nickname])
	assert_received {:mix_shell, :info, [message]}
	assert message == "User #{nickname} statuses deleted."
	end
	end
	end
	diff --git a/test/web/twitter_api/twitter_api_test.exs b/test/web/twitter_api/twitter_api_test.exs
	index 716fccfb2..519141c96 100644
	--- a/test/web/twitter_api/twitter_api_test.exs
	+++ b/test/web/twitter_api/twitter_api_test.exs
	@@ -1,725 +1,711 @@
	# Pleroma: A lightweight social networking server
	# Copyright © 2017-2018 Pleroma Authors <https://pleroma.social/>
	# SPDX-License-Identifier: AGPL-3.0-only

	defmodule Pleroma.Web.TwitterAPI.TwitterAPITest do
	use Pleroma.DataCase
	alias Pleroma.Activity
	alias Pleroma.Object
	alias Pleroma.Repo
	alias Pleroma.User
	alias Pleroma.UserInviteToken
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.TwitterAPI.ActivityView
	alias Pleroma.Web.TwitterAPI.TwitterAPI
	alias Pleroma.Web.TwitterAPI.UserView

	import Pleroma.Factory

	setup_all do
	Tesla.Mock.mock_global(fn env -> apply(HttpRequestMock, :request, [env]) end)
	:ok
	end

	test "create a status" do
	user = insert(:user)
	mentioned_user = insert(:user, %{nickname: "shp", ap_id: "shp"})

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

	object = Repo.insert!(%Object{data: object_data})

	input = %{
	"status" =>
	"Hello again, @shp.<script></script>\nThis is on another :moominmamma: line. #2hu #epic #phantasmagoric",
	"media_ids" => [object.id]
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	expected_text =
	"Hello again, <span class='h-card'><a data-user='#{mentioned_user.id}' class='u-url mention' href='shp'>@<span>shp</span></a></span>.<script></script><br>This is on another :moominmamma: line. <a class='hashtag' data-tag='2hu' href='http://localhost:4001/tag/2hu' rel='tag'>#2hu</a> <a class='hashtag' data-tag='epic' href='http://localhost:4001/tag/epic' rel='tag'>#epic</a> <a class='hashtag' data-tag='phantasmagoric' href='http://localhost:4001/tag/phantasmagoric' rel='tag'>#phantasmagoric</a><br><a href=\"http://example.org/image.jpg\" class='attachment'>image.jpg</a>"

	assert get_in(activity.data, ["object", "content"]) == expected_text
	assert get_in(activity.data, ["object", "type"]) == "Note"
	assert get_in(activity.data, ["object", "actor"]) == user.ap_id
	assert get_in(activity.data, ["actor"]) == user.ap_id
	assert Enum.member?(get_in(activity.data, ["cc"]), User.ap_followers(user))

	assert Enum.member?(
	get_in(activity.data, ["to"]),
	"https://www.w3.org/ns/activitystreams#Public"
	)

	assert Enum.member?(get_in(activity.data, ["to"]), "shp")
	assert activity.local == true

	assert %{"moominmamma" => "http://localhost:4001/finmoji/128px/moominmamma-128.png"} =
	activity.data["object"]["emoji"]

	# hashtags
	assert activity.data["object"]["tag"] == ["2hu", "epic", "phantasmagoric"]

	# Add a context
	assert is_binary(get_in(activity.data, ["context"]))
	assert is_binary(get_in(activity.data, ["object", "context"]))

	assert is_list(activity.data["object"]["attachment"])

	assert activity.data["object"] == Object.get_by_ap_id(activity.data["object"]["id"]).data

	user = User.get_by_ap_id(user.ap_id)

	assert user.info.note_count == 1
	end

	test "create a status that is a reply" do
	user = insert(:user)

	input = %{
	"status" => "Hello again."
	}

	{:ok, activity = %Activity{}} = TwitterAPI.create_status(user, input)

	input = %{
	"status" => "Here's your (you).",
	"in_reply_to_status_id" => activity.id
	}

	{:ok, reply = %Activity{}} = TwitterAPI.create_status(user, input)

	assert get_in(reply.data, ["context"]) == get_in(activity.data, ["context"])

	assert get_in(reply.data, ["object", "context"]) ==
	get_in(activity.data, ["object", "context"])

	assert get_in(reply.data, ["object", "inReplyTo"]) == get_in(activity.data, ["object", "id"])
	assert get_in(reply.data, ["object", "inReplyToStatusId"]) == activity.id
	end

	test "Follow another user using user_id" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert User.ap_followers(followed) in user.following

	{:error, msg} = TwitterAPI.follow(user, %{"user_id" => followed.id})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Follow another user using screen_name" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user, followed, _activity} =
	TwitterAPI.follow(user, %{"screen_name" => followed.nickname})

	assert User.ap_followers(followed) in user.following

	followed = User.get_by_ap_id(followed.ap_id)
	assert followed.info.follower_count == 1

	{:error, msg} = TwitterAPI.follow(user, %{"screen_name" => followed.nickname})
	assert msg == "Could not follow user: #{followed.nickname} is already on your list."
	end

	test "Unfollow another user using user_id" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})
	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"user_id" => unfollowed.id})
	assert msg == "Not subscribed!"
	end

	test "Unfollow another user using screen_name" do
	unfollowed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(unfollowed)]})

	ActivityPub.follow(user, unfollowed)

	{:ok, user, unfollowed} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert user.following == []

	{:error, msg} = TwitterAPI.unfollow(user, %{"screen_name" => unfollowed.nickname})
	assert msg == "Not subscribed!"
	end

	test "Block another user using user_id" do
	user = insert(:user)
	blocked = insert(:user)

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

	test "Block another user using screen_name" do
	user = insert(:user)
	blocked = insert(:user)

	{:ok, user, blocked} = TwitterAPI.block(user, %{"screen_name" => blocked.nickname})
	assert User.blocks?(user, blocked)
	end

	test "Unblock another user using user_id" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"user_id" => unblocked.id})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"user_id" => unblocked.id})
	assert user.info.blocks == []
	end

	test "Unblock another user using screen_name" do
	unblocked = insert(:user)
	user = insert(:user)
	{:ok, user, _unblocked} = TwitterAPI.block(user, %{"screen_name" => unblocked.nickname})

	{:ok, user, _unblocked} = TwitterAPI.unblock(user, %{"screen_name" => unblocked.nickname})
	assert user.info.blocks == []
	end

	test "upload a file" do
	user = insert(:user)

	file = %Plug.Upload{
	content_type: "image/jpg",
	path: Path.absname("test/fixtures/image.jpg"),
	filename: "an_image.jpg"
	}

	response = TwitterAPI.upload(file, user)

	assert is_binary(response)
	end

	test "it favorites a status, returns the updated activity" do
	user = insert(:user)
	other_user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.fav(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 1

	object = Object.normalize(note_activity.data["object"])

	assert object.data["like_count"] == 1

	assert status == updated_activity

	{:ok, _status} = TwitterAPI.fav(other_user, note_activity.id)

	object = Object.normalize(note_activity.data["object"])

	assert object.data["like_count"] == 2

	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])
	assert ActivityView.render("activity.json", %{activity: updated_activity})["fave_num"] == 2
	end

	test "it unfavorites a status, returns the updated activity" do
	user = insert(:user)
	note_activity = insert(:note_activity)
	object = Object.get_by_ap_id(note_activity.data["object"]["id"])

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

	assert ActivityView.render("activity.json", activity: updated_activity)["fave_num"] == 1

	{:ok, activity} = TwitterAPI.unfav(user, note_activity.id)

	assert ActivityView.render("activity.json", activity: activity)["fave_num"] == 0
	end

	test "it retweets a status and returns the retweet" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, status} = TwitterAPI.repeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it unretweets an already retweeted status" do
	user = insert(:user)
	note_activity = insert(:note_activity)

	{:ok, _status} = TwitterAPI.repeat(user, note_activity.id)
	{:ok, status} = TwitterAPI.unrepeat(user, note_activity.id)
	updated_activity = Activity.get_by_ap_id(note_activity.data["id"])

	assert status == updated_activity
	end

	test "it registers a new user and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_by_nickname("lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it registers a new user with empty string in bio and returns the user." do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_by_nickname("lain")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "it sends confirmation email if :account_activation_required is specified in instance config" do
	setting = Pleroma.Config.get([:instance, :account_activation_required])

	unless setting do
	Pleroma.Config.put([:instance, :account_activation_required], true)
	on_exit(fn -> Pleroma.Config.put([:instance, :account_activation_required], setting) end)
	end

	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user} = TwitterAPI.register_user(data)

	assert user.info.confirmation_pending

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

	test "it registers a new user and parses mentions in the bio" do
	data1 = %{
	"nickname" => "john",
	"email" => "john@gmail.com",
	"fullname" => "John Doe",
	"bio" => "test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user1} = TwitterAPI.register_user(data1)

	data2 = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "@john test",
	"password" => "bear",
	"confirm" => "bear"
	}

	{:ok, user2} = TwitterAPI.register_user(data2)

	expected_text =
	"<span class='h-card'><a data-user='#{user1.id}' class='u-url mention' href='#{user1.ap_id}'>@<span>john</span></a></span> test"

	assert user2.bio == expected_text
	end

	describe "register with one time token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success" do
	- {:ok, token} = UserInviteToken.create_token()
	+ {:ok, invite} = UserInviteToken.create_invite()

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)

	fetched_user = User.get_by_nickname("vinny")
	- token = Repo.get_by(UserInviteToken, token: token.token)
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)

	- assert token.used == true
	+ assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "returns error on invalid token" do
	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	"token" => "DudeLetMeInImAFairy"
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Invalid token"
	refute User.get_by_nickname("GrimReaper")
	end

	test "returns error on expired token" do
	- {:ok, token} = UserInviteToken.create_token()
	- UserInviteToken.mark_as_used(token.token)
	+ {:ok, invite} = UserInviteToken.create_invite()
	+ UserInviteToken.update_invite!(invite, used: true)

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_by_nickname("GrimReaper")
	end
	end

	describe "registers with date limited token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees"
	}

	- check_fn = fn token ->
	- data = Map.put(data, "token", token.token)
	+ check_fn = fn invite ->
	+ data = Map.put(data, "token", invite.token)
	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_by_nickname("vinny")

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	{:ok, data: data, check_fn: check_fn}
	end

	test "returns user on success", %{check_fn: check_fn} do
	- {:ok, token} = UserInviteToken.create_token(expire_at: Date.utc_today())
	+ {:ok, invite} = UserInviteToken.create_invite(%{expire_at: Date.utc_today()})

	- check_fn.(token)
	+ check_fn.(invite)

	- token = Repo.get_by(UserInviteToken, token: token.token)
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)

	- refute token.used
	+ refute invite.used
	end

	test "returns user on token which expired tomorrow", %{check_fn: check_fn} do
	- {:ok, token} = UserInviteToken.create_token(expire_at: Date.add(Date.utc_today(), 1))
	+ {:ok, invite} = UserInviteToken.create_invite(%{expire_at: Date.add(Date.utc_today(), 1)})

	- check_fn.(token)
	+ check_fn.(invite)

	- token = Repo.get_by(UserInviteToken, token: token.token)
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)

	- refute token.used
	+ refute invite.used
	end

	test "returns an error on overdue date", %{data: data} do
	- {:ok, token} = UserInviteToken.create_token(expire_at: Date.add(Date.utc_today(), -1))
	+ {:ok, invite} = UserInviteToken.create_invite(%{expire_at: Date.add(Date.utc_today(), -1)})

	- data = Map.put(data, "token", token.token)
	+ data = Map.put(data, "token", invite.token)

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_by_nickname("vinny")
	- token = Repo.get_by(UserInviteToken, token: token.token)
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)

	- assert token.used == true
	+ assert invite.used == true
	end
	end

	describe "registers with reusable token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success, after him registration fails" do
	- {:ok, token} = UserInviteToken.create_token(max_use: 100)
	+ {:ok, invite} = UserInviteToken.create_invite(%{max_use: 100})

	- Ecto.Changeset.change(token, uses: 99) \|> Repo.update!()
	+ UserInviteToken.update_invite!(invite, uses: 99)

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_by_nickname("vinny")
	- token = Repo.get_by(UserInviteToken, token: token.token)
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)

	- assert token.used == true
	+ assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_by_nickname("GrimReaper")
	end
	end

	describe "registers with reusable date limited token" do
	setup do
	setting = Pleroma.Config.get([:instance, :registrations_open])

	if setting do
	Pleroma.Config.put([:instance, :registrations_open], false)
	on_exit(fn -> Pleroma.Config.put([:instance, :registrations_open], setting) end)
	end

	:ok
	end

	test "returns user on success" do
	- {:ok, token} =
	- UserInviteToken.create_token(
	- expire_at: Date.utc_today(),
	- max_use: 100
	- )
	+ {:ok, invite} = UserInviteToken.create_invite(%{expire_at: Date.utc_today(), max_use: 100})

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_by_nickname("vinny")
	- token = Repo.get_by(UserInviteToken, token: token.token)
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)

	- refute token.used
	+ refute invite.used

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})
	end

	test "error after max uses" do
	- {:ok, token} =
	- UserInviteToken.create_token(
	- expire_at: Date.utc_today(),
	- max_use: 100
	- )
	+ {:ok, invite} = UserInviteToken.create_invite(%{expire_at: Date.utc_today(), max_use: 100})

	- Ecto.Changeset.change(token, uses: 99) \|> Repo.update!()
	+ UserInviteToken.update_invite!(invite, uses: 99)

	data = %{
	"nickname" => "vinny",
	"email" => "pasta@pizza.vs",
	"fullname" => "Vinny Vinesauce",
	"bio" => "streamer",
	"password" => "hiptofbees",
	"confirm" => "hiptofbees",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:ok, user} = TwitterAPI.register_user(data)
	fetched_user = User.get_by_nickname("vinny")
	- token = Repo.get_by(UserInviteToken, token: token.token)
	- assert token.used == true
	+ invite = Repo.get_by(UserInviteToken, token: invite.token)
	+ assert invite.used == true

	assert UserView.render("show.json", %{user: user}) ==
	UserView.render("show.json", %{user: fetched_user})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_by_nickname("GrimReaper")
	end

	test "returns error on overdue date" do
	- {:ok, token} =
	- UserInviteToken.create_token(
	- expire_at: Date.add(Date.utc_today(), -1),
	- max_use: 100
	- )
	+ {:ok, invite} =
	+ UserInviteToken.create_invite(%{expire_at: Date.add(Date.utc_today(), -1), max_use: 100})

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_by_nickname("GrimReaper")
	end

	test "returns error on with overdue date and after max" do
	- {:ok, token} =
	- UserInviteToken.create_token(
	- expire_at: Date.add(Date.utc_today(), -1),
	- max_use: 100
	- )
	+ {:ok, invite} =
	+ UserInviteToken.create_invite(%{expire_at: Date.add(Date.utc_today(), -1), max_use: 100})

	- Ecto.Changeset.change(token, uses: 100) \|> Repo.update!()
	+ UserInviteToken.update_invite!(invite, uses: 100)

	data = %{
	"nickname" => "GrimReaper",
	"email" => "death@reapers.afterlife",
	"fullname" => "Reaper Grim",
	"bio" => "Your time has come",
	"password" => "scythe",
	"confirm" => "scythe",
	- "token" => token.token
	+ "token" => invite.token
	}

	{:error, msg} = TwitterAPI.register_user(data)

	assert msg == "Expired token"
	refute User.get_by_nickname("GrimReaper")
	end
	end

	test "it returns the error on registration problems" do
	data = %{
	"nickname" => "lain",
	"email" => "lain@wired.jp",
	"fullname" => "lain iwakura",
	"bio" => "close the world.",
	"password" => "bear"
	}

	{:error, error_object} = TwitterAPI.register_user(data)

	assert is_binary(error_object[:error])
	refute User.get_by_nickname("lain")
	end

	test "it assigns an integer conversation_id" do
	note_activity = insert(:note_activity)
	status = ActivityView.render("activity.json", activity: note_activity)

	assert is_number(status["statusnet_conversation_id"])
	end

	setup do
	Supervisor.terminate_child(Pleroma.Supervisor, Cachex)
	Supervisor.restart_child(Pleroma.Supervisor, Cachex)
	:ok
	end

	describe "fetching a user by uri" do
	test "fetches a user by uri" do
	id = "https://mastodon.social/users/lambadalambda"
	user = insert(:user)
	{:ok, represented} = TwitterAPI.get_external_profile(user, id)
	remote = User.get_by_ap_id(id)

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

	# Also fetches the feed.
	# assert Activity.get_create_by_object_ap_id("tag:mastodon.social,2017-04-05:objectId=1641750:objectType=Status")
	# credo:disable-for-previous-line Credo.Check.Readability.MaxLineLength
	end
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Sep 19, 2:03 AM (12 h, 31 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1768628
Default Alt Text: (63 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions