No OneTemporary
Actions

Size

116 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/app/Http/Controllers/API/SignupController.php b/src/app/Http/Controllers/API/SignupController.php
	index b1a69e2f..754e393c 100644
	--- a/src/app/Http/Controllers/API/SignupController.php
	+++ b/src/app/Http/Controllers/API/SignupController.php
	@@ -1,380 +1,378 @@
	<?php

	namespace App\Http\Controllers\API;

	use App\Http\Controllers\Controller;
	use App\Jobs\SignupVerificationEmail;
	use App\Jobs\SignupVerificationSMS;
	use App\Discount;
	use App\Domain;
	use App\Plan;
	use App\Rules\ExternalEmail;
	use App\Rules\UserEmailDomain;
	use App\Rules\UserEmailLocal;
	use App\SignupCode;
	use App\User;
	use Illuminate\Http\Request;
	use Illuminate\Support\Facades\DB;
	use Illuminate\Support\Facades\Validator;
	use Illuminate\Support\Str;

	/**
	* Signup process API
	*/
	class SignupController extends Controller
	{
	/** @var ?\App\SignupCode A verification code object */
	protected $code;

	/** @var ?\App\Plan Signup plan object */
	protected $plan;


	/**
	* Returns plans definitions for signup.
	*
	* @param \Illuminate\Http\Request $request HTTP request
	*
	* @return \Illuminate\Http\JsonResponse JSON response
	*/
	public function plans(Request $request)
	{
	$plans = [];

	// Use reverse order just to have individual on left, group on right ;)
	Plan::select()->orderByDesc('title')->get()->map(function ($plan) use (&$plans) {
	$plans[] = [
	'title' => $plan->title,
	'name' => $plan->name,
	'button' => __('app.planbutton', ['plan' => $plan->name]),
	'description' => $plan->description,
	];
	});

	return response()->json(['status' => 'success', 'plans' => $plans]);
	}

	/**
	* Starts signup process.
	*
	* Verifies user name and email/phone, sends verification email/sms message.
	* Returns the verification code.
	*
	* @param \Illuminate\Http\Request $request HTTP request
	*
	* @return \Illuminate\Http\JsonResponse JSON response
	*/
	public function init(Request $request)
	{
	// Check required fields
	$v = Validator::make(
	$request->all(),
	[
	'email' => 'required',
	'first_name' => 'max:128',
	'last_name' => 'max:128',
	'plan' => 'nullable\|alpha_num\|max:128',
	'voucher' => 'max:32',
	]
	);

	$is_phone = false;
	$errors = $v->fails() ? $v->errors()->toArray() : [];

	// Validate user email (or phone)
	if (empty($errors['email'])) {
	if ($error = $this->validatePhoneOrEmail($request->email, $is_phone)) {
	$errors['email'] = $error;
	}
	}

	if (!empty($errors)) {
	return response()->json(['status' => 'error', 'errors' => $errors], 422);
	}

	// Generate the verification code
	$code = SignupCode::create([
	- 'data' => [
	- 'email' => $request->email,
	- 'first_name' => $request->first_name,
	- 'last_name' => $request->last_name,
	- 'plan' => $request->plan,
	- 'voucher' => $request->voucher,
	- ]
	+ 'email' => $request->email,
	+ 'first_name' => $request->first_name,
	+ 'last_name' => $request->last_name,
	+ 'plan' => $request->plan,
	+ 'voucher' => $request->voucher,
	]);

	// Send email/sms message
	if ($is_phone) {
	SignupVerificationSMS::dispatch($code);
	} else {
	SignupVerificationEmail::dispatch($code);
	}

	return response()->json(['status' => 'success', 'code' => $code->code]);
	}

	/**
	* Validation of the verification code.
	*
	* @param \Illuminate\Http\Request $request HTTP request
	*
	* @return \Illuminate\Http\JsonResponse JSON response
	*/
	public function verify(Request $request)
	{
	// Validate the request args
	$v = Validator::make(
	$request->all(),
	[
	'code' => 'required',
	'short_code' => 'required',
	]
	);

	if ($v->fails()) {
	return response()->json(['status' => 'error', 'errors' => $v->errors()], 422);
	}

	// Validate the verification code
	$code = SignupCode::find($request->code);

	if (
	empty($code)
	\|\| $code->isExpired()
	\|\| Str::upper($request->short_code) !== Str::upper($code->short_code)
	) {
	$errors = ['short_code' => "The code is invalid or expired."];
	return response()->json(['status' => 'error', 'errors' => $errors], 422);
	}

	// For signup last-step mode remember the code object, so we can delete it
	// with single SQL query (->delete()) instead of two (::destroy())
	$this->code = $code;

	$has_domain = $this->getPlan()->hasDomain();

	// Return user name and email/phone/voucher from the codes database,
	// domains list for selection and "plan type" flag
	return response()->json([
	'status' => 'success',
	- 'email' => $code->data['email'],
	- 'first_name' => $code->data['first_name'],
	- 'last_name' => $code->data['last_name'],
	- 'voucher' => $code->data['voucher'],
	+ 'email' => $code->email,
	+ 'first_name' => $code->first_name,
	+ 'last_name' => $code->last_name,
	+ 'voucher' => $code->voucher,
	'is_domain' => $has_domain,
	'domains' => $has_domain ? [] : Domain::getPublicDomains(),
	]);
	}

	/**
	* Finishes the signup process by creating the user account.
	*
	* @param \Illuminate\Http\Request $request HTTP request
	*
	* @return \Illuminate\Http\JsonResponse JSON response
	*/
	public function signup(Request $request)
	{
	// Validate input
	$v = Validator::make(
	$request->all(),
	[
	'login' => 'required\|min:2',
	'password' => 'required\|min:4\|confirmed',
	'domain' => 'required',
	'voucher' => 'max:32',
	]
	);

	if ($v->fails()) {
	return response()->json(['status' => 'error', 'errors' => $v->errors()], 422);
	}

	// Validate verification codes (again)
	$v = $this->verify($request);
	if ($v->status() !== 200) {
	return $v;
	}

	// Find the voucher discount
	if ($request->voucher) {
	$discount = Discount::where('code', \strtoupper($request->voucher))
	->where('active', true)->first();

	if (!$discount) {
	$errors = ['voucher' => \trans('validation.voucherinvalid')];
	return response()->json(['status' => 'error', 'errors' => $errors], 422);
	}
	}

	// Get the plan
	$plan = $this->getPlan();
	$is_domain = $plan->hasDomain();

	$login = $request->login;
	$domain_name = $request->domain;

	// Validate login
	if ($errors = self::validateLogin($login, $domain_name, $is_domain)) {
	return response()->json(['status' => 'error', 'errors' => $errors], 422);
	}

	// Get user name/email from the verification code database
	$code_data = $v->getData();
	$user_email = $code_data->email;

	// We allow only ASCII, so we can safely lower-case the email address
	$login = Str::lower($login);
	$domain_name = Str::lower($domain_name);
	$domain = null;

	DB::beginTransaction();

	// Create domain record
	if ($is_domain) {
	$domain = Domain::create([
	'namespace' => $domain_name,
	'status' => Domain::STATUS_NEW,
	'type' => Domain::TYPE_EXTERNAL,
	]);
	}

	// Create user record
	$user = User::create([
	'email' => $login . '@' . $domain_name,
	'password' => $request->password,
	]);

	if (!empty($discount)) {
	$wallet = $user->wallets()->first();
	$wallet->discount()->associate($discount);
	$wallet->save();
	}

	$user->assignPlan($plan, $domain);

	// Save the external email and plan in user settings
	$user->setSettings([
	'external_email' => $user_email,
	'first_name' => $code_data->first_name,
	'last_name' => $code_data->last_name,
	]);

	// Remove the verification code
	$this->code->delete();

	DB::commit();

	return AuthController::logonResponse($user);
	}

	/**
	* Returns plan for the signup process
	*
	* @returns \App\Plan Plan object selected for current signup process
	*/
	protected function getPlan()
	{
	if (!$this->plan) {
	// Get the plan if specified and exists...
	- if ($this->code && $this->code->data['plan']) {
	- $plan = Plan::where('title', $this->code->data['plan'])->first();
	+ if ($this->code && $this->code->plan) {
	+ $plan = Plan::where('title', $this->code->plan)->first();
	}

	// ...otherwise use the default plan
	if (empty($plan)) {
	// TODO: Get default plan title from config
	$plan = Plan::where('title', 'individual')->first();
	}

	$this->plan = $plan;
	}

	return $this->plan;
	}

	/**
	* Checks if the input string is a valid email address or a phone number
	*
	* @param string $input Email address or phone number
	* @param bool $is_phone Will have been set to True if the string is valid phone number
	*
	* @return string Error message on validation error
	*/
	protected static function validatePhoneOrEmail($input, &$is_phone = false): ?string
	{
	$is_phone = false;

	$v = Validator::make(
	['email' => $input],
	['email' => ['required', 'string', new ExternalEmail()]]
	);

	if ($v->fails()) {
	return $v->errors()->toArray()['email'][0];
	}

	// TODO: Phone number support
	/*
	$input = str_replace(array('-', ' '), '', $input);

	if (!preg_match('/^\+?[0-9]{9,12}$/', $input)) {
	return \trans('validation.noemailorphone');
	}

	$is_phone = true;
	*/
	return null;
	}

	/**
	* Login (kolab identity) validation
	*
	* @param string $login Login (local part of an email address)
	* @param string $domain Domain name
	* @param bool $external Enables additional checks for domain part
	*
	* @return array Error messages on validation error
	*/
	protected static function validateLogin($login, $domain, $external = false): ?array
	{
	// Validate login part alone
	$v = Validator::make(
	['login' => $login],
	['login' => ['required', 'string', new UserEmailLocal($external)]]
	);

	if ($v->fails()) {
	return ['login' => $v->errors()->toArray()['login'][0]];
	}

	$domains = $external ? null : Domain::getPublicDomains();

	// Validate the domain
	$v = Validator::make(
	['domain' => $domain],
	['domain' => ['required', 'string', new UserEmailDomain($domains)]]
	);

	if ($v->fails()) {
	return ['domain' => $v->errors()->toArray()['domain'][0]];
	}

	$domain = Str::lower($domain);

	// Check if domain is already registered with us
	if ($external) {
	if (Domain::where('namespace', $domain)->first()) {
	return ['domain' => \trans('validation.domainexists')];
	}
	}

	// Check if user with specified login already exists
	$email = $login . '@' . $domain;
	if (User::emailExists($email) \|\| User::aliasExists($email) \|\| \App\Group::emailExists($email)) {
	return ['login' => \trans('validation.loginexists')];
	}

	return null;
	}
	}
	diff --git a/src/app/Http/Controllers/Controller.php b/src/app/Http/Controllers/Controller.php
	index 9e957987..846658d7 100644
	--- a/src/app/Http/Controllers/Controller.php
	+++ b/src/app/Http/Controllers/Controller.php
	@@ -1,49 +1,50 @@
	<?php

	namespace App\Http\Controllers;

	use Illuminate\Foundation\Bus\DispatchesJobs;
	use Illuminate\Routing\Controller as BaseController;
	use Illuminate\Foundation\Validation\ValidatesRequests;
	use Illuminate\Foundation\Auth\Access\AuthorizesRequests;

	class Controller extends BaseController
	{
	use AuthorizesRequests;
	use DispatchesJobs;
	use ValidatesRequests;


	/**
	* Common error response builder for API (JSON) responses
	*
	* @param int $code Error code
	* @param string $message Error message
	* @param array $data Additional response data
	*
	* @return \Illuminate\Http\JsonResponse
	*/
	protected function errorResponse(int $code, string $message = null, array $data = [])
	{
	$errors = [
	400 => "Bad request",
	401 => "Unauthorized",
	403 => "Access denied",
	404 => "Not found",
	- 422 => "Input validation error",
	405 => "Method not allowed",
	+ 422 => "Input validation error",
	+ 429 => "Too many requests",
	500 => "Internal server error",
	];

	$response = [
	'status' => 'error',
	'message' => $message ?: (isset($errors[$code]) ? $errors[$code] : "Server error"),
	];

	if (!empty($data)) {
	$response = $response + $data;
	}

	return response()->json($response, $code);
	}
	}
	diff --git a/src/app/Jobs/SignupVerificationEmail.php b/src/app/Jobs/SignupVerificationEmail.php
	index dd578fce..bf51ed2c 100644
	--- a/src/app/Jobs/SignupVerificationEmail.php
	+++ b/src/app/Jobs/SignupVerificationEmail.php
	@@ -1,63 +1,63 @@
	<?php

	namespace App\Jobs;

	use App\Mail\SignupVerification;
	use App\SignupCode;
	use Illuminate\Bus\Queueable;
	use Illuminate\Contracts\Queue\ShouldQueue;
	use Illuminate\Foundation\Bus\Dispatchable;
	use Illuminate\Support\Facades\Mail;
	use Illuminate\Queue\SerializesModels;
	use Illuminate\Queue\InteractsWithQueue;

	class SignupVerificationEmail implements ShouldQueue
	{
	use Dispatchable;
	use InteractsWithQueue;
	use Queueable;
	use SerializesModels;

	/** @var int The number of times the job may be attempted. */
	public $tries = 2;

	/** @var bool Delete the job if its models no longer exist. */
	public $deleteWhenMissingModels = true;

	/** @var SignupCode Signup verification code object */
	protected $code;


	/**
	* Create a new job instance.
	*
	* @param SignupCode $code Verification code object
	*
	* @return void
	*/
	public function __construct(SignupCode $code)
	{
	$this->code = $code;
	}

	/**
	* Determine the time at which the job should timeout.
	*
	* @return \DateTime
	*/
	public function retryUntil()
	{
	// FIXME: I think it does not make sense to continue trying after 1 hour
	return now()->addHours(1);
	}

	/**
	* Execute the job.
	*
	* @return void
	*/
	public function handle()
	{
	- Mail::to($this->code->data['email'])->send(new SignupVerification($this->code));
	+ Mail::to($this->code->email)->send(new SignupVerification($this->code));
	}
	}
	diff --git a/src/app/Mail/SignupVerification.php b/src/app/Mail/SignupVerification.php
	index 039263a1..e8847b88 100644
	--- a/src/app/Mail/SignupVerification.php
	+++ b/src/app/Mail/SignupVerification.php
	@@ -1,87 +1,85 @@
	<?php

	namespace App\Mail;

	use App\SignupCode;
	use App\Utils;
	use Illuminate\Bus\Queueable;
	use Illuminate\Mail\Mailable;
	use Illuminate\Queue\SerializesModels;
	use Illuminate\Support\Str;

	class SignupVerification extends Mailable
	{
	use Queueable;
	use SerializesModels;

	/** @var SignupCode A signup verification code object */
	protected $code;


	/**
	* Create a new message instance.
	*
	* @param SignupCode $code A signup verification code object
	*
	* @return void
	*/
	public function __construct(SignupCode $code)
	{
	$this->code = $code;
	}

	/**
	* Build the message.
	*
	* @return $this
	*/
	public function build()
	{
	$href = Utils::serviceUrl(
	sprintf('/signup/%s-%s', $this->code->short_code, $this->code->code)
	);

	- $username = $this->code->data['first_name'] ?? '';
	- if (!empty($this->code->data['last_name'])) {
	- $username .= ' ' . $this->code->data['last_name'];
	+ $username = $this->code->first_name ?? '';
	+ if (!empty($this->code->last_name)) {
	+ $username .= ' ' . $this->code->last_name;
	}
	$username = trim($username);

	$this->view('emails.html.signup_code')
	->text('emails.plain.signup_code')
	->subject(__('mail.signupcode-subject', ['site' => \config('app.name')]))
	->with([
	'site' => \config('app.name'),
	'username' => $username ?: 'User',
	'code' => $this->code->code,
	'short_code' => $this->code->short_code,
	'href' => $href,
	]);

	return $this;
	}

	/**
	* Render the mail template with fake data
	*
	* @param string $type Output format ('html' or 'text')
	*
	* @return string HTML or Plain Text output
	*/
	public static function fakeRender(string $type = 'html'): string
	{
	$code = new SignupCode([
	'code' => Str::random(SignupCode::CODE_LENGTH),
	'short_code' => SignupCode::generateShortCode(),
	- 'data' => [
	- 'email' => 'test@' . \config('app.domain'),
	- 'first_name' => 'Firstname',
	- 'last_name' => 'Lastname',
	- ],
	+ 'email' => 'test@' . \config('app.domain'),
	+ 'first_name' => 'Firstname',
	+ 'last_name' => 'Lastname',
	]);

	$mail = new self($code);

	return Helper::render($mail, $type);
	}
	}
	diff --git a/src/app/Observers/SignupCodeObserver.php b/src/app/Observers/SignupCodeObserver.php
	index 9f90c9fc..8c832697 100644
	--- a/src/app/Observers/SignupCodeObserver.php
	+++ b/src/app/Observers/SignupCodeObserver.php
	@@ -1,39 +1,67 @@
	<?php

	namespace App\Observers;

	use App\SignupCode;
	use Carbon\Carbon;
	use Illuminate\Support\Str;

	class SignupCodeObserver
	{
	/**
	* Handle the "creating" event.
	*
	* Ensure that the code entry is created with a random code/short_code.
	*
	* @param \App\SignupCode $code The code being created.
	*
	* @return void
	*/
	public function creating(SignupCode $code): void
	{
	$code_length = SignupCode::CODE_LENGTH;
	$exp_hours = env('SIGNUP_CODE_EXPIRY', SignupCode::CODE_EXP_HOURS);

	if (empty($code->code)) {
	$code->short_code = SignupCode::generateShortCode();

	// FIXME: Replace this with something race-condition free
	while (true) {
	$code->code = Str::random($code_length);
	if (!SignupCode::find($code->code)) {
	break;
	}
	}
	}

	$code->expires_at = Carbon::now()->addHours($exp_hours);
	+ $code->ip_address = request()->ip();
	+
	+ if ($code->email) {
	+ $parts = explode('@', $code->email);
	+
	+ $code->local_part = $parts[0];
	+ $code->domain_part = $parts[1];
	+ }
	+ }
	+
	+ /**
	+ * Handle the "updating" event.
	+ *
	+ * @param SignupCode $code The code being updated.
	+ *
	+ * @return void
	+ */
	+ public function updating(SignupCode $code)
	+ {
	+ if ($code->email) {
	+ $parts = explode('@', $code->email);
	+
	+ $code->local_part = $parts[0];
	+ $code->domain_part = $parts[1];
	+ } else {
	+ $code->local_part = null;
	+ $code->domain_part = null;
	+ }
	}
	}
	diff --git a/src/app/Observers/VerificationCodeObserver.php b/src/app/Observers/VerificationCodeObserver.php
	index 755b2898..4b33ba73 100644
	--- a/src/app/Observers/VerificationCodeObserver.php
	+++ b/src/app/Observers/VerificationCodeObserver.php
	@@ -1,40 +1,39 @@
	<?php

	namespace App\Observers;

	use App\VerificationCode;
	-use App\SignupCode;
	use Carbon\Carbon;
	use Illuminate\Support\Str;

	class VerificationCodeObserver
	{
	/**
	* Handle the "creating" event.
	*
	* Ensure that the code entry is created with a random code/short_code.
	*
	* @param \App\VerificationCode $code The code being created.
	*
	* @return void
	*/
	public function creating(VerificationCode $code): void
	{
	$code_length = VerificationCode::CODE_LENGTH;
	$exp_hours = env('VERIFICATION_CODE_EXPIRY', VerificationCode::CODE_EXP_HOURS);

	if (empty($code->code)) {
	$code->short_code = VerificationCode::generateShortCode();

	// FIXME: Replace this with something race-condition free
	while (true) {
	$code->code = Str::random($code_length);
	if (!VerificationCode::find($code->code)) {
	break;
	}
	}
	}

	$code->expires_at = Carbon::now()->addHours($exp_hours);
	}
	}
	diff --git a/src/app/SignupCode.php b/src/app/SignupCode.php
	index 9f44dae0..29e43e2a 100644
	--- a/src/app/SignupCode.php
	+++ b/src/app/SignupCode.php
	@@ -1,96 +1,104 @@
	<?php

	namespace App;

	use Carbon\Carbon;
	use Illuminate\Database\Eloquent\Model;
	+use Illuminate\Database\Eloquent\SoftDeletes;

	/**
	* The eloquent definition of a SignupCode.
	*
	- * @property string $code
	- * @property array $data
	- * @property \Carbon\Carbon $expires_at
	- * @property string $short_code
	+ * @property string $code The full code identifier
	+ * @property \Carbon\Carbon $created_at The creation timestamp
	+ * @property \Carbon\Carbon $deleted_at The deletion timestamp
	+ * @property string $domain_part Email domain
	+ * @property string $email Email address
	+ * @property \Carbon\Carbon $expires_at The code expiration timestamp
	+ * @property string $first_name Firstname
	+ * @property string $ip_address IP address the request came from
	+ * @property string $last_name Lastname
	+ * @property string $local_part Email local part
	+ * @property string $plan Plan title
	+ * @property string $short_code Short validation code
	+ * @property \Carbon\Carbon $updated_at The update timestamp
	+ * @property string $voucher Voucher discount code
	*/
	class SignupCode extends Model
	{
	+ use SoftDeletes;
	+
	public const SHORTCODE_LENGTH = 5;
	public const CODE_LENGTH = 32;

	// Code expires after so many hours
	public const CODE_EXP_HOURS = 24;


	/**
	* The primary key associated with the table.
	*
	* @var string
	*/
	protected $primaryKey = 'code';

	/**
	* Indicates if the IDs are auto-incrementing.
	*
	* @var bool
	*/
	public $incrementing = false;

	/**
	* The "type" of the auto-incrementing ID.
	*
	* @var string
	*/
	protected $keyType = 'string';

	- /**
	- * Indicates if the model should be timestamped.
	- *
	- * @var bool
	- */
	- public $timestamps = false;
	-
	/**
	* The attributes that are mass assignable.
	*
	* @var array
	*/
	- protected $fillable = ['code', 'short_code', 'data', 'expires_at'];
	-
	- /**
	- * The attributes that should be cast to native types.
	- *
	- * @var array
	- */
	- protected $casts = ['data' => 'array'];
	+ protected $fillable = [
	+ 'code',
	+ 'email',
	+ 'expires_at',
	+ 'first_name',
	+ 'last_name',
	+ 'plan',
	+ 'short_code',
	+ 'voucher'
	+ ];

	/**
	* The attributes that should be mutated to dates.
	*
	* @var array
	*/
	protected $dates = ['expires_at'];

	/**
	* Check if code is expired.
	*
	* @return bool True if code is expired, False otherwise
	*/
	public function isExpired()
	{
	// @phpstan-ignore-next-line
	return $this->expires_at ? Carbon::now()->gte($this->expires_at) : false;
	}

	/**
	* Generate a short code (for human).
	*
	* @return string
	*/
	public static function generateShortCode(): string
	{
	$code_length = env('SIGNUP_CODE_LENGTH', self::SHORTCODE_LENGTH);

	return \App\Utils::randStr($code_length);
	}
	}
	diff --git a/src/app/User.php b/src/app/User.php
	index 343953fb..44f2ff0e 100644
	--- a/src/app/User.php
	+++ b/src/app/User.php
	@@ -1,723 +1,721 @@
	<?php

	namespace App;

	use App\Entitlement;
	use App\UserAlias;
	use App\Sku;
	use App\Traits\UserAliasesTrait;
	use App\Traits\SettingsTrait;
	use App\Wallet;
	-use Illuminate\Notifications\Notifiable;
	use Illuminate\Database\Eloquent\SoftDeletes;
	use Illuminate\Foundation\Auth\User as Authenticatable;
	use Iatstuti\Database\Support\NullableFields;
	use Tymon\JWTAuth\Contracts\JWTSubject;

	/**
	* The eloquent definition of a User.
	*
	* @property string $email
	* @property int $id
	* @property string $password
	* @property int $status
	*/
	class User extends Authenticatable implements JWTSubject
	{
	- use Notifiable;
	use NullableFields;
	use UserAliasesTrait;
	use SettingsTrait;
	use SoftDeletes;

	// a new user, default on creation
	public const STATUS_NEW = 1 << 0;
	// it's been activated
	public const STATUS_ACTIVE = 1 << 1;
	// user has been suspended
	public const STATUS_SUSPENDED = 1 << 2;
	// user has been deleted
	public const STATUS_DELETED = 1 << 3;
	// user has been created in LDAP
	public const STATUS_LDAP_READY = 1 << 4;
	// user mailbox has been created in IMAP
	public const STATUS_IMAP_READY = 1 << 5;


	// change the default primary key type
	public $incrementing = false;
	protected $keyType = 'bigint';

	/**
	* The attributes that are mass assignable.
	*
	* @var array
	*/
	protected $fillable = [
	'id',
	'email',
	'password',
	'password_ldap',
	'status'
	];

	/**
	* The attributes that should be hidden for arrays.
	*
	* @var array
	*/
	protected $hidden = [
	'password',
	'password_ldap',
	'role'
	];

	protected $nullable = [
	'password',
	'password_ldap'
	];

	/**
	* Any wallets on which this user is a controller.
	*
	* This does not include wallets owned by the user.
	*
	* @return \Illuminate\Database\Eloquent\Relations\BelongsToMany
	*/
	public function accounts()
	{
	return $this->belongsToMany(
	'App\Wallet', // The foreign object definition
	'user_accounts', // The table name
	'user_id', // The local foreign key
	'wallet_id' // The remote foreign key
	);
	}

	/**
	* Email aliases of this user.
	*
	* @return \Illuminate\Database\Eloquent\Relations\HasMany
	*/
	public function aliases()
	{
	return $this->hasMany('App\UserAlias', 'user_id');
	}

	/**
	* Assign a package to a user. The user should not have any existing entitlements.
	*
	* @param \App\Package $package The package to assign.
	* @param \App\User\|null $user Assign the package to another user.
	*
	* @return \App\User
	*/
	public function assignPackage($package, $user = null)
	{
	if (!$user) {
	$user = $this;
	}

	$wallet_id = $this->wallets()->first()->id;

	foreach ($package->skus as $sku) {
	for ($i = $sku->pivot->qty; $i > 0; $i--) {
	\App\Entitlement::create(
	[
	'wallet_id' => $wallet_id,
	'sku_id' => $sku->id,
	'cost' => $sku->pivot->cost(),
	'entitleable_id' => $user->id,
	'entitleable_type' => User::class
	]
	);
	}
	}

	return $user;
	}

	/**
	* Assign a package plan to a user.
	*
	* @param \App\Plan $plan The plan to assign
	* @param \App\Domain $domain Optional domain object
	*
	* @return \App\User Self
	*/
	public function assignPlan($plan, $domain = null): User
	{
	$this->setSetting('plan_id', $plan->id);

	foreach ($plan->packages as $package) {
	if ($package->isDomain()) {
	$domain->assignPackage($package, $this);
	} else {
	$this->assignPackage($package);
	}
	}

	return $this;
	}

	/**
	* Assign a Sku to a user.
	*
	* @param \App\Sku $sku The sku to assign.
	* @param int $count Count of entitlements to add
	*
	* @return \App\User Self
	* @throws \Exception
	*/
	public function assignSku(Sku $sku, int $count = 1): User
	{
	// TODO: I guess wallet could be parametrized in future
	$wallet = $this->wallet();
	$exists = $this->entitlements()->where('sku_id', $sku->id)->count();

	while ($count > 0) {
	\App\Entitlement::create([
	'wallet_id' => $wallet->id,
	'sku_id' => $sku->id,
	'cost' => $exists >= $sku->units_free ? $sku->cost : 0,
	'entitleable_id' => $this->id,
	'entitleable_type' => User::class
	]);

	$exists++;
	$count--;
	}

	return $this;
	}

	/**
	* Check if current user can delete another object.
	*
	* @param \App\User\|\App\Domain $object A user\|domain object
	*
	* @return bool True if he can, False otherwise
	*/
	public function canDelete($object): bool
	{
	if (!method_exists($object, 'wallet')) {
	return false;
	}

	$wallet = $object->wallet();

	// TODO: For now controller can delete/update the account owner,
	// this may change in future, controllers are not 0-regression feature

	return $this->wallets->contains($wallet) \|\| $this->accounts->contains($wallet);
	}

	/**
	* Check if current user can read data of another object.
	*
	* @param \App\User\|\App\Domain\|\App\Wallet $object A user\|domain\|wallet object
	*
	* @return bool True if he can, False otherwise
	*/
	public function canRead($object): bool
	{
	if ($this->role == "admin") {
	return true;
	}

	if ($object instanceof User && $this->id == $object->id) {
	return true;
	}

	if ($object instanceof Wallet) {
	return $object->user_id == $this->id \|\| $object->controllers->contains($this);
	}

	if (!method_exists($object, 'wallet')) {
	return false;
	}

	$wallet = $object->wallet();

	return $this->wallets->contains($wallet) \|\| $this->accounts->contains($wallet);
	}

	/**
	* Check if current user can update data of another object.
	*
	* @param \App\User\|\App\Domain $object A user\|domain object
	*
	* @return bool True if he can, False otherwise
	*/
	public function canUpdate($object): bool
	{
	if (!method_exists($object, 'wallet')) {
	return false;
	}

	if ($object instanceof User && $this->id == $object->id) {
	return true;
	}

	return $this->canDelete($object);
	}

	/**
	* Return the \App\Domain for this user.
	*
	* @return \App\Domain\|null
	*/
	public function domain()
	{
	list($local, $domainName) = explode('@', $this->email);

	$domain = \App\Domain::withTrashed()->where('namespace', $domainName)->first();

	return $domain;
	}

	/**
	* List the domains to which this user is entitled.
	*
	* @return Domain[]
	*/
	public function domains()
	{
	$dbdomains = Domain::whereRaw(
	sprintf(
	'(type & %s) AND (status & %s)',
	Domain::TYPE_PUBLIC,
	Domain::STATUS_ACTIVE
	)
	)->get();

	$domains = [];

	foreach ($dbdomains as $dbdomain) {
	$domains[] = $dbdomain;
	}

	foreach ($this->wallets as $wallet) {
	$entitlements = $wallet->entitlements()->where('entitleable_type', Domain::class)->get();
	foreach ($entitlements as $entitlement) {
	$domain = $entitlement->entitleable;
	\Log::info("Found domain for {$this->email}: {$domain->namespace} (owned)");
	$domains[] = $domain;
	}
	}

	foreach ($this->accounts as $wallet) {
	$entitlements = $wallet->entitlements()->where('entitleable_type', Domain::class)->get();
	foreach ($entitlements as $entitlement) {
	$domain = $entitlement->entitleable;
	\Log::info("Found domain {$this->email}: {$domain->namespace} (charged)");
	$domains[] = $domain;
	}
	}

	return $domains;
	}

	/**
	* The user entitlement.
	*
	* @return \Illuminate\Database\Eloquent\Relations\MorphOne
	*/
	public function entitlement()
	{
	return $this->morphOne('App\Entitlement', 'entitleable');
	}

	/**
	* Entitlements for this user.
	*
	* Note that these are entitlements that apply to the user account, and not entitlements that
	* this user owns.
	*
	* @return \Illuminate\Database\Eloquent\Relations\HasMany
	*/
	public function entitlements()
	{
	return $this->hasMany('App\Entitlement', 'entitleable_id', 'id')
	->where('entitleable_type', User::class);
	}

	/**
	* Find whether an email address exists as a user (including deleted users).
	*
	* @param string $email Email address
	* @param bool $return_user Return User instance instead of boolean
	*
	* @return \App\User\|bool True or User model object if found, False otherwise
	*/
	public static function emailExists(string $email, bool $return_user = false)
	{
	if (strpos($email, '@') === false) {
	return false;
	}

	$email = \strtolower($email);

	$user = self::withTrashed()->where('email', $email)->first();

	if ($user) {
	return $return_user ? $user : true;
	}

	return false;
	}

	/**
	* Helper to find user by email address, whether it is
	* main email address, alias or an external email.
	*
	* If there's more than one alias NULL will be returned.
	*
	* @param string $email Email address
	* @param bool $external Search also for an external email
	*
	* @return \App\User User model object if found
	*/
	public static function findByEmail(string $email, bool $external = false): ?User
	{
	if (strpos($email, '@') === false) {
	return null;
	}

	$email = \strtolower($email);

	$user = self::where('email', $email)->first();

	if ($user) {
	return $user;
	}

	$aliases = UserAlias::where('alias', $email)->get();

	if (count($aliases) == 1) {
	return $aliases->first()->user;
	}

	// TODO: External email

	return null;
	}

	public function getJWTIdentifier()
	{
	return $this->getKey();
	}

	public function getJWTCustomClaims()
	{
	return [];
	}

	/**
	* Return groups controlled by the current user.
	*
	* @return \Illuminate\Database\Eloquent\Builder Query builder
	*/
	public function groups()
	{
	$wallets = $this->wallets()->pluck('id')->all();

	$groupIds = \App\Entitlement::whereIn('entitlements.wallet_id', $wallets)
	->where('entitlements.entitleable_type', Group::class)
	->pluck('entitleable_id')
	->all();

	return Group::whereIn('id', $groupIds);
	}

	/**
	* Check if user has an entitlement for the specified SKU.
	*
	* @param string $title The SKU title
	*
	* @return bool True if specified SKU entitlement exists
	*/
	public function hasSku($title): bool
	{
	$sku = Sku::where('title', $title)->first();

	if (!$sku) {
	return false;
	}

	return $this->entitlements()->where('sku_id', $sku->id)->count() > 0;
	}

	/**
	* Returns whether this domain is active.
	*
	* @return bool
	*/
	public function isActive(): bool
	{
	return ($this->status & self::STATUS_ACTIVE) > 0;
	}

	/**
	* Returns whether this domain is deleted.
	*
	* @return bool
	*/
	public function isDeleted(): bool
	{
	return ($this->status & self::STATUS_DELETED) > 0;
	}

	/**
	* Returns whether this (external) domain has been verified
	* to exist in DNS.
	*
	* @return bool
	*/
	public function isImapReady(): bool
	{
	return ($this->status & self::STATUS_IMAP_READY) > 0;
	}

	/**
	* Returns whether this user is registered in LDAP.
	*
	* @return bool
	*/
	public function isLdapReady(): bool
	{
	return ($this->status & self::STATUS_LDAP_READY) > 0;
	}

	/**
	* Returns whether this user is new.
	*
	* @return bool
	*/
	public function isNew(): bool
	{
	return ($this->status & self::STATUS_NEW) > 0;
	}

	/**
	* Returns whether this domain is suspended.
	*
	* @return bool
	*/
	public function isSuspended(): bool
	{
	return ($this->status & self::STATUS_SUSPENDED) > 0;
	}

	/**
	* A shortcut to get the user name.
	*
	* @param bool $fallback Return "<aa.name> User" if there's no name
	*
	* @return string Full user name
	*/
	public function name(bool $fallback = false): string
	{
	$firstname = $this->getSetting('first_name');
	$lastname = $this->getSetting('last_name');

	$name = trim($firstname . ' ' . $lastname);

	if (empty($name) && $fallback) {
	return \config('app.name') . ' User';
	}

	return $name;
	}

	/**
	* Remove a number of entitlements for the SKU.
	*
	* @param \App\Sku $sku The SKU
	* @param int $count The number of entitlements to remove
	*
	* @return User Self
	*/
	public function removeSku(Sku $sku, int $count = 1): User
	{
	$entitlements = $this->entitlements()
	->where('sku_id', $sku->id)
	->orderBy('cost', 'desc')
	->orderBy('created_at')
	->get();

	$entitlements_count = count($entitlements);

	foreach ($entitlements as $entitlement) {
	if ($entitlements_count <= $sku->units_free) {
	continue;
	}

	if ($count > 0) {
	$entitlement->delete();
	$entitlements_count--;
	$count--;
	}
	}

	return $this;
	}

	/**
	* Any (additional) properties of this user.
	*
	* @return \Illuminate\Database\Eloquent\Relations\HasMany
	*/
	public function settings()
	{
	return $this->hasMany('App\UserSetting', 'user_id');
	}

	/**
	* Suspend this domain.
	*
	* @return void
	*/
	public function suspend(): void
	{
	if ($this->isSuspended()) {
	return;
	}

	$this->status \|= User::STATUS_SUSPENDED;
	$this->save();
	}

	/**
	* Unsuspend this domain.
	*
	* @return void
	*/
	public function unsuspend(): void
	{
	if (!$this->isSuspended()) {
	return;
	}

	$this->status ^= User::STATUS_SUSPENDED;
	$this->save();
	}

	/**
	* Return users controlled by the current user.
	*
	* @param bool $with_accounts Include users assigned to wallets
	* the current user controls but not owns.
	*
	* @return \Illuminate\Database\Eloquent\Builder Query builder
	*/
	public function users($with_accounts = true)
	{
	$wallets = $this->wallets()->pluck('id')->all();

	if ($with_accounts) {
	$wallets = array_merge($wallets, $this->accounts()->pluck('wallet_id')->all());
	}

	return $this->select(['users.*', 'entitlements.wallet_id'])
	->distinct()
	->leftJoin('entitlements', 'entitlements.entitleable_id', '=', 'users.id')
	->whereIn('entitlements.wallet_id', $wallets)
	->where('entitlements.entitleable_type', User::class);
	}

	/**
	* Verification codes for this user.
	*
	* @return \Illuminate\Database\Eloquent\Relations\HasMany
	*/
	public function verificationcodes()
	{
	return $this->hasMany('App\VerificationCode', 'user_id', 'id');
	}

	/**
	* Returns the wallet by which the user is controlled
	*
	* @return ?\App\Wallet A wallet object
	*/
	public function wallet(): ?Wallet
	{
	$entitlement = $this->entitlement()->withTrashed()->first();

	// TODO: No entitlement should not happen, but in tests we have
	// such cases, so we fallback to the user's wallet in this case
	return $entitlement ? $entitlement->wallet : $this->wallets()->first();
	}

	/**
	* Wallets this user owns.
	*
	* @return \Illuminate\Database\Eloquent\Relations\HasMany
	*/
	public function wallets()
	{
	return $this->hasMany('App\Wallet');
	}

	/**
	* User password mutator
	*
	* @param string $password The password in plain text.
	*
	* @return void
	*/
	public function setPasswordAttribute($password)
	{
	if (!empty($password)) {
	$this->attributes['password'] = bcrypt($password, [ "rounds" => 12 ]);
	$this->attributes['password_ldap'] = '{SSHA512}' . base64_encode(
	pack('H*', hash('sha512', $password))
	);
	}
	}

	/**
	* User LDAP password mutator
	*
	* @param string $password The password in plain text.
	*
	* @return void
	*/
	public function setPasswordLdapAttribute($password)
	{
	$this->setPasswordAttribute($password);
	}

	/**
	* User status mutator
	*
	* @throws \Exception
	*/
	public function setStatusAttribute($status)
	{
	$new_status = 0;

	$allowed_values = [
	self::STATUS_NEW,
	self::STATUS_ACTIVE,
	self::STATUS_SUSPENDED,
	self::STATUS_DELETED,
	self::STATUS_LDAP_READY,
	self::STATUS_IMAP_READY,
	];

	foreach ($allowed_values as $value) {
	if ($status & $value) {
	$new_status \|= $value;
	$status ^= $value;
	}
	}

	if ($status > 0) {
	throw new \Exception("Invalid user status: {$status}");
	}

	$this->attributes['status'] = $new_status;
	}
	}
	diff --git a/src/app/Utils.php b/src/app/Utils.php
	index d06c0ada..0f4f6320 100644
	--- a/src/app/Utils.php
	+++ b/src/app/Utils.php
	@@ -1,409 +1,407 @@
	<?php

	namespace App;

	use Carbon\Carbon;
	use Illuminate\Support\Facades\Auth;
	use Ramsey\Uuid\Uuid;

	/**
	* Small utility functions for App.
	*/
	class Utils
	{
	// Note: Removed '0', 'O', '1', 'I' as problematic with some fonts
	public const CHARS = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';

	/**
	* Count the number of lines in a file.
	*
	* Useful for progress bars.
	*
	* @param string $file The filepath to count the lines of.
	*
	* @return int
	*/
	public static function countLines($file)
	{
	$fh = fopen($file, 'rb');
	$numLines = 0;

	while (!feof($fh)) {
	$numLines += substr_count(fread($fh, 8192), "\n");
	}

	fclose($fh);

	return $numLines;
	}

	/**
	* Return the country ISO code for an IP address.
	*
	* @return string
	*/
	public static function countryForIP($ip)
	{
	if (strpos(':', $ip) === false) {
	$query = "
	SELECT country FROM ip4nets
	WHERE INET_ATON(net_number) <= INET_ATON(?)
	AND INET_ATON(net_broadcast) >= INET_ATON(?)
	ORDER BY INET_ATON(net_number), net_mask DESC LIMIT 1
	";
	} else {
	$query = "
	SELECT id FROM ip6nets
	WHERE INET6_ATON(net_number) <= INET6_ATON(?)
	AND INET6_ATON(net_broadcast) >= INET6_ATON(?)
	ORDER BY INET6_ATON(net_number), net_mask DESC LIMIT 1
	";
	}

	$nets = \Illuminate\Support\Facades\DB::select($query, [$ip, $ip]);

	if (sizeof($nets) > 0) {
	return $nets[0]->country;
	}

	return 'CH';
	}

	/**
	* Return the country ISO code for the current request.
	*/
	public static function countryForRequest()
	{
	$request = \request();
	$ip = $request->ip();

	return self::countryForIP($ip);
	}

	/**
	* Shortcut to creating a progress bar of a particular format with a particular message.
	*
	* @param \Illuminate\Console\OutputStyle $output Console output object
	* @param int $count Number of progress steps
	* @param string $message The description
	*
	* @return \Symfony\Component\Console\Helper\ProgressBar
	*/
	public static function createProgressBar($output, $count, $message = null)
	{
	$bar = $output->createProgressBar($count);

	$bar->setFormat(
	'%current:7s%/%max:7s% [%bar%] %percent:3s%% %elapsed:7s%/%estimated:-7s% %message% '
	);

	if ($message) {
	$bar->setMessage($message . " ...");
	}

	$bar->start();

	return $bar;
	}

	/**
	* Return the number of days in the month prior to this one.
	*
	* @return int
	*/
	public static function daysInLastMonth()
	{
	$start = new Carbon('first day of last month');
	$end = new Carbon('last day of last month');

	return $start->diffInDays($end) + 1;
	}

	/**
	* Download a file from the interwebz and store it locally.
	*
	* @param string $source The source location
	* @param string $target The target location
	* @param bool $force Force the download (and overwrite target)
	*
	* @return void
	*/
	public static function downloadFile($source, $target, $force = false)
	{
	if (is_file($target) && !$force) {
	return;
	}

	\Log::info("Retrieving {$source}");

	$fp = fopen($target, 'w');

	$curl = curl_init();
	curl_setopt($curl, CURLOPT_URL, $source);
	curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
	curl_setopt($curl, CURLOPT_FILE, $fp);
	curl_exec($curl);

	if (curl_errno($curl)) {
	\Log::error("Request error on {$source}: " . curl_error($curl));

	curl_close($curl);
	fclose($fp);

	unlink($target);
	return;
	}

	curl_close($curl);
	fclose($fp);
	}

	/**
	* Calculate the broadcast address provided a net number and a prefix.
	*
	* @param string $net A valid IPv6 network number.
	* @param int $prefix The network prefix.
	*
	* @return string
	*/
	public static function ip6Broadcast($net, $prefix)
	{
	$netHex = bin2hex(inet_pton($net));

	// Overwriting first address string to make sure notation is optimal
	$net = inet_ntop(hex2bin($netHex));

	// Calculate the number of 'flexible' bits
	$flexbits = 128 - $prefix;

	// Build the hexadecimal string of the last address
	$lastAddrHex = $netHex;

	// We start at the end of the string (which is always 32 characters long)
	$pos = 31;
	while ($flexbits > 0) {
	// Get the character at this position
	$orig = substr($lastAddrHex, $pos, 1);

	// Convert it to an integer
	$origval = hexdec($orig);

	// OR it with (2^flexbits)-1, with flexbits limited to 4 at a time
	$newval = $origval \| (pow(2, min(4, $flexbits)) - 1);

	// Convert it back to a hexadecimal character
	$new = dechex($newval);

	// And put that character back in the string
	$lastAddrHex = substr_replace($lastAddrHex, $new, $pos, 1);

	// We processed one nibble, move to previous position
	$flexbits -= 4;
	$pos -= 1;
	}

	// Convert the hexadecimal string to a binary string
	- # Using pack() here
	- # Newer PHP version can use hex2bin()
	- $lastaddrbin = pack('H*', $lastAddrHex);
	+ $lastaddrbin = hex2bin($lastAddrHex);

	// And create an IPv6 address from the binary string
	$lastaddrstr = inet_ntop($lastaddrbin);

	return $lastaddrstr;
	}

	/**
	* Provide all unique combinations of elements in $input, with order and duplicates irrelevant.
	*
	* @param array $input The input array of elements.
	*
	* @return array[]
	*/
	public static function powerSet(array $input): array
	{
	$output = [];

	for ($x = 0; $x < count($input); $x++) {
	self::combine($input, $x + 1, 0, [], 0, $output);
	}

	return $output;
	}

	/**
	* Returns the current user's email address or null.
	*
	* @return string
	*/
	public static function userEmailOrNull(): ?string
	{
	$user = Auth::user();

	if (!$user) {
	return null;
	}

	return $user->email;
	}

	/**
	* Returns a random string consisting of a quantity of segments of a certain length joined.
	*
	* Example:
	*
	* ```php
	* $roomName = strtolower(\App\Utils::randStr(3, 3, '-');
	* // $roomName == '3qb-7cs-cjj'
	* ```
	*
	* @param int $length The length of each segment
	* @param int $qty The quantity of segments
	* @param string $join The string to use to join the segments
	*
	* @return string
	*/
	public static function randStr($length, $qty = 1, $join = '')
	{
	$chars = env('SHORTCODE_CHARS', self::CHARS);

	$randStrs = [];

	for ($x = 0; $x < $qty; $x++) {
	$randStrs[$x] = [];

	for ($y = 0; $y < $length; $y++) {
	$randStrs[$x][] = $chars[rand(0, strlen($chars) - 1)];
	}

	shuffle($randStrs[$x]);

	$randStrs[$x] = implode('', $randStrs[$x]);
	}

	return implode($join, $randStrs);
	}

	/**
	* Returns a UUID in the form of an integer.
	*
	* @return integer
	*/
	public static function uuidInt(): int
	{
	$hex = Uuid::uuid4();
	$bin = pack('h*', str_replace('-', '', $hex));
	$ids = unpack('L', $bin);
	$id = array_shift($ids);

	return $id;
	}

	/**
	* Returns a UUID in the form of a string.
	*
	* @return string
	*/
	public static function uuidStr(): string
	{
	return Uuid::uuid4()->toString();
	}

	private static function combine($input, $r, $index, $data, $i, &$output): void
	{
	$n = count($input);

	// Current cobination is ready
	if ($index == $r) {
	$output[] = array_slice($data, 0, $r);
	return;
	}

	// When no more elements are there to put in data[]
	if ($i >= $n) {
	return;
	}

	// current is included, put next at next location
	$data[$index] = $input[$i];
	self::combine($input, $r, $index + 1, $data, $i + 1, $output);

	// current is excluded, replace it with next (Note that i+1
	// is passed, but index is not changed)
	self::combine($input, $r, $index, $data, $i + 1, $output);
	}

	/**
	* Create self URL
	*
	* @param string $route Route/Path
	* @todo Move this to App\Http\Controllers\Controller
	*
	* @return string Full URL
	*/
	public static function serviceUrl(string $route): string
	{
	$url = \config('app.public_url');

	if (!$url) {
	$url = \config('app.url');
	}

	return rtrim(trim($url, '/') . '/' . ltrim($route, '/'), '/');
	}

	/**
	* Create a configuration/environment data to be passed to
	* the UI
	*
	* @todo Move this to App\Http\Controllers\Controller
	*
	* @return array Configuration data
	*/
	public static function uiEnv(): array
	{
	$countries = include resource_path('countries.php');
	$req_domain = preg_replace('/:[0-9]+$/', '', request()->getHttpHost());
	$sys_domain = \config('app.domain');
	$path = request()->path();
	$opts = [
	'app.name',
	'app.url',
	'app.domain',
	'app.theme',
	'app.webmail_url',
	'app.support_email',
	'mail.from.address'
	];

	$env = \app('config')->getMany($opts);

	$env['countries'] = $countries ?: [];
	$env['view'] = 'root';
	$env['jsapp'] = 'user.js';

	if ($req_domain == "admin.$sys_domain") {
	$env['jsapp'] = 'admin.js';
	}

	$env['paymentProvider'] = \config('services.payment_provider');
	$env['stripePK'] = \config('services.stripe.public_key');

	$theme_file = resource_path("themes/{$env['app.theme']}/theme.json");
	$menu = [];

	if (file_exists($theme_file)) {
	$theme = json_decode(file_get_contents($theme_file), true);

	if (json_last_error() != JSON_ERROR_NONE) {
	\Log::error("Failed to parse $theme_file: " . json_last_error_msg());
	} elseif (!empty($theme['menu'])) {
	$menu = $theme['menu'];
	}
	}

	$env['menu'] = $menu;

	return $env;
	}
	}
	diff --git a/src/app/VerificationCode.php b/src/app/VerificationCode.php
	index 89c90d5f..e7298d79 100644
	--- a/src/app/VerificationCode.php
	+++ b/src/app/VerificationCode.php
	@@ -1,56 +1,102 @@
	<?php

	namespace App;

	-use App\SignupCode;
	+use Carbon\Carbon;
	use Illuminate\Database\Eloquent\Model;

	/**
	* The eloquent definition of a VerificationCode
	*
	+ * @property string $code
	* @property string $mode
	* @property \App\User $user
	+ * @property int $user_id
	+ * @property string $short_code
	*/
	-class VerificationCode extends SignupCode
	+class VerificationCode extends Model
	{
	// Code expires after so many hours
	- public const CODE_EXP_HOURS = 8;
	public const SHORTCODE_LENGTH = 8;

	+ public const CODE_LENGTH = 32;
	+
	+ // Code expires after so many hours
	+ public const CODE_EXP_HOURS = 8;

	/**
	- * The attributes that are mass assignable.
	+ * The primary key associated with the table.
	*
	- * @var array
	+ * @var string
	*/
	- protected $fillable = ['user_id', 'code', 'short_code', 'mode', 'expires_at'];
	+ protected $primaryKey = 'code';
	+
	+ /**
	+ * Indicates if the IDs are auto-incrementing.
	+ *
	+ * @var bool
	+ */
	+ public $incrementing = false;

	/**
	- * The attributes that should be cast to native types.
	+ * The "type" of the auto-incrementing ID.
	+ *
	+ * @var string
	+ */
	+ protected $keyType = 'string';
	+
	+ /**
	+ * Indicates if the model should be timestamped.
	+ *
	+ * @var bool
	+ */
	+ public $timestamps = false;
	+
	+ /**
	+ * The attributes that are mass assignable.
	*
	* @var array
	*/
	- protected $casts = [];
	+ protected $fillable = ['user_id', 'code', 'short_code', 'mode', 'expires_at'];

	/**
	- * The user to which this setting belongs.
	+ * The attributes that should be mutated to dates.
	*
	- * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
	+ * @var array
	*/
	- public function user()
	- {
	- return $this->belongsTo('\App\User', 'user_id', 'id');
	- }
	+ protected $dates = ['expires_at'];
	+

	/**
	* Generate a short code (for human).
	*
	* @return string
	*/
	public static function generateShortCode(): string
	{
	$code_length = env('VERIFICATION_CODE_LENGTH', self::SHORTCODE_LENGTH);

	return \App\Utils::randStr($code_length);
	}
	+
	+ /**
	+ * Check if code is expired.
	+ *
	+ * @return bool True if code is expired, False otherwise
	+ */
	+ public function isExpired()
	+ {
	+ // @phpstan-ignore-next-line
	+ return $this->expires_at ? Carbon::now()->gte($this->expires_at) : false;
	+ }
	+
	+ /**
	+ * The user to which this setting belongs.
	+ *
	+ * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
	+ */
	+ public function user()
	+ {
	+ return $this->belongsTo('\App\User', 'user_id', 'id');
	+ }
	}
	diff --git a/src/database/migrations/2021_03_25_100000_signup_code_refactor.php b/src/database/migrations/2021_03_25_100000_signup_code_refactor.php
	new file mode 100644
	index 00000000..48c65510
	--- /dev/null
	+++ b/src/database/migrations/2021_03_25_100000_signup_code_refactor.php
	@@ -0,0 +1,117 @@
	+<?php
	+
	+use Illuminate\Database\Migrations\Migration;
	+use Illuminate\Database\Schema\Blueprint;
	+use Illuminate\Support\Facades\DB;
	+use Illuminate\Support\Facades\Schema;
	+
	+// phpcs:ignore
	+class SignupCodeRefactor extends Migration
	+{
	+ /**
	+ * Run the migrations.
	+ *
	+ * @return void
	+ */
	+ public function up()
	+ {
	+ Schema::table(
	+ 'signup_codes',
	+ function (Blueprint $table) {
	+ $table->string('email');
	+ $table->string('first_name')->nullable();
	+ $table->string('last_name')->nullable();
	+ $table->string('plan', 128)->nullable();
	+ $table->string('voucher', 32)->nullable();
	+ $table->string('local_part')->nullable();
	+ $table->string('domain_part')->nullable();
	+ $table->string('ip_address')->nullable();
	+ $table->timestamp('created_at')->useCurrent();
	+ $table->timestamp('updated_at')->useCurrent();
	+ $table->softDeletes();
	+ }
	+ );
	+
	+ DB::table('signup_codes')->get()->each(function ($code) {
	+ if (empty($code->data)) {
	+ return;
	+ }
	+
	+ $data = json_decode($code->data);
	+
	+ if (!empty($data->email)) {
	+ $parts = explode('@', $data->email);
	+
	+ $data->local_part = $parts[0] ?? null;
	+ $data->domain_part = $parts[1] ?? null;
	+ }
	+
	+ DB::table('signup_codes')
	+ ->where('code', $code->code)
	+ ->update([
	+ 'email' => $data->email ?? null,
	+ 'first_name' => $data->first_name ?? null,
	+ 'last_name' => $data->last_name ?? null,
	+ 'plan' => $data->plan ?? null,
	+ 'voucher' => $data->voucher ?? null,
	+ 'local_part' => $data->local_part ?? null,
	+ 'domain_part' => $data->domain_part ?? null,
	+ ]);
	+ });
	+
	+ Schema::table(
	+ 'signup_codes',
	+ function (Blueprint $table) {
	+ $table->dropColumn('data');
	+ }
	+ );
	+ }
	+
	+ /**
	+ * Reverse the migrations.
	+ *
	+ * @return void
	+ */
	+ public function down()
	+ {
	+ Schema::table(
	+ 'signup_codes',
	+ function (Blueprint $table) {
	+ $table->text('data');
	+ }
	+ );
	+
	+ DB::table('signup_codes')->get()->each(function ($code) {
	+ $data = json_encode([
	+ 'email' => $code->email,
	+ 'first_name' => $code->first_name,
	+ 'last_name' => $code->last_name,
	+ 'plan' => $code->plan,
	+ 'voucher' => $code->voucher,
	+ ]);
	+
	+ DB::table('signup_codes')
	+ ->where('code', $code->code)
	+ ->update(['data' => $data]);
	+ });
	+
	+ Schema::table(
	+ 'signup_codes',
	+ function (Blueprint $table) {
	+ $table->dropColumn([
	+ 'created_at',
	+ 'updated_at',
	+ 'deleted_at',
	+ 'ip_address',
	+ 'email',
	+ 'local_part',
	+ 'domain_part',
	+ 'first_name',
	+ 'last_name',
	+ 'plan',
	+ 'voucher',
	+ ]);
	+ }
	+ );
	+ }
	+}
	diff --git a/src/tests/Browser/SignupTest.php b/src/tests/Browser/SignupTest.php
	index eed0948d..4fecedf3 100644
	--- a/src/tests/Browser/SignupTest.php
	+++ b/src/tests/Browser/SignupTest.php
	@@ -1,545 +1,543 @@
	<?php

	namespace Tests\Browser;

	use App\Discount;
	use App\Domain;
	use App\SignupCode;
	use App\User;
	use Tests\Browser;
	use Tests\Browser\Components\Menu;
	use Tests\Browser\Components\Toast;
	use Tests\Browser\Pages\Dashboard;
	use Tests\Browser\Pages\Signup;
	use Tests\TestCaseDusk;
	use Illuminate\Foundation\Testing\DatabaseMigrations;

	class SignupTest extends TestCaseDusk
	{
	/**
	* {@inheritDoc}
	*/
	public function setUp(): void
	{
	parent::setUp();

	$this->deleteTestUser('signuptestdusk@' . \config('app.domain'));
	$this->deleteTestUser('admin@user-domain-signup.com');
	$this->deleteTestDomain('user-domain-signup.com');
	}

	public function tearDown(): void
	{
	$this->deleteTestUser('signuptestdusk@' . \config('app.domain'));
	$this->deleteTestUser('admin@user-domain-signup.com');
	$this->deleteTestDomain('user-domain-signup.com');

	parent::tearDown();
	}

	/**
	* Test signup code verification with a link
	*/
	public function testSignupCodeByLink(): void
	{
	// Test invalid code (invalid format)
	$this->browse(function (Browser $browser) {
	// Register Signup page element selectors we'll be using
	$browser->onWithoutAssert(new Signup());

	// TODO: Test what happens if user is logged in

	$browser->visit('/signup/invalid-code');

	// TODO: According to https://github.com/vuejs/vue-router/issues/977
	// it is not yet easily possible to display error page component (route)
	// without changing the URL
	// TODO: Instead of css selector we should probably define page/component
	// and use it instead
	$browser->waitFor('#error-page');
	});

	// Test invalid code (valid format)
	$this->browse(function (Browser $browser) {
	$browser->visit('/signup/XXXXX-code');

	// FIXME: User will not be able to continue anyway, so we should
	// either display 1st step or 404 error page
	$browser->waitFor('@step1')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Test valid code
	$this->browse(function (Browser $browser) {
	$code = SignupCode::create([
	- 'data' => [
	- 'email' => 'User@example.org',
	- 'first_name' => 'User',
	- 'last_name' => 'Name',
	- 'plan' => 'individual',
	- 'voucher' => '',
	- ]
	+ 'email' => 'User@example.org',
	+ 'first_name' => 'User',
	+ 'last_name' => 'Name',
	+ 'plan' => 'individual',
	+ 'voucher' => '',
	]);

	$browser->visit('/signup/' . $code->short_code . '-' . $code->code)
	->waitFor('@step3')
	->assertMissing('@step1')
	->assertMissing('@step2');

	// FIXME: Find a nice way to read javascript data without using hidden inputs
	$this->assertSame($code->code, $browser->value('@step2 #signup_code'));

	// TODO: Test if the signup process can be completed
	});
	}

	/**
	* Test signup "welcome" page
	*/
	public function testSignupStep0(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit(new Signup());

	$browser->assertVisible('@step0')
	->assertMissing('@step1')
	->assertMissing('@step2')
	->assertMissing('@step3');

	$browser->within(new Menu(), function ($browser) {
	$browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'login'], 'signup');
	});

	$browser->waitFor('@step0 .plan-selector > .card');

	// Assert first plan box and press the button
	$browser->with('@step0 .plan-selector > .plan-individual', function ($step) {
	$step->assertVisible('button')
	->assertSeeIn('button', 'Individual Account')
	->assertVisible('.plan-description')
	->click('button');
	});

	$browser->waitForLocation('/signup/individual')
	->assertVisible('@step1')
	->assertMissing('@step0')
	->assertMissing('@step2')
	->assertMissing('@step3')
	->assertFocused('@step1 #signup_first_name');

	// Click Back button
	$browser->click('@step1 [type=button]')
	->waitForLocation('/signup')
	->assertVisible('@step0')
	->assertMissing('@step1')
	->assertMissing('@step2')
	->assertMissing('@step3');

	// Choose the group account plan
	$browser->click('@step0 .plan-selector > .plan-group button')
	->waitForLocation('/signup/group')
	->assertVisible('@step1')
	->assertMissing('@step0')
	->assertMissing('@step2')
	->assertMissing('@step3')
	->assertFocused('@step1 #signup_first_name');

	// TODO: Test if 'plan' variable is set properly in vue component
	});
	}

	/**
	* Test 1st step of the signup process
	*/
	public function testSignupStep1(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit('/signup/individual')
	->onWithoutAssert(new Signup());

	// Here we expect two text inputs and Back and Continue buttons
	$browser->with('@step1', function ($step) {
	$step->assertVisible('#signup_last_name')
	->assertVisible('#signup_first_name')
	->assertFocused('#signup_first_name')
	->assertVisible('#signup_email')
	->assertVisible('[type=button]')
	->assertVisible('[type=submit]');
	});

	// Submit empty form
	// Email is required, so after pressing Submit
	// we expect focus to be moved to the email input
	$browser->with('@step1', function ($step) {
	$step->click('[type=submit]');
	$step->assertFocused('#signup_email');
	});

	$browser->within(new Menu(), function ($browser) {
	$browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'login'], 'signup');
	});

	// Submit invalid email, and first_name
	// We expect both inputs to have is-invalid class added, with .invalid-feedback element
	$browser->with('@step1', function ($step) {
	$step->type('#signup_first_name', str_repeat('a', 250))
	->type('#signup_email', '@test')
	->click('[type=submit]')
	->waitFor('#signup_email.is-invalid')
	->assertVisible('#signup_first_name.is-invalid')
	->assertVisible('#signup_email + .invalid-feedback')
	->assertVisible('#signup_last_name + .invalid-feedback')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit valid data
	// We expect error state on email input to be removed, and Step 2 form visible
	$browser->with('@step1', function ($step) {
	$step->type('#signup_first_name', 'Test')
	->type('#signup_last_name', 'User')
	->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
	->click('[type=submit]')
	->assertMissing('#signup_email.is-invalid')
	->assertMissing('#signup_email + .invalid-feedback');
	});

	$browser->waitUntilMissing('@step2 #signup_code[value=""]');
	$browser->waitFor('@step2');
	$browser->assertMissing('@step1');
	});
	}

	/**
	* Test 2nd Step of the signup process
	*
	* @depends testSignupStep1
	*/
	public function testSignupStep2(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->assertVisible('@step2')
	->assertMissing('@step0')
	->assertMissing('@step1')
	->assertMissing('@step3');

	// Here we expect one text input, Back and Continue buttons
	$browser->with('@step2', function ($step) {
	$step->assertVisible('#signup_short_code')
	->assertFocused('#signup_short_code')
	->assertVisible('[type=button]')
	->assertVisible('[type=submit]');
	});

	// Test Back button functionality
	$browser->click('@step2 [type=button]')
	->waitFor('@step1')
	->assertFocused('@step1 #signup_first_name')
	->assertMissing('@step2');

	// Submit valid Step 1 data (again)
	$browser->with('@step1', function ($step) {
	$step->type('#signup_first_name', 'User')
	->type('#signup_last_name', 'User')
	->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
	->click('[type=submit]');
	});

	$browser->waitFor('@step2');
	$browser->assertMissing('@step1');

	// Submit invalid code
	// We expect code input to have is-invalid class added, with .invalid-feedback element
	$browser->with('@step2', function ($step) {
	$step->type('#signup_short_code', 'XXXXX');
	$step->click('[type=submit]');

	$step->waitFor('#signup_short_code.is-invalid')
	->assertVisible('#signup_short_code + .invalid-feedback')
	->assertFocused('#signup_short_code')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit valid code
	// We expect error state on code input to be removed, and Step 3 form visible
	$browser->with('@step2', function ($step) {
	// Get the code and short_code from database
	// FIXME: Find a nice way to read javascript data without using hidden inputs
	$code = $step->value('#signup_code');

	$this->assertNotEmpty($code);

	$code = SignupCode::find($code);

	$step->type('#signup_short_code', $code->short_code);
	$step->click('[type=submit]');

	$step->assertMissing('#signup_short_code.is-invalid');
	$step->assertMissing('#signup_short_code + .invalid-feedback');
	});

	$browser->waitFor('@step3');
	$browser->assertMissing('@step2');
	});
	}

	/**
	* Test 3rd Step of the signup process
	*
	* @depends testSignupStep2
	*/
	public function testSignupStep3(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->assertVisible('@step3');

	// Here we expect 3 text inputs, Back and Continue buttons
	$browser->with('@step3', function ($step) {
	$step->assertVisible('#signup_login');
	$step->assertVisible('#signup_password');
	$step->assertVisible('#signup_confirm');
	$step->assertVisible('select#signup_domain');
	$step->assertVisible('[type=button]');
	$step->assertVisible('[type=submit]');
	$step->assertFocused('#signup_login');
	$step->assertValue('select#signup_domain', \config('app.domain'));
	$step->assertValue('#signup_login', '');
	$step->assertValue('#signup_password', '');
	$step->assertValue('#signup_confirm', '');

	// TODO: Test domain selector
	});

	// Test Back button
	$browser->click('@step3 [type=button]');
	$browser->waitFor('@step2');
	$browser->assertFocused('@step2 #signup_short_code');
	$browser->assertMissing('@step3');

	// TODO: Test form reset when going back

	// Submit valid code again
	$browser->with('@step2', function ($step) {
	$code = $step->value('#signup_code');

	$this->assertNotEmpty($code);

	$code = SignupCode::find($code);

	$step->type('#signup_short_code', $code->short_code);
	$step->click('[type=submit]');
	});

	$browser->waitFor('@step3');

	// Submit invalid data
	$browser->with('@step3', function ($step) {
	$step->assertFocused('#signup_login')
	->type('#signup_login', '*')
	->type('#signup_password', '12345678')
	->type('#signup_confirm', '123456789')
	->click('[type=submit]')
	->waitFor('#signup_login.is-invalid')
	->assertVisible('#signup_domain + .invalid-feedback')
	->assertVisible('#signup_password.is-invalid')
	->assertVisible('#signup_password + .invalid-feedback')
	->assertFocused('#signup_login')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit invalid data (valid login, invalid password)
	$browser->with('@step3', function ($step) {
	$step->type('#signup_login', 'SignupTestDusk')
	->click('[type=submit]')
	->waitFor('#signup_password.is-invalid')
	->assertVisible('#signup_password + .invalid-feedback')
	->assertMissing('#signup_login.is-invalid')
	->assertMissing('#signup_domain + .invalid-feedback')
	->assertFocused('#signup_password')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit valid data
	$browser->with('@step3', function ($step) {
	$step->type('#signup_confirm', '12345678');

	$step->click('[type=submit]');
	});

	// At this point we should be auto-logged-in to dashboard
	$browser->waitUntilMissing('@step3')
	->waitUntilMissing('.app-loader')
	->on(new Dashboard())
	->assertUser('signuptestdusk@' . \config('app.domain'))
	->assertVisible('@links a.link-profile')
	->assertMissing('@links a.link-domains')
	->assertVisible('@links a.link-users')
	->assertVisible('@links a.link-wallet');

	// Logout the user
	$browser->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});
	}

	/**
	* Test signup for a group account
	*/
	public function testSignupGroup(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit(new Signup());

	// Choose the group account plan
	$browser->waitFor('@step0 .plan-group button')
	->click('@step0 .plan-group button');

	// Submit valid data
	// We expect error state on email input to be removed, and Step 2 form visible
	$browser->whenAvailable('@step1', function ($step) {
	$step->type('#signup_first_name', 'Test')
	->type('#signup_last_name', 'User')
	->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
	->click('[type=submit]');
	});

	// Submit valid code
	$browser->whenAvailable('@step2', function ($step) {
	// Get the code and short_code from database
	// FIXME: Find a nice way to read javascript data without using hidden inputs
	$code = $step->value('#signup_code');
	$code = SignupCode::find($code);

	$step->type('#signup_short_code', $code->short_code)
	->click('[type=submit]');
	});

	// Here we expect 4 text inputs, Back and Continue buttons
	$browser->whenAvailable('@step3', function ($step) {
	$step->assertVisible('#signup_login')
	->assertVisible('#signup_password')
	->assertVisible('#signup_confirm')
	->assertVisible('input#signup_domain')
	->assertVisible('[type=button]')
	->assertVisible('[type=submit]')
	->assertFocused('#signup_login')
	->assertValue('input#signup_domain', '')
	->assertValue('#signup_login', '')
	->assertValue('#signup_password', '')
	->assertValue('#signup_confirm', '');
	});

	// Submit invalid login and password data
	$browser->with('@step3', function ($step) {
	$step->assertFocused('#signup_login')
	->type('#signup_login', '*')
	->type('#signup_domain', 'test.com')
	->type('#signup_password', '12345678')
	->type('#signup_confirm', '123456789')
	->click('[type=submit]')
	->waitFor('#signup_login.is-invalid')
	->assertVisible('#signup_domain + .invalid-feedback')
	->assertVisible('#signup_password.is-invalid')
	->assertVisible('#signup_password + .invalid-feedback')
	->assertFocused('#signup_login')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit invalid domain
	$browser->with('@step3', function ($step) {
	$step->type('#signup_login', 'admin')
	->type('#signup_domain', 'aaa')
	->type('#signup_password', '12345678')
	->type('#signup_confirm', '12345678')
	->click('[type=submit]')
	->waitUntilMissing('#signup_login.is-invalid')
	->waitFor('#signup_domain.is-invalid + .invalid-feedback')
	->assertMissing('#signup_password.is-invalid')
	->assertMissing('#signup_password + .invalid-feedback')
	->assertFocused('#signup_domain')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit invalid domain
	$browser->with('@step3', function ($step) {
	$step->type('#signup_domain', 'user-domain-signup.com')
	->click('[type=submit]');
	});

	// At this point we should be auto-logged-in to dashboard
	$browser->waitUntilMissing('@step3')
	->waitUntilMissing('.app-loader')
	->on(new Dashboard())
	->assertUser('admin@user-domain-signup.com')
	->assertVisible('@links a.link-profile')
	->assertVisible('@links a.link-domains')
	->assertVisible('@links a.link-users')
	->assertVisible('@links a.link-wallet');

	$browser->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});
	}

	/**
	* Test signup with voucher
	*/
	public function testSignupVoucherLink(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit('/signup/voucher/TEST')
	->onWithoutAssert(new Signup())
	->waitUntilMissing('.app-loader')
	->waitFor('@step0')
	->click('.plan-individual button')
	->whenAvailable('@step1', function (Browser $browser) {
	$browser->type('#signup_first_name', 'Test')
	->type('#signup_last_name', 'User')
	->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
	->click('[type=submit]');
	})
	->whenAvailable('@step2', function (Browser $browser) {
	// Get the code and short_code from database
	// FIXME: Find a nice way to read javascript data without using hidden inputs
	$code = $browser->value('#signup_code');

	$this->assertNotEmpty($code);

	$code = SignupCode::find($code);

	$browser->type('#signup_short_code', $code->short_code)
	->click('[type=submit]');
	})
	->whenAvailable('@step3', function (Browser $browser) {
	// Assert that the code is filled in the input
	// Change it and test error handling
	$browser->assertValue('#signup_voucher', 'TEST')
	->type('#signup_voucher', 'TESTXX')
	->type('#signup_login', 'signuptestdusk')
	->type('#signup_password', '123456789')
	->type('#signup_confirm', '123456789')
	->click('[type=submit]')
	->waitFor('#signup_voucher.is-invalid')
	->assertVisible('#signup_voucher + .invalid-feedback')
	->assertFocused('#signup_voucher')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error')
	// Submit the correct code
	->type('#signup_voucher', 'TEST')
	->click('[type=submit]');
	})
	->waitUntilMissing('@step3')
	->waitUntilMissing('.app-loader')
	->on(new Dashboard())
	->assertUser('signuptestdusk@' . \config('app.domain'))
	// Logout the user
	->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});

	$user = $this->getTestUser('signuptestdusk@' . \config('app.domain'));
	$discount = Discount::where('code', 'TEST')->first();
	$this->assertSame($discount->id, $user->wallets()->first()->discount_id);
	}
	}
	diff --git a/src/tests/Feature/Controller/SignupTest.php b/src/tests/Feature/Controller/SignupTest.php
	index 704f2697..bbbe0221 100644
	--- a/src/tests/Feature/Controller/SignupTest.php
	+++ b/src/tests/Feature/Controller/SignupTest.php
	@@ -1,710 +1,710 @@
	<?php

	namespace Tests\Feature\Controller;

	use App\Http\Controllers\API\SignupController;
	use App\Discount;
	use App\Domain;
	use App\SignupCode;
	use App\User;
	use Illuminate\Support\Facades\Queue;
	use Tests\TestCase;

	class SignupTest extends TestCase
	{
	private $domain;

	/**
	* {@inheritDoc}
	*/
	public function setUp(): void
	{
	parent::setUp();

	// TODO: Some tests depend on existence of individual and group plans,
	// we should probably create plans here to not depend on that
	$this->domain = $this->getPublicDomain();

	$this->deleteTestUser("SignupControllerTest1@$this->domain");
	$this->deleteTestUser("signuplogin@$this->domain");
	$this->deleteTestUser("admin@external.com");

	$this->deleteTestDomain('external.com');
	$this->deleteTestDomain('signup-domain.com');

	$this->deleteTestGroup('group-test@kolabnow.com');
	}

	/**
	* {@inheritDoc}
	*/
	public function tearDown(): void
	{
	$this->deleteTestUser("SignupControllerTest1@$this->domain");
	$this->deleteTestUser("signuplogin@$this->domain");
	$this->deleteTestUser("admin@external.com");

	$this->deleteTestDomain('external.com');
	$this->deleteTestDomain('signup-domain.com');

	$this->deleteTestGroup('group-test@kolabnow.com');

	parent::tearDown();
	}

	/**
	* Return a public domain for signup tests
	*/
	private function getPublicDomain(): string
	{
	if (!$this->domain) {
	$this->refreshApplication();
	$public_domains = Domain::getPublicDomains();
	$this->domain = reset($public_domains);

	if (empty($this->domain)) {
	$this->domain = 'signup-domain.com';
	Domain::create([
	'namespace' => $this->domain,
	'status' => Domain::STATUS_ACTIVE,
	'type' => Domain::TYPE_PUBLIC,
	]);
	}
	}

	return $this->domain;
	}

	/**
	* Test fetching plans for signup
	*
	* @return void
	*/
	public function testSignupPlans()
	{
	$response = $this->get('/api/auth/signup/plans');
	$json = $response->json();

	$response->assertStatus(200);

	$this->assertSame('success', $json['status']);
	$this->assertCount(2, $json['plans']);
	$this->assertArrayHasKey('title', $json['plans'][0]);
	$this->assertArrayHasKey('name', $json['plans'][0]);
	$this->assertArrayHasKey('description', $json['plans'][0]);
	$this->assertArrayHasKey('button', $json['plans'][0]);
	}

	/**
	* Test signup initialization with invalid input
	*
	* @return void
	*/
	public function testSignupInitInvalidInput()
	{
	// Empty input data
	$data = [];

	$response = $this->post('/api/auth/signup/init', $data);
	$json = $response->json();

	$response->assertStatus(422);

	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('email', $json['errors']);

	// Data with missing name
	$data = [
	'email' => 'UsersApiControllerTest1@UsersApiControllerTest.com',
	'first_name' => str_repeat('a', 250),
	'last_name' => str_repeat('a', 250),
	];

	$response = $this->post('/api/auth/signup/init', $data);
	$json = $response->json();

	$response->assertStatus(422);

	$this->assertSame('error', $json['status']);
	$this->assertCount(2, $json['errors']);
	$this->assertArrayHasKey('first_name', $json['errors']);
	$this->assertArrayHasKey('last_name', $json['errors']);

	// Data with invalid email (but not phone number)
	$data = [
	'email' => '@example.org',
	'first_name' => 'Signup',
	'last_name' => 'User',
	];

	$response = $this->post('/api/auth/signup/init', $data);
	$json = $response->json();

	$response->assertStatus(422);

	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('email', $json['errors']);

	// Sanity check on voucher code, last/first name is optional
	$data = [
	'voucher' => '123456789012345678901234567890123',
	'email' => 'valid@email.com',
	];

	$response = $this->post('/api/auth/signup/init', $data);
	$json = $response->json();

	$response->assertStatus(422);

	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('voucher', $json['errors']);

	// TODO: Test phone validation
	}

	/**
	* Test signup initialization with valid input
	*
	* @return array
	*/
	public function testSignupInitValidInput()
	{
	Queue::fake();

	// Assert that no jobs were pushed...
	Queue::assertNothingPushed();

	$data = [
	'email' => 'testuser@external.com',
	'first_name' => 'Signup',
	'last_name' => 'User',
	'plan' => 'individual',
	];

	$response = $this->post('/api/auth/signup/init', $data);
	$json = $response->json();

	$response->assertStatus(200);
	$this->assertCount(2, $json);
	$this->assertSame('success', $json['status']);
	$this->assertNotEmpty($json['code']);

	// Assert the email sending job was pushed once
	Queue::assertPushed(\App\Jobs\SignupVerificationEmail::class, 1);

	// Assert the job has proper data assigned
	Queue::assertPushed(\App\Jobs\SignupVerificationEmail::class, function ($job) use ($data, $json) {
	$code = TestCase::getObjectProperty($job, 'code');

	return $code->code === $json['code']
	- && $code->data['plan'] === $data['plan']
	- && $code->data['email'] === $data['email']
	- && $code->data['first_name'] === $data['first_name']
	- && $code->data['last_name'] === $data['last_name'];
	+ && $code->plan === $data['plan']
	+ && $code->email === $data['email']
	+ && $code->first_name === $data['first_name']
	+ && $code->last_name === $data['last_name'];
	});

	// Try the same with voucher
	$data['voucher'] = 'TEST';

	$response = $this->post('/api/auth/signup/init', $data);
	$json = $response->json();

	$response->assertStatus(200);
	$this->assertCount(2, $json);
	$this->assertSame('success', $json['status']);
	$this->assertNotEmpty($json['code']);

	// Assert the job has proper data assigned
	Queue::assertPushed(\App\Jobs\SignupVerificationEmail::class, function ($job) use ($data, $json) {
	$code = TestCase::getObjectProperty($job, 'code');

	return $code->code === $json['code']
	- && $code->data['plan'] === $data['plan']
	- && $code->data['email'] === $data['email']
	- && $code->data['voucher'] === $data['voucher']
	- && $code->data['first_name'] === $data['first_name']
	- && $code->data['last_name'] === $data['last_name'];
	+ && $code->plan === $data['plan']
	+ && $code->email === $data['email']
	+ && $code->voucher === $data['voucher']
	+ && $code->first_name === $data['first_name']
	+ && $code->last_name === $data['last_name'];
	});

	return [
	'code' => $json['code'],
	'email' => $data['email'],
	'first_name' => $data['first_name'],
	'last_name' => $data['last_name'],
	'plan' => $data['plan'],
	'voucher' => $data['voucher']
	];
	}

	/**
	* Test signup code verification with invalid input
	*
	* @depends testSignupInitValidInput
	* @return void
	*/
	public function testSignupVerifyInvalidInput(array $result)
	{
	// Empty data
	$data = [];

	$response = $this->post('/api/auth/signup/verify', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(2, $json['errors']);
	$this->assertArrayHasKey('code', $json['errors']);
	$this->assertArrayHasKey('short_code', $json['errors']);

	// Data with existing code but missing short_code
	$data = [
	'code' => $result['code'],
	];

	$response = $this->post('/api/auth/signup/verify', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('short_code', $json['errors']);

	// Data with invalid short_code
	$data = [
	'code' => $result['code'],
	'short_code' => 'XXXX',
	];

	$response = $this->post('/api/auth/signup/verify', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('short_code', $json['errors']);

	// TODO: Test expired code
	}

	/**
	* Test signup code verification with valid input
	*
	* @depends testSignupInitValidInput
	*
	* @return array
	*/
	public function testSignupVerifyValidInput(array $result)
	{
	$code = SignupCode::find($result['code']);
	$data = [
	'code' => $code->code,
	'short_code' => $code->short_code,
	];

	$response = $this->post('/api/auth/signup/verify', $data);
	$json = $response->json();

	$response->assertStatus(200);
	$this->assertCount(7, $json);
	$this->assertSame('success', $json['status']);
	$this->assertSame($result['email'], $json['email']);
	$this->assertSame($result['first_name'], $json['first_name']);
	$this->assertSame($result['last_name'], $json['last_name']);
	$this->assertSame($result['voucher'], $json['voucher']);
	$this->assertSame(false, $json['is_domain']);
	$this->assertTrue(is_array($json['domains']) && !empty($json['domains']));

	return $result;
	}

	/**
	* Test last signup step with invalid input
	*
	* @depends testSignupVerifyValidInput
	* @return void
	*/
	public function testSignupInvalidInput(array $result)
	{
	// Empty data
	$data = [];

	$response = $this->post('/api/auth/signup', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(3, $json['errors']);
	$this->assertArrayHasKey('login', $json['errors']);
	$this->assertArrayHasKey('password', $json['errors']);
	$this->assertArrayHasKey('domain', $json['errors']);

	$domain = $this->getPublicDomain();

	// Passwords do not match and missing domain
	$data = [
	'login' => 'test',
	'password' => 'test',
	'password_confirmation' => 'test2',
	];

	$response = $this->post('/api/auth/signup', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(2, $json['errors']);
	$this->assertArrayHasKey('password', $json['errors']);
	$this->assertArrayHasKey('domain', $json['errors']);

	$domain = $this->getPublicDomain();

	// Login too short
	$data = [
	'login' => '1',
	'domain' => $domain,
	'password' => 'test',
	'password_confirmation' => 'test',
	];

	$response = $this->post('/api/auth/signup', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('login', $json['errors']);

	// Missing codes
	$data = [
	'login' => 'login-valid',
	'domain' => $domain,
	'password' => 'test',
	'password_confirmation' => 'test',
	];

	$response = $this->post('/api/auth/signup', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(2, $json['errors']);
	$this->assertArrayHasKey('code', $json['errors']);
	$this->assertArrayHasKey('short_code', $json['errors']);

	// Data with invalid short_code
	$data = [
	'login' => 'TestLogin',
	'domain' => $domain,
	'password' => 'test',
	'password_confirmation' => 'test',
	'code' => $result['code'],
	'short_code' => 'XXXX',
	];

	$response = $this->post('/api/auth/signup', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('short_code', $json['errors']);

	$code = SignupCode::find($result['code']);

	// Data with invalid voucher
	$data = [
	'login' => 'TestLogin',
	'domain' => $domain,
	'password' => 'test',
	'password_confirmation' => 'test',
	'code' => $result['code'],
	'short_code' => $code->short_code,
	'voucher' => 'XXX',
	];

	$response = $this->post('/api/auth/signup', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('voucher', $json['errors']);

	// Valid code, invalid login
	$data = [
	'login' => 'żżżżżż',
	'domain' => $domain,
	'password' => 'test',
	'password_confirmation' => 'test',
	'code' => $result['code'],
	'short_code' => $code->short_code,
	];

	$response = $this->post('/api/auth/signup', $data);
	$json = $response->json();

	$response->assertStatus(422);
	$this->assertSame('error', $json['status']);
	$this->assertCount(1, $json['errors']);
	$this->assertArrayHasKey('login', $json['errors']);
	}

	/**
	* Test last signup step with valid input (user creation)
	*
	* @depends testSignupVerifyValidInput
	* @return void
	*/
	public function testSignupValidInput(array $result)
	{
	$queue = Queue::fake();

	$domain = $this->getPublicDomain();
	$identity = \strtolower('SignupLogin@') . $domain;
	$code = SignupCode::find($result['code']);
	$data = [
	'login' => 'SignupLogin',
	'domain' => $domain,
	'password' => 'test',
	'password_confirmation' => 'test',
	'code' => $code->code,
	'short_code' => $code->short_code,
	'voucher' => 'TEST',
	];

	$response = $this->post('/api/auth/signup', $data);
	$json = $response->json();

	$response->assertStatus(200);
	$this->assertSame('success', $json['status']);
	$this->assertSame('bearer', $json['token_type']);
	$this->assertTrue(!empty($json['expires_in']) && is_int($json['expires_in']) && $json['expires_in'] > 0);
	$this->assertNotEmpty($json['access_token']);
	$this->assertSame($identity, $json['email']);

	Queue::assertPushed(\App\Jobs\User\CreateJob::class, 1);

	Queue::assertPushed(
	\App\Jobs\User\CreateJob::class,
	function ($job) use ($data) {
	$userEmail = TestCase::getObjectProperty($job, 'userEmail');
	return $userEmail === \strtolower($data['login'] . '@' . $data['domain']);
	}
	);

	// Check if the code has been removed
	$this->assertNull(SignupCode::where('code', $result['code'])->first());

	// Check if the user has been created
	$user = User::where('email', $identity)->first();

	$this->assertNotEmpty($user);
	$this->assertSame($identity, $user->email);

	// Check user settings
	$this->assertSame($result['first_name'], $user->getSetting('first_name'));
	$this->assertSame($result['last_name'], $user->getSetting('last_name'));
	$this->assertSame($result['email'], $user->getSetting('external_email'));

	// Discount
	$discount = Discount::where('code', 'TEST')->first();
	$this->assertSame($discount->id, $user->wallets()->first()->discount_id);

	// TODO: Check SKUs/Plan

	// TODO: Check if the access token works
	}

	/**
	* Test signup for a group (custom domain) account
	*
	* @return void
	*/
	public function testSignupGroupAccount()
	{
	Queue::fake();

	// Initial signup request
	$user_data = $data = [
	'email' => 'testuser@external.com',
	'first_name' => 'Signup',
	'last_name' => 'User',
	'plan' => 'group',
	];

	$response = $this->withoutMiddleware()->post('/api/auth/signup/init', $data);
	$json = $response->json();

	$response->assertStatus(200);
	$this->assertCount(2, $json);
	$this->assertSame('success', $json['status']);
	$this->assertNotEmpty($json['code']);

	// Assert the email sending job was pushed once
	Queue::assertPushed(\App\Jobs\SignupVerificationEmail::class, 1);

	// Assert the job has proper data assigned
	Queue::assertPushed(\App\Jobs\SignupVerificationEmail::class, function ($job) use ($data, $json) {
	$code = TestCase::getObjectProperty($job, 'code');

	return $code->code === $json['code']
	- && $code->data['plan'] === $data['plan']
	- && $code->data['email'] === $data['email']
	- && $code->data['first_name'] === $data['first_name']
	- && $code->data['last_name'] === $data['last_name'];
	+ && $code->plan === $data['plan']
	+ && $code->email === $data['email']
	+ && $code->first_name === $data['first_name']
	+ && $code->last_name === $data['last_name'];
	});

	// Verify the code
	$code = SignupCode::find($json['code']);
	$data = [
	'code' => $code->code,
	'short_code' => $code->short_code,
	];

	$response = $this->post('/api/auth/signup/verify', $data);
	$result = $response->json();

	$response->assertStatus(200);
	$this->assertCount(7, $result);
	$this->assertSame('success', $result['status']);
	$this->assertSame($user_data['email'], $result['email']);
	$this->assertSame($user_data['first_name'], $result['first_name']);
	$this->assertSame($user_data['last_name'], $result['last_name']);
	$this->assertSame(null, $result['voucher']);
	$this->assertSame(true, $result['is_domain']);
	$this->assertSame([], $result['domains']);

	// Final signup request
	$login = 'admin';
	$domain = 'external.com';
	$data = [
	'login' => $login,
	'domain' => $domain,
	'password' => 'test',
	'password_confirmation' => 'test',
	'code' => $code->code,
	'short_code' => $code->short_code,
	];

	$response = $this->post('/api/auth/signup', $data);
	$result = $response->json();

	$response->assertStatus(200);
	$this->assertSame('success', $result['status']);
	$this->assertSame('bearer', $result['token_type']);
	$this->assertTrue(!empty($result['expires_in']) && is_int($result['expires_in']) && $result['expires_in'] > 0);
	$this->assertNotEmpty($result['access_token']);
	$this->assertSame("$login@$domain", $result['email']);

	Queue::assertPushed(\App\Jobs\Domain\CreateJob::class, 1);

	Queue::assertPushed(
	\App\Jobs\Domain\CreateJob::class,
	function ($job) use ($domain) {
	$domainNamespace = TestCase::getObjectProperty($job, 'domainNamespace');

	return $domainNamespace === $domain;
	}
	);

	Queue::assertPushed(\App\Jobs\User\CreateJob::class, 1);

	Queue::assertPushed(
	\App\Jobs\User\CreateJob::class,
	function ($job) use ($data) {
	$userEmail = TestCase::getObjectProperty($job, 'userEmail');

	return $userEmail === $data['login'] . '@' . $data['domain'];
	}
	);

	// Check if the code has been removed
	$this->assertNull(SignupCode::find($code->id));

	// Check if the user has been created
	$user = User::where('email', $login . '@' . $domain)->first();

	$this->assertNotEmpty($user);

	// Check user settings
	$this->assertSame($user_data['email'], $user->getSetting('external_email'));
	$this->assertSame($user_data['first_name'], $user->getSetting('first_name'));
	$this->assertSame($user_data['last_name'], $user->getSetting('last_name'));

	// TODO: Check domain record

	// TODO: Check SKUs/Plan

	// TODO: Check if the access token works
	}

	/**
	* List of login/domain validation cases for testValidateLogin()
	*
	* @return array Arguments for testValidateLogin()
	*/
	public function dataValidateLogin(): array
	{
	$domain = $this->getPublicDomain();

	return [
	// Individual account
	['', $domain, false, ['login' => 'The login field is required.']],
	['test123456', 'localhost', false, ['domain' => 'The specified domain is invalid.']],
	['test123456', 'unknown-domain.org', false, ['domain' => 'The specified domain is invalid.']],
	['test.test', $domain, false, null],
	['test_test', $domain, false, null],
	['test-test', $domain, false, null],
	['admin', $domain, false, ['login' => 'The specified login is not available.']],
	['administrator', $domain, false, ['login' => 'The specified login is not available.']],
	['sales', $domain, false, ['login' => 'The specified login is not available.']],
	['root', $domain, false, ['login' => 'The specified login is not available.']],

	// TODO existing (public domain) user
	// ['signuplogin', $domain, false, ['login' => 'The specified login is not available.']],

	// Domain account
	['admin', 'kolabsys.com', true, null],
	['testnonsystemdomain', 'invalid', true, ['domain' => 'The specified domain is invalid.']],
	['testnonsystemdomain', '.com', true, ['domain' => 'The specified domain is invalid.']],

	// existing custom domain
	['jack', 'kolab.org', true, ['domain' => 'The specified domain is not available.']],
	];
	}

	/**
	* Signup login/domain validation.
	*
	* Note: Technically these include unit tests, but let's keep it here for now.
	* FIXME: Shall we do a http request for each case?
	*
	* @dataProvider dataValidateLogin
	*/
	public function testValidateLogin($login, $domain, $external, $expected_result): void
	{
	$result = $this->invokeMethod(new SignupController(), 'validateLogin', [$login, $domain, $external]);

	$this->assertSame($expected_result, $result);
	}

	/**
	* Signup login/domain validation, more cases
	*
	* Note: Technically these include unit tests, but let's keep it here for now.
	*/
	public function testValidateLoginMore(): void
	{
	$group = $this->getTestGroup('group-test@kolabnow.com');
	$login = 'group-test';
	$domain = 'kolabnow.com';
	$external = false;

	$result = $this->invokeMethod(new SignupController(), 'validateLogin', [$login, $domain, $external]);

	$this->assertSame(['login' => 'The specified login is not available.'], $result);
	}
	}
	diff --git a/src/tests/Feature/Jobs/SignupVerificationEmailTest.php b/src/tests/Feature/Jobs/SignupVerificationEmailTest.php
	index f9a97cb7..0a4d189f 100644
	--- a/src/tests/Feature/Jobs/SignupVerificationEmailTest.php
	+++ b/src/tests/Feature/Jobs/SignupVerificationEmailTest.php
	@@ -1,66 +1,64 @@
	<?php

	namespace Tests\Feature\Jobs;

	use App\Jobs\SignupVerificationEmail;
	use App\Mail\SignupVerification;
	use App\SignupCode;
	use Illuminate\Support\Facades\Mail;
	use Tests\TestCase;

	class SignupVerificationEmailTest extends TestCase
	{
	private $code;

	/**
	* {@inheritDoc}
	*
	* @return void
	*/
	public function setUp(): void
	{
	parent::setUp();

	$this->code = SignupCode::create([
	- 'data' => [
	- 'email' => 'SignupVerificationEmailTest1@' . \config('app.domain'),
	- 'first_name' => "Test",
	- 'last_name' => "Job"
	- ]
	+ 'email' => 'SignupVerificationEmailTest1@' . \config('app.domain'),
	+ 'first_name' => "Test",
	+ 'last_name' => "Job"
	]);
	}

	/**
	* {@inheritDoc}
	*
	* @return void
	*/
	public function tearDown(): void
	{
	$this->code->delete();
	}

	/**
	* Test job handle
	*
	* @return void
	*/
	public function testSignupVerificationEmailHandle()
	{
	Mail::fake();

	// Assert that no jobs were pushed...
	Mail::assertNothingSent();

	$job = new SignupVerificationEmail($this->code);
	$job->handle();

	// Assert the email sending job was pushed once
	Mail::assertSent(SignupVerification::class, 1);

	// Assert the mail was sent to the code's email
	Mail::assertSent(SignupVerification::class, function ($mail) {
	- return $mail->hasTo($this->code->data['email']);
	+ return $mail->hasTo($this->code->email);
	});
	}
	}
	diff --git a/src/tests/Feature/SignupCodeTest.php b/src/tests/Feature/SignupCodeTest.php
	index 170a7205..4be5ea6b 100644
	--- a/src/tests/Feature/SignupCodeTest.php
	+++ b/src/tests/Feature/SignupCodeTest.php
	@@ -1,43 +1,49 @@
	<?php

	namespace Tests\Feature;

	use App\SignupCode;
	use Carbon\Carbon;
	use Tests\TestCase;

	class SignupCodeTest extends TestCase
	{
	/**
	* Test SignupCode creation
	*
	* @return void
	*/
	public function testSignupCodeCreate()
	{
	$data = [
	- 'data' => [
	- 'email' => 'User@email.org',
	- ]
	+ 'email' => 'User@email.org',
	];

	$now = Carbon::now();

	$code = SignupCode::create($data);
	-
	$code_length = env('VERIFICATION_CODE_LENGTH', SignupCode::SHORTCODE_LENGTH);
	$exp = Carbon::now()->addHours(env('SIGNUP_CODE_EXPIRY', SignupCode::CODE_EXP_HOURS));

	$this->assertFalse($code->isExpired());
	$this->assertTrue(strlen($code->code) === SignupCode::CODE_LENGTH);
	$this->assertTrue(strlen($code->short_code) === $code_length);
	- $this->assertSame($data['data'], $code->data);
	+ $this->assertSame($data['email'], $code->email);
	+ $this->assertSame('User', $code->local_part);
	+ $this->assertSame('email.org', $code->domain_part);
	+ $this->assertSame('127.0.0.1', $code->ip_address);
	$this->assertInstanceOf(Carbon::class, $code->expires_at);
	$this->assertSame($code->expires_at->toDateTimeString(), $exp->toDateTimeString());

	$inst = SignupCode::find($code->code);

	$this->assertInstanceOf(SignupCode::class, $inst);
	$this->assertSame($inst->code, $code->code);
	+
	+ $inst->email = 'other@email.com';
	+ $inst->save();
	+
	+ $this->assertSame('other', $inst->local_part);
	+ $this->assertSame('email.com', $inst->domain_part);
	}
	}
	diff --git a/src/tests/Unit/Mail/SignupVerificationTest.php b/src/tests/Unit/Mail/SignupVerificationTest.php
	index c7796658..3fa1ab0e 100644
	--- a/src/tests/Unit/Mail/SignupVerificationTest.php
	+++ b/src/tests/Unit/Mail/SignupVerificationTest.php
	@@ -1,48 +1,46 @@
	<?php

	namespace Tests\Unit\Mail;

	use App\Mail\SignupVerification;
	use App\SignupCode;
	use App\Utils;
	use Tests\MailInterceptTrait;
	use Tests\TestCase;

	class SignupVerificationTest extends TestCase
	{
	use MailInterceptTrait;

	/**
	* Test email content
	*/
	public function testBuild(): void
	{
	$code = new SignupCode([
	'code' => 'code',
	'short_code' => 'short-code',
	- 'data' => [
	- 'email' => 'test@email',
	- 'first_name' => 'First',
	- 'last_name' => 'Last',
	- ],
	+ 'email' => 'test@email',
	+ 'first_name' => 'First',
	+ 'last_name' => 'Last',
	]);

	$mail = $this->fakeMail(new SignupVerification($code));

	$html = $mail['html'];
	$plain = $mail['plain'];

	$url = Utils::serviceUrl('/signup/' . $code->short_code . '-' . $code->code);
	$link = "<a href=\"$url\">$url</a>";
	$appName = \config('app.name');

	$this->assertMailSubject("$appName Registration", $mail['message']);

	$this->assertStringStartsWith('<!DOCTYPE html>', $html);
	$this->assertTrue(strpos($html, $link) > 0);
	$this->assertTrue(strpos($html, 'First Last') > 0);

	$this->assertStringStartsWith('Dear First Last', $plain);
	$this->assertTrue(strpos($plain, $url) > 0);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Feb 3, 11:26 AM (1 d, 1 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 427150
Default Alt Text: (116 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions