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)
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}")
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
end
def register_user(params) do
- token_string = params["token"]
+ token = params["token"]
params = %{
nickname: params["nickname"],
{: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)
_ ->
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
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([
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([
end
test "returns user on success" do
- {:ok, token} = UserInviteToken.create_token()
+ {:ok, invite} = UserInviteToken.create_invite()
data = %{
"nickname" => "vinny",
"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 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",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
- "token" => token.token
+ "token" => invite.token
}
{:error, msg} = TwitterAPI.register_user(data)
"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")
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
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",
"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})
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
- "token" => token.token
+ "token" => invite.token
}
{:error, msg} = TwitterAPI.register_user(data)
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",
"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",
"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})
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
- "token" => token.token
+ "token" => invite.token
}
{:error, msg} = TwitterAPI.register_user(data)
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",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
- "token" => token.token
+ "token" => invite.token
}
{:error, msg} = TwitterAPI.register_user(data)
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",
"bio" => "Your time has come",
"password" => "scythe",
"confirm" => "scythe",
- "token" => token.token
+ "token" => invite.token
}
{:error, msg} = TwitterAPI.register_user(data)
projects / akkoma / commitdiff