No OneTemporary
Actions

Authored By

Unknown

Size

268 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/src/app/Handlers/Beta/Meet.php b/src/app/Handlers/Beta/Meet.php
	deleted file mode 100644
	index 33757764..00000000
	--- a/src/app/Handlers/Beta/Meet.php
	+++ /dev/null
	@@ -1,18 +0,0 @@
	-<?php
	-
	-namespace App\Handlers\Beta;
	-
	-class Meet extends Base
	-{
	- /**
	- * The entitleable class for this handler.
	- *
	- * @return string
	- */
	- public static function entitleableClass(): string
	- {
	- // Note: We connot just inherit from the parent because
	- // we use static:: there.
	- return \App\User::class;
	- }
	-}
	diff --git a/src/app/Handlers/Meet.php b/src/app/Handlers/Meet.php
	new file mode 100644
	index 00000000..277f1138
	--- /dev/null
	+++ b/src/app/Handlers/Meet.php
	@@ -0,0 +1,43 @@
	+<?php
	+
	+namespace App\Handlers;
	+
	+class Meet extends Base
	+{
	+ /**
	+ * The entitleable class for this handler.
	+ *
	+ * @return string
	+ */
	+ public static function entitleableClass(): string
	+ {
	+ return \App\User::class;
	+ }
	+
	+ /**
	+ * SKU handler metadata.
	+ *
	+ * @param \App\Sku $sku The SKU object
	+ *
	+ * @return array
	+ */
	+ public static function metadata(\App\Sku $sku): array
	+ {
	+ $data = parent::metadata($sku);
	+
	+ $data['required'] = ['groupware'];
	+
	+ return $data;
	+ }
	+
	+ /**
	+ * The priority that specifies the order of SKUs in UI.
	+ * Higher number means higher on the list.
	+ *
	+ * @return int
	+ */
	+ public static function priority(): int
	+ {
	+ return 50;
	+ }
	+}
	diff --git a/src/app/Http/Controllers/API/V4/UsersController.php b/src/app/Http/Controllers/API/V4/UsersController.php
	index 8bbc0a90..2d441230 100644
	--- a/src/app/Http/Controllers/API/V4/UsersController.php
	+++ b/src/app/Http/Controllers/API/V4/UsersController.php
	@@ -1,820 +1,821 @@
	<?php

	namespace App\Http\Controllers\API\V4;

	use App\Http\Controllers\Controller;
	use App\Domain;
	use App\Group;
	use App\Rules\UserEmailDomain;
	use App\Rules\UserEmailLocal;
	use App\Sku;
	use App\User;
	use Carbon\Carbon;
	use Illuminate\Http\Request;
	use Illuminate\Support\Facades\Auth;
	use Illuminate\Support\Facades\DB;
	use Illuminate\Support\Facades\Validator;
	use Illuminate\Support\Str;

	class UsersController extends Controller
	{
	/** @const array List of user setting keys available for modification in UI */
	public const USER_SETTINGS = [
	'billing_address',
	'country',
	'currency',
	'external_email',
	'first_name',
	'last_name',
	'organization',
	'phone',
	];

	/**
	* On user create it is filled with a user or group object to force-delete
	* before the creation of a new user record is possible.
	*
	* @var \App\User\|\App\Group\|null
	*/
	protected $deleteBeforeCreate;


	/**
	* Delete a user.
	*
	* @param int $id User identifier
	*
	* @return \Illuminate\Http\JsonResponse The response
	*/
	public function destroy($id)
	{
	$user = User::find($id);

	if (empty($user)) {
	return $this->errorResponse(404);
	}

	// User can't remove himself until he's the controller
	if (!$this->guard()->user()->canDelete($user)) {
	return $this->errorResponse(403);
	}

	$user->delete();

	return response()->json([
	'status' => 'success',
	'message' => __('app.user-delete-success'),
	]);
	}

	/**
	* Listing of users.
	*
	* The user-entitlements billed to the current user wallet(s)
	*
	* @return \Illuminate\Http\JsonResponse
	*/
	public function index()
	{
	$user = $this->guard()->user();

	$result = $user->users()->orderBy('email')->get()->map(function ($user) {
	$data = $user->toArray();
	$data = array_merge($data, self::userStatuses($user));
	return $data;
	});

	return response()->json($result);
	}

	/**
	* Display information on the user account specified by $id.
	*
	* @param int $id The account to show information for.
	*
	* @return \Illuminate\Http\JsonResponse
	*/
	public function show($id)
	{
	$user = User::find($id);

	if (empty($user)) {
	return $this->errorResponse(404);
	}

	if (!$this->guard()->user()->canRead($user)) {
	return $this->errorResponse(403);
	}

	$response = $this->userResponse($user);

	// Simplified Entitlement/SKU information,
	// TODO: I agree this format may need to be extended in future
	$response['skus'] = [];
	foreach ($user->entitlements as $ent) {
	$sku = $ent->sku;
	$response['skus'][$sku->id] = [
	// 'cost' => $ent->cost,
	'count' => isset($response['skus'][$sku->id]) ? $response['skus'][$sku->id]['count'] + 1 : 1,
	];
	}

	return response()->json($response);
	}

	/**
	* Fetch user status (and reload setup process)
	*
	* @param int $id User identifier
	*
	* @return \Illuminate\Http\JsonResponse
	*/
	public function status($id)
	{
	$user = User::find($id);

	if (empty($user)) {
	return $this->errorResponse(404);
	}

	if (!$this->guard()->user()->canRead($user)) {
	return $this->errorResponse(403);
	}

	$response = self::statusInfo($user);

	if (!empty(request()->input('refresh'))) {
	$updated = false;
	$async = false;
	$last_step = 'none';

	foreach ($response['process'] as $idx => $step) {
	$last_step = $step['label'];

	if (!$step['state']) {
	$exec = $this->execProcessStep($user, $step['label']);

	if (!$exec) {
	if ($exec === null) {
	$async = true;
	}

	break;
	}

	$updated = true;
	}
	}

	if ($updated) {
	$response = self::statusInfo($user);
	}

	$success = $response['isReady'];
	$suffix = $success ? 'success' : 'error-' . $last_step;

	$response['status'] = $success ? 'success' : 'error';
	$response['message'] = \trans('app.process-' . $suffix);

	if ($async && !$success) {
	$response['processState'] = 'waiting';
	$response['status'] = 'success';
	$response['message'] = \trans('app.process-async');
	}
	}

	$response = array_merge($response, self::userStatuses($user));

	return response()->json($response);
	}

	/**
	* User status (extended) information
	*
	* @param \App\User $user User object
	*
	* @return array Status information
	*/
	public static function statusInfo(User $user): array
	{
	$process = [];
	$steps = [
	'user-new' => true,
	'user-ldap-ready' => $user->isLdapReady(),
	'user-imap-ready' => $user->isImapReady(),
	];

	// Create a process check list
	foreach ($steps as $step_name => $state) {
	$step = [
	'label' => $step_name,
	'title' => \trans("app.process-{$step_name}"),
	'state' => $state,
	];

	$process[] = $step;
	}

	list ($local, $domain) = explode('@', $user->email);
	$domain = Domain::where('namespace', $domain)->first();

	// If that is not a public domain, add domain specific steps
	if ($domain && !$domain->isPublic()) {
	$domain_status = DomainsController::statusInfo($domain);
	$process = array_merge($process, $domain_status['process']);
	}

	$all = count($process);
	$checked = count(array_filter($process, function ($v) {
	return $v['state'];
	}));

	$state = $all === $checked ? 'done' : 'running';

	// After 180 seconds assume the process is in failed state,
	// this should unlock the Refresh button in the UI
	if ($all !== $checked && $user->created_at->diffInSeconds(Carbon::now()) > 180) {
	$state = 'failed';
	}

	// Check if the user is a controller of his wallet
	$isController = $user->canDelete($user);
	$hasCustomDomain = $user->wallet()->entitlements()
	->where('entitleable_type', Domain::class)
	->count() > 0;

	- // Get user's beta entitlements
	- $betaSKUs = $user->entitlements()->select('skus.title')
	+ // Get user's entitlements titles
	+ $skus = $user->entitlements()->select('skus.title')
	->join('skus', 'skus.id', '=', 'entitlements.sku_id')
	- ->where('handler_class', 'like', 'App\\\\Handlers\\\\Beta\\\\%')
	->get()
	->pluck('title')
	+ ->sort()
	->unique()
	+ ->values()
	->all();

	return [
	- 'betaSKUs' => $betaSKUs,
	+ 'skus' => $skus,
	// TODO: This will change when we enable all users to create domains
	'enableDomains' => $isController && $hasCustomDomain,
	'enableUsers' => $isController,
	'enableWallets' => $isController,
	'process' => $process,
	'processState' => $state,
	'isReady' => $all === $checked,
	];
	}

	/**
	* Create a new user record.
	*
	* @param \Illuminate\Http\Request $request The API request.
	*
	* @return \Illuminate\Http\JsonResponse The response
	*/
	public function store(Request $request)
	{
	$current_user = $this->guard()->user();
	$owner = $current_user->wallet()->owner;

	if ($owner->id != $current_user->id) {
	return $this->errorResponse(403);
	}

	$this->deleteBeforeCreate = null;

	if ($error_response = $this->validateUserRequest($request, null, $settings)) {
	return $error_response;
	}

	if (empty($request->package) \|\| !($package = \App\Package::find($request->package))) {
	$errors = ['package' => \trans('validation.packagerequired')];
	return response()->json(['status' => 'error', 'errors' => $errors], 422);
	}

	if ($package->isDomain()) {
	$errors = ['package' => \trans('validation.packageinvalid')];
	return response()->json(['status' => 'error', 'errors' => $errors], 422);
	}

	DB::beginTransaction();

	// @phpstan-ignore-next-line
	if ($this->deleteBeforeCreate) {
	$this->deleteBeforeCreate->forceDelete();
	}

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

	$owner->assignPackage($package, $user);

	if (!empty($settings)) {
	$user->setSettings($settings);
	}

	if (!empty($request->aliases)) {
	$user->setAliases($request->aliases);
	}

	DB::commit();

	return response()->json([
	'status' => 'success',
	'message' => __('app.user-create-success'),
	]);
	}

	/**
	* Update user data.
	*
	* @param \Illuminate\Http\Request $request The API request.
	* @param string $id User identifier
	*
	* @return \Illuminate\Http\JsonResponse The response
	*/
	public function update(Request $request, $id)
	{
	$user = User::find($id);

	if (empty($user)) {
	return $this->errorResponse(404);
	}

	$current_user = $this->guard()->user();

	// TODO: Decide what attributes a user can change on his own profile
	if (!$current_user->canUpdate($user)) {
	return $this->errorResponse(403);
	}

	if ($error_response = $this->validateUserRequest($request, $user, $settings)) {
	return $error_response;
	}

	// Entitlements, only controller can do that
	if ($request->skus !== null && !$current_user->canDelete($user)) {
	return $this->errorResponse(422, "You have no permission to change entitlements");
	}

	DB::beginTransaction();

	$this->updateEntitlements($user, $request->skus);

	if (!empty($settings)) {
	$user->setSettings($settings);
	}

	if (!empty($request->password)) {
	$user->password = $request->password;
	$user->save();
	}

	if (isset($request->aliases)) {
	$user->setAliases($request->aliases);
	}

	// TODO: Make sure that UserUpdate job is created in case of entitlements update
	// and no password change. So, for example quota change is applied to LDAP
	// TODO: Review use of $user->save() in the above context

	DB::commit();

	$response = [
	'status' => 'success',
	'message' => __('app.user-update-success'),
	];

	// For self-update refresh the statusInfo in the UI
	if ($user->id == $current_user->id) {
	$response['statusInfo'] = self::statusInfo($user);
	}

	return response()->json($response);
	}

	/**
	* Get the guard to be used during authentication.
	*
	* @return \Illuminate\Contracts\Auth\Guard
	*/
	public function guard()
	{
	return Auth::guard();
	}

	/**
	* Update user entitlements.
	*
	* @param \App\User $user The user
	* @param array $rSkus List of SKU IDs requested for the user in the form [id=>qty]
	*/
	protected function updateEntitlements(User $user, $rSkus)
	{
	if (!is_array($rSkus)) {
	return;
	}

	// list of skus, [id=>obj]
	$skus = Sku::all()->mapWithKeys(
	function ($sku) {
	return [$sku->id => $sku];
	}
	);

	// existing entitlement's SKUs
	$eSkus = [];

	$user->entitlements()->groupBy('sku_id')
	->selectRaw('count(*) as total, sku_id')->each(
	function ($e) use (&$eSkus) {
	$eSkus[$e->sku_id] = $e->total;
	}
	);

	foreach ($skus as $skuID => $sku) {
	$e = array_key_exists($skuID, $eSkus) ? $eSkus[$skuID] : 0;
	$r = array_key_exists($skuID, $rSkus) ? $rSkus[$skuID] : 0;

	if ($sku->handler_class == \App\Handlers\Mailbox::class) {
	if ($r != 1) {
	throw new \Exception("Invalid quantity of mailboxes");
	}
	}

	if ($e > $r) {
	// remove those entitled more than existing
	$user->removeSku($sku, ($e - $r));
	} elseif ($e < $r) {
	// add those requested more than entitled
	$user->assignSku($sku, ($r - $e));
	}
	}
	}

	/**
	* Create a response data array for specified user.
	*
	* @param \App\User $user User object
	*
	* @return array Response data
	*/
	public static function userResponse(User $user): array
	{
	$response = $user->toArray();

	// Settings
	$response['settings'] = [];
	foreach ($user->settings()->whereIn('key', self::USER_SETTINGS)->get() as $item) {
	$response['settings'][$item->key] = $item->value;
	}

	// Aliases
	$response['aliases'] = [];
	foreach ($user->aliases as $item) {
	$response['aliases'][] = $item->alias;
	}

	// Status info
	$response['statusInfo'] = self::statusInfo($user);

	$response = array_merge($response, self::userStatuses($user));

	// Add more info to the wallet object output
	$map_func = function ($wallet) use ($user) {
	$result = $wallet->toArray();

	if ($wallet->discount) {
	$result['discount'] = $wallet->discount->discount;
	$result['discount_description'] = $wallet->discount->description;
	}

	if ($wallet->user_id != $user->id) {
	$result['user_email'] = $wallet->owner->email;
	}

	$provider = \App\Providers\PaymentProvider::factory($wallet);
	$result['provider'] = $provider->name();

	return $result;
	};

	// Information about wallets and accounts for access checks
	$response['wallets'] = $user->wallets->map($map_func)->toArray();
	$response['accounts'] = $user->accounts->map($map_func)->toArray();
	$response['wallet'] = $map_func($user->wallet());

	return $response;
	}

	/**
	* Prepare user statuses for the UI
	*
	* @param \App\User $user User object
	*
	* @return array Statuses array
	*/
	protected static function userStatuses(User $user): array
	{
	return [
	'isImapReady' => $user->isImapReady(),
	'isLdapReady' => $user->isLdapReady(),
	'isSuspended' => $user->isSuspended(),
	'isActive' => $user->isActive(),
	'isDeleted' => $user->isDeleted() \|\| $user->trashed(),
	];
	}

	/**
	* Validate user input
	*
	* @param \Illuminate\Http\Request $request The API request.
	* @param \App\User\|null $user User identifier
	* @param array $settings User settings (from the request)
	*
	* @return \Illuminate\Http\JsonResponse\|null The error response on error
	*/
	protected function validateUserRequest(Request $request, $user, &$settings = [])
	{
	$rules = [
	'external_email' => 'nullable\|email',
	'phone' => 'string\|nullable\|max:64\|regex:/^[0-9+() -]+$/',
	'first_name' => 'string\|nullable\|max:128',
	'last_name' => 'string\|nullable\|max:128',
	'organization' => 'string\|nullable\|max:512',
	'billing_address' => 'string\|nullable\|max:1024',
	'country' => 'string\|nullable\|alpha\|size:2',
	'currency' => 'string\|nullable\|alpha\|size:3',
	'aliases' => 'array\|nullable',
	];

	if (empty($user) \|\| !empty($request->password) \|\| !empty($request->password_confirmation)) {
	$rules['password'] = 'required\|min:4\|max:2048\|confirmed';
	}

	$errors = [];

	// Validate input
	$v = Validator::make($request->all(), $rules);

	if ($v->fails()) {
	$errors = $v->errors()->toArray();
	}

	$controller = $user ? $user->wallet()->owner : $this->guard()->user();

	// For new user validate email address
	if (empty($user)) {
	$email = $request->email;

	if (empty($email)) {
	$errors['email'] = \trans('validation.required', ['attribute' => 'email']);
	} elseif ($error = self::validateEmail($email, $controller, $this->deleteBeforeCreate)) {
	$errors['email'] = $error;
	}
	}

	// Validate aliases input
	if (isset($request->aliases)) {
	$aliases = [];
	$existing_aliases = $user ? $user->aliases()->get()->pluck('alias')->toArray() : [];

	foreach ($request->aliases as $idx => $alias) {
	if (is_string($alias) && !empty($alias)) {
	// Alias cannot be the same as the email address (new user)
	if (!empty($email) && Str::lower($alias) == Str::lower($email)) {
	continue;
	}

	// validate new aliases
	if (
	!in_array($alias, $existing_aliases)
	&& ($error = self::validateAlias($alias, $controller))
	) {
	if (!isset($errors['aliases'])) {
	$errors['aliases'] = [];
	}
	$errors['aliases'][$idx] = $error;
	continue;
	}

	$aliases[] = $alias;
	}
	}

	$request->aliases = $aliases;
	}

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

	// Update user settings
	$settings = $request->only(array_keys($rules));
	unset($settings['password'], $settings['aliases'], $settings['email']);

	return null;
	}

	/**
	* Execute (synchronously) specified step in a user setup process.
	*
	* @param \App\User $user User object
	* @param string $step Step identifier (as in self::statusInfo())
	*
	* @return bool\|null True if the execution succeeded, False if not, Null when
	* the job has been sent to the worker (result unknown)
	*/
	public static function execProcessStep(User $user, string $step): ?bool
	{
	try {
	if (strpos($step, 'domain-') === 0) {
	list ($local, $domain) = explode('@', $user->email);
	$domain = Domain::where('namespace', $domain)->first();

	return DomainsController::execProcessStep($domain, $step);
	}

	switch ($step) {
	case 'user-ldap-ready':
	// User not in LDAP, create it
	$job = new \App\Jobs\User\CreateJob($user->id);
	$job->handle();

	$user->refresh();

	return $user->isLdapReady();

	case 'user-imap-ready':
	// User not in IMAP? Verify again
	// Do it synchronously if the imap admin credentials are available
	// otherwise let the worker do the job
	if (!\config('imap.admin_password')) {
	\App\Jobs\User\VerifyJob::dispatch($user->id);

	return null;
	}

	$job = new \App\Jobs\User\VerifyJob($user->id);
	$job->handle();

	$user->refresh();

	return $user->isImapReady();
	}
	} catch (\Exception $e) {
	\Log::error($e);
	}

	return false;
	}

	/**
	* Email address validation for use as a user mailbox (login).
	*
	* @param string $email Email address
	* @param \App\User $user The account owner
	* @param null\|\App\User\|\App\Group $deleted Filled with an instance of a deleted user or group
	* with the specified email address, if exists
	*
	* @return ?string Error message on validation error
	*/
	public static function validateEmail(string $email, \App\User $user, &$deleted = null): ?string
	{
	$deleted = null;

	if (strpos($email, '@') === false) {
	return \trans('validation.entryinvalid', ['attribute' => 'email']);
	}

	list($login, $domain) = explode('@', Str::lower($email));

	if (strlen($login) === 0 \|\| strlen($domain) === 0) {
	return \trans('validation.entryinvalid', ['attribute' => 'email']);
	}

	// Check if domain exists
	$domain = Domain::where('namespace', $domain)->first();

	if (empty($domain)) {
	return \trans('validation.domaininvalid');
	}

	// Validate login part alone
	$v = Validator::make(
	['email' => $login],
	['email' => ['required', new UserEmailLocal(!$domain->isPublic())]]
	);

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

	// Check if it is one of domains available to the user
	$domains = \collect($user->domains())->pluck('namespace')->all();

	if (!in_array($domain->namespace, $domains)) {
	return \trans('validation.entryexists', ['attribute' => 'domain']);
	}

	// Check if a user with specified address already exists
	if ($existing_user = User::emailExists($email, true)) {
	// If this is a deleted user in the same custom domain
	// we'll force delete him before
	if (!$domain->isPublic() && $existing_user->trashed()) {
	$deleted = $existing_user;
	} else {
	return \trans('validation.entryexists', ['attribute' => 'email']);
	}
	}

	// Check if an alias with specified address already exists.
	if (User::aliasExists($email)) {
	return \trans('validation.entryexists', ['attribute' => 'email']);
	}

	// Check if a group with specified address already exists
	if ($existing_group = Group::emailExists($email, true)) {
	// If this is a deleted group in the same custom domain
	// we'll force delete it before
	if (!$domain->isPublic() && $existing_group->trashed()) {
	$deleted = $existing_group;
	} else {
	return \trans('validation.entryexists', ['attribute' => 'email']);
	}
	}

	return null;
	}

	/**
	* Email address validation for use as an alias.
	*
	* @param string $email Email address
	* @param \App\User $user The account owner
	*
	* @return ?string Error message on validation error
	*/
	public static function validateAlias(string $email, \App\User $user): ?string
	{
	if (strpos($email, '@') === false) {
	return \trans('validation.entryinvalid', ['attribute' => 'alias']);
	}

	list($login, $domain) = explode('@', Str::lower($email));

	if (strlen($login) === 0 \|\| strlen($domain) === 0) {
	return \trans('validation.entryinvalid', ['attribute' => 'alias']);
	}

	// Check if domain exists
	$domain = Domain::where('namespace', $domain)->first();

	if (empty($domain)) {
	return \trans('validation.domaininvalid');
	}

	// Validate login part alone
	$v = Validator::make(
	['alias' => $login],
	['alias' => ['required', new UserEmailLocal(!$domain->isPublic())]]
	);

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

	// Check if it is one of domains available to the user
	$domains = \collect($user->domains())->pluck('namespace')->all();

	if (!in_array($domain->namespace, $domains)) {
	return \trans('validation.entryexists', ['attribute' => 'domain']);
	}

	// Check if a user with specified address already exists
	if ($existing_user = User::emailExists($email, true)) {
	// Allow an alias in a custom domain to an address that was a user before
	if ($domain->isPublic() \|\| !$existing_user->trashed()) {
	return \trans('validation.entryexists', ['attribute' => 'alias']);
	}
	}

	// Check if an alias with specified address already exists
	if (User::aliasExists($email)) {
	// Allow assigning the same alias to a user in the same group account,
	// but only for non-public domains
	if ($domain->isPublic()) {
	return \trans('validation.entryexists', ['attribute' => 'alias']);
	}
	}

	// Check if a group with specified address already exists
	if (Group::emailExists($email)) {
	return \trans('validation.entryexists', ['attribute' => 'alias']);
	}

	return null;
	}
	}
	diff --git a/src/database/migrations/2021_01_26_150000_change_sku_descriptions.php b/src/database/migrations/2021_01_26_150000_change_sku_descriptions.php
	new file mode 100644
	index 00000000..7af011e5
	--- /dev/null
	+++ b/src/database/migrations/2021_01_26_150000_change_sku_descriptions.php
	@@ -0,0 +1,36 @@
	+<?php
	+
	+use Illuminate\Support\Facades\Schema;
	+use Illuminate\Database\Schema\Blueprint;
	+use Illuminate\Database\Migrations\Migration;
	+
	+// phpcs:ignore
	+class ChangeSkuDescriptions extends Migration
	+{
	+ /**
	+ * Run the migrations.
	+ *
	+ * @return void
	+ */
	+ public function up()
	+ {
	+ $beta_sku = \App\Sku::where('title', 'beta')->first();
	+ $beta_sku->name = 'Private Beta (invitation only)';
	+ $beta_sku->description = 'Access to the private beta program subscriptions';
	+ $beta_sku->save();
	+
	+ $meet_sku = \App\Sku::where('title', 'meet')->first();
	+ $meet_sku->name = 'Voice & Video Conferencing (public beta)';
	+ $meet_sku->handler_class = 'App\Handlers\Meet';
	+ $meet_sku->save();
	+ }
	+
	+ /**
	+ * Reverse the migrations.
	+ *
	+ * @return void
	+ */
	+ public function down()
	+ {
	+ }
	+}
	diff --git a/src/database/seeds/local/SkuSeeder.php b/src/database/seeds/local/SkuSeeder.php
	index a4ccb62a..0b68202c 100644
	--- a/src/database/seeds/local/SkuSeeder.php
	+++ b/src/database/seeds/local/SkuSeeder.php
	@@ -1,203 +1,203 @@
	<?php

	namespace Database\Seeds\Local;

	use App\Sku;
	use Illuminate\Database\Seeder;

	class SkuSeeder extends Seeder
	{
	/**
	* Run the database seeds.
	*
	* @return void
	*/
	public function run()
	{
	Sku::create(
	[
	'title' => 'mailbox',
	'name' => 'User Mailbox',
	'description' => 'Just a mailbox',
	'cost' => 444,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Mailbox',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'domain',
	'name' => 'Hosted Domain',
	'description' => 'Somewhere to place a mailbox',
	'cost' => 100,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Domain',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => 'domain-registration',
	'name' => 'Domain Registration',
	'description' => 'Register a domain with us',
	'cost' => 101,
	'period' => 'yearly',
	'handler_class' => 'App\Handlers\DomainRegistration',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => 'domain-hosting',
	'name' => 'External Domain',
	'description' => 'Host a domain that is externally registered',
	'cost' => 100,
	'units_free' => 1,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\DomainHosting',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'domain-relay',
	'name' => 'Domain Relay',
	'description' => 'A domain you host at home, for which we relay email',
	'cost' => 103,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\DomainRelay',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => 'storage',
	'name' => 'Storage Quota',
	'description' => 'Some wiggle room',
	'cost' => 25,
	'units_free' => 2,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Storage',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'groupware',
	'name' => 'Groupware Features',
	'description' => 'Groupware functions like Calendar, Tasks, Notes, etc.',
	'cost' => 555,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Groupware',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'resource',
	'name' => 'Resource',
	'description' => 'Reservation taker',
	'cost' => 101,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Resource',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => 'shared_folder',
	'name' => 'Shared Folder',
	'description' => 'A shared folder',
	'cost' => 89,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\SharedFolder',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => '2fa',
	'name' => '2-Factor Authentication',
	'description' => 'Two factor authentication for webmail and administration panel',
	'cost' => 0,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Auth2F',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'activesync',
	'name' => 'Activesync',
	'description' => 'Mobile synchronization',
	'cost' => 100,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Activesync',
	'active' => true,
	]
	);

	// Check existence because migration might have added this already
	if (!\App\Sku::where('title', 'beta')->first()) {
	Sku::create(
	[
	'title' => 'beta',
	- 'name' => 'Beta program',
	- 'description' => 'Access to beta program subscriptions',
	+ 'name' => 'Private Beta (invitation only)',
	+ 'description' => 'Access to the private beta program subscriptions',
	'cost' => 0,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Beta',
	'active' => false,
	]
	);
	}

	// Check existence because migration might have added this already
	if (!\App\Sku::where('title', 'meet')->first()) {
	Sku::create(
	[
	'title' => 'meet',
	- 'name' => 'Video chat',
	+ 'name' => 'Voice & Video Conferencing (public beta)',
	'description' => 'Video conferencing tool',
	'cost' => 0,
	'units_free' => 0,
	'period' => 'monthly',
	- 'handler_class' => 'App\Handlers\Beta\Meet',
	+ 'handler_class' => 'App\Handlers\Meet',
	'active' => true,
	]
	);
	}

	// Check existence because migration might have added this already
	if (!\App\Sku::where('title', 'group')->first()) {
	Sku::create(
	[
	'title' => 'group',
	'name' => 'Group',
	'description' => 'Distribution list',
	'cost' => 0,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Group',
	'active' => true,
	]
	);
	}
	}
	}
	diff --git a/src/database/seeds/local/UserSeeder.php b/src/database/seeds/local/UserSeeder.php
	index a70bc7fd..1733d4e1 100644
	--- a/src/database/seeds/local/UserSeeder.php
	+++ b/src/database/seeds/local/UserSeeder.php
	@@ -1,149 +1,149 @@
	<?php

	namespace Database\Seeds\Local;

	use App\Auth\SecondFactor;
	use App\Domain;
	use App\Entitlement;
	use App\User;
	use App\Sku;
	use Carbon\Carbon;
	use Illuminate\Database\Seeder;
	use App\Wallet;

	class UserSeeder extends Seeder
	{
	/**
	* Run the database seeds.
	*
	* @return void
	*/
	public function run()
	{
	$domain = Domain::create(
	[
	'namespace' => 'kolab.org',
	'status' => Domain::STATUS_NEW
	+ Domain::STATUS_ACTIVE
	+ Domain::STATUS_CONFIRMED
	+ Domain::STATUS_VERIFIED,
	'type' => Domain::TYPE_EXTERNAL
	]
	);

	$john = User::create(
	[
	'email' => 'john@kolab.org',
	'password' => 'simple123',
	]
	);

	$john->setSettings(
	[
	'first_name' => 'John',
	'last_name' => 'Doe',
	'currency' => 'USD',
	'country' => 'US',
	'billing_address' => "601 13th Street NW\nSuite 900 South\nWashington, DC 20005",
	'external_email' => 'john.doe.external@gmail.com',
	'organization' => 'Kolab Developers',
	'phone' => '+1 509-248-1111',
	]
	);

	$john->setAliases(['john.doe@kolab.org']);

	$wallet = $john->wallets->first();

	$package_domain = \App\Package::where('title', 'domain-hosting')->first();
	$package_kolab = \App\Package::where('title', 'kolab')->first();
	$package_lite = \App\Package::where('title', 'lite')->first();

	$domain->assignPackage($package_domain, $john);
	$john->assignPackage($package_kolab);

	$jack = User::create(
	[
	'email' => 'jack@kolab.org',
	'password' => 'simple123',
	]
	);

	$jack->setSettings(
	[
	'first_name' => 'Jack',
	'last_name' => 'Daniels',
	'currency' => 'USD',
	'country' => 'US'
	]
	);

	$jack->setAliases(['jack.daniels@kolab.org']);

	$john->assignPackage($package_kolab, $jack);

	foreach ($john->entitlements as $entitlement) {
	$entitlement->created_at = Carbon::now()->subMonthsWithoutOverflow(1);
	$entitlement->updated_at = Carbon::now()->subMonthsWithoutOverflow(1);
	$entitlement->save();
	}

	$ned = User::create(
	[
	'email' => 'ned@kolab.org',
	'password' => 'simple123',
	]
	);

	$ned->setSettings(
	[
	'first_name' => 'Edward',
	'last_name' => 'Flanders',
	'currency' => 'USD',
	'country' => 'US'
	]
	);

	$john->assignPackage($package_kolab, $ned);

	$ned->assignSku(\App\Sku::where('title', 'activesync')->first(), 1);

	// Ned is a controller on Jack's wallet
	$john->wallets()->first()->addController($ned);

	// Ned is also our 2FA test user
	$sku2fa = Sku::firstOrCreate(['title' => '2fa']);
	$ned->assignSku($sku2fa);
	try {
	SecondFactor::seed('ned@kolab.org');
	} catch (\Exception $e) {
	// meh
	}

	$joe = User::create(
	[
	'email' => 'joe@kolab.org',
	'password' => 'simple123',
	]
	);

	$john->assignPackage($package_lite, $joe);

	- $john->assignSku(Sku::firstOrCreate(['title' => 'beta']));
	- $john->assignSku(Sku::firstOrCreate(['title' => 'meet']));
	+ //$john->assignSku(Sku::firstOrCreate(['title' => 'beta']));
	+ //$john->assignSku(Sku::firstOrCreate(['title' => 'meet']));

	$joe->setAliases(['joe.monster@kolab.org']);

	// factory(User::class, 10)->create();

	$jeroen = User::create(
	[
	'email' => 'jeroen@jeroen.jeroen',
	'password' => 'jeroen',
	]
	);

	$jeroen->role = 'admin';
	$jeroen->save();
	}
	}
	diff --git a/src/database/seeds/production/SkuSeeder.php b/src/database/seeds/production/SkuSeeder.php
	index c082aee8..fe466fe0 100644
	--- a/src/database/seeds/production/SkuSeeder.php
	+++ b/src/database/seeds/production/SkuSeeder.php
	@@ -1,203 +1,203 @@
	<?php

	namespace Database\Seeds\Production;

	use App\Sku;
	use Illuminate\Database\Seeder;

	class SkuSeeder extends Seeder
	{
	/**
	* Run the database seeds.
	*
	* @return void
	*/
	public function run()
	{
	Sku::create(
	[
	'title' => 'mailbox',
	'name' => 'User Mailbox',
	'description' => 'Just a mailbox',
	'cost' => 444,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Mailbox',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'domain',
	'name' => 'Hosted Domain',
	'description' => 'Somewhere to place a mailbox',
	'cost' => 100,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Domain',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => 'domain-registration',
	'name' => 'Domain Registration',
	'description' => 'Register a domain with us',
	'cost' => 101,
	'period' => 'yearly',
	'handler_class' => 'App\Handlers\DomainRegistration',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => 'domain-hosting',
	'name' => 'External Domain',
	'description' => 'Host a domain that is externally registered',
	'cost' => 100,
	'units_free' => 1,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\DomainHosting',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'domain-relay',
	'name' => 'Domain Relay',
	'description' => 'A domain you host at home, for which we relay email',
	'cost' => 103,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\DomainRelay',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => 'storage',
	'name' => 'Storage Quota',
	'description' => 'Some wiggle room',
	'cost' => 50,
	'units_free' => 2,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Storage',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'groupware',
	'name' => 'Groupware Features',
	'description' => 'Groupware functions like Calendar, Tasks, Notes, etc.',
	'cost' => 555,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Groupware',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'resource',
	'name' => 'Resource',
	'description' => 'Reservation taker',
	'cost' => 101,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Resource',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => 'shared_folder',
	'name' => 'Shared Folder',
	'description' => 'A shared folder',
	'cost' => 89,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\SharedFolder',
	'active' => false,
	]
	);

	Sku::create(
	[
	'title' => '2fa',
	'name' => '2-Factor Authentication',
	'description' => 'Two factor authentication for webmail and administration panel',
	'cost' => 0,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Auth2F',
	'active' => true,
	]
	);

	Sku::create(
	[
	'title' => 'activesync',
	'name' => 'Activesync',
	'description' => 'Mobile synchronization',
	'cost' => 100,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Activesync',
	'active' => true,
	]
	);

	// Check existence because migration might have added this already
	if (!\App\Sku::where('title', 'beta')->first()) {
	Sku::create(
	[
	'title' => 'beta',
	- 'name' => 'Beta program',
	- 'description' => 'Access to beta program subscriptions',
	+ 'name' => 'Private Beta (invitation only)',
	+ 'description' => 'Access to the private beta program subscriptions',
	'cost' => 0,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Beta',
	'active' => false,
	]
	);
	}

	// Check existence because migration might have added this already
	if (!\App\Sku::where('title', 'meet')->first()) {
	Sku::create(
	[
	'title' => 'meet',
	- 'name' => 'Video chat',
	+ 'name' => 'Voice & Video Conferencing (public beta)',
	'description' => 'Video conferencing tool',
	'cost' => 0,
	'units_free' => 0,
	'period' => 'monthly',
	- 'handler_class' => 'App\Handlers\Beta\Meet',
	+ 'handler_class' => 'App\Handlers\Meet',
	'active' => true,
	]
	);
	}

	// Check existence because migration might have added this already
	if (!\App\Sku::where('title', 'group')->first()) {
	Sku::create(
	[
	'title' => 'group',
	'name' => 'Group',
	'description' => 'Distribution list',
	'cost' => 0,
	'units_free' => 0,
	'period' => 'monthly',
	'handler_class' => 'App\Handlers\Group',
	'active' => true,
	]
	);
	}
	}
	}
	diff --git a/src/resources/js/app.js b/src/resources/js/app.js
	index 9d0b0168..ebd77287 100644
	--- a/src/resources/js/app.js
	+++ b/src/resources/js/app.js
	@@ -1,469 +1,469 @@
	/**
	* First we will load all of this project's JavaScript dependencies which
	* includes Vue and other libraries. It is a great starting point when
	* building robust, powerful web applications using Vue and Laravel.
	*/

	require('./bootstrap')

	import AppComponent from '../vue/App'
	import MenuComponent from '../vue/Widgets/Menu'
	import SupportForm from '../vue/Widgets/SupportForm'
	import store from './store'

	const loader = '<div class="app-loader"><div class="spinner-border" role="status"><span class="sr-only">Loading</span></div></div>'

	let isLoading = 0

	// Lock the UI with the 'loading...' element
	const startLoading = () => {
	isLoading++
	let loading = $('#app > .app-loader').removeClass('fadeOut')
	if (!loading.length) {
	$('#app').append($(loader))
	}
	}

	// Hide "loading" overlay
	const stopLoading = () => {
	if (isLoading > 0) {
	$('#app > .app-loader').addClass('fadeOut')
	isLoading--;
	}
	}

	let loadingRoute

	// Note: This has to be before the app is created
	// Note: You cannot use app inside of the function
	window.router.beforeEach((to, from, next) => {
	// check if the route requires authentication and user is not logged in
	if (to.matched.some(route => route.meta.requiresAuth) && !store.state.isLoggedIn) {
	// remember the original request, to use after login
	store.state.afterLogin = to;

	// redirect to login page
	next({ name: 'login' })

	return
	}

	if (to.meta.loading) {
	startLoading()
	loadingRoute = to.name
	}

	next()
	})

	window.router.afterEach((to, from) => {
	if (to.name && loadingRoute === to.name) {
	stopLoading()
	loadingRoute = null
	}

	// When changing a page remove old:
	// - error page
	// - modal backdrop
	$('#error-page,.modal-backdrop.show').remove()
	})

	const app = new Vue({
	el: '#app',
	components: {
	AppComponent,
	MenuComponent,
	},
	store,
	router: window.router,
	data() {
	return {
	isAdmin: window.isAdmin
	}
	},
	methods: {
	// Clear (bootstrap) form validation state
	clearFormValidation(form) {
	$(form).find('.is-invalid').removeClass('is-invalid')
	$(form).find('.invalid-feedback').remove()
	},
	hasRoute(name) {
	return this.$router.resolve({ name: name }).resolved.matched.length > 0
	},
	- hasBeta(name) {
	+ hasSKU(name) {
	const authInfo = store.state.authInfo
	- return authInfo.statusInfo.betaSKUs && authInfo.statusInfo.betaSKUs.indexOf(name) != -1
	+ return authInfo.statusInfo.skus && authInfo.statusInfo.skus.indexOf(name) != -1
	},
	isController(wallet_id) {
	if (wallet_id && store.state.authInfo) {
	let i
	for (i = 0; i < store.state.authInfo.wallets.length; i++) {
	if (wallet_id == store.state.authInfo.wallets[i].id) {
	return true
	}
	}
	for (i = 0; i < store.state.authInfo.accounts.length; i++) {
	if (wallet_id == store.state.authInfo.accounts[i].id) {
	return true
	}
	}
	}

	return false
	},
	// Set user state to "logged in"
	loginUser(response, dashboard, update) {
	if (!update) {
	store.commit('logoutUser') // destroy old state data
	store.commit('loginUser')
	}

	localStorage.setItem('token', response.access_token)
	axios.defaults.headers.common.Authorization = 'Bearer ' + response.access_token

	if (response.email) {
	store.state.authInfo = response
	}

	if (dashboard !== false) {
	this.$router.push(store.state.afterLogin \|\| { name: 'dashboard' })
	}

	store.state.afterLogin = null

	// Refresh the token before it expires
	let timeout = response.expires_in \|\| 0

	// We'll refresh 60 seconds before the token expires
	if (timeout > 60) {
	timeout -= 60
	}

	// TODO: We probably should try a few times in case of an error
	// TODO: We probably should prevent axios from doing any requests
	// while the token is being refreshed

	this.refreshTimeout = setTimeout(() => {
	axios.post('/api/auth/refresh').then(response => {
	this.loginUser(response.data, false, true)
	})
	}, timeout * 1000)
	},
	// Set user state to "not logged in"
	logoutUser(redirect) {
	store.commit('logoutUser')
	localStorage.setItem('token', '')
	delete axios.defaults.headers.common.Authorization

	if (redirect !== false) {
	this.$router.push({ name: 'login' })
	}

	clearTimeout(this.refreshTimeout)
	},
	// Display "loading" overlay inside of the specified element
	addLoader(elem) {
	$(elem).css({position: 'relative'}).append($(loader).addClass('small'))
	},
	// Remove loader element added in addLoader()
	removeLoader(elem) {
	$(elem).find('.app-loader').remove()
	},
	startLoading,
	stopLoading,
	isLoading() {
	return isLoading > 0
	},
	errorPage(code, msg) {
	// Until https://github.com/vuejs/vue-router/issues/977 is implemented
	// we can't really use router to display error page as it has two side
	// effects: it changes the URL and adds the error page to browser history.
	// For now we'll be replacing current view with error page "manually".
	const map = {
	400: "Bad request",
	401: "Unauthorized",
	403: "Access denied",
	404: "Not found",
	405: "Method not allowed",
	500: "Internal server error"
	}

	if (!msg) msg = map[code] \|\| "Unknown Error"

	const error_page = `<div id="error-page" class="error-page"><div class="code">${code}</div><div class="message">${msg}</div></div>`

	$('#error-page').remove()
	$('#app').append(error_page)

	app.updateBodyClass('error')
	},
	errorHandler(error) {
	this.stopLoading()

	if (!error.response) {
	// TODO: probably network connection error
	} else if (error.response.status === 401) {
	// Remember requested route to come back to it after log in
	if (this.$route.meta.requiresAuth) {
	store.state.afterLogin = this.$route
	this.logoutUser()
	} else {
	this.logoutUser(false)
	}
	} else {
	this.errorPage(error.response.status, error.response.statusText)
	}
	},
	downloadFile(url) {
	// TODO: This might not be a best way for big files as the content
	// will be stored (temporarily) in browser memory
	// TODO: This method does not show the download progress in the browser
	// but it could be implemented in the UI, axios has 'progress' property
	axios.get(url, { responseType: 'blob' })
	.then(response => {
	const link = document.createElement('a')
	const contentDisposition = response.headers['content-disposition']
	let filename = 'unknown'

	if (contentDisposition) {
	const match = contentDisposition.match(/filename="(.+)"/);
	if (match.length === 2) {
	filename = match[1];
	}
	}

	link.href = window.URL.createObjectURL(response.data)
	link.download = filename
	link.click()
	})
	},
	price(price, currency) {
	return ((price \|\| 0) / 100).toLocaleString('de-DE', { style: 'currency', currency: currency \|\| 'CHF' })
	},
	priceLabel(cost, units = 1, discount) {
	let index = ''

	if (units < 0) {
	units = 1
	}

	if (discount) {
	cost = Math.floor(cost * ((100 - discount) / 100))
	index = '\u00B9'
	}

	return this.price(cost * units) + '/month' + index
	},
	clickRecord(event) {
	if (!/^(a\|button\|svg\|path)$/i.test(event.target.nodeName)) {
	let link = $(event.target).closest('tr').find('a')[0]
	if (link) {
	link.click()
	}
	}
	},
	domainStatusClass(domain) {
	if (domain.isDeleted) {
	return 'text-muted'
	}

	if (domain.isSuspended) {
	return 'text-warning'
	}

	if (!domain.isVerified \|\| !domain.isLdapReady \|\| !domain.isConfirmed) {
	return 'text-danger'
	}

	return 'text-success'
	},
	domainStatusText(domain) {
	if (domain.isDeleted) {
	return 'Deleted'
	}

	if (domain.isSuspended) {
	return 'Suspended'
	}

	if (!domain.isVerified \|\| !domain.isLdapReady \|\| !domain.isConfirmed) {
	return 'Not Ready'
	}

	return 'Active'
	},
	pageName(path) {
	let page = this.$route.path

	// check if it is a "menu page", find the page name
	// otherwise we'll use the real path as page name
	window.config.menu.every(item => {
	if (item.location == page && item.page) {
	page = item.page
	return false
	}
	})

	page = page.replace(/^\//, '')

	return page ? page : '404'
	},
	supportDialog(container) {
	let dialog = $('#support-dialog')

	// FIXME: Find a nicer way of doing this
	if (!dialog.length) {
	let form = new Vue(SupportForm)
	form.$mount($('<div>').appendTo(container)[0])
	form.$root = this
	form.$toast = this.$toast
	dialog = $(form.$el)
	}

	dialog.on('shown.bs.modal', () => {
	dialog.find('input').first().focus()
	}).modal()
	},
	userStatusClass(user) {
	if (user.isDeleted) {
	return 'text-muted'
	}

	if (user.isSuspended) {
	return 'text-warning'
	}

	if (!user.isImapReady \|\| !user.isLdapReady) {
	return 'text-danger'
	}

	return 'text-success'
	},
	userStatusText(user) {
	if (user.isDeleted) {
	return 'Deleted'
	}

	if (user.isSuspended) {
	return 'Suspended'
	}

	if (!user.isImapReady \|\| !user.isLdapReady) {
	return 'Not Ready'
	}

	return 'Active'
	},
	updateBodyClass(name) {
	// Add 'class' attribute to the body, different for each page
	// so, we can apply page-specific styles
	let className = 'page-' + (name \|\| this.pageName()).replace(/\/.*$/, '')
	$(document.body).removeClass().addClass(className)
	}
	}
	})

	// Add a axios request interceptor
	window.axios.interceptors.request.use(
	config => {
	// This is the only way I found to change configuration options
	// on a running application. We need this for browser testing.
	config.headers['X-Test-Payment-Provider'] = window.config.paymentProvider

	return config
	},
	error => {
	// Do something with request error
	return Promise.reject(error)
	}
	)

	// Add a axios response interceptor for general/validation error handler
	window.axios.interceptors.response.use(
	response => {
	if (response.config.onFinish) {
	response.config.onFinish()
	}

	return response
	},
	error => {
	let error_msg
	let status = error.response ? error.response.status : 200

	// Do not display the error in a toast message, pass the error as-is
	if (error.config.ignoreErrors) {
	return Promise.reject(error)
	}

	if (error.config.onFinish) {
	error.config.onFinish()
	}

	if (error.response && status == 422) {
	error_msg = "Form validation error"

	const modal = $('div.modal.show')

	$(modal.length ? modal : 'form').each((i, form) => {
	form = $(form)

	$.each(error.response.data.errors \|\| {}, (idx, msg) => {
	const input_name = (form.data('validation-prefix') \|\| form.find('form').first().data('validation-prefix') \|\| '') + idx
	let input = form.find('#' + input_name)

	if (!input.length) {
	input = form.find('[name="' + input_name + '"]');
	}

	if (input.length) {
	// Create an error message\
	// API responses can use a string, array or object
	let msg_text = ''
	if ($.type(msg) !== 'string') {
	$.each(msg, (index, str) => {
	msg_text += str + ' '
	})
	}
	else {
	msg_text = msg
	}

	let feedback = $('<div class="invalid-feedback">').text(msg_text)

	if (input.is('.list-input')) {
	// List input widget
	input.children(':not(:first-child)').each((index, element) => {
	if (msg[index]) {
	$(element).find('input').addClass('is-invalid')
	}
	})

	input.addClass('is-invalid').next('.invalid-feedback').remove()
	input.after(feedback)
	}
	else {
	// Standard form element
	input.addClass('is-invalid')
	input.parent().find('.invalid-feedback').remove()
	input.parent().append(feedback)
	}
	}
	})

	form.find('.is-invalid:not(.listinput-widget)').first().focus()
	})
	}
	else if (error.response && error.response.data) {
	error_msg = error.response.data.message
	}
	else {
	error_msg = error.request ? error.request.statusText : error.message
	}

	app.$toast.error(error_msg \|\| "Server Error")

	// Pass the error as-is
	return Promise.reject(error)
	}
	)
	diff --git a/src/resources/vue/Dashboard.vue b/src/resources/vue/Dashboard.vue
	index 302cc2bb..1ec8db1f 100644
	--- a/src/resources/vue/Dashboard.vue
	+++ b/src/resources/vue/Dashboard.vue
	@@ -1,63 +1,63 @@
	<template>
	<div class="container" dusk="dashboard-component">
	<status-component :status="status" @status-update="statusUpdate"></status-component>

	<div id="dashboard-nav">
	<router-link class="card link-profile" :to="{ name: 'profile' }">
	<svg-icon icon="user-cog"></svg-icon><span class="name">Your profile</span>
	</router-link>
	<router-link v-if="status.enableDomains" class="card link-domains" :to="{ name: 'domains' }">
	<svg-icon icon="globe"></svg-icon><span class="name">Domains</span>
	</router-link>
	<router-link v-if="status.enableUsers" class="card link-users" :to="{ name: 'users' }">
	<svg-icon icon="users"></svg-icon><span class="name">User accounts</span>
	</router-link>
	<router-link v-if="status.enableWallets" class="card link-wallet" :to="{ name: 'wallet' }">
	<svg-icon icon="wallet"></svg-icon><span class="name">Wallet</span>
	<span v-if="balance < 0" class="badge badge-danger">{{ $root.price(balance) }}</span>
	</router-link>
	- <router-link v-if="$root.hasBeta('meet')" class="card link-chat" :to="{ name: 'rooms' }">
	+ <router-link v-if="$root.hasSKU('meet')" class="card link-chat" :to="{ name: 'rooms' }">
	<svg-icon icon="comments"></svg-icon><span class="name">Video chat</span>
	<span class="badge badge-primary">beta</span>
	</router-link>
	<a v-if="webmailURL" class="card link-webmail" :href="webmailURL">
	<svg-icon icon="envelope"></svg-icon><span class="name">Webmail</span>
	</a>
	</div>
	</div>
	</template>

	<script>
	import StatusComponent from './Widgets/Status'

	export default {
	components: {
	StatusComponent
	},
	data() {
	return {
	status: {},
	balance: 0,
	webmailURL: window.config['app.webmail_url']
	}
	},
	mounted() {
	const authInfo = this.$store.state.authInfo
	this.status = authInfo.statusInfo
	this.getBalance(authInfo)
	},
	methods: {
	getBalance(authInfo) {
	this.balance = 0;
	// TODO: currencies, multi-wallets, accounts
	authInfo.wallets.forEach(wallet => {
	this.balance += wallet.balance
	})
	},
	statusUpdate(user) {
	this.status = Object.assign({}, this.status, user)
	this.$store.state.authInfo.statusInfo = this.status
	}
	}
	}
	</script>
	diff --git a/src/resources/vue/Rooms.vue b/src/resources/vue/Rooms.vue
	index f4051c5e..bb3f017e 100644
	--- a/src/resources/vue/Rooms.vue
	+++ b/src/resources/vue/Rooms.vue
	@@ -1,88 +1,88 @@
	<template>
	<div class="container" dusk="rooms-component">
	<div id="meet-rooms" class="card">
	<div class="card-body">
	<div class="card-title">Voice & Video Conferencing <small><sup class="badge badge-primary">beta</sup></small></div>
	<div class="card-text">
	<p>
	Welcome to our beta program for Voice & Video Conferencing.
	</p>
	<p>
	You have a room of your own at the URL below. This room is only open when you yourself are in
	attendance. Use this URL to invite people to join you.
	</p>
	<p>
	<router-link v-if="href" :to="roomRoute">{{ href }}</router-link>
	</p>
	<p>
	This is a work in progress and more features will be added over time. Current features include:
	</p>
	<p>
	<dl>
	<dt>Screen Sharing</dt>
	<dd>
	Share your screen for presentations or show-and-tell.
	</dd>

	<dt>Room Security</dt>
	<dd>
	Increase the room security by setting a password that attendees will need to know
	before they can enter, or lock the door so attendees will have to knock, and you (the
	moderator) can accept or deny those requests.
	</dd>

	<dt>Eject Attendees</dt>
	<dd>
	Eject attendees from the session in order to force them to reconnect, or address policy
	violations. Click the user icon for effective dismissal.
	</dd>

	<dt>Silent Audience Members</dt>
	<dd>
	For a webinar-style session, have people that join choose 'None' for both the
	microphone and the camera so as to render them silent audience members, to allow more
	people in to the room.
	</dd>
	</dl>
	</p>
	<p>
	Keep in mind that this is still in beta and might come with some issues.
	Should you encounter any on your way, let us know by contacting support.
	</p>
	</div>
	</div>
	</div>
	</div>
	</template>

	<script>
	export default {
	data() {
	return {
	rooms: [],
	href: '',
	roomRoute: ''
	}
	},
	mounted() {
	- if (!this.$root.hasBeta('meet')) {
	+ if (!this.$root.hasSKU('meet')) {
	this.$root.errorPage(403)
	return
	}

	this.$root.startLoading()

	axios.get('/api/v4/openvidu/rooms')
	.then(response => {
	this.$root.stopLoading()

	this.rooms = response.data.list
	if (response.data.count) {
	this.roomRoute = '/meet/' + encodeURI(this.rooms[0].name)
	this.href = window.config['app.url'] + this.roomRoute
	}
	})
	.catch(this.$root.errorHandler)
	}
	}
	</script>
	diff --git a/src/tests/Browser/Admin/UserTest.php b/src/tests/Browser/Admin/UserTest.php
	index 0755a234..43e498df 100644
	--- a/src/tests/Browser/Admin/UserTest.php
	+++ b/src/tests/Browser/Admin/UserTest.php
	@@ -1,439 +1,443 @@
	<?php

	namespace Tests\Browser\Admin;

	use App\Auth\SecondFactor;
	use App\Discount;
	use App\Sku;
	use App\User;
	use Tests\Browser;
	use Tests\Browser\Components\Dialog;
	use Tests\Browser\Components\Toast;
	use Tests\Browser\Pages\Admin\User as UserPage;
	use Tests\Browser\Pages\Dashboard;
	use Tests\Browser\Pages\Home;
	use Tests\TestCaseDusk;
	use Illuminate\Foundation\Testing\DatabaseMigrations;

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

	$john = $this->getTestUser('john@kolab.org');
	$john->setSettings([
	'phone' => '+48123123123',
	'external_email' => 'john.doe.external@gmail.com',
	]);
	if ($john->isSuspended()) {
	User::where('email', $john->email)->update(['status' => $john->status - User::STATUS_SUSPENDED]);
	}
	$wallet = $john->wallets()->first();
	$wallet->discount()->dissociate();
	$wallet->save();
	+
	+ $this->clearMeetEntitlements();
	}

	/**
	* {@inheritDoc}
	*/
	public function tearDown(): void
	{
	$john = $this->getTestUser('john@kolab.org');
	$john->setSettings([
	'phone' => null,
	'external_email' => 'john.doe.external@gmail.com',
	]);
	if ($john->isSuspended()) {
	User::where('email', $john->email)->update(['status' => $john->status - User::STATUS_SUSPENDED]);
	}
	$wallet = $john->wallets()->first();
	$wallet->discount()->dissociate();
	$wallet->save();

	+ $this->clearMeetEntitlements();
	+
	parent::tearDown();
	}

	/**
	* Test user info page (unauthenticated)
	*/
	public function testUserUnauth(): void
	{
	// Test that the page requires authentication
	$this->browse(function (Browser $browser) {
	$jack = $this->getTestUser('jack@kolab.org');
	$browser->visit('/user/' . $jack->id)->on(new Home());
	});
	}

	/**
	* Test user info page
	*/
	public function testUserInfo(): void
	{
	$this->browse(function (Browser $browser) {
	$jack = $this->getTestUser('jack@kolab.org');
	$page = new UserPage($jack->id);

	$browser->visit(new Home())
	->submitLogon('jeroen@jeroen.jeroen', 'jeroen', true)
	->on(new Dashboard())
	->visit($page)
	->on($page);

	// Assert main info box content
	$browser->assertSeeIn('@user-info .card-title', $jack->email)
	->with('@user-info form', function (Browser $browser) use ($jack) {
	$browser->assertElementsCount('.row', 7)
	->assertSeeIn('.row:nth-child(1) label', 'Managed by')
	->assertSeeIn('.row:nth-child(1) #manager a', 'john@kolab.org')
	->assertSeeIn('.row:nth-child(2) label', 'ID (Created at)')
	->assertSeeIn('.row:nth-child(2) #userid', "{$jack->id} ({$jack->created_at})")
	->assertSeeIn('.row:nth-child(3) label', 'Status')
	->assertSeeIn('.row:nth-child(3) #status span.text-success', 'Active')
	->assertSeeIn('.row:nth-child(4) label', 'First name')
	->assertSeeIn('.row:nth-child(4) #first_name', 'Jack')
	->assertSeeIn('.row:nth-child(5) label', 'Last name')
	->assertSeeIn('.row:nth-child(5) #last_name', 'Daniels')
	->assertSeeIn('.row:nth-child(6) label', 'External email')
	->assertMissing('.row:nth-child(6) #external_email a')
	->assertSeeIn('.row:nth-child(7) label', 'Country')
	->assertSeeIn('.row:nth-child(7) #country', 'United States');
	});

	// Some tabs are loaded in background, wait a second
	$browser->pause(500)
	->assertElementsCount('@nav a', 5);

	// Note: Finances tab is tested in UserFinancesTest.php
	$browser->assertSeeIn('@nav #tab-finances', 'Finances');

	// Assert Aliases tab
	$browser->assertSeeIn('@nav #tab-aliases', 'Aliases (1)')
	->click('@nav #tab-aliases')
	->whenAvailable('@user-aliases', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 1)
	->assertSeeIn('table tbody tr:first-child td:first-child', 'jack.daniels@kolab.org')
	->assertMissing('table tfoot');
	});

	// Assert Subscriptions tab
	$browser->assertSeeIn('@nav #tab-subscriptions', 'Subscriptions (3)')
	->click('@nav #tab-subscriptions')
	->with('@user-subscriptions', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 3)
	->assertSeeIn('table tbody tr:nth-child(1) td:first-child', 'User Mailbox')
	->assertSeeIn('table tbody tr:nth-child(1) td:last-child', '4,44 CHF')
	->assertSeeIn('table tbody tr:nth-child(2) td:first-child', 'Storage Quota 2 GB')
	->assertSeeIn('table tbody tr:nth-child(2) td:last-child', '0,00 CHF')
	->assertSeeIn('table tbody tr:nth-child(3) td:first-child', 'Groupware Features')
	->assertSeeIn('table tbody tr:nth-child(3) td:last-child', '5,55 CHF')
	->assertMissing('table tfoot')
	->assertMissing('#reset2fa');
	});

	// Assert Domains tab
	$browser->assertSeeIn('@nav #tab-domains', 'Domains (0)')
	->click('@nav #tab-domains')
	->with('@user-domains', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 0)
	->assertSeeIn('table tfoot tr td', 'There are no domains in this account.');
	});

	// Assert Users tab
	$browser->assertSeeIn('@nav #tab-users', 'Users (0)')
	->click('@nav #tab-users')
	->with('@user-users', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 0)
	->assertSeeIn('table tfoot tr td', 'There are no users in this account.');
	});
	});
	}

	/**
	* Test user info page (continue)
	*
	* @depends testUserInfo
	*/
	public function testUserInfo2(): void
	{
	$this->browse(function (Browser $browser) {
	$john = $this->getTestUser('john@kolab.org');
	$page = new UserPage($john->id);
	$discount = Discount::where('code', 'TEST')->first();
	$wallet = $john->wallet();
	$wallet->discount()->associate($discount);
	$wallet->debit(2010);
	$wallet->save();

	// Click the managed-by link on Jack's page
	$browser->click('@user-info #manager a')
	->on($page);

	// Assert main info box content
	$browser->assertSeeIn('@user-info .card-title', $john->email)
	->with('@user-info form', function (Browser $browser) use ($john) {
	$ext_email = $john->getSetting('external_email');

	$browser->assertElementsCount('.row', 9)
	->assertSeeIn('.row:nth-child(1) label', 'ID (Created at)')
	->assertSeeIn('.row:nth-child(1) #userid', "{$john->id} ({$john->created_at})")
	->assertSeeIn('.row:nth-child(2) label', 'Status')
	->assertSeeIn('.row:nth-child(2) #status span.text-success', 'Active')
	->assertSeeIn('.row:nth-child(3) label', 'First name')
	->assertSeeIn('.row:nth-child(3) #first_name', 'John')
	->assertSeeIn('.row:nth-child(4) label', 'Last name')
	->assertSeeIn('.row:nth-child(4) #last_name', 'Doe')
	->assertSeeIn('.row:nth-child(5) label', 'Organization')
	->assertSeeIn('.row:nth-child(5) #organization', 'Kolab Developers')
	->assertSeeIn('.row:nth-child(6) label', 'Phone')
	->assertSeeIn('.row:nth-child(6) #phone', $john->getSetting('phone'))
	->assertSeeIn('.row:nth-child(7) label', 'External email')
	->assertSeeIn('.row:nth-child(7) #external_email a', $ext_email)
	->assertAttribute('.row:nth-child(7) #external_email a', 'href', "mailto:$ext_email")
	->assertSeeIn('.row:nth-child(8) label', 'Address')
	->assertSeeIn('.row:nth-child(8) #billing_address', $john->getSetting('billing_address'))
	->assertSeeIn('.row:nth-child(9) label', 'Country')
	->assertSeeIn('.row:nth-child(9) #country', 'United States');
	});

	// Some tabs are loaded in background, wait a second
	$browser->pause(500)
	->assertElementsCount('@nav a', 5);

	// Note: Finances tab is tested in UserFinancesTest.php
	$browser->assertSeeIn('@nav #tab-finances', 'Finances');

	// Assert Aliases tab
	$browser->assertSeeIn('@nav #tab-aliases', 'Aliases (1)')
	->click('@nav #tab-aliases')
	->whenAvailable('@user-aliases', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 1)
	->assertSeeIn('table tbody tr:first-child td:first-child', 'john.doe@kolab.org')
	->assertMissing('table tfoot');
	});

	// Assert Subscriptions tab
	$browser->assertSeeIn('@nav #tab-subscriptions', 'Subscriptions (3)')
	->click('@nav #tab-subscriptions')
	->with('@user-subscriptions', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 3)
	->assertSeeIn('table tbody tr:nth-child(1) td:first-child', 'User Mailbox')
	->assertSeeIn('table tbody tr:nth-child(1) td:last-child', '3,99 CHF/month¹')
	->assertSeeIn('table tbody tr:nth-child(2) td:first-child', 'Storage Quota 2 GB')
	->assertSeeIn('table tbody tr:nth-child(2) td:last-child', '0,00 CHF/month¹')
	->assertSeeIn('table tbody tr:nth-child(3) td:first-child', 'Groupware Features')
	->assertSeeIn('table tbody tr:nth-child(3) td:last-child', '4,99 CHF/month¹')
	->assertMissing('table tfoot')
	->assertSeeIn('table + .hint', '¹ applied discount: 10% - Test voucher');
	});

	// Assert Domains tab
	$browser->assertSeeIn('@nav #tab-domains', 'Domains (1)')
	->click('@nav #tab-domains')
	->with('@user-domains table', function (Browser $browser) {
	$browser->assertElementsCount('tbody tr', 1)
	->assertSeeIn('tbody tr:nth-child(1) td:first-child a', 'kolab.org')
	->assertVisible('tbody tr:nth-child(1) td:first-child svg.text-success')
	->assertMissing('tfoot');
	});

	// Assert Users tab
	$browser->assertSeeIn('@nav #tab-users', 'Users (4)')
	->click('@nav #tab-users')
	->with('@user-users table', function (Browser $browser) {
	$browser->assertElementsCount('tbody tr', 4)
	->assertSeeIn('tbody tr:nth-child(1) td:first-child a', 'jack@kolab.org')
	->assertVisible('tbody tr:nth-child(1) td:first-child svg.text-success')
	->assertSeeIn('tbody tr:nth-child(2) td:first-child a', 'joe@kolab.org')
	->assertVisible('tbody tr:nth-child(2) td:first-child svg.text-success')
	->assertSeeIn('tbody tr:nth-child(3) td:first-child span', 'john@kolab.org')
	->assertVisible('tbody tr:nth-child(3) td:first-child svg.text-success')
	->assertSeeIn('tbody tr:nth-child(4) td:first-child a', 'ned@kolab.org')
	->assertVisible('tbody tr:nth-child(4) td:first-child svg.text-success')
	->assertMissing('tfoot');
	});
	});

	// Now we go to Ned's info page, he's a controller on John's wallet
	$this->browse(function (Browser $browser) {
	$ned = $this->getTestUser('ned@kolab.org');
	$page = new UserPage($ned->id);

	$browser->click('@user-users tbody tr:nth-child(4) td:first-child a')
	->on($page);

	// Assert main info box content
	$browser->assertSeeIn('@user-info .card-title', $ned->email)
	->with('@user-info form', function (Browser $browser) use ($ned) {
	$browser->assertSeeIn('.row:nth-child(2) label', 'ID (Created at)')
	->assertSeeIn('.row:nth-child(2) #userid', "{$ned->id} ({$ned->created_at})");
	});

	// Some tabs are loaded in background, wait a second
	$browser->pause(500)
	->assertElementsCount('@nav a', 5);

	// Note: Finances tab is tested in UserFinancesTest.php
	$browser->assertSeeIn('@nav #tab-finances', 'Finances');

	// Assert Aliases tab
	$browser->assertSeeIn('@nav #tab-aliases', 'Aliases (0)')
	->click('@nav #tab-aliases')
	->whenAvailable('@user-aliases', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 0)
	->assertSeeIn('table tfoot tr td', 'This user has no email aliases.');
	});

	// Assert Subscriptions tab, we expect John's discount here
	$browser->assertSeeIn('@nav #tab-subscriptions', 'Subscriptions (5)')
	->click('@nav #tab-subscriptions')
	->with('@user-subscriptions', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 5)
	->assertSeeIn('table tbody tr:nth-child(1) td:first-child', 'User Mailbox')
	->assertSeeIn('table tbody tr:nth-child(1) td:last-child', '3,99 CHF/month¹')
	->assertSeeIn('table tbody tr:nth-child(2) td:first-child', 'Storage Quota 2 GB')
	->assertSeeIn('table tbody tr:nth-child(2) td:last-child', '0,00 CHF/month¹')
	->assertSeeIn('table tbody tr:nth-child(3) td:first-child', 'Groupware Features')
	->assertSeeIn('table tbody tr:nth-child(3) td:last-child', '4,99 CHF/month¹')
	->assertSeeIn('table tbody tr:nth-child(4) td:first-child', 'Activesync')
	->assertSeeIn('table tbody tr:nth-child(4) td:last-child', '0,90 CHF/month¹')
	->assertSeeIn('table tbody tr:nth-child(5) td:first-child', '2-Factor Authentication')
	->assertSeeIn('table tbody tr:nth-child(5) td:last-child', '0,00 CHF/month¹')
	->assertMissing('table tfoot')
	->assertSeeIn('table + .hint', '¹ applied discount: 10% - Test voucher')
	->assertSeeIn('#reset2fa', 'Reset 2-Factor Auth');
	});

	// We don't expect John's domains here
	$browser->assertSeeIn('@nav #tab-domains', 'Domains (0)')
	->click('@nav #tab-domains')
	->with('@user-domains', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 0)
	->assertSeeIn('table tfoot tr td', 'There are no domains in this account.');
	});

	// We don't expect John's users here
	$browser->assertSeeIn('@nav #tab-users', 'Users (0)')
	->click('@nav #tab-users')
	->with('@user-users', function (Browser $browser) {
	$browser->assertElementsCount('table tbody tr', 0)
	->assertSeeIn('table tfoot tr td', 'There are no users in this account.');
	});
	});
	}

	/**
	* Test editing an external email
	*
	* @depends testUserInfo2
	*/
	public function testExternalEmail(): void
	{
	$this->browse(function (Browser $browser) {
	$john = $this->getTestUser('john@kolab.org');

	$browser->visit(new UserPage($john->id))
	->waitFor('@user-info #external_email button')
	->click('@user-info #external_email button')
	// Test dialog content, and closing it with Cancel button
	->with(new Dialog('#email-dialog'), function (Browser $browser) {
	$browser->assertSeeIn('@title', 'External email')
	->assertFocused('@body input')
	->assertValue('@body input', 'john.doe.external@gmail.com')
	->assertSeeIn('@button-cancel', 'Cancel')
	->assertSeeIn('@button-action', 'Submit')
	->click('@button-cancel');
	})
	->assertMissing('#email-dialog')
	->click('@user-info #external_email button')
	// Test email validation error handling, and email update
	->with(new Dialog('#email-dialog'), function (Browser $browser) {
	$browser->type('@body input', 'test')
	->click('@button-action')
	->waitFor('@body input.is-invalid')
	->assertSeeIn(
	'@body input + .invalid-feedback',
	'The external email must be a valid email address.'
	)
	->assertToast(Toast::TYPE_ERROR, 'Form validation error')
	->type('@body input', 'test@test.com')
	->click('@button-action');
	})
	->assertToast(Toast::TYPE_SUCCESS, 'User data updated successfully.')
	->assertSeeIn('@user-info #external_email a', 'test@test.com')
	->click('@user-info #external_email button')
	->with(new Dialog('#email-dialog'), function (Browser $browser) {
	$browser->assertValue('@body input', 'test@test.com')
	->assertMissing('@body input.is-invalid')
	->assertMissing('@body input + .invalid-feedback')
	->click('@button-cancel');
	})
	->assertSeeIn('@user-info #external_email a', 'test@test.com');

	// $john->getSetting() may not work here as it uses internal cache
	// read the value form database
	$current_ext_email = $john->settings()->where('key', 'external_email')->first()->value;
	$this->assertSame('test@test.com', $current_ext_email);
	});
	}

	/**
	* Test suspending/unsuspending the user
	*/
	public function testSuspendAndUnsuspend(): void
	{
	$this->browse(function (Browser $browser) {
	$john = $this->getTestUser('john@kolab.org');

	$browser->visit(new UserPage($john->id))
	->assertVisible('@user-info #button-suspend')
	->assertMissing('@user-info #button-unsuspend')
	->click('@user-info #button-suspend')
	->assertToast(Toast::TYPE_SUCCESS, 'User suspended successfully.')
	->assertSeeIn('@user-info #status span.text-warning', 'Suspended')
	->assertMissing('@user-info #button-suspend')
	->click('@user-info #button-unsuspend')
	->assertToast(Toast::TYPE_SUCCESS, 'User unsuspended successfully.')
	->assertSeeIn('@user-info #status span.text-success', 'Active')
	->assertVisible('@user-info #button-suspend')
	->assertMissing('@user-info #button-unsuspend');
	});
	}

	/**
	* Test resetting 2FA for the user
	*/
	public function testReset2FA(): void
	{
	$this->browse(function (Browser $browser) {
	$this->deleteTestUser('userstest1@kolabnow.com');
	$user = $this->getTestUser('userstest1@kolabnow.com');
	$sku2fa = Sku::firstOrCreate(['title' => '2fa']);
	$user->assignSku($sku2fa);
	SecondFactor::seed('userstest1@kolabnow.com');

	$browser->visit(new UserPage($user->id))
	->click('@nav #tab-subscriptions')
	->with('@user-subscriptions', function (Browser $browser) use ($sku2fa) {
	$browser->waitFor('#reset2fa')
	->assertVisible('#sku' . $sku2fa->id);
	})
	->assertSeeIn('@nav #tab-subscriptions', 'Subscriptions (1)')
	->click('#reset2fa')
	->with(new Dialog('#reset-2fa-dialog'), function (Browser $browser) {
	$browser->assertSeeIn('@title', '2-Factor Authentication Reset')
	->assertSeeIn('@button-cancel', 'Cancel')
	->assertSeeIn('@button-action', 'Reset')
	->click('@button-action');
	})
	->assertToast(Toast::TYPE_SUCCESS, '2-Factor authentication reset successfully.')
	->assertMissing('#sku' . $sku2fa->id)
	->assertSeeIn('@nav #tab-subscriptions', 'Subscriptions (0)');
	});
	}
	}
	diff --git a/src/tests/Browser/Meet/RoomControlsTest.php b/src/tests/Browser/Meet/RoomControlsTest.php
	index 9684116e..0e69c772 100644
	--- a/src/tests/Browser/Meet/RoomControlsTest.php
	+++ b/src/tests/Browser/Meet/RoomControlsTest.php
	@@ -1,397 +1,397 @@
	<?php

	namespace Tests\Browser\Meet;

	use App\OpenVidu\Room;
	use Tests\Browser;
	use Tests\Browser\Pages\Meet\Room as RoomPage;
	use Tests\TestCaseDusk;

	class RoomControlsTest extends TestCaseDusk
	{
	/**
	* {@inheritDoc}
	*/
	public function setUp(): void
	{
	parent::setUp();
	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	}

	public function tearDown(): void
	{
	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	parent::tearDown();
	}

	/**
	* Test fullscreen buttons
	*
	* @group openvidu
	*/
	public function testFullscreen(): void
	{
	// TODO: This test does not work in headless mode
	$this->markTestIncomplete();
	/*
	// Make sure there's no session yet
	$room = Room::where('name', 'john')->first();
	if ($room->session_id) {
	$room->session_id = null;
	$room->save();
	}

	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->assignMeetEntitlement('john@kolab.org');

	$this->browse(function (Browser $browser) {
	// Join the room as an owner (authenticate)
	$browser->visit(new RoomPage('john'))
	->click('@setup-button')
	->assertMissing('@toolbar')
	->assertMissing('@menu')
	->assertMissing('@session')
	->assertMissing('@chat')
	->assertMissing('@setup-form')
	->assertVisible('@login-form')
	->submitLogon('john@kolab.org', 'simple123')
	->waitFor('@setup-form')
	->assertMissing('@login-form')
	->waitUntilMissing('@setup-status-message.loading')
	->click('@setup-button')
	->waitFor('@session')

	// Test fullscreen for the whole room
	->click('@menu button.link-fullscreen.closed')
	->assertVisible('@toolbar')
	->assertVisible('@session')
	->assertMissing('nav')
	->assertMissing('@menu button.link-fullscreen.closed')
	->click('@menu button.link-fullscreen.open')
	->assertVisible('nav')

	// Test fullscreen for the participant video
	->click('@session button.link-fullscreen.closed')
	->assertVisible('@session')
	->assertMissing('@toolbar')
	->assertMissing('nav')
	->assertMissing('@session button.link-fullscreen.closed')
	->click('@session button.link-fullscreen.open')
	->assertVisible('nav')
	->assertVisible('@toolbar');
	});
	*/
	}

	/**
	* Test nickname and muting audio/video
	*
	* @group openvidu
	*/
	public function testNicknameAndMuting(): void
	{
	// Make sure there's no session yet
	$room = Room::where('name', 'john')->first();
	if ($room->session_id) {
	$room->session_id = null;
	$room->save();
	}

	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->assignMeetEntitlement('john@kolab.org');

	$this->browse(function (Browser $owner, Browser $guest) {
	// Join the room as an owner (authenticate)
	$owner->visit(new RoomPage('john'))
	->click('@setup-button')
	->submitLogon('john@kolab.org', 'simple123')
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->type('@setup-nickname-input', 'john')
	->keys('@setup-nickname-input', '{enter}') // Test form submit with Enter key
	->waitFor('@session');

	// In another browser act as a guest
	$guest->visit(new RoomPage('john'))
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->assertMissing('@setup-status-message')
	->assertSeeIn('@setup-button', "JOIN")
	// Join the room, disable cam/mic
	->select('@setup-mic-select', '')
	//->select('@setup-cam-select', '')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session');

	// Assert current UI state
	$owner->assertToolbar([
	'audio' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'video' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'screen' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED,
	'chat' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED,
	'fullscreen' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'security' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'logout' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	])
	->whenAvailable('div.meet-video.self', function (Browser $browser) {
	$browser->waitFor('video')
	->assertAudioMuted('video', true)
	->assertSeeIn('.meet-nickname', 'john')
	->assertVisible('.controls button.link-fullscreen')
	->assertMissing('.controls button.link-audio')
	->assertMissing('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->whenAvailable('div.meet-video:not(.self)', function (Browser $browser) {
	$browser->waitFor('video')
	->assertVisible('.meet-nickname')
	->assertVisible('.controls button.link-fullscreen')
	->assertVisible('.controls button.link-audio')
	->assertVisible('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->assertElementsCount('@session div.meet-video', 2);

	// Assert current UI state
	$guest->assertToolbar([
	'audio' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED,
	'video' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'screen' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED,
	'chat' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED,
	'fullscreen' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'logout' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	])
	->whenAvailable('div.meet-video:not(.self)', function (Browser $browser) {
	$browser->waitFor('video')
	->assertSeeIn('.meet-nickname', 'john')
	->assertVisible('.controls button.link-fullscreen')
	->assertVisible('.controls button.link-audio')
	->assertMissing('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->whenAvailable('div.meet-video.self', function (Browser $browser) {
	$browser->waitFor('video')
	->assertVisible('.controls button.link-fullscreen')
	->assertMissing('.controls button.link-audio')
	->assertVisible('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->assertElementsCount('@session div.meet-video', 2);

	// Test nickname change propagation

	// Use script() because type() does not work with this contenteditable widget
	$guest->setNickname('div.meet-video.self', 'guest');
	$owner->waitFor('div.meet-video:not(.self) .meet-nickname')
	->assertSeeIn('div.meet-video:not(.self) .meet-nickname', 'guest');

	// Test muting audio
	$owner->click('@menu button.link-audio')
	->assertToolbarButtonState('audio', RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED)
	->assertVisible('div.meet-video.self .status .status-audio');

	// FIXME: It looks that we can't just check the <video> element state
	// We might consider using OpenVidu API to make sure
	$guest->waitFor('div.meet-video:not(.self) .status .status-audio');

	// Test unmuting audio
	$owner->click('@menu button.link-audio')
	->assertToolbarButtonState('audio', RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED)
	->assertMissing('div.meet-video.self .status .status-audio');

	$guest->waitUntilMissing('div.meet-video:not(.self) .status .status-audio');

	// Test muting video
	$owner->click('@menu button.link-video')
	->assertToolbarButtonState('video', RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED)
	->assertVisible('div.meet-video.self .status .status-video');

	// FIXME: It looks that we can't just check the <video> element state
	// We might consider using OpenVidu API to make sure
	$guest->waitFor('div.meet-video:not(.self) .status .status-video');

	// Test unmuting video
	$owner->click('@menu button.link-video')
	->assertToolbarButtonState('video', RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED)
	->assertMissing('div.meet-video.self .status .status-video');

	$guest->waitUntilMissing('div.meet-video:not(.self) .status .status-video');

	// Test muting other user
	$guest->with('div.meet-video:not(.self)', function (Browser $browser) {
	$browser->click('.controls button.link-audio')
	->assertAudioMuted('video', true)
	->assertVisible('.controls button.link-audio.text-danger')
	->click('.controls button.link-audio')
	->assertAudioMuted('video', false)
	->assertVisible('.controls button.link-audio:not(.text-danger)');
	});
	});
	}

	/**
	* Test text chat
	*
	* @group openvidu
	*/
	public function testChat(): void
	{
	// Make sure there's no session yet
	$room = Room::where('name', 'john')->first();
	if ($room->session_id) {
	$room->session_id = null;
	$room->save();
	}

	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->assignMeetEntitlement('john@kolab.org');

	$this->browse(function (Browser $owner, Browser $guest) {
	// Join the room as an owner
	$owner->visit(new RoomPage('john'))
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->type('@setup-nickname-input', 'john')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session');

	// In another browser act as a guest
	$guest->visit(new RoomPage('john'))
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->assertMissing('@setup-status-message')
	->assertSeeIn('@setup-button', "JOIN")
	// Join the room, disable cam/mic
	->select('@setup-mic-select', '')
	// ->select('@setup-cam-select', '')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session');

	// Test chat elements

	$owner->click('@menu button.link-chat')
	->assertToolbarButtonState('chat', RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED)
	->assertVisible('@chat')
	->assertVisible('@session')
	->assertFocused('@chat-input')
	->assertElementsCount('@chat-list .message', 0)
	->keys('@chat-input', 'test1', '{enter}')
	->assertValue('@chat-input', '')
	->assertElementsCount('@chat-list .message', 1)
	->assertSeeIn('@chat-list .message .nickname', 'john')
	->assertSeeIn('@chat-list .message div:last-child', 'test1');

	$guest->waitFor('@menu button.link-chat .badge')
	->assertSeeIn('@menu button.link-chat .badge', '1')
	->click('@menu button.link-chat')
	->assertToolbarButtonState('chat', RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED)
	->assertMissing('@menu button.link-chat .badge')
	->assertVisible('@chat')
	->assertVisible('@session')
	->assertElementsCount('@chat-list .message', 1)
	->assertSeeIn('@chat-list .message .nickname', 'john')
	->assertSeeIn('@chat-list .message div:last-child', 'test1');

	// Test the number of (hidden) incoming messages
	$guest->click('@menu button.link-chat')
	->assertMissing('@chat');

	$owner->keys('@chat-input', 'test2', '{enter}', 'test3', '{enter}')
	->assertElementsCount('@chat-list .message', 1)
	->assertSeeIn('@chat-list .message .nickname', 'john')
	->assertElementsCount('@chat-list .message div', 4)
	->assertSeeIn('@chat-list .message div:last-child', 'test3');

	$guest->waitFor('@menu button.link-chat .badge')
	->assertSeeIn('@menu button.link-chat .badge', '2')
	->click('@menu button.link-chat')
	->assertElementsCount('@chat-list .message', 1)
	->assertSeeIn('@chat-list .message .nickname', 'john')
	->assertSeeIn('@chat-list .message div:last-child', 'test3')
	->keys('@chat-input', 'guest1', '{enter}')
	->assertElementsCount('@chat-list .message', 2)
	->assertMissing('@chat-list .message:last-child .nickname')
	->assertSeeIn('@chat-list .message:last-child div:last-child', 'guest1');

	$owner->assertElementsCount('@chat-list .message', 2)
	->assertMissing('@chat-list .message:last-child .nickname')
	->assertSeeIn('@chat-list .message:last-child div:last-child', 'guest1');

	// Test nickname change is propagated to chat messages

	$guest->setNickname('div.meet-video.self', 'guest')
	->keys('@chat-input', 'guest2', '{enter}')
	->assertElementsCount('@chat-list .message', 2)
	->assertSeeIn('@chat-list .message:last-child .nickname', 'guest')
	->assertSeeIn('@chat-list .message:last-child div:last-child', 'guest2');

	$owner->assertElementsCount('@chat-list .message', 2)
	->assertSeeIn('@chat-list .message:last-child .nickname', 'guest')
	->assertSeeIn('@chat-list .message:last-child div:last-child', 'guest2');

	// TODO: Test text chat features, e.g. link handling
	});
	}

	/**
	* Test screen sharing
	*
	* @group openvidu
	*/
	public function testShareScreen(): void
	{
	// Make sure there's no session yet
	$room = Room::where('name', 'john')->first();
	if ($room->session_id) {
	$room->session_id = null;
	$room->save();
	}

	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->assignMeetEntitlement('john@kolab.org');

	$this->browse(function (Browser $owner, Browser $guest) {
	// Join the room as an owner
	$owner->visit(new RoomPage('john'))
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->type('@setup-nickname-input', 'john')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session');

	// In another browser act as a guest
	$guest->visit(new RoomPage('john'))
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	// Join the room, disable cam/mic
	->select('@setup-mic-select', '')
	->select('@setup-cam-select', '')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session');

	// Test screen sharing
	$owner->assertToolbarButtonState('screen', RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED)
	->assertElementsCount('@session div.meet-video', 1)
	->click('@menu button.link-screen')
	->whenAvailable('div.meet-video:not(.self)', function (Browser $browser) {
	$browser->waitFor('video')
	->assertSeeIn('.meet-nickname', 'john')
	->assertVisible('.controls button.link-fullscreen')
	->assertVisible('.controls button.link-audio')
	->assertVisible('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->assertElementsCount('@session div.meet-video', 2)
	->assertElementsCount('@subscribers .meet-subscriber', 1)
	->assertToolbarButtonState('screen', RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED);

	$guest
	->whenAvailable('div.meet-video:nth-child(3)', function (Browser $browser) {
	$browser->waitFor('video')
	->assertSeeIn('.meet-nickname', 'john')
	->assertVisible('.controls button.link-fullscreen')
	->assertVisible('.controls button.link-audio')
	->assertVisible('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->assertElementsCount('@session div.meet-video', 2)
	->assertElementsCount('@subscribers .meet-subscriber', 1);
	});
	}
	}
	diff --git a/src/tests/Browser/Meet/RoomSecurityTest.php b/src/tests/Browser/Meet/RoomSecurityTest.php
	index 6dfc6dc5..a6b38b09 100644
	--- a/src/tests/Browser/Meet/RoomSecurityTest.php
	+++ b/src/tests/Browser/Meet/RoomSecurityTest.php
	@@ -1,250 +1,250 @@
	<?php

	namespace Tests\Browser\Meet;

	use App\OpenVidu\Room;
	use Tests\Browser;
	use Tests\Browser\Components\Dialog;
	use Tests\Browser\Components\Toast;
	use Tests\Browser\Pages\Meet\Room as RoomPage;
	use Tests\TestCaseDusk;

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

	- $this->clearBetaEntitlements();
	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->clearMeetEntitlements();
	+ $this->assignMeetEntitlement('john@kolab.org');

	$room = Room::where('name', 'john')->first();
	$room->setSettings(['password' => null, 'locked' => null]);
	}

	public function tearDown(): void
	{
	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	$room = Room::where('name', 'john')->first();
	$room->setSettings(['password' => null, 'locked' => null]);

	parent::tearDown();
	}

	/**
	* Test password protected room
	*
	* @group openvidu
	*/
	public function testRoomPassword(): void
	{
	$this->browse(function (Browser $owner, Browser $guest) {
	// Make sure there's no session yet
	$room = Room::where('name', 'john')->first();
	if ($room->session_id) {
	$room->session_id = null;
	$room->save();
	}

	// Join the room as an owner (authenticate)
	$owner->visit(new RoomPage('john'))
	->click('@setup-button')
	->submitLogon('john@kolab.org', 'simple123')
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->assertMissing('@setup-password-input')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session')
	// Enter Security option dialog
	->click('@menu button.link-security')
	->with(new Dialog('#security-options-dialog'), function (Browser $browser) use ($room) {
	$browser->assertSeeIn('@title', 'Security options')
	->assertSeeIn('@button-action', 'Close')
	->assertElementsCount('.modal-footer button', 1)
	->assertSeeIn('#password-input .label', 'Password:')
	->assertSeeIn('#password-input-text.text-muted', 'none')
	->assertVisible('#password-input + small')
	->assertSeeIn('#password-set-btn', 'Set password')
	->assertElementsCount('#password-input button', 1)
	->assertMissing('#password-input input')
	// Test setting a password
	->click('#password-set-btn')
	->assertMissing('#password-input-text')
	->assertVisible('#password-input input')
	->assertValue('#password-input input', '')
	->assertSeeIn('#password-input #password-save-btn', 'Save')
	->assertElementsCount('#password-input button', 1)
	->type('#password-input input', 'pass')
	->click('#password-input #password-save-btn')
	->assertToast(Toast::TYPE_SUCCESS, 'Room configuration updated successfully.')
	->assertMissing('#password-input input')
	->assertSeeIn('#password-input-text:not(.text-muted)', 'pass')
	->assertSeeIn('#password-clear-btn.btn-outline-danger', 'Clear password')
	->assertElementsCount('#password-input button', 1)
	->click('@button-action');

	$this->assertSame('pass', $room->fresh()->getSetting('password'));
	});

	// In another browser act as a guest, expect password required
	$guest->visit(new RoomPage('john'))
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->assertSeeIn('@setup-status-message', "Please, provide a valid password.")
	->assertVisible('@setup-form .input-group:nth-child(4) svg')
	->assertAttribute('@setup-form .input-group:nth-child(4) .input-group-text', 'title', 'Password')
	->assertAttribute('@setup-password-input', 'placeholder', 'Password')
	->assertValue('@setup-password-input', '')
	->assertSeeIn('@setup-button', "JOIN")
	// Try to join w/o password
	->clickWhenEnabled('@setup-button')
	->waitFor('#setup-password.is-invalid')
	// Try to join with a valid password
	->type('#setup-password', 'pass')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session');

	// Test removing the password
	$owner->click('@menu button.link-security')
	->with(new Dialog('#security-options-dialog'), function (Browser $browser) use ($room) {
	$browser->assertSeeIn('@title', 'Security options')
	->assertSeeIn('#password-input-text:not(.text-muted)', 'pass')
	->assertSeeIn('#password-clear-btn.btn-outline-danger', 'Clear password')
	->assertElementsCount('#password-input button', 1)
	->click('#password-clear-btn')
	->assertToast(Toast::TYPE_SUCCESS, "Room configuration updated successfully.")
	->assertMissing('#password-input input')
	->assertSeeIn('#password-input-text.text-muted', 'none')
	->assertSeeIn('#password-set-btn', 'Set password')
	->assertElementsCount('#password-input button', 1)
	->click('@button-action');

	$this->assertSame(null, $room->fresh()->getSetting('password'));
	});
	});
	}

	/**
	* Test locked room
	*
	* @group openvidu
	*/
	public function testLockedRoom(): void
	{
	$this->browse(function (Browser $owner, Browser $guest) {
	// Make sure there's no session yet
	$room = Room::where('name', 'john')->first();
	if ($room->session_id) {
	$room->session_id = null;
	$room->save();
	}

	// Join the room as an owner (authenticate)
	$owner->visit(new RoomPage('john'))
	// ->click('@setup-button')
	// ->submitLogon('john@kolab.org', 'simple123')
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->type('@setup-nickname-input', 'John')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session')
	// Enter Security option dialog
	->click('@menu button.link-security')
	->with(new Dialog('#security-options-dialog'), function (Browser $browser) use ($room) {
	$browser->assertSeeIn('@title', 'Security options')
	->assertSeeIn('#room-lock label', 'Locked room:')
	->assertVisible('#room-lock input[type=checkbox]:not(:checked)')
	->assertVisible('#room-lock + small')
	// Test setting the lock
	->click('#room-lock input')
	->assertToast(Toast::TYPE_SUCCESS, "Room configuration updated successfully.")
	->click('@button-action');

	$this->assertSame('true', $room->fresh()->getSetting('locked'));
	});

	// In another browser act as a guest
	$guest->visit(new RoomPage('john'))
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->assertButtonEnabled('@setup-button')
	->assertSeeIn('@setup-button.btn-success', 'JOIN NOW')
	// try without the nickname
	->clickWhenEnabled('@setup-button')
	->waitFor('@setup-nickname-input.is-invalid')
	->assertSeeIn(
	'@setup-status-message',
	"The room is locked. Please, enter your name and try again."
	)
	->assertMissing('@setup-password-input')
	->assertButtonEnabled('@setup-button')
	->assertSeeIn('@setup-button.btn-success', 'JOIN NOW')
	->type('@setup-nickname-input', 'Guest<p>')
	->clickWhenEnabled('@setup-button')
	->assertMissing('@setup-nickname-input.is-invalid')
	->waitForText("Waiting for permission to join the room.")
	->assertButtonDisabled('@setup-button');

	// Test denying the request (this will also test custom toasts)
	$owner
	->whenAvailable(new Toast(Toast::TYPE_CUSTOM), function ($browser) {
	$browser->assertToastTitle('Join request')
	->assertVisible('.toast-header svg.fa-user')
	->assertSeeIn('@message', 'Guest<p> requested to join.')
	->assertAttributeRegExp('@message img', 'src', '\|^data:image\|')
	->assertSeeIn('@message button.accept.btn-success', 'Accept')
	->assertSeeIn('@message button.deny.btn-danger', 'Deny')
	->click('@message button.deny');
	})
	->waitUntilMissing('.toast')
	// wait 10 seconds to make sure the request message does not show up again
	->pause(10 * 1000)
	->assertMissing('.toast');

	// Test accepting the request
	$guest->refresh()
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->type('@setup-nickname-input', 'guest')
	->clickWhenEnabled('@setup-button')
	->waitForText("Waiting for permission to join the room.")
	->assertButtonDisabled('@setup-button');

	$owner
	->whenAvailable(new Toast(Toast::TYPE_CUSTOM), function ($browser) {
	$browser->assertToastTitle('Join request')
	->assertSeeIn('@message', 'guest requested to join.')
	->click('@message button.accept');
	});

	// Guest automatically anters the room
	$guest->waitFor('@session', 12)
	// make sure he has no access to the Options menu
	->waitFor('@session .meet-video:not(.self)')
	->assertSeeIn('@session .meet-video:not(.self) .meet-nickname', 'John')
	// TODO: Assert title and icon
	->click('@session .meet-video:not(.self) .meet-nickname')
	->pause(100)
	->assertMissing('.dropdown-menu');

	// Test dismissing the participant
	$owner->click('@session .meet-video:not(.self) .meet-nickname')
	->waitFor('@session .meet-video:not(.self) .dropdown-menu')
	->assertSeeIn('@session .meet-video:not(.self) .dropdown-menu > .action-dismiss', 'Dismiss')
	->click('@session .meet-video:not(.self) .dropdown-menu > .action-dismiss')
	->waitUntilMissing('.dropdown-menu')
	->waitUntilMissing('@session .meet-video:not(.self)');

	// Expect a "end of session" dialog on the participant side
	$guest->with(new Dialog('#leave-dialog'), function (Browser $browser) {
	$browser->assertSeeIn('@title', 'Room closed')
	->assertSeeIn('@body', "The session has been closed by the room owner.")
	->assertMissing('@button-cancel')
	->assertSeeIn('@button-action', 'Close');
	});
	});
	}
	}
	diff --git a/src/tests/Browser/Meet/RoomSetupTest.php b/src/tests/Browser/Meet/RoomSetupTest.php
	index 160da948..1b993102 100644
	--- a/src/tests/Browser/Meet/RoomSetupTest.php
	+++ b/src/tests/Browser/Meet/RoomSetupTest.php
	@@ -1,373 +1,373 @@
	<?php

	namespace Tests\Browser\Meet;

	use App\OpenVidu\Room;
	use Tests\Browser;
	use Tests\Browser\Components\Dialog;
	use Tests\Browser\Components\Menu;
	use Tests\Browser\Pages\Meet\Room as RoomPage;
	use Tests\TestCaseDusk;

	class RoomSetupTest extends TestCaseDusk
	{
	/**
	* {@inheritDoc}
	*/
	public function setUp(): void
	{
	parent::setUp();
	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	}

	public function tearDown(): void
	{
	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	parent::tearDown();
	}

	/**
	* Test non-existing room
	*
	* @group openvidu
	*/
	public function testRoomNonExistingRoom(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit(new RoomPage('unknown'))
	->within(new Menu(), function ($browser) {
	$browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'login']);
	});

	if ($browser->isDesktop()) {
	$browser->within(new Menu('footer'), function ($browser) {
	$browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'tos', 'login']);
	});
	} else {
	$browser->assertMissing('#footer-menu .navbar-nav');
	}

	// FIXME: Maybe it would be better to just display the usual 404 Not Found error page?

	$browser->assertMissing('@toolbar')
	->assertMissing('@menu')
	->assertMissing('@session')
	->assertMissing('@chat')
	->assertMissing('@login-form')
	->assertVisible('@setup-form')
	->assertSeeIn('@setup-status-message', "The room does not exist.")
	->assertButtonDisabled('@setup-button');
	});
	}

	/**
	* Test the room setup page
	*
	* @group openvidu
	*/
	public function testRoomSetup(): void
	{
	// Make sure there's no session yet
	$room = Room::where('name', 'john')->first();
	if ($room->session_id) {
	$room->session_id = null;
	$room->save();
	}

	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->assignMeetEntitlement('john@kolab.org', 'meet');

	$this->browse(function (Browser $browser) {
	$browser->visit(new RoomPage('john'))
	->within(new Menu(), function ($browser) {
	$browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'login']);
	});

	if ($browser->isDesktop()) {
	$browser->within(new Menu('footer'), function ($browser) {
	$browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'tos', 'login']);
	});
	} else {
	$browser->assertMissing('#footer-menu .navbar-nav');
	}

	// Note: I've found out that if I have another Chrome instance running
	// that uses media, here the media devices will not be available

	// TODO: Test enabling/disabling cam/mic in the setup widget

	$browser->assertMissing('@toolbar')
	->assertMissing('@menu')
	->assertMissing('@session')
	->assertMissing('@chat')
	->assertMissing('@login-form')
	->assertVisible('@setup-form')
	->assertSeeIn('@setup-title', 'Set up your session')
	->assertVisible('@setup-video')
	->assertVisible('@setup-form .input-group:nth-child(1) svg')
	->assertAttribute('@setup-form .input-group:nth-child(1) .input-group-text', 'title', 'Microphone')
	->assertVisible('@setup-mic-select')
	->assertVisible('@setup-form .input-group:nth-child(2) svg')
	->assertAttribute('@setup-form .input-group:nth-child(2) .input-group-text', 'title', 'Camera')
	->assertVisible('@setup-cam-select')
	->assertVisible('@setup-form .input-group:nth-child(3) svg')
	->assertAttribute('@setup-form .input-group:nth-child(3) .input-group-text', 'title', 'Nickname')
	->assertValue('@setup-nickname-input', '')
	->assertAttribute('@setup-nickname-input', 'placeholder', 'Your name')
	->assertMissing('@setup-password-input')
	->assertSeeIn(
	'@setup-status-message',
	"The room is closed. Please, wait for the owner to start the session."
	)
	->assertSeeIn('@setup-button', "I'm the owner");
	});
	}

	/**
	* Test two users in a room (joining/leaving and some basic functionality)
	*
	* @group openvidu
	* @depends testRoomSetup
	*/
	public function testTwoUsersInARoom(): void
	{
	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->assignMeetEntitlement('john@kolab.org', 'meet');

	$this->browse(function (Browser $browser, Browser $guest) {
	// In one browser window act as a guest
	$guest->visit(new RoomPage('john'))
	->assertMissing('@toolbar')
	->assertMissing('@menu')
	->assertMissing('@session')
	->assertMissing('@chat')
	->assertMissing('@login-form')
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->assertSeeIn(
	'@setup-status-message',
	"The room is closed. Please, wait for the owner to start the session."
	)
	->assertSeeIn('@setup-button', "I'm the owner");

	// In another window join the room as the owner (authenticate)
	$browser->on(new RoomPage('john'))
	->assertSeeIn('@setup-button', "I'm the owner")
	->clickWhenEnabled('@setup-button')
	->assertMissing('@toolbar')
	->assertMissing('@menu')
	->assertMissing('@session')
	->assertMissing('@chat')
	->assertMissing('@setup-form')
	->assertVisible('@login-form')
	->submitLogon('john@kolab.org', 'simple123')
	->waitFor('@setup-form')
	->assertMissing('@login-form')
	->waitUntilMissing('@setup-status-message.loading')
	->waitFor('@setup-status-message')
	->assertSeeIn('@setup-status-message', "The room is closed. It will be open for others after you join.")
	->assertSeeIn('@setup-button', "JOIN")
	->type('@setup-nickname-input', 'john')
	// Join the room (click the button twice, to make sure it does not
	// produce redundant participants/subscribers in the room)
	->clickWhenEnabled('@setup-button')
	->pause(10)
	->click('@setup-button')
	->waitFor('@session')
	->assertMissing('@setup-form')
	->whenAvailable('div.meet-video.self', function (Browser $browser) {
	$browser->waitFor('video')
	->assertSeeIn('.meet-nickname', 'john')
	->assertVisible('.controls button.link-fullscreen')
	->assertMissing('.controls button.link-audio')
	->assertMissing('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->within(new Menu(), function ($browser) {
	$browser->assertMenuItems(['explore', 'blog', 'support', 'dashboard', 'logout']);
	});

	if ($browser->isDesktop()) {
	$browser->within(new Menu('footer'), function ($browser) {
	$browser->assertMenuItems(['explore', 'blog', 'support', 'tos', 'dashboard', 'logout']);
	});
	}

	// After the owner "opened the room" guest should be able to join
	$guest->waitUntilMissing('@setup-status-message', 10)
	->assertSeeIn('@setup-button', "JOIN")
	// Join the room, disable cam/mic
	->select('@setup-mic-select', '')
	//->select('@setup-cam-select', '')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session')
	->assertMissing('@setup-form')
	->whenAvailable('div.meet-video.self', function (Browser $browser) {
	$browser->waitFor('video')
	->assertVisible('.meet-nickname')
	->assertVisible('.controls button.link-fullscreen')
	->assertMissing('.controls button.link-audio')
	->assertVisible('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->whenAvailable('div.meet-video:not(.self)', function (Browser $browser) {
	$browser->waitFor('video')
	->assertSeeIn('.meet-nickname', 'john')
	->assertVisible('.controls button.link-fullscreen')
	->assertVisible('.controls button.link-audio')
	->assertMissing('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->assertElementsCount('@session div.meet-video', 2)
	->within(new Menu(), function ($browser) {
	$browser->assertMenuItems(['explore', 'blog', 'support', 'signup', 'login']);
	});

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

	// Check guest's elements in the owner's window
	$browser
	->whenAvailable('div.meet-video:not(.self)', function (Browser $browser) {
	$browser->waitFor('video')
	->assertVisible('.meet-nickname')
	->assertVisible('.controls button.link-fullscreen')
	->assertVisible('.controls button.link-audio')
	->assertVisible('.status .status-audio')
	->assertMissing('.status .status-video');
	})
	->assertElementsCount('@session div.meet-video', 2);

	// Test leaving the room

	// Guest is leaving
	$guest->click('@menu button.link-logout')
	->waitForLocation('/login');

	// Expect the participant removed from other users windows
	$browser->waitUntilMissing('@session div.meet-video:not(.self)');

	// Join the room as guest again
	$guest->visit(new RoomPage('john'))
	->assertMissing('@toolbar')
	->assertMissing('@menu')
	->assertMissing('@session')
	->assertMissing('@chat')
	->assertMissing('@login-form')
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->assertMissing('@setup-status-message')
	->assertSeeIn('@setup-button', "JOIN")
	// Join the room, disable cam/mic
	->select('@setup-mic-select', '')
	//->select('@setup-cam-select', '')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session');

	// Leave the room as the room owner
	// TODO: Test leaving the room by closing the browser window,
	// it should not destroy the session
	$browser->click('@menu button.link-logout')
	->waitForLocation('/dashboard');

	// Expect other participants be informed about the end of the session
	$guest->with(new Dialog('#leave-dialog'), function (Browser $browser) {
	$browser->assertSeeIn('@title', 'Room closed')
	->assertSeeIn('@body', "The session has been closed by the room owner.")
	->assertMissing('@button-cancel')
	->assertSeeIn('@button-action', 'Close')
	->click('@button-action');
	})
	->assertMissing('#leave-dialog')
	->waitForLocation('/login');
	});
	}

	/**
	* Test two subscribers-only users in a room
	*
	* @group openvidu
	* @depends testTwoUsersInARoom
	*/
	public function testSubscribers(): void
	{
	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->assignMeetEntitlement('john@kolab.org', 'meet');

	$this->browse(function (Browser $browser, Browser $guest) {
	// Join the room as the owner
	$browser->visit(new RoomPage('john'))
	->waitFor('@setup-form')
	->waitUntilMissing('@setup-status-message.loading')
	->waitFor('@setup-status-message')
	->type('@setup-nickname-input', 'john')
	->select('@setup-mic-select', '')
	->select('@setup-cam-select', '')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session')
	->assertMissing('@setup-form')
	->whenAvailable('@subscribers .meet-subscriber.self', function (Browser $browser) {
	$browser->assertSeeIn('.meet-nickname', 'john');
	})
	->assertElementsCount('@session div.meet-video', 0)
	->assertElementsCount('@session video', 0)
	->assertElementsCount('@session .meet-subscriber', 1)
	->assertToolbar([
	'audio' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_DISABLED,
	'video' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_DISABLED,
	'screen' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_DISABLED,
	'chat' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED,
	'fullscreen' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'security' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'logout' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	]);

	// After the owner "opened the room" guest should be able to join
	// In one browser window act as a guest
	$guest->visit(new RoomPage('john'))
	->waitUntilMissing('@setup-status-message', 10)
	->assertSeeIn('@setup-button', "JOIN")
	// Join the room, disable cam/mic
	->select('@setup-mic-select', '')
	->select('@setup-cam-select', '')
	->clickWhenEnabled('@setup-button')
	->waitFor('@session')
	->assertMissing('@setup-form')
	->whenAvailable('@subscribers .meet-subscriber.self', function (Browser $browser) {
	$browser->assertVisible('.meet-nickname');
	})
	->whenAvailable('@subscribers .meet-subscriber:not(.self)', function (Browser $browser) {
	$browser->assertSeeIn('.meet-nickname', 'john');
	})
	->assertElementsCount('@session div.meet-video', 0)
	->assertElementsCount('@session video', 0)
	->assertElementsCount('@session div.meet-subscriber', 2)
	->assertToolbar([
	'audio' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_DISABLED,
	'video' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_DISABLED,
	'screen' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_DISABLED,
	'chat' => RoomPage::BUTTON_INACTIVE \| RoomPage::BUTTON_ENABLED,
	'fullscreen' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	'logout' => RoomPage::BUTTON_ACTIVE \| RoomPage::BUTTON_ENABLED,
	]);

	// Check guest's elements in the owner's window
	$browser
	->whenAvailable('@subscribers .meet-subscriber:not(.self)', function (Browser $browser) {
	$browser->assertVisible('.meet-nickname');
	})
	->assertElementsCount('@session div.meet-video', 0)
	->assertElementsCount('@session video', 0)
	->assertElementsCount('@session .meet-subscriber', 2);

	// Test leaving the room

	// Guest is leaving
	$guest->click('@menu button.link-logout')
	->waitForLocation('/login');

	// Expect the participant removed from other users windows
	$browser->waitUntilMissing('@session .meet-subscriber:not(.self)');
	});
	}
	}
	diff --git a/src/tests/Browser/Meet/RoomsTest.php b/src/tests/Browser/Meet/RoomsTest.php
	index b7e635e7..3865d145 100644
	--- a/src/tests/Browser/Meet/RoomsTest.php
	+++ b/src/tests/Browser/Meet/RoomsTest.php
	@@ -1,111 +1,111 @@
	<?php

	namespace Tests\Browser\Meet;

	use App\Sku;
	use Tests\Browser;
	use Tests\Browser\Components\Toast;
	use Tests\Browser\Pages\Dashboard;
	use Tests\Browser\Pages\Home;
	use Tests\Browser\Pages\Meet\Room as RoomPage;
	use Tests\Browser\Pages\UserInfo;
	use Tests\TestCaseDusk;

	class RoomsTest extends TestCaseDusk
	{
	/**
	* {@inheritDoc}
	*/
	public function setUp(): void
	{
	parent::setUp();
	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	}

	/**
	* {@inheritDoc}
	*/
	public function tearDown(): void
	{
	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	parent::tearDown();
	}

	/**
	* Test rooms page (unauthenticated and unauthorized)
	*
	* @group openvidu
	*/
	public function testRoomsUnauth(): void
	{
	// Test that the page requires authentication
	$this->browse(function (Browser $browser) {
	$browser->visit('/rooms')
	->on(new Home())
	// User has no 'meet' entitlement yet, expect redirect to error page
	->submitLogon('john@kolab.org', 'simple123', false)
	->waitFor('#app > #error-page')
	->assertSeeIn('#error-page .code', '403')
	->assertSeeIn('#error-page .message', 'Access denied');
	});
	}

	/**
	* Test rooms page
	*
	* @group openvidu
	*/
	public function testRooms(): void
	{
	$this->browse(function (Browser $browser) {
	$href = \config('app.url') . '/meet/john';
	$john = $this->getTestUser('john@kolab.org');
	$john->assignSku(Sku::where('title', 'beta')->first());

	// User has no 'meet' entitlement yet
	$browser->visit('/login')
	->on(new Home())
	->submitLogon('john@kolab.org', 'simple123', true)
	->on(new Dashboard())
	->assertMissing('@links a.link-chat');

	// Goto user subscriptions, and enable 'meet' subscription
	$browser->visit('/user/' . $john->id)
	->on(new UserInfo())
	->with('@skus', function ($browser) {
	$browser->click('#sku-input-meet');
	})
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_SUCCESS, 'User data updated successfully.')
	->click('.navbar-brand')
	->on(new Dashboard())
	->assertSeeIn('@links a.link-chat', 'Video chat')
	// Make sure the element also exists on Dashboard page load
	->refresh()
	->on(new Dashboard())
	->assertSeeIn('@links a.link-chat', 'Video chat');

	// Test Video chat page
	$browser->click('@links a.link-chat')
	->waitFor('#meet-rooms')
	->waitFor('.card-text a')
	->assertSeeIn('.card-title', 'Voice & Video Conferencing')
	->assertSeeIn('.card-text a', $href)
	->assertAttribute('.card-text a', 'href', $href)
	->click('.card-text a')
	->on(new RoomPage('john'))
	// check that entering the room skips the logon form
	->assertMissing('@toolbar')
	->assertMissing('@menu')
	->assertMissing('@session')
	->assertMissing('@chat')
	->assertMissing('@login-form')
	->assertVisible('@setup-form')
	->assertSeeIn('@setup-status-message', "The room is closed. It will be open for others after you join.")
	->assertSeeIn('@setup-button', "JOIN")
	->click('@setup-button')
	->waitFor('@session')
	->assertMissing('@setup-form');
	});
	}
	}
	diff --git a/src/tests/Browser/UsersTest.php b/src/tests/Browser/UsersTest.php
	index dc152883..1d732422 100644
	--- a/src/tests/Browser/UsersTest.php
	+++ b/src/tests/Browser/UsersTest.php
	@@ -1,656 +1,672 @@
	<?php

	namespace Tests\Browser;

	use App\Discount;
	use App\Entitlement;
	use App\Sku;
	use App\User;
	use App\UserAlias;
	use Tests\Browser;
	use Tests\Browser\Components\Dialog;
	use Tests\Browser\Components\ListInput;
	use Tests\Browser\Components\QuotaInput;
	use Tests\Browser\Components\Toast;
	use Tests\Browser\Pages\Dashboard;
	use Tests\Browser\Pages\Home;
	use Tests\Browser\Pages\UserInfo;
	use Tests\Browser\Pages\UserList;
	use Tests\TestCaseDusk;
	use Illuminate\Foundation\Testing\DatabaseMigrations;

	class UsersTest extends TestCaseDusk
	{
	private $profile = [
	'first_name' => 'John',
	'last_name' => 'Doe',
	'organization' => 'Kolab Developers',
	];

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

	$this->deleteTestUser('julia.roberts@kolab.org');

	$john = User::where('email', 'john@kolab.org')->first();
	$john->setSettings($this->profile);
	UserAlias::where('user_id', $john->id)
	->where('alias', 'john.test@kolab.org')->delete();

	Entitlement::where('entitleable_id', $john->id)->whereIn('cost', [25, 100])->delete();

	$wallet = $john->wallets()->first();
	$wallet->discount()->dissociate();
	$wallet->save();

	- $betas = Sku::where('handler_class', 'like', '%\\Beta%')->pluck('id')->all();
	- Entitlement::whereIn('sku_id', $betas)->delete();
	+ $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	}

	/**
	* {@inheritDoc}
	*/
	public function tearDown(): void
	{
	$this->deleteTestUser('julia.roberts@kolab.org');

	$john = User::where('email', 'john@kolab.org')->first();
	$john->setSettings($this->profile);
	UserAlias::where('user_id', $john->id)
	->where('alias', 'john.test@kolab.org')->delete();

	Entitlement::where('entitleable_id', $john->id)->whereIn('cost', [25, 100])->delete();

	$wallet = $john->wallets()->first();
	$wallet->discount()->dissociate();
	$wallet->save();

	- $betas = Sku::where('handler_class', 'like', '%\\Beta%')->pluck('id')->all();
	- Entitlement::whereIn('sku_id', $betas)->delete();
	+ $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();

	parent::tearDown();
	}

	/**
	* Test user info page (unauthenticated)
	*/
	public function testInfoUnauth(): void
	{
	// Test that the page requires authentication
	$this->browse(function (Browser $browser) {
	$user = User::where('email', 'john@kolab.org')->first();

	$browser->visit('/user/' . $user->id)->on(new Home());
	});
	}

	/**
	* Test users list page (unauthenticated)
	*/
	public function testListUnauth(): void
	{
	// Test that the page requires authentication
	$this->browse(function (Browser $browser) {
	$browser->visit('/users')->on(new Home());
	});
	}

	/**
	* Test users list page
	*/
	public function testList(): void
	{
	// Test that the page requires authentication
	$this->browse(function (Browser $browser) {
	$browser->visit(new Home())
	->submitLogon('john@kolab.org', 'simple123', true)
	->on(new Dashboard())
	->assertSeeIn('@links .link-users', 'User accounts')
	->click('@links .link-users')
	->on(new UserList())
	->whenAvailable('@table', function (Browser $browser) {
	$browser->waitFor('tbody tr')
	->assertElementsCount('tbody tr', 4)
	->assertSeeIn('tbody tr:nth-child(1) a', 'jack@kolab.org')
	->assertSeeIn('tbody tr:nth-child(2) a', 'joe@kolab.org')
	->assertSeeIn('tbody tr:nth-child(3) a', 'john@kolab.org')
	->assertSeeIn('tbody tr:nth-child(4) a', 'ned@kolab.org')
	->assertVisible('tbody tr:nth-child(1) button.button-delete')
	->assertVisible('tbody tr:nth-child(2) button.button-delete')
	->assertVisible('tbody tr:nth-child(3) button.button-delete')
	->assertVisible('tbody tr:nth-child(4) button.button-delete')
	->assertMissing('tfoot');
	});
	});
	}

	/**
	* Test user account editing page (not profile page)
	*
	* @depends testList
	*/
	public function testInfo(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->on(new UserList())
	->click('@table tr:nth-child(3) a')
	->on(new UserInfo())
	->assertSeeIn('#user-info .card-title', 'User account')
	->with('@form', function (Browser $browser) {
	// Assert form content
	$browser->assertSeeIn('div.row:nth-child(1) label', 'Status')
	->assertSeeIn('div.row:nth-child(1) #status', 'Active')
	->assertFocused('div.row:nth-child(2) input')
	->assertSeeIn('div.row:nth-child(2) label', 'First name')
	->assertValue('div.row:nth-child(2) input[type=text]', $this->profile['first_name'])
	->assertSeeIn('div.row:nth-child(3) label', 'Last name')
	->assertValue('div.row:nth-child(3) input[type=text]', $this->profile['last_name'])
	->assertSeeIn('div.row:nth-child(4) label', 'Organization')
	->assertValue('div.row:nth-child(4) input[type=text]', $this->profile['organization'])
	->assertSeeIn('div.row:nth-child(5) label', 'Email')
	->assertValue('div.row:nth-child(5) input[type=text]', 'john@kolab.org')
	->assertDisabled('div.row:nth-child(5) input[type=text]')
	->assertSeeIn('div.row:nth-child(6) label', 'Email aliases')
	->assertVisible('div.row:nth-child(6) .list-input')
	->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->assertListInputValue(['john.doe@kolab.org'])
	->assertValue('@input', '');
	})
	->assertSeeIn('div.row:nth-child(7) label', 'Password')
	->assertValue('div.row:nth-child(7) input[type=password]', '')
	->assertSeeIn('div.row:nth-child(8) label', 'Confirm password')
	->assertValue('div.row:nth-child(8) input[type=password]', '')
	->assertSeeIn('button[type=submit]', 'Submit')
	// Clear some fields and submit
	->vueClear('#first_name')
	->vueClear('#last_name')
	->click('button[type=submit]');
	})
	->assertToast(Toast::TYPE_SUCCESS, 'User data updated successfully.')
	->on(new UserList())
	->click('@table tr:nth-child(3) a')
	->on(new UserInfo())
	->assertSeeIn('#user-info .card-title', 'User account')
	->with('@form', function (Browser $browser) {
	// Test error handling (password)
	$browser->type('#password', 'aaaaaa')
	->vueClear('#password_confirmation')
	->click('button[type=submit]')
	->waitFor('#password + .invalid-feedback')
	->assertSeeIn('#password + .invalid-feedback', 'The password confirmation does not match.')
	->assertFocused('#password')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');

	// TODO: Test password change

	// Test form error handling (aliases)
	$browser->vueClear('#password')
	->vueClear('#password_confirmation')
	->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->addListEntry('invalid address');
	})
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');

	$browser->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->assertFormError(2, 'The specified alias is invalid.', false);
	});

	// Test adding aliases
	$browser->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->removeListEntry(2)
	->addListEntry('john.test@kolab.org');
	})
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_SUCCESS, 'User data updated successfully.');
	})
	->on(new UserList())
	->click('@table tr:nth-child(3) a')
	->on(new UserInfo());

	$john = User::where('email', 'john@kolab.org')->first();
	$alias = UserAlias::where('user_id', $john->id)->where('alias', 'john.test@kolab.org')->first();
	$this->assertTrue(!empty($alias));

	// Test subscriptions
	$browser->with('@form', function (Browser $browser) {
	$browser->assertSeeIn('div.row:nth-child(9) label', 'Subscriptions')
	->assertVisible('@skus.row:nth-child(9)')
	->with('@skus', function ($browser) {
	- $browser->assertElementsCount('tbody tr', 5)
	+ $browser->assertElementsCount('tbody tr', 6)
	// Mailbox SKU
	->assertSeeIn('tbody tr:nth-child(1) td.name', 'User Mailbox')
	->assertSeeIn('tbody tr:nth-child(1) td.price', '4,44 CHF/month')
	->assertChecked('tbody tr:nth-child(1) td.selection input')
	->assertDisabled('tbody tr:nth-child(1) td.selection input')
	->assertTip(
	'tbody tr:nth-child(1) td.buttons button',
	'Just a mailbox'
	)
	// Storage SKU
	->assertSeeIn('tbody tr:nth-child(2) td.name', 'Storage Quota')
	->assertSeeIn('tr:nth-child(2) td.price', '0,00 CHF/month')
	->assertChecked('tbody tr:nth-child(2) td.selection input')
	->assertDisabled('tbody tr:nth-child(2) td.selection input')
	->assertTip(
	'tbody tr:nth-child(2) td.buttons button',
	'Some wiggle room'
	)
	->with(new QuotaInput('tbody tr:nth-child(2) .range-input'), function ($browser) {
	$browser->assertQuotaValue(2)->setQuotaValue(3);
	})
	->assertSeeIn('tr:nth-child(2) td.price', '0,25 CHF/month')
	// groupware SKU
	->assertSeeIn('tbody tr:nth-child(3) td.name', 'Groupware Features')
	->assertSeeIn('tbody tr:nth-child(3) td.price', '5,55 CHF/month')
	->assertChecked('tbody tr:nth-child(3) td.selection input')
	->assertEnabled('tbody tr:nth-child(3) td.selection input')
	->assertTip(
	'tbody tr:nth-child(3) td.buttons button',
	'Groupware functions like Calendar, Tasks, Notes, etc.'
	)
	// ActiveSync SKU
	->assertSeeIn('tbody tr:nth-child(4) td.name', 'Activesync')
	->assertSeeIn('tbody tr:nth-child(4) td.price', '1,00 CHF/month')
	->assertNotChecked('tbody tr:nth-child(4) td.selection input')
	->assertEnabled('tbody tr:nth-child(4) td.selection input')
	->assertTip(
	'tbody tr:nth-child(4) td.buttons button',
	'Mobile synchronization'
	)
	// 2FA SKU
	->assertSeeIn('tbody tr:nth-child(5) td.name', '2-Factor Authentication')
	->assertSeeIn('tbody tr:nth-child(5) td.price', '0,00 CHF/month')
	->assertNotChecked('tbody tr:nth-child(5) td.selection input')
	->assertEnabled('tbody tr:nth-child(5) td.selection input')
	->assertTip(
	'tbody tr:nth-child(5) td.buttons button',
	'Two factor authentication for webmail and administration panel'
	)
	+ // Meet SKU
	+ ->assertSeeIn('tbody tr:nth-child(6) td.name', 'Voice & Video Conferencing (public beta)')
	+ ->assertSeeIn('tbody tr:nth-child(6) td.price', '0,00 CHF/month')
	+ ->assertNotChecked('tbody tr:nth-child(6) td.selection input')
	+ ->assertEnabled('tbody tr:nth-child(6) td.selection input')
	+ ->assertTip(
	+ 'tbody tr:nth-child(6) td.buttons button',
	+ 'Video conferencing tool'
	+ )
	->click('tbody tr:nth-child(4) td.selection input');
	})
	->assertMissing('@skus table + .hint')
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_SUCCESS, 'User data updated successfully.');
	})
	->on(new UserList())
	->click('@table tr:nth-child(3) a')
	->on(new UserInfo());

	$expected = ['activesync', 'groupware', 'mailbox', 'storage', 'storage', 'storage'];
	$this->assertUserEntitlements($john, $expected);

	// Test subscriptions interaction
	$browser->with('@form', function (Browser $browser) {
	$browser->with('@skus', function ($browser) {
	// Uncheck 'groupware', expect activesync unchecked
	$browser->click('#sku-input-groupware')
	->assertNotChecked('#sku-input-groupware')
	->assertNotChecked('#sku-input-activesync')
	->assertEnabled('#sku-input-activesync')
	->assertNotReadonly('#sku-input-activesync')
	// Check 'activesync', expect an alert
	->click('#sku-input-activesync')
	->assertDialogOpened('Activesync requires Groupware Features.')
	->acceptDialog()
	->assertNotChecked('#sku-input-activesync')
	+ // Check 'meet', expect an alert
	+ ->click('#sku-input-meet')
	+ ->assertDialogOpened('Voice & Video Conferencing (public beta) requires Groupware Features.')
	+ ->acceptDialog()
	+ ->assertNotChecked('#sku-input-meet')
	// Check '2FA', expect 'activesync' unchecked and readonly
	->click('#sku-input-2fa')
	->assertChecked('#sku-input-2fa')
	->assertNotChecked('#sku-input-activesync')
	->assertReadonly('#sku-input-activesync')
	// Uncheck '2FA'
	->click('#sku-input-2fa')
	->assertNotChecked('#sku-input-2fa')
	->assertNotReadonly('#sku-input-activesync');
	});
	});
	});
	}

	/**
	* Test user adding page
	*
	* @depends testList
	*/
	public function testNewUser(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit(new UserList())
	->assertSeeIn('button.create-user', 'Create user')
	->click('button.create-user')
	->on(new UserInfo())
	->assertSeeIn('#user-info .card-title', 'New user account')
	->with('@form', function (Browser $browser) {
	// Assert form content
	$browser->assertFocused('div.row:nth-child(1) input')
	->assertSeeIn('div.row:nth-child(1) label', 'First name')
	->assertValue('div.row:nth-child(1) input[type=text]', '')
	->assertSeeIn('div.row:nth-child(2) label', 'Last name')
	->assertValue('div.row:nth-child(2) input[type=text]', '')
	->assertSeeIn('div.row:nth-child(3) label', 'Organization')
	->assertValue('div.row:nth-child(3) input[type=text]', '')
	->assertSeeIn('div.row:nth-child(4) label', 'Email')
	->assertValue('div.row:nth-child(4) input[type=text]', '')
	->assertEnabled('div.row:nth-child(4) input[type=text]')
	->assertSeeIn('div.row:nth-child(5) label', 'Email aliases')
	->assertVisible('div.row:nth-child(5) .list-input')
	->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->assertListInputValue([])
	->assertValue('@input', '');
	})
	->assertSeeIn('div.row:nth-child(6) label', 'Password')
	->assertValue('div.row:nth-child(6) input[type=password]', '')
	->assertSeeIn('div.row:nth-child(7) label', 'Confirm password')
	->assertValue('div.row:nth-child(7) input[type=password]', '')
	->assertSeeIn('div.row:nth-child(8) label', 'Package')
	// assert packages list widget, select "Lite Account"
	->with('@packages', function ($browser) {
	$browser->assertElementsCount('tbody tr', 2)
	->assertSeeIn('tbody tr:nth-child(1)', 'Groupware Account')
	->assertSeeIn('tbody tr:nth-child(2)', 'Lite Account')
	->assertSeeIn('tbody tr:nth-child(1) .price', '9,99 CHF/month')
	->assertSeeIn('tbody tr:nth-child(2) .price', '4,44 CHF/month')
	->assertChecked('tbody tr:nth-child(1) input')
	->click('tbody tr:nth-child(2) input')
	->assertNotChecked('tbody tr:nth-child(1) input')
	->assertChecked('tbody tr:nth-child(2) input');
	})
	->assertMissing('@packages table + .hint')
	->assertSeeIn('button[type=submit]', 'Submit');

	// Test browser-side required fields and error handling
	$browser->click('button[type=submit]')
	->assertFocused('#email')
	->type('#email', 'invalid email')
	->click('button[type=submit]')
	->assertFocused('#password')
	->type('#password', 'simple123')
	->click('button[type=submit]')
	->assertFocused('#password_confirmation')
	->type('#password_confirmation', 'simple')
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error')
	->assertSeeIn('#email + .invalid-feedback', 'The specified email is invalid.')
	->assertSeeIn('#password + .invalid-feedback', 'The password confirmation does not match.');
	});

	// Test form error handling (aliases)
	$browser->with('@form', function (Browser $browser) {
	$browser->type('#email', 'julia.roberts@kolab.org')
	->type('#password_confirmation', 'simple123')
	->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->addListEntry('invalid address');
	})
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error')
	->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->assertFormError(1, 'The specified alias is invalid.', false);
	});
	});

	// Successful account creation
	$browser->with('@form', function (Browser $browser) {
	$browser->type('#first_name', 'Julia')
	->type('#last_name', 'Roberts')
	->type('#organization', 'Test Org')
	->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->removeListEntry(1)
	->addListEntry('julia.roberts2@kolab.org');
	})
	->click('button[type=submit]');
	})
	->assertToast(Toast::TYPE_SUCCESS, 'User created successfully.')
	// check redirection to users list
	->on(new UserList())
	->whenAvailable('@table', function (Browser $browser) {
	$browser->assertElementsCount('tbody tr', 5)
	->assertSeeIn('tbody tr:nth-child(4) a', 'julia.roberts@kolab.org');
	});

	$julia = User::where('email', 'julia.roberts@kolab.org')->first();
	$alias = UserAlias::where('user_id', $julia->id)->where('alias', 'julia.roberts2@kolab.org')->first();
	$this->assertTrue(!empty($alias));
	$this->assertUserEntitlements($julia, ['mailbox', 'storage', 'storage']);
	$this->assertSame('Julia', $julia->getSetting('first_name'));
	$this->assertSame('Roberts', $julia->getSetting('last_name'));
	$this->assertSame('Test Org', $julia->getSetting('organization'));

	// Some additional tests for the list input widget
	$browser->click('tbody tr:nth-child(4) a')
	->on(new UserInfo())
	->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->assertListInputValue(['julia.roberts2@kolab.org'])
	->addListEntry('invalid address')
	->type('.input-group:nth-child(2) input', '@kolab.org');
	})
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error')
	->with(new ListInput('#aliases'), function (Browser $browser) {
	$browser->assertVisible('.input-group:nth-child(2) input.is-invalid')
	->assertVisible('.input-group:nth-child(3) input.is-invalid')
	->type('.input-group:nth-child(2) input', 'julia.roberts3@kolab.org')
	->type('.input-group:nth-child(3) input', 'julia.roberts4@kolab.org');
	})
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_SUCCESS, 'User data updated successfully.');

	$julia = User::where('email', 'julia.roberts@kolab.org')->first();
	$aliases = $julia->aliases()->orderBy('alias')->get()->pluck('alias')->all();
	$this->assertSame(['julia.roberts3@kolab.org', 'julia.roberts4@kolab.org'], $aliases);
	});
	}

	/**
	* Test user delete
	*
	* @depends testNewUser
	*/
	public function testDeleteUser(): void
	{
	// First create a new user
	$john = $this->getTestUser('john@kolab.org');
	$julia = $this->getTestUser('julia.roberts@kolab.org');
	$package_kolab = \App\Package::where('title', 'kolab')->first();
	$john->assignPackage($package_kolab, $julia);

	// Test deleting non-controller user
	$this->browse(function (Browser $browser) {
	$browser->visit(new UserList())
	->whenAvailable('@table', function (Browser $browser) {
	$browser->assertElementsCount('tbody tr', 5)
	->assertSeeIn('tbody tr:nth-child(4) a', 'julia.roberts@kolab.org')
	->click('tbody tr:nth-child(4) button.button-delete');
	})
	->with(new Dialog('#delete-warning'), function (Browser $browser) {
	$browser->assertSeeIn('@title', 'Delete julia.roberts@kolab.org')
	->assertFocused('@button-cancel')
	->assertSeeIn('@button-cancel', 'Cancel')
	->assertSeeIn('@button-action', 'Delete')
	->click('@button-cancel');
	})
	->whenAvailable('@table', function (Browser $browser) {
	$browser->click('tbody tr:nth-child(4) button.button-delete');
	})
	->with(new Dialog('#delete-warning'), function (Browser $browser) {
	$browser->click('@button-action');
	})
	->assertToast(Toast::TYPE_SUCCESS, 'User deleted successfully.')
	->with('@table', function (Browser $browser) {
	$browser->assertElementsCount('tbody tr', 4)
	->assertSeeIn('tbody tr:nth-child(1) a', 'jack@kolab.org')
	->assertSeeIn('tbody tr:nth-child(2) a', 'joe@kolab.org')
	->assertSeeIn('tbody tr:nth-child(3) a', 'john@kolab.org')
	->assertSeeIn('tbody tr:nth-child(4) a', 'ned@kolab.org');
	});

	$julia = User::where('email', 'julia.roberts@kolab.org')->first();
	$this->assertTrue(empty($julia));

	// Test clicking Delete on the controller record redirects to /profile/delete
	$browser
	->with('@table', function (Browser $browser) {
	$browser->click('tbody tr:nth-child(3) button.button-delete');
	})
	->waitForLocation('/profile/delete');
	});

	// Test that non-controller user cannot see/delete himself on the users list
	// Note: Access to /profile/delete page is tested in UserProfileTest.php
	$this->browse(function (Browser $browser) {
	$browser->visit('/logout')
	->on(new Home())
	->submitLogon('jack@kolab.org', 'simple123', true)
	->visit(new UserList())
	->whenAvailable('@table', function (Browser $browser) {
	$browser->assertElementsCount('tbody tr', 0)
	->assertSeeIn('tfoot td', 'There are no users in this account.');
	});
	});

	// Test that controller user (Ned) can see/delete all the users ???
	$this->browse(function (Browser $browser) {
	$browser->visit('/logout')
	->on(new Home())
	->submitLogon('ned@kolab.org', 'simple123', true)
	->visit(new UserList())
	->whenAvailable('@table', function (Browser $browser) {
	$browser->assertElementsCount('tbody tr', 4)
	->assertElementsCount('tbody button.button-delete', 4);
	});

	// TODO: Test the delete action in details
	});

	// TODO: Test what happens with the logged in user session after he's been deleted by another user
	}

	/**
	* Test discounted sku/package prices in the UI
	*/
	public function testDiscountedPrices(): void
	{
	// Add 10% discount
	$discount = Discount::where('code', 'TEST')->first();
	$john = User::where('email', 'john@kolab.org')->first();
	$wallet = $john->wallet();
	$wallet->discount()->associate($discount);
	$wallet->save();

	// SKUs on user edit page
	$this->browse(function (Browser $browser) {
	$browser->visit('/logout')
	->on(new Home())
	->submitLogon('john@kolab.org', 'simple123', true)
	->visit(new UserList())
	->waitFor('@table tr:nth-child(2)')
	->click('@table tr:nth-child(2) a')
	->on(new UserInfo())
	->with('@form', function (Browser $browser) {
	$browser->whenAvailable('@skus', function (Browser $browser) {
	$quota_input = new QuotaInput('tbody tr:nth-child(2) .range-input');
	$browser->waitFor('tbody tr')
	- ->assertElementsCount('tbody tr', 5)
	+ ->assertElementsCount('tbody tr', 6)
	// Mailbox SKU
	->assertSeeIn('tbody tr:nth-child(1) td.price', '3,99 CHF/month¹')
	// Storage SKU
	->assertSeeIn('tr:nth-child(2) td.price', '0,00 CHF/month¹')
	->with($quota_input, function (Browser $browser) {
	$browser->setQuotaValue(100);
	})
	->assertSeeIn('tr:nth-child(2) td.price', '21,56 CHF/month¹')
	// groupware SKU
	->assertSeeIn('tbody tr:nth-child(3) td.price', '4,99 CHF/month¹')
	// ActiveSync SKU
	->assertSeeIn('tbody tr:nth-child(4) td.price', '0,90 CHF/month¹')
	// 2FA SKU
	->assertSeeIn('tbody tr:nth-child(5) td.price', '0,00 CHF/month¹');
	})
	->assertSeeIn('@skus table + .hint', '¹ applied discount: 10% - Test voucher');
	});
	});

	// Packages on new user page
	$this->browse(function (Browser $browser) {
	$browser->visit(new UserList())
	->click('button.create-user')
	->on(new UserInfo())
	->with('@form', function (Browser $browser) {
	$browser->whenAvailable('@packages', function (Browser $browser) {
	$browser->assertElementsCount('tbody tr', 2)
	->assertSeeIn('tbody tr:nth-child(1) .price', '8,99 CHF/month¹') // Groupware
	->assertSeeIn('tbody tr:nth-child(2) .price', '3,99 CHF/month¹'); // Lite
	})
	->assertSeeIn('@packages table + .hint', '¹ applied discount: 10% - Test voucher');
	});
	});
	}

	/**
	* Test beta entitlements
	*
	* @depends testList
	*/
	public function testBetaEntitlements(): void
	{
	$this->browse(function (Browser $browser) {
	$john = User::where('email', 'john@kolab.org')->first();
	$sku = Sku::where('title', 'beta')->first();
	$john->assignSku($sku);

	$browser->visit('/user/' . $john->id)
	->on(new UserInfo())
	->with('@skus', function ($browser) {
	$browser->assertElementsCount('tbody tr', 7)
	- // Beta SKU
	- ->assertSeeIn('tbody tr:nth-child(6) td.name', 'Beta program')
	- ->assertSeeIn('tbody tr:nth-child(6) td.price', '0,00 CHF/month')
	- ->assertChecked('tbody tr:nth-child(6) td.selection input')
	+ // Beta/Meet SKU
	+ ->assertSeeIn('tbody tr:nth-child(6) td.name', 'Voice & Video Conferencing (public beta)')
	+ ->assertSeeIn('tr:nth-child(6) td.price', '0,00 CHF/month')
	+ ->assertNotChecked('tbody tr:nth-child(6) td.selection input')
	->assertEnabled('tbody tr:nth-child(6) td.selection input')
	->assertTip(
	'tbody tr:nth-child(6) td.buttons button',
	- 'Access to beta program subscriptions'
	+ 'Video conferencing tool'
	)
	- // Beta/Meet SKU
	- ->assertSeeIn('tbody tr:nth-child(7) td.name', 'Video chat')
	- ->assertSeeIn('tr:nth-child(7) td.price', '0,00 CHF/month')
	- ->assertNotChecked('tbody tr:nth-child(7) td.selection input')
	+ // Beta SKU
	+ ->assertSeeIn('tbody tr:nth-child(7) td.name', 'Private Beta (invitation only)')
	+ ->assertSeeIn('tbody tr:nth-child(7) td.price', '0,00 CHF/month')
	+ ->assertChecked('tbody tr:nth-child(7) td.selection input')
	->assertEnabled('tbody tr:nth-child(7) td.selection input')
	->assertTip(
	'tbody tr:nth-child(7) td.buttons button',
	- 'Video conferencing tool'
	+ 'Access to the private beta program subscriptions'
	)
	+/*
	// Check Meet, Uncheck Beta, expect Meet unchecked
	->click('#sku-input-meet')
	->click('#sku-input-beta')
	->assertNotChecked('#sku-input-beta')
	->assertNotChecked('#sku-input-meet')
	// Click Meet expect an alert
	->click('#sku-input-meet')
	->assertDialogOpened('Video chat requires Beta program.')
	->acceptDialog()
	- // Enable Meet and Beta and submit
	- ->click('#sku-input-beta')
	+*/
	+ // Enable Meet and submit
	->click('#sku-input-meet');
	})
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_SUCCESS, 'User data updated successfully.');

	$expected = ['beta', 'groupware', 'mailbox', 'meet', 'storage', 'storage'];
	$this->assertUserEntitlements($john, $expected);

	$browser->visit('/user/' . $john->id)
	->on(new UserInfo())
	->click('#sku-input-beta')
	+ ->click('#sku-input-meet')
	->click('button[type=submit]')
	->assertToast(Toast::TYPE_SUCCESS, 'User data updated successfully.');

	$expected = ['groupware', 'mailbox', 'storage', 'storage'];
	$this->assertUserEntitlements($john, $expected);
	});
	}
	}
	diff --git a/src/tests/Feature/Controller/OpenViduTest.php b/src/tests/Feature/Controller/OpenViduTest.php
	index f15017be..c17875a1 100644
	--- a/src/tests/Feature/Controller/OpenViduTest.php
	+++ b/src/tests/Feature/Controller/OpenViduTest.php
	@@ -1,557 +1,557 @@
	<?php

	namespace Tests\Feature\Controller;

	use App\Http\Controllers\API\V4\OpenViduController;
	use App\OpenVidu\Room;
	use Tests\TestCase;

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

	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	$room = Room::where('name', 'john')->first();
	$room->setSettings(['password' => null, 'locked' => null]);
	}

	public function tearDown(): void
	{
	- $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	$room = Room::where('name', 'john')->first();
	$room->setSettings(['password' => null, 'locked' => null]);

	parent::tearDown();
	}

	/**
	* Test listing user rooms
	*
	* @group openvidu
	*/
	public function testIndex(): void
	{
	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	Room::where('user_id', $jack->id)->delete();

	// Unauth access not allowed
	$response = $this->get("api/v4/openvidu/rooms");
	$response->assertStatus(401);

	// John has one room
	$response = $this->actingAs($john)->get("api/v4/openvidu/rooms");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertSame(1, $json['count']);
	$this->assertCount(1, $json['list']);
	$this->assertSame('john', $json['list'][0]['name']);

	// Jack has no room, but it will be auto-created
	$response = $this->actingAs($jack)->get("api/v4/openvidu/rooms");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertSame(1, $json['count']);
	$this->assertCount(1, $json['list']);
	$this->assertRegExp('/^[0-9a-z-]{11}$/', $json['list'][0]['name']);
	}

	/**
	* Test joining the room
	*
	* @group openvidu
	*/
	public function testJoinRoom(): void
	{
	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$room = Room::where('name', 'john')->first();
	$room->session_id = null;
	$room->save();

	- $this->assignBetaEntitlement($john, 'meet');
	+ $this->assignMeetEntitlement($john);

	// Unauth access, no session yet
	$response = $this->post("api/v4/openvidu/rooms/{$room->name}");
	$response->assertStatus(422);

	$json = $response->json();
	$this->assertSame(323, $json['code']);

	// Non-existing room name
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/non-existing");
	$response->assertStatus(404);

	// TODO: Test accessing an existing room of deleted owner

	// Non-owner, no session yet
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}");
	$response->assertStatus(422);

	$json = $response->json();
	$this->assertSame(323, $json['code']);

	// Room owner, no session yet
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}");
	$response->assertStatus(422);

	$json = $response->json();
	$this->assertSame(324, $json['code']);

	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}", ['init' => 1]);
	$response->assertStatus(200);

	$json = $response->json();

	$session_id = $room->fresh()->session_id;

	$this->assertSame(Room::ROLE_SUBSCRIBER \| Room::ROLE_MODERATOR \| Room::ROLE_OWNER, $json['role']);
	$this->assertSame($session_id, $json['session']);
	$this->assertTrue(is_string($session_id) && !empty($session_id));
	$this->assertTrue(strpos($json['token'], 'wss://') === 0);
	$this->assertTrue(!array_key_exists('shareToken', $json));

	$john_token = $json['token'];

	// Non-owner, now the session exists, no 'init' argument
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}");
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertSame(322, $json['code']);
	$this->assertTrue(empty($json['token']));
	$this->assertTrue(empty($json['shareToken']));

	// Non-owner, now the session exists, with 'init', but no 'canPublish' argument
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", ['init' => 1]);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertSame(Room::ROLE_SUBSCRIBER, $json['role']);
	$this->assertSame($session_id, $json['session']);
	$this->assertTrue(strpos($json['token'], 'wss://') === 0);
	$this->assertTrue($json['token'] != $john_token);
	$this->assertTrue(empty($json['shareToken']));

	// Non-owner, now the session exists, with 'init', and with 'role=PUBLISHER'
	$post = ['canPublish' => true, 'init' => 1];
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertSame(Room::ROLE_PUBLISHER, $json['role']);
	$this->assertSame($session_id, $json['session']);
	$this->assertTrue(strpos($json['token'], 'wss://') === 0);
	$this->assertTrue($json['token'] != $john_token);
	$this->assertTrue(!array_key_exists('shareToken', $json));
	$this->assertEmpty($json['config']['password']);
	$this->assertEmpty($json['config']['requires_password']);

	// Non-owner, password protected room, password not provided
	$room->setSettings(['password' => 'pass']);
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}");
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertCount(4, $json);
	$this->assertSame(325, $json['code']);
	$this->assertSame('error', $json['status']);
	$this->assertSame('Failed to join the session. Invalid password.', $json['message']);
	$this->assertEmpty($json['config']['password']);
	$this->assertTrue($json['config']['requires_password']);

	// Non-owner, password protected room, invalid provided
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", ['password' => 'aa']);
	$response->assertStatus(422);

	$json = $response->json();
	$this->assertSame(325, $json['code']);

	// Non-owner, password protected room, valid password provided
	// TODO: Test without init=1
	$post = ['password' => 'pass', 'init' => 'init'];
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertSame($session_id, $json['session']);

	// Make sure the room owner can access the password protected room w/o password
	// TODO: Test without init=1
	$post = ['init' => 'init'];
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(200);
	}

	/**
	* Test locked room and join requests
	*
	* @group openvidu
	*/
	public function testJoinRequests(): void
	{
	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$room = Room::where('name', 'john')->first();
	$room->session_id = null;
	$room->save();
	$room->setSettings(['password' => null, 'locked' => 'true']);

	- $this->assignBetaEntitlement($john, 'meet');
	+ $this->assignMeetEntitlement($john);

	// Create the session (also makes sure the owner can access a locked room)
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}", ['init' => 1]);
	$response->assertStatus(200);

	// Non-owner, locked room, invalid/missing input
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}");
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertCount(4, $json);
	$this->assertSame(326, $json['code']);
	$this->assertSame('error', $json['status']);
	$this->assertSame('Failed to join the session. Room locked.', $json['message']);
	$this->assertTrue($json['config']['locked']);

	// Non-owner, locked room, invalid requestId
	$post = ['nickname' => 'name', 'requestId' => '-----', 'init' => 1];
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(422);

	$json = $response->json();
	$this->assertSame(326, $json['code']);

	// Non-owner, locked room, invalid requestId
	$post = ['nickname' => 'name', 'init' => 1];
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(422);

	$json = $response->json();
	$this->assertSame(326, $json['code']);

	// Non-owner, locked room, valid input
	$reqId = '12345678';
	$post = ['nickname' => 'name', 'requestId' => $reqId, 'picture' => 'data:image/png;base64,01234'];
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertCount(4, $json);
	$this->assertSame(327, $json['code']);
	$this->assertSame('error', $json['status']);
	$this->assertSame('Failed to join the session. Room locked.', $json['message']);
	$this->assertTrue($json['config']['locked']);

	// TODO: How do we assert that a signal has been sent to the owner?

	// Test denying a request

	// Unknown room
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/unknown/request/unknown/deny");
	$response->assertStatus(404);

	// Unknown request Id
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/request/unknown/deny");
	$response->assertStatus(500);
	$json = $response->json();

	$this->assertCount(2, $json);
	$this->assertSame('error', $json['status']);
	$this->assertSame('Failed to deny the join request.', $json['message']);

	// Non-owner access forbidden
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}/request/{$reqId}/deny");
	$response->assertStatus(403);

	// Valid request
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/request/{$reqId}/deny");
	$response->assertStatus(200);
	$json = $response->json();

	$this->assertSame('success', $json['status']);

	// Non-owner, locked room, join request denied
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(422);

	$json = $response->json();
	$this->assertSame(327, $json['code']);

	// Test accepting a request

	// Unknown room
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/unknown/request/unknown/accept");
	$response->assertStatus(404);

	// Unknown request Id
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/request/unknown/accept");
	$response->assertStatus(500);
	$json = $response->json();

	$this->assertCount(2, $json);
	$this->assertSame('error', $json['status']);
	$this->assertSame('Failed to accept the join request.', $json['message']);

	// Non-owner access forbidden
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}/request/{$reqId}/accept");
	$response->assertStatus(403);

	// Valid request
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/request/{$reqId}/accept");
	$response->assertStatus(200);
	$json = $response->json();

	$this->assertSame('success', $json['status']);

	// Non-owner, locked room, join request accepted
	$post['init'] = 1;
	$post['canPublish'] = true;
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(200);
	$json = $response->json();

	$this->assertSame(Room::ROLE_PUBLISHER, $json['role']);
	$this->assertTrue(strpos($json['token'], 'wss://') === 0);

	// TODO: Test a scenario where both password and lock are enabled
	}

	/**
	* Test joining the room
	*
	* @group openvidu
	* @depends testJoinRoom
	*/
	public function testJoinRoomGuest(): void
	{
	- $this->assignBetaEntitlement('john@kolab.org', 'meet');
	+ $this->assignMeetEntitlement('john@kolab.org');

	// There's no asy way to logout the user in the same test after
	// using actingAs(). That's why this is moved to a separate test
	$room = Room::where('name', 'john')->first();

	// Guest, request with screenShare token
	$post = ['canPublish' => true, 'screenShare' => 1, 'init' => 1];
	$response = $this->post("api/v4/openvidu/rooms/{$room->name}", $post);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertSame(Room::ROLE_PUBLISHER, $json['role']);
	$this->assertSame($room->session_id, $json['session']);
	$this->assertTrue(strpos($json['token'], 'wss://') === 0);
	$this->assertTrue(strpos($json['shareToken'], 'wss://') === 0);
	$this->assertTrue($json['shareToken'] != $json['token']);
	}

	/**
	* Test closing the room (session)
	*
	* @group openvidu
	* @depends testJoinRoom
	*/
	public function testCloseRoom(): void
	{
	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$room = Room::where('name', 'john')->first();

	// Unauth access not allowed
	$response = $this->post("api/v4/openvidu/rooms/{$room->name}/close", []);
	$response->assertStatus(401);

	// Non-existing room name
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/non-existing/close", []);
	$response->assertStatus(404);

	// Non-owner
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}/close", []);
	$response->assertStatus(403);

	// Room owner
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/close", []);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertNull($room->fresh()->session_id);
	$this->assertSame('success', $json['status']);
	$this->assertSame("The session has been closed successfully.", $json['message']);
	$this->assertCount(2, $json);

	// TODO: Test if the session is removed from the OpenVidu server too

	// Test error handling when it's not possible to delete the session on
	// the OpenVidu server (use fake session_id)
	$room->session_id = 'aaa';
	$room->save();

	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/close", []);
	$response->assertStatus(500);

	$json = $response->json();

	$this->assertSame('aaa', $room->fresh()->session_id);
	$this->assertSame('error', $json['status']);
	$this->assertSame("Failed to close the session.", $json['message']);
	$this->assertCount(2, $json);
	}

	/**
	* Test dismissing a participant (closing a connection)
	*
	* @group openvidu
	*/
	public function testDismissConnection(): void
	{
	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$room = Room::where('name', 'john')->first();
	$room->session_id = null;
	$room->save();

	- $this->assignBetaEntitlement($john, 'meet');
	+ $this->assignMeetEntitlement($john);

	// First we create the session
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}", ['init' => 1]);
	$response->assertStatus(200);

	$json = $response->json();

	// And the other user connection
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}", ['init' => 1]);
	$response->assertStatus(200);

	$json = $response->json();

	$conn_id = $json['connectionId'];
	$room->refresh();
	$conn_data = $room->getOVConnection($conn_id);

	$this->assertSame($conn_id, $conn_data['connectionId']);

	// Non-existing room name
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/non-existing/connections/{$conn_id}/dismiss");
	$response->assertStatus(404);

	// TODO: Test accessing an existing room of deleted owner

	// Non-existing connection
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/connections/123/dismiss");
	$response->assertStatus(404);

	$json = $response->json();

	$this->assertCount(2, $json);
	$this->assertSame('error', $json['status']);
	$this->assertSame('The connection does not exist.', $json['message']);

	// Non-owner access
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}/connections/{$conn_id}/dismiss");
	$response->assertStatus(403);

	// Expected success
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/connections/{$conn_id}/dismiss");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertSame('success', $json['status']);
	$this->assertNull($room->getOVConnection($conn_id));
	}

	/**
	* Test configuring the room (session)
	*
	* @group openvidu
	*/
	public function testSetRoomConfig(): void
	{
	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$room = Room::where('name', 'john')->first();

	// Unauth access not allowed
	$response = $this->post("api/v4/openvidu/rooms/{$room->name}/config", []);
	$response->assertStatus(401);

	// Non-existing room name
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/non-existing/config", []);
	$response->assertStatus(404);

	// TODO: Test a room with a deleted owner

	// Non-owner
	$response = $this->actingAs($jack)->post("api/v4/openvidu/rooms/{$room->name}/config", []);
	$response->assertStatus(403);

	// Room owner
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/config", []);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(2, $json);
	$this->assertSame('success', $json['status']);
	$this->assertSame("Room configuration updated successfully.", $json['message']);

	// Set password and room lock
	$post = ['password' => 'aaa', 'locked' => 1];
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/config", $post);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(2, $json);
	$this->assertSame('success', $json['status']);
	$this->assertSame("Room configuration updated successfully.", $json['message']);
	$room->refresh();
	$this->assertSame('aaa', $room->getSetting('password'));
	$this->assertSame('true', $room->getSetting('locked'));

	// Unset password and room lock
	$post = ['password' => '', 'locked' => 0];
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/config", $post);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(2, $json);
	$this->assertSame('success', $json['status']);
	$this->assertSame("Room configuration updated successfully.", $json['message']);
	$room->refresh();
	$this->assertSame(null, $room->getSetting('password'));
	$this->assertSame(null, $room->getSetting('locked'));

	// Test invalid option error
	$post = ['password' => 'eee', 'unknown' => 0];
	$response = $this->actingAs($john)->post("api/v4/openvidu/rooms/{$room->name}/config", $post);
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertCount(2, $json);
	$this->assertSame('error', $json['status']);
	$this->assertSame("Invalid room configuration option.", $json['errors']['unknown']);

	$room->refresh();
	$this->assertSame(null, $room->getSetting('password'));
	}
	}
	diff --git a/src/tests/Feature/Controller/SkusTest.php b/src/tests/Feature/Controller/SkusTest.php
	index 392f2e20..38e3434d 100644
	--- a/src/tests/Feature/Controller/SkusTest.php
	+++ b/src/tests/Feature/Controller/SkusTest.php
	@@ -1,211 +1,220 @@
	<?php

	namespace Tests\Feature\Controller;

	use App\Entitlement;
	use App\Http\Controllers\API\V4\SkusController;
	use App\Sku;
	use Tests\TestCase;

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

	- $betas = Sku::where('handler_class', 'like', '%\\Beta%')->pluck('id')->all();
	- Entitlement::whereIn('sku_id', $betas)->delete();
	+ $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();
	}

	/**
	* {@inheritDoc}
	*/
	public function tearDown(): void
	{
	- $betas = Sku::where('handler_class', 'like', '%\\Beta%')->pluck('id')->all();
	- Entitlement::whereIn('sku_id', $betas)->delete();
	+ $this->clearBetaEntitlements();
	+ $this->clearMeetEntitlements();

	parent::tearDown();
	}


	/**
	* Test fetching SKUs list
	*/
	public function testIndex(): void
	{
	// Unauth access not allowed
	$response = $this->get("api/v4/skus");
	$response->assertStatus(401);

	$user = $this->getTestUser('john@kolab.org');
	$sku = Sku::where('title', 'mailbox')->first();

	$response = $this->actingAs($user)->get("api/v4/skus");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(8, $json);

	$this->assertSame(100, $json[0]['prio']);
	$this->assertSame($sku->id, $json[0]['id']);
	$this->assertSame($sku->title, $json[0]['title']);
	$this->assertSame($sku->name, $json[0]['name']);
	$this->assertSame($sku->description, $json[0]['description']);
	$this->assertSame($sku->cost, $json[0]['cost']);
	$this->assertSame($sku->units_free, $json[0]['units_free']);
	$this->assertSame($sku->period, $json[0]['period']);
	$this->assertSame($sku->active, $json[0]['active']);
	$this->assertSame('user', $json[0]['type']);
	$this->assertSame('mailbox', $json[0]['handler']);
	}

	/**
	* Test fetching SKUs list for a user (GET /users/<id>/skus)
	*/
	public function testUserSkus(): void
	{
	$user = $this->getTestUser('john@kolab.org');

	// Unauth access not allowed
	$response = $this->get("api/v4/users/{$user->id}/skus");
	$response->assertStatus(401);

	$response = $this->actingAs($user)->get("api/v4/users/{$user->id}/skus");
	$response->assertStatus(200);

	$json = $response->json();

	- $this->assertCount(7, $json);
	+ $this->assertCount(8, $json);

	$this->assertSkuElement('mailbox', $json[0], [
	'prio' => 100,
	'type' => 'user',
	'handler' => 'mailbox',
	'enabled' => true,
	'readonly' => true,
	]);

	$this->assertSkuElement('storage', $json[1], [
	'prio' => 90,
	'type' => 'user',
	'handler' => 'storage',
	'enabled' => true,
	'readonly' => true,
	'range' => [
	'min' => 2,
	'max' => 100,
	'unit' => 'GB',
	]
	]);

	$this->assertSkuElement('groupware', $json[2], [
	'prio' => 80,
	'type' => 'user',
	'handler' => 'groupware',
	'enabled' => false,
	'readonly' => false,
	]);

	$this->assertSkuElement('activesync', $json[3], [
	'prio' => 70,
	'type' => 'user',
	'handler' => 'activesync',
	'enabled' => false,
	'readonly' => false,
	'required' => ['groupware'],
	]);

	$this->assertSkuElement('2fa', $json[4], [
	'prio' => 60,
	'type' => 'user',
	'handler' => 'auth2f',
	'enabled' => false,
	'readonly' => false,
	'forbidden' => ['activesync'],
	]);

	- $this->assertSkuElement('domain-hosting', $json[5], [
	+ $this->assertSkuElement('meet', $json[5], [
	+ 'prio' => 50,
	+ 'type' => 'user',
	+ 'handler' => 'meet',
	+ 'enabled' => false,
	+ 'readonly' => false,
	+ 'required' => ['groupware'],
	+ ]);
	+
	+ $this->assertSkuElement('domain-hosting', $json[6], [
	'prio' => 0,
	'type' => 'domain',
	'handler' => 'domainhosting',
	'enabled' => false,
	'readonly' => false,
	]);

	- $this->assertSkuElement('group', $json[6], [
	+ $this->assertSkuElement('group', $json[7], [
	'prio' => 0,
	'type' => 'group',
	'handler' => 'group',
	'enabled' => false,
	'readonly' => false,
	]);

	// Test filter by type
	$response = $this->actingAs($user)->get("api/v4/users/{$user->id}/skus?type=domain");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(1, $json);
	$this->assertSame('domain', $json[0]['type']);

	// Test inclusion of beta SKUs
	$sku = Sku::where('title', 'beta')->first();
	$user->assignSku($sku);
	$response = $this->actingAs($user)->get("api/v4/users/{$user->id}/skus?type=user");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(7, $json);

	- $this->assertSkuElement('beta', $json[5], [
	- 'prio' => 10,
	+ $this->assertSkuElement('meet', $json[5], [
	+ 'prio' => 50,
	'type' => 'user',
	- 'handler' => 'beta',
	+ 'handler' => 'meet',
	'enabled' => false,
	'readonly' => false,
	+ 'required' => ['groupware'],
	]);

	- $this->assertSkuElement('meet', $json[6], [
	- 'prio' => 0,
	+ $this->assertSkuElement('beta', $json[6], [
	+ 'prio' => 10,
	'type' => 'user',
	- 'handler' => 'meet',
	+ 'handler' => 'beta',
	'enabled' => false,
	'readonly' => false,
	- 'required' => ['beta'],
	]);
	}

	/**
	* Assert content of the SKU element in an API response
	*
	* @param string $sku_title The SKU title
	* @param array $result The result to assert
	* @param array $other Other items the SKU itself does not include
	*/
	protected function assertSkuElement($sku_title, $result, $other = []): void
	{
	$sku = Sku::where('title', $sku_title)->first();

	$this->assertSame($sku->id, $result['id']);
	$this->assertSame($sku->title, $result['title']);
	$this->assertSame($sku->name, $result['name']);
	$this->assertSame($sku->description, $result['description']);
	$this->assertSame($sku->cost, $result['cost']);
	$this->assertSame($sku->units_free, $result['units_free']);
	$this->assertSame($sku->period, $result['period']);
	$this->assertSame($sku->active, $result['active']);

	foreach ($other as $key => $value) {
	$this->assertSame($value, $result[$key]);
	}

	$this->assertCount(8 + count($other), $result);
	}
	}
	diff --git a/src/tests/Feature/Controller/UsersTest.php b/src/tests/Feature/Controller/UsersTest.php
	index 21802e5e..485eb472 100644
	--- a/src/tests/Feature/Controller/UsersTest.php
	+++ b/src/tests/Feature/Controller/UsersTest.php
	@@ -1,1269 +1,1266 @@
	<?php

	namespace Tests\Feature\Controller;

	use App\Discount;
	use App\Domain;
	use App\Http\Controllers\API\V4\UsersController;
	use App\Package;
	use App\Sku;
	use App\User;
	use App\Wallet;
	use Carbon\Carbon;
	use Illuminate\Support\Facades\Queue;
	use Illuminate\Support\Str;
	use Tests\TestCase;

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

	$this->deleteTestUser('jane@kolabnow.com');
	$this->deleteTestUser('UsersControllerTest1@userscontroller.com');
	$this->deleteTestUser('UsersControllerTest2@userscontroller.com');
	$this->deleteTestUser('UsersControllerTest3@userscontroller.com');
	$this->deleteTestUser('UserEntitlement2A@UserEntitlement.com');
	$this->deleteTestUser('john2.doe2@kolab.org');
	$this->deleteTestUser('deleted@kolab.org');
	$this->deleteTestUser('deleted@kolabnow.com');
	$this->deleteTestDomain('userscontroller.com');
	$this->deleteTestGroup('group-test@kolabnow.com');
	$this->deleteTestGroup('group-test@kolab.org');

	$user = $this->getTestUser('john@kolab.org');
	$wallet = $user->wallets()->first();
	$wallet->discount()->dissociate();
	$wallet->settings()->whereIn('key', ['mollie_id', 'stripe_id'])->delete();
	$wallet->save();
	$user->status \|= User::STATUS_IMAP_READY;
	$user->save();
	}

	/**
	* {@inheritDoc}
	*/
	public function tearDown(): void
	{
	$this->deleteTestUser('jane@kolabnow.com');
	$this->deleteTestUser('UsersControllerTest1@userscontroller.com');
	$this->deleteTestUser('UsersControllerTest2@userscontroller.com');
	$this->deleteTestUser('UsersControllerTest3@userscontroller.com');
	$this->deleteTestUser('UserEntitlement2A@UserEntitlement.com');
	$this->deleteTestUser('john2.doe2@kolab.org');
	$this->deleteTestUser('deleted@kolab.org');
	$this->deleteTestUser('deleted@kolabnow.com');
	$this->deleteTestDomain('userscontroller.com');
	$this->deleteTestGroup('group-test@kolabnow.com');
	$this->deleteTestGroup('group-test@kolab.org');

	$user = $this->getTestUser('john@kolab.org');
	$wallet = $user->wallets()->first();
	$wallet->discount()->dissociate();
	$wallet->settings()->whereIn('key', ['mollie_id', 'stripe_id'])->delete();
	$wallet->save();
	$user->status \|= User::STATUS_IMAP_READY;
	$user->save();

	parent::tearDown();
	}

	/**
	* Test user deleting (DELETE /api/v4/users/<id>)
	*/
	public function testDestroy(): void
	{
	// First create some users/accounts to delete
	$package_kolab = \App\Package::where('title', 'kolab')->first();
	$package_domain = \App\Package::where('title', 'domain-hosting')->first();

	$john = $this->getTestUser('john@kolab.org');
	$user1 = $this->getTestUser('UsersControllerTest1@userscontroller.com');
	$user2 = $this->getTestUser('UsersControllerTest2@userscontroller.com');
	$user3 = $this->getTestUser('UsersControllerTest3@userscontroller.com');
	$domain = $this->getTestDomain('userscontroller.com', [
	'status' => Domain::STATUS_NEW,
	'type' => Domain::TYPE_PUBLIC,
	]);
	$user1->assignPackage($package_kolab);
	$domain->assignPackage($package_domain, $user1);
	$user1->assignPackage($package_kolab, $user2);
	$user1->assignPackage($package_kolab, $user3);

	// Test unauth access
	$response = $this->delete("api/v4/users/{$user2->id}");
	$response->assertStatus(401);

	// Test access to other user/account
	$response = $this->actingAs($john)->delete("api/v4/users/{$user2->id}");
	$response->assertStatus(403);
	$response = $this->actingAs($john)->delete("api/v4/users/{$user1->id}");
	$response->assertStatus(403);
	$json = $response->json();

	$this->assertSame('error', $json['status']);
	$this->assertSame("Access denied", $json['message']);
	$this->assertCount(2, $json);

	// Test that non-controller cannot remove himself
	$response = $this->actingAs($user3)->delete("api/v4/users/{$user3->id}");
	$response->assertStatus(403);

	// Test removing a non-controller user
	$response = $this->actingAs($user1)->delete("api/v4/users/{$user3->id}");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertEquals('success', $json['status']);
	$this->assertEquals('User deleted successfully.', $json['message']);

	// Test removing self (an account with users)
	$response = $this->actingAs($user1)->delete("api/v4/users/{$user1->id}");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertEquals('success', $json['status']);
	$this->assertEquals('User deleted successfully.', $json['message']);
	}

	/**
	* Test user deleting (DELETE /api/v4/users/<id>)
	*/
	public function testDestroyByController(): void
	{
	// Create an account with additional controller - $user2
	$package_kolab = \App\Package::where('title', 'kolab')->first();
	$package_domain = \App\Package::where('title', 'domain-hosting')->first();
	$user1 = $this->getTestUser('UsersControllerTest1@userscontroller.com');
	$user2 = $this->getTestUser('UsersControllerTest2@userscontroller.com');
	$user3 = $this->getTestUser('UsersControllerTest3@userscontroller.com');
	$domain = $this->getTestDomain('userscontroller.com', [
	'status' => Domain::STATUS_NEW,
	'type' => Domain::TYPE_PUBLIC,
	]);
	$user1->assignPackage($package_kolab);
	$domain->assignPackage($package_domain, $user1);
	$user1->assignPackage($package_kolab, $user2);
	$user1->assignPackage($package_kolab, $user3);
	$user1->wallets()->first()->addController($user2);

	// TODO/FIXME:
	// For now controller can delete himself, as well as
	// the whole account he has control to, including the owner
	// Probably he should not be able to do none of those
	// However, this is not 0-regression scenario as we
	// do not fully support additional controllers.

	//$response = $this->actingAs($user2)->delete("api/v4/users/{$user2->id}");
	//$response->assertStatus(403);

	$response = $this->actingAs($user2)->delete("api/v4/users/{$user3->id}");
	$response->assertStatus(200);

	$response = $this->actingAs($user2)->delete("api/v4/users/{$user1->id}");
	$response->assertStatus(200);

	// Note: More detailed assertions in testDestroy() above

	$this->assertTrue($user1->fresh()->trashed());
	$this->assertTrue($user2->fresh()->trashed());
	$this->assertTrue($user3->fresh()->trashed());
	}

	/**
	* Test user listing (GET /api/v4/users)
	*/
	public function testIndex(): void
	{
	// Test unauth access
	$response = $this->get("api/v4/users");
	$response->assertStatus(401);

	$jack = $this->getTestUser('jack@kolab.org');
	$joe = $this->getTestUser('joe@kolab.org');
	$john = $this->getTestUser('john@kolab.org');
	$ned = $this->getTestUser('ned@kolab.org');

	$response = $this->actingAs($jack)->get("/api/v4/users");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(0, $json);

	$response = $this->actingAs($john)->get("/api/v4/users");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(4, $json);
	$this->assertSame($jack->email, $json[0]['email']);
	$this->assertSame($joe->email, $json[1]['email']);
	$this->assertSame($john->email, $json[2]['email']);
	$this->assertSame($ned->email, $json[3]['email']);
	// Values below are tested by Unit tests
	$this->assertArrayHasKey('isDeleted', $json[0]);
	$this->assertArrayHasKey('isSuspended', $json[0]);
	$this->assertArrayHasKey('isActive', $json[0]);
	$this->assertArrayHasKey('isLdapReady', $json[0]);
	$this->assertArrayHasKey('isImapReady', $json[0]);

	$response = $this->actingAs($ned)->get("/api/v4/users");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertCount(4, $json);
	$this->assertSame($jack->email, $json[0]['email']);
	$this->assertSame($joe->email, $json[1]['email']);
	$this->assertSame($john->email, $json[2]['email']);
	$this->assertSame($ned->email, $json[3]['email']);
	}

	/**
	* Test fetching user data/profile (GET /api/v4/users/<user-id>)
	*/
	public function testShow(): void
	{
	$userA = $this->getTestUser('UserEntitlement2A@UserEntitlement.com');

	// Test getting profile of self
	$response = $this->actingAs($userA)->get("/api/v4/users/{$userA->id}");

	$json = $response->json();

	$response->assertStatus(200);
	$this->assertEquals($userA->id, $json['id']);
	$this->assertEquals($userA->email, $json['email']);
	$this->assertTrue(is_array($json['statusInfo']));
	$this->assertTrue(is_array($json['settings']));
	$this->assertTrue(is_array($json['aliases']));
	$this->assertSame([], $json['skus']);
	// Values below are tested by Unit tests
	$this->assertArrayHasKey('isDeleted', $json);
	$this->assertArrayHasKey('isSuspended', $json);
	$this->assertArrayHasKey('isActive', $json);
	$this->assertArrayHasKey('isLdapReady', $json);
	$this->assertArrayHasKey('isImapReady', $json);

	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$ned = $this->getTestUser('ned@kolab.org');

	// Test unauthorized access to a profile of other user
	$response = $this->actingAs($jack)->get("/api/v4/users/{$userA->id}");
	$response->assertStatus(403);

	// Test authorized access to a profile of other user
	// Ned: Additional account controller
	$response = $this->actingAs($ned)->get("/api/v4/users/{$john->id}");
	$response->assertStatus(200);
	$response = $this->actingAs($ned)->get("/api/v4/users/{$jack->id}");
	$response->assertStatus(200);

	// John: Account owner
	$response = $this->actingAs($john)->get("/api/v4/users/{$jack->id}");
	$response->assertStatus(200);
	$response = $this->actingAs($john)->get("/api/v4/users/{$ned->id}");
	$response->assertStatus(200);

	$json = $response->json();

	$storage_sku = Sku::where('title', 'storage')->first();
	$groupware_sku = Sku::where('title', 'groupware')->first();
	$mailbox_sku = Sku::where('title', 'mailbox')->first();
	$secondfactor_sku = Sku::where('title', '2fa')->first();

	$this->assertCount(5, $json['skus']);

	$this->assertSame(2, $json['skus'][$storage_sku->id]['count']);
	$this->assertSame(1, $json['skus'][$groupware_sku->id]['count']);
	$this->assertSame(1, $json['skus'][$mailbox_sku->id]['count']);
	$this->assertSame(1, $json['skus'][$secondfactor_sku->id]['count']);
	}

	/**
	* Test fetching user status (GET /api/v4/users/<user-id>/status)
	* and forcing setup process update (?refresh=1)
	*
	* @group imap
	* @group dns
	*/
	public function testStatus(): void
	{
	Queue::fake();

	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');

	// Test unauthorized access
	$response = $this->actingAs($jack)->get("/api/v4/users/{$john->id}/status");
	$response->assertStatus(403);

	if ($john->isImapReady()) {
	$john->status ^= User::STATUS_IMAP_READY;
	$john->save();
	}

	// Get user status
	$response = $this->actingAs($john)->get("/api/v4/users/{$john->id}/status");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertFalse($json['isImapReady']);
	$this->assertFalse($json['isReady']);
	$this->assertCount(7, $json['process']);
	$this->assertSame('user-imap-ready', $json['process'][2]['label']);
	$this->assertSame(false, $json['process'][2]['state']);
	$this->assertTrue(empty($json['status']));
	$this->assertTrue(empty($json['message']));

	// Make sure the domain is confirmed (other test might unset that status)
	$domain = $this->getTestDomain('kolab.org');
	$domain->status \|= Domain::STATUS_CONFIRMED;
	$domain->save();

	// Now "reboot" the process and verify the user in imap synchronously
	$response = $this->actingAs($john)->get("/api/v4/users/{$john->id}/status?refresh=1");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertTrue($json['isImapReady']);
	$this->assertTrue($json['isReady']);
	$this->assertCount(7, $json['process']);
	$this->assertSame('user-imap-ready', $json['process'][2]['label']);
	$this->assertSame(true, $json['process'][2]['state']);
	$this->assertSame('success', $json['status']);
	$this->assertSame('Setup process finished successfully.', $json['message']);

	Queue::size(1);

	// Test case for when the verify job is dispatched to the worker
	$john->refresh();
	$john->status ^= User::STATUS_IMAP_READY;
	$john->save();

	\config(['imap.admin_password' => null]);

	$response = $this->actingAs($john)->get("/api/v4/users/{$john->id}/status?refresh=1");
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertFalse($json['isImapReady']);
	$this->assertFalse($json['isReady']);
	$this->assertSame('success', $json['status']);
	$this->assertSame('waiting', $json['processState']);
	$this->assertSame('Setup process has been pushed. Please wait.', $json['message']);

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

	/**
	* Test UsersController::statusInfo()
	*/
	public function testStatusInfo(): void
	{
	$user = $this->getTestUser('UsersControllerTest1@userscontroller.com');
	$domain = $this->getTestDomain('userscontroller.com', [
	'status' => Domain::STATUS_NEW,
	'type' => Domain::TYPE_PUBLIC,
	]);

	$user->created_at = Carbon::now();
	$user->status = User::STATUS_NEW;
	$user->save();

	$result = UsersController::statusInfo($user);

	$this->assertFalse($result['isReady']);
	- $this->assertSame([], $result['betaSKUs']);
	+ $this->assertSame([], $result['skus']);
	$this->assertCount(3, $result['process']);
	$this->assertSame('user-new', $result['process'][0]['label']);
	$this->assertSame(true, $result['process'][0]['state']);
	$this->assertSame('user-ldap-ready', $result['process'][1]['label']);
	$this->assertSame(false, $result['process'][1]['state']);
	$this->assertSame('user-imap-ready', $result['process'][2]['label']);
	$this->assertSame(false, $result['process'][2]['state']);
	$this->assertSame('running', $result['processState']);

	$user->created_at = Carbon::now()->subSeconds(181);
	$user->save();

	$result = UsersController::statusInfo($user);

	$this->assertSame('failed', $result['processState']);

	$user->status \|= User::STATUS_LDAP_READY \| User::STATUS_IMAP_READY;
	$user->save();

	$result = UsersController::statusInfo($user);

	$this->assertTrue($result['isReady']);
	$this->assertCount(3, $result['process']);
	$this->assertSame('user-new', $result['process'][0]['label']);
	$this->assertSame(true, $result['process'][0]['state']);
	$this->assertSame('user-ldap-ready', $result['process'][1]['label']);
	$this->assertSame(true, $result['process'][1]['state']);
	$this->assertSame('user-imap-ready', $result['process'][2]['label']);
	$this->assertSame(true, $result['process'][2]['state']);
	$this->assertSame('done', $result['processState']);

	$domain->status \|= Domain::STATUS_VERIFIED;
	$domain->type = Domain::TYPE_EXTERNAL;
	$domain->save();

	$result = UsersController::statusInfo($user);

	$this->assertFalse($result['isReady']);
	- $this->assertSame([], $result['betaSKUs']);
	+ $this->assertSame([], $result['skus']);
	$this->assertCount(7, $result['process']);
	$this->assertSame('user-new', $result['process'][0]['label']);
	$this->assertSame(true, $result['process'][0]['state']);
	$this->assertSame('user-ldap-ready', $result['process'][1]['label']);
	$this->assertSame(true, $result['process'][1]['state']);
	$this->assertSame('user-imap-ready', $result['process'][2]['label']);
	$this->assertSame(true, $result['process'][2]['state']);
	$this->assertSame('domain-new', $result['process'][3]['label']);
	$this->assertSame(true, $result['process'][3]['state']);
	$this->assertSame('domain-ldap-ready', $result['process'][4]['label']);
	$this->assertSame(false, $result['process'][4]['state']);
	$this->assertSame('domain-verified', $result['process'][5]['label']);
	$this->assertSame(true, $result['process'][5]['state']);
	$this->assertSame('domain-confirmed', $result['process'][6]['label']);
	$this->assertSame(false, $result['process'][6]['state']);

	- // Test betaSKUs property
	+ // Test 'skus' property
	$user->assignSku(Sku::where('title', 'beta')->first());

	$result = UsersController::statusInfo($user);

	- $this->assertSame([], $result['betaSKUs']);
	+ $this->assertSame(['beta'], $result['skus']);

	$user->assignSku(Sku::where('title', 'meet')->first());

	$result = UsersController::statusInfo($user);

	- $this->assertSame(['meet'], $result['betaSKUs']);
	+ $this->assertSame(['beta', 'meet'], $result['skus']);

	$user->assignSku(Sku::where('title', 'meet')->first());

	$result = UsersController::statusInfo($user);

	- $this->assertSame(['meet'], $result['betaSKUs']);
	+ $this->assertSame(['beta', 'meet'], $result['skus']);
	}

	/**
	* Test user creation (POST /api/v4/users)
	*/
	public function testStore(): void
	{
	Queue::fake();

	$jack = $this->getTestUser('jack@kolab.org');
	$john = $this->getTestUser('john@kolab.org');
	$deleted_priv = $this->getTestUser('deleted@kolab.org');
	$deleted_priv->delete();

	// Test empty request
	$response = $this->actingAs($john)->post("/api/v4/users", []);
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertSame('error', $json['status']);
	$this->assertSame("The email field is required.", $json['errors']['email']);
	$this->assertSame("The password field is required.", $json['errors']['password'][0]);
	$this->assertCount(2, $json);

	// Test access by user not being a wallet controller
	$post = ['first_name' => 'Test'];
	$response = $this->actingAs($jack)->post("/api/v4/users", $post);
	$json = $response->json();

	$response->assertStatus(403);

	$this->assertSame('error', $json['status']);
	$this->assertSame("Access denied", $json['message']);
	$this->assertCount(2, $json);

	// Test some invalid data
	$post = ['password' => '12345678', 'email' => 'invalid'];
	$response = $this->actingAs($john)->post("/api/v4/users", $post);
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertSame('error', $json['status']);
	$this->assertCount(2, $json);
	$this->assertSame('The password confirmation does not match.', $json['errors']['password'][0]);
	$this->assertSame('The specified email is invalid.', $json['errors']['email']);

	// Test existing user email
	$post = [
	'password' => 'simple',
	'password_confirmation' => 'simple',
	'first_name' => 'John2',
	'last_name' => 'Doe2',
	'email' => 'jack.daniels@kolab.org',
	];

	$response = $this->actingAs($john)->post("/api/v4/users", $post);
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertSame('error', $json['status']);
	$this->assertCount(2, $json);
	$this->assertSame('The specified email is not available.', $json['errors']['email']);

	$package_kolab = \App\Package::where('title', 'kolab')->first();
	$package_domain = \App\Package::where('title', 'domain-hosting')->first();

	$post = [
	'password' => 'simple',
	'password_confirmation' => 'simple',
	'first_name' => 'John2',
	'last_name' => 'Doe2',
	'email' => 'john2.doe2@kolab.org',
	'organization' => 'TestOrg',
	'aliases' => ['useralias1@kolab.org', 'deleted@kolab.org'],
	];

	// Missing package
	$response = $this->actingAs($john)->post("/api/v4/users", $post);
	$json = $response->json();

	$response->assertStatus(422);

	$this->assertSame('error', $json['status']);
	$this->assertSame("Package is required.", $json['errors']['package']);
	$this->assertCount(2, $json);

	// Invalid package
	$post['package'] = $package_domain->id;
	$response = $this->actingAs($john)->post("/api/v4/users", $post);
	$json = $response->json();

	$response->assertStatus(422);

	$this->assertSame('error', $json['status']);
	$this->assertSame("Invalid package selected.", $json['errors']['package']);
	$this->assertCount(2, $json);

	// Test full and valid data
	$post['package'] = $package_kolab->id;
	$response = $this->actingAs($john)->post("/api/v4/users", $post);
	$json = $response->json();

	$response->assertStatus(200);

	$this->assertSame('success', $json['status']);
	$this->assertSame("User created successfully.", $json['message']);
	$this->assertCount(2, $json);

	$user = User::where('email', 'john2.doe2@kolab.org')->first();
	$this->assertInstanceOf(User::class, $user);
	$this->assertSame('John2', $user->getSetting('first_name'));
	$this->assertSame('Doe2', $user->getSetting('last_name'));
	$this->assertSame('TestOrg', $user->getSetting('organization'));
	$aliases = $user->aliases()->orderBy('alias')->get();
	$this->assertCount(2, $aliases);
	$this->assertSame('deleted@kolab.org', $aliases[0]->alias);
	$this->assertSame('useralias1@kolab.org', $aliases[1]->alias);
	// Assert the new user entitlements
	$this->assertUserEntitlements($user, ['groupware', 'mailbox', 'storage', 'storage']);
	// Assert the wallet to which the new user should be assigned to
	$wallet = $user->wallet();
	$this->assertSame($john->wallets()->first()->id, $wallet->id);

	// Attempt to create a user previously deleted
	$user->delete();

	$post['package'] = $package_kolab->id;
	$post['aliases'] = [];
	$response = $this->actingAs($john)->post("/api/v4/users", $post);
	$json = $response->json();

	$response->assertStatus(200);

	$this->assertSame('success', $json['status']);
	$this->assertSame("User created successfully.", $json['message']);
	$this->assertCount(2, $json);

	$user = User::where('email', 'john2.doe2@kolab.org')->first();
	$this->assertInstanceOf(User::class, $user);
	$this->assertSame('John2', $user->getSetting('first_name'));
	$this->assertSame('Doe2', $user->getSetting('last_name'));
	$this->assertSame('TestOrg', $user->getSetting('organization'));
	$this->assertCount(0, $user->aliases()->get());
	$this->assertUserEntitlements($user, ['groupware', 'mailbox', 'storage', 'storage']);

	// Test acting as account controller (not owner)

	$this->markTestIncomplete();
	}

	/**
	* Test user update (PUT /api/v4/users/<user-id>)
	*/
	public function testUpdate(): void
	{
	$userA = $this->getTestUser('UsersControllerTest1@userscontroller.com');
	$jack = $this->getTestUser('jack@kolab.org');
	$john = $this->getTestUser('john@kolab.org');
	$ned = $this->getTestUser('ned@kolab.org');
	$domain = $this->getTestDomain(
	'userscontroller.com',
	['status' => Domain::STATUS_NEW, 'type' => Domain::TYPE_EXTERNAL]
	);

	// Test unauthorized update of other user profile
	$response = $this->actingAs($jack)->get("/api/v4/users/{$userA->id}", []);
	$response->assertStatus(403);

	// Test authorized update of account owner by account controller
	$response = $this->actingAs($ned)->get("/api/v4/users/{$john->id}", []);
	$response->assertStatus(200);

	// Test updating of self (empty request)
	$response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", []);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertSame('success', $json['status']);
	$this->assertSame("User data updated successfully.", $json['message']);
	$this->assertTrue(!empty($json['statusInfo']));
	$this->assertCount(3, $json);

	// Test some invalid data
	$post = ['password' => '12345678', 'currency' => 'invalid'];
	$response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", $post);
	$response->assertStatus(422);

	$json = $response->json();

	$this->assertSame('error', $json['status']);
	$this->assertCount(2, $json);
	$this->assertSame('The password confirmation does not match.', $json['errors']['password'][0]);
	$this->assertSame('The currency must be 3 characters.', $json['errors']['currency'][0]);

	// Test full profile update including password
	$post = [
	'password' => 'simple',
	'password_confirmation' => 'simple',
	'first_name' => 'John2',
	'last_name' => 'Doe2',
	'organization' => 'TestOrg',
	'phone' => '+123 123 123',
	'external_email' => 'external@gmail.com',
	'billing_address' => 'billing',
	'country' => 'CH',
	'currency' => 'CHF',
	'aliases' => ['useralias1@' . \config('app.domain'), 'useralias2@' . \config('app.domain')]
	];

	$response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", $post);
	$json = $response->json();

	$response->assertStatus(200);

	$this->assertSame('success', $json['status']);
	$this->assertSame("User data updated successfully.", $json['message']);
	$this->assertTrue(!empty($json['statusInfo']));
	$this->assertCount(3, $json);
	$this->assertTrue($userA->password != $userA->fresh()->password);
	unset($post['password'], $post['password_confirmation'], $post['aliases']);
	foreach ($post as $key => $value) {
	$this->assertSame($value, $userA->getSetting($key));
	}
	$aliases = $userA->aliases()->orderBy('alias')->get();
	$this->assertCount(2, $aliases);
	$this->assertSame('useralias1@' . \config('app.domain'), $aliases[0]->alias);
	$this->assertSame('useralias2@' . \config('app.domain'), $aliases[1]->alias);

	// Test unsetting values
	$post = [
	'first_name' => '',
	'last_name' => '',
	'organization' => '',
	'phone' => '',
	'external_email' => '',
	'billing_address' => '',
	'country' => '',
	'currency' => '',
	'aliases' => ['useralias2@' . \config('app.domain')]
	];

	$response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", $post);
	$json = $response->json();

	$response->assertStatus(200);

	$this->assertSame('success', $json['status']);
	$this->assertSame("User data updated successfully.", $json['message']);
	$this->assertTrue(!empty($json['statusInfo']));
	$this->assertCount(3, $json);
	unset($post['aliases']);
	foreach ($post as $key => $value) {
	$this->assertNull($userA->getSetting($key));
	}
	$aliases = $userA->aliases()->get();
	$this->assertCount(1, $aliases);
	$this->assertSame('useralias2@' . \config('app.domain'), $aliases[0]->alias);

	// Test error on some invalid aliases missing password confirmation
	$post = [
	'password' => 'simple123',
	'aliases' => [
	'useralias2@' . \config('app.domain'),
	'useralias1@kolab.org',
	'@kolab.org',
	]
	];

	$response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", $post);
	$json = $response->json();

	$response->assertStatus(422);

	$this->assertSame('error', $json['status']);
	$this->assertCount(2, $json['errors']);
	$this->assertCount(2, $json['errors']['aliases']);
	$this->assertSame("The specified domain is not available.", $json['errors']['aliases'][1]);
	$this->assertSame("The specified alias is invalid.", $json['errors']['aliases'][2]);
	$this->assertSame("The password confirmation does not match.", $json['errors']['password'][0]);

	// Test authorized update of other user
	$response = $this->actingAs($ned)->put("/api/v4/users/{$jack->id}", []);
	$response->assertStatus(200);

	$json = $response->json();

	$this->assertTrue(empty($json['statusInfo']));

	// TODO: Test error on aliases with invalid/non-existing/other-user's domain

	// Create entitlements and additional user for following tests
	$owner = $this->getTestUser('UsersControllerTest1@userscontroller.com');
	$user = $this->getTestUser('UsersControllerTest2@userscontroller.com');
	$package_domain = Package::where('title', 'domain-hosting')->first();
	$package_kolab = Package::where('title', 'kolab')->first();
	$package_lite = Package::where('title', 'lite')->first();
	$sku_mailbox = Sku::where('title', 'mailbox')->first();
	$sku_storage = Sku::where('title', 'storage')->first();
	$sku_groupware = Sku::where('title', 'groupware')->first();

	$domain = $this->getTestDomain(
	'userscontroller.com',
	[
	'status' => Domain::STATUS_NEW,
	'type' => Domain::TYPE_EXTERNAL,
	]
	);

	$domain->assignPackage($package_domain, $owner);
	$owner->assignPackage($package_kolab);
	$owner->assignPackage($package_lite, $user);

	// Non-controller cannot update his own entitlements
	$post = ['skus' => []];
	$response = $this->actingAs($user)->put("/api/v4/users/{$user->id}", $post);
	$response->assertStatus(422);

	// Test updating entitlements
	$post = [
	'skus' => [
	$sku_mailbox->id => 1,
	$sku_storage->id => 3,
	$sku_groupware->id => 1,
	],
	];

	$response = $this->actingAs($owner)->put("/api/v4/users/{$user->id}", $post);
	$response->assertStatus(200);

	$json = $response->json();

	$storage_cost = $user->entitlements()
	->where('sku_id', $sku_storage->id)
	->orderBy('cost')
	->pluck('cost')->all();

	$this->assertUserEntitlements(
	$user,
	['groupware', 'mailbox', 'storage', 'storage', 'storage']
	);

	$this->assertSame([0, 0, 25], $storage_cost);
	$this->assertTrue(empty($json['statusInfo']));
	}

	/**
	* Test UsersController::updateEntitlements()
	*/
	public function testUpdateEntitlements(): void
	{
	$jane = $this->getTestUser('jane@kolabnow.com');

	$kolab = \App\Package::where('title', 'kolab')->first();
	$storage = \App\Sku::where('title', 'storage')->first();
	$activesync = \App\Sku::where('title', 'activesync')->first();
	$groupware = \App\Sku::where('title', 'groupware')->first();
	$mailbox = \App\Sku::where('title', 'mailbox')->first();

	// standard package, 1 mailbox, 1 groupware, 2 storage
	$jane->assignPackage($kolab);

	// add 2 storage, 1 activesync
	$post = [
	'skus' => [
	$mailbox->id => 1,
	$groupware->id => 1,
	$storage->id => 4,
	$activesync->id => 1
	]
	];

	$response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
	$response->assertStatus(200);

	$this->assertUserEntitlements(
	$jane,
	[
	'activesync',
	'groupware',
	'mailbox',
	'storage',
	'storage',
	'storage',
	'storage'
	]
	);

	// add 2 storage, remove 1 activesync
	$post = [
	'skus' => [
	$mailbox->id => 1,
	$groupware->id => 1,
	$storage->id => 6,
	$activesync->id => 0
	]
	];

	$response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
	$response->assertStatus(200);

	$this->assertUserEntitlements(
	$jane,
	[
	'groupware',
	'mailbox',
	'storage',
	'storage',
	'storage',
	'storage',
	'storage',
	'storage'
	]
	);

	// add mailbox
	$post = [
	'skus' => [
	$mailbox->id => 2,
	$groupware->id => 1,
	$storage->id => 6,
	$activesync->id => 0
	]
	];

	$response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
	$response->assertStatus(500);

	$this->assertUserEntitlements(
	$jane,
	[
	'groupware',
	'mailbox',
	'storage',
	'storage',
	'storage',
	'storage',
	'storage',
	'storage'
	]
	);

	// remove mailbox
	$post = [
	'skus' => [
	$mailbox->id => 0,
	$groupware->id => 1,
	$storage->id => 6,
	$activesync->id => 0
	]
	];

	$response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
	$response->assertStatus(500);

	$this->assertUserEntitlements(
	$jane,
	[
	'groupware',
	'mailbox',
	'storage',
	'storage',
	'storage',
	'storage',
	'storage',
	'storage'
	]
	);

	// less than free storage
	$post = [
	'skus' => [
	$mailbox->id => 1,
	$groupware->id => 1,
	$storage->id => 1,
	$activesync->id => 0
	]
	];

	$response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
	$response->assertStatus(200);

	$this->assertUserEntitlements(
	$jane,
	[
	'groupware',
	'mailbox',
	'storage',
	'storage'
	]
	);
	}

	/**
	* Test user data response used in show and info actions
	*/
	public function testUserResponse(): void
	{
	$provider = \config('services.payment_provider') ?: 'mollie';
	$user = $this->getTestUser('john@kolab.org');
	$wallet = $user->wallets()->first();
	$wallet->setSettings(['mollie_id' => null, 'stripe_id' => null]);
	$result = $this->invokeMethod(new UsersController(), 'userResponse', [$user]);

	$this->assertEquals($user->id, $result['id']);
	$this->assertEquals($user->email, $result['email']);
	$this->assertEquals($user->status, $result['status']);
	$this->assertTrue(is_array($result['statusInfo']));

	$this->assertTrue(is_array($result['aliases']));
	$this->assertCount(1, $result['aliases']);
	$this->assertSame('john.doe@kolab.org', $result['aliases'][0]);

	$this->assertTrue(is_array($result['settings']));
	$this->assertSame('US', $result['settings']['country']);
	$this->assertSame('USD', $result['settings']['currency']);

	$this->assertTrue(is_array($result['accounts']));
	$this->assertTrue(is_array($result['wallets']));
	$this->assertCount(0, $result['accounts']);
	$this->assertCount(1, $result['wallets']);
	$this->assertSame($wallet->id, $result['wallet']['id']);
	$this->assertArrayNotHasKey('discount', $result['wallet']);

	$this->assertTrue($result['statusInfo']['enableDomains']);
	$this->assertTrue($result['statusInfo']['enableWallets']);
	$this->assertTrue($result['statusInfo']['enableUsers']);
	- $this->assertSame([], $result['statusInfo']['betaSKUs']);

	// Ned is John's wallet controller
	$ned = $this->getTestUser('ned@kolab.org');
	$ned_wallet = $ned->wallets()->first();
	$result = $this->invokeMethod(new UsersController(), 'userResponse', [$ned]);

	$this->assertEquals($ned->id, $result['id']);
	$this->assertEquals($ned->email, $result['email']);
	$this->assertTrue(is_array($result['accounts']));
	$this->assertTrue(is_array($result['wallets']));
	$this->assertCount(1, $result['accounts']);
	$this->assertCount(1, $result['wallets']);
	$this->assertSame($wallet->id, $result['wallet']['id']);
	$this->assertSame($wallet->id, $result['accounts'][0]['id']);
	$this->assertSame($ned_wallet->id, $result['wallets'][0]['id']);
	$this->assertSame($provider, $result['wallet']['provider']);
	$this->assertSame($provider, $result['wallets'][0]['provider']);

	$this->assertTrue($result['statusInfo']['enableDomains']);
	$this->assertTrue($result['statusInfo']['enableWallets']);
	$this->assertTrue($result['statusInfo']['enableUsers']);
	- $this->assertSame([], $result['statusInfo']['betaSKUs']);

	// Test discount in a response
	$discount = Discount::where('code', 'TEST')->first();
	$wallet->discount()->associate($discount);
	$wallet->save();
	$mod_provider = $provider == 'mollie' ? 'stripe' : 'mollie';
	$wallet->setSetting($mod_provider . '_id', 123);
	$user->refresh();

	$result = $this->invokeMethod(new UsersController(), 'userResponse', [$user]);

	$this->assertEquals($user->id, $result['id']);
	$this->assertSame($discount->id, $result['wallet']['discount_id']);
	$this->assertSame($discount->discount, $result['wallet']['discount']);
	$this->assertSame($discount->description, $result['wallet']['discount_description']);
	$this->assertSame($mod_provider, $result['wallet']['provider']);
	$this->assertSame($discount->id, $result['wallets'][0]['discount_id']);
	$this->assertSame($discount->discount, $result['wallets'][0]['discount']);
	$this->assertSame($discount->description, $result['wallets'][0]['discount_description']);
	$this->assertSame($mod_provider, $result['wallets'][0]['provider']);

	// Jack is not a John's wallet controller
	$jack = $this->getTestUser('jack@kolab.org');
	$result = $this->invokeMethod(new UsersController(), 'userResponse', [$jack]);

	$this->assertFalse($result['statusInfo']['enableDomains']);
	$this->assertFalse($result['statusInfo']['enableWallets']);
	$this->assertFalse($result['statusInfo']['enableUsers']);
	- $this->assertSame([], $result['statusInfo']['betaSKUs']);
	}

	/**
	* List of email address validation cases for testValidateEmail()
	*
	* @return array Arguments for testValidateEmail()
	*/
	public function dataValidateEmail(): array
	{
	$this->refreshApplication();
	$public_domains = Domain::getPublicDomains();
	$domain = reset($public_domains);

	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$user = $this->getTestUser('UsersControllerTest1@userscontroller.com');

	return [
	// Invalid format
	["$domain", $john, 'The specified email is invalid.'],
	[".@$domain", $john, 'The specified email is invalid.'],
	["test123456@localhost", $john, 'The specified domain is invalid.'],
	["test123456@unknown-domain.org", $john, 'The specified domain is invalid.'],

	["$domain", $john, 'The specified email is invalid.'],
	[".@$domain", $john, 'The specified email is invalid.'],

	// forbidden local part on public domains
	["admin@$domain", $john, 'The specified email is not available.'],
	["administrator@$domain", $john, 'The specified email is not available.'],

	// forbidden (other user's domain)
	["testtest@kolab.org", $user, 'The specified domain is not available.'],

	// existing alias of other user, to be a user email
	["jack.daniels@kolab.org", $john, 'The specified email is not available.'],

	// valid (user domain)
	["admin@kolab.org", $john, null],

	// valid (public domain)
	["test.test@$domain", $john, null],
	];
	}

	/**
	* User email address 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 dataValidateEmail
	*/
	public function testValidateEmail($email, $user, $expected_result): void
	{
	$result = UsersController::validateEmail($email, $user);
	$this->assertSame($expected_result, $result);
	}

	/**
	* User email validation - tests for $deleted argument
	*
	* Note: Technically these include unit tests, but let's keep it here for now.
	* FIXME: Shall we do a http request for each case?
	*/
	public function testValidateEmailDeleted(): void
	{
	Queue::fake();

	$john = $this->getTestUser('john@kolab.org');
	$deleted_priv = $this->getTestUser('deleted@kolab.org');
	$deleted_priv->delete();
	$deleted_pub = $this->getTestUser('deleted@kolabnow.com');
	$deleted_pub->delete();

	$result = UsersController::validateEmail('deleted@kolab.org', $john, $deleted);
	$this->assertSame(null, $result);
	$this->assertSame($deleted_priv->id, $deleted->id);

	$result = UsersController::validateEmail('deleted@kolabnow.com', $john, $deleted);
	$this->assertSame('The specified email is not available.', $result);
	$this->assertSame(null, $deleted);

	$result = UsersController::validateEmail('jack@kolab.org', $john, $deleted);
	$this->assertSame('The specified email is not available.', $result);
	$this->assertSame(null, $deleted);
	}

	/**
	* User email validation - tests for an address being a group email address
	*
	* Note: Technically these include unit tests, but let's keep it here for now.
	* FIXME: Shall we do a http request for each case?
	*/
	public function testValidateEmailGroup(): void
	{
	Queue::fake();

	$john = $this->getTestUser('john@kolab.org');
	$pub_group = $this->getTestGroup('group-test@kolabnow.com');
	$priv_group = $this->getTestGroup('group-test@kolab.org');

	// A group in a public domain, existing
	$result = UsersController::validateEmail($pub_group->email, $john, $deleted);
	$this->assertSame('The specified email is not available.', $result);
	$this->assertNull($deleted);

	$pub_group->delete();

	// A group in a public domain, deleted
	$result = UsersController::validateEmail($pub_group->email, $john, $deleted);
	$this->assertSame('The specified email is not available.', $result);
	$this->assertNull($deleted);

	// A group in a private domain, existing
	$result = UsersController::validateEmail($priv_group->email, $john, $deleted);
	$this->assertSame('The specified email is not available.', $result);
	$this->assertNull($deleted);

	$priv_group->delete();

	// A group in a private domain, deleted
	$result = UsersController::validateEmail($priv_group->email, $john, $deleted);
	$this->assertSame(null, $result);
	$this->assertSame($priv_group->id, $deleted->id);
	}

	/**
	* List of alias validation cases for testValidateAlias()
	*
	* @return array Arguments for testValidateAlias()
	*/
	public function dataValidateAlias(): array
	{
	$this->refreshApplication();
	$public_domains = Domain::getPublicDomains();
	$domain = reset($public_domains);

	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$user = $this->getTestUser('UsersControllerTest1@userscontroller.com');

	return [
	// Invalid format
	["$domain", $john, 'The specified alias is invalid.'],
	[".@$domain", $john, 'The specified alias is invalid.'],
	["test123456@localhost", $john, 'The specified domain is invalid.'],
	["test123456@unknown-domain.org", $john, 'The specified domain is invalid.'],

	["$domain", $john, 'The specified alias is invalid.'],
	[".@$domain", $john, 'The specified alias is invalid.'],

	// forbidden local part on public domains
	["admin@$domain", $john, 'The specified alias is not available.'],
	["administrator@$domain", $john, 'The specified alias is not available.'],

	// forbidden (other user's domain)
	["testtest@kolab.org", $user, 'The specified domain is not available.'],

	// existing alias of other user, to be an alias, user in the same group account
	["jack.daniels@kolab.org", $john, null],

	// existing user
	["jack@kolab.org", $john, 'The specified alias is not available.'],

	// valid (user domain)
	["admin@kolab.org", $john, null],

	// valid (public domain)
	["test.test@$domain", $john, null],
	];
	}

	/**
	* User email alias 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 dataValidateAlias
	*/
	public function testValidateAlias($alias, $user, $expected_result): void
	{
	$result = UsersController::validateAlias($alias, $user);
	$this->assertSame($expected_result, $result);
	}

	/**
	* User alias validation - more cases.
	*
	* Note: Technically these include unit tests, but let's keep it here for now.
	* FIXME: Shall we do a http request for each case?
	*/
	public function testValidateAlias2(): void
	{
	Queue::fake();

	$john = $this->getTestUser('john@kolab.org');
	$jack = $this->getTestUser('jack@kolab.org');
	$user = $this->getTestUser('UsersControllerTest1@userscontroller.com');
	$deleted_priv = $this->getTestUser('deleted@kolab.org');
	$deleted_priv->setAliases(['deleted-alias@kolab.org']);
	$deleted_priv->delete();
	$deleted_pub = $this->getTestUser('deleted@kolabnow.com');
	$deleted_pub->setAliases(['deleted-alias@kolabnow.com']);
	$deleted_pub->delete();
	$group = $this->getTestGroup('group-test@kolabnow.com');

	// An alias that was a user email before is allowed, but only for custom domains
	$result = UsersController::validateAlias('deleted@kolab.org', $john);
	$this->assertSame(null, $result);

	$result = UsersController::validateAlias('deleted-alias@kolab.org', $john);
	$this->assertSame(null, $result);

	$result = UsersController::validateAlias('deleted@kolabnow.com', $john);
	$this->assertSame('The specified alias is not available.', $result);

	$result = UsersController::validateAlias('deleted-alias@kolabnow.com', $john);
	$this->assertSame('The specified alias is not available.', $result);

	// A grpoup with the same email address exists
	$result = UsersController::validateAlias($group->email, $john);
	$this->assertSame('The specified alias is not available.', $result);
	}
	}
	diff --git a/src/tests/TestCaseTrait.php b/src/tests/TestCaseTrait.php
	index 6b8d8e3c..1cb3bb56 100644
	--- a/src/tests/TestCaseTrait.php
	+++ b/src/tests/TestCaseTrait.php
	@@ -1,257 +1,266 @@
	<?php

	namespace Tests;

	use App\Domain;
	use App\Group;
	use App\Transaction;
	use App\User;
	use Carbon\Carbon;
	use Illuminate\Contracts\Console\Kernel;
	use Illuminate\Support\Facades\Queue;
	use PHPUnit\Framework\Assert;

	trait TestCaseTrait
	{
	/**
	- * Assign beta entitlement to a user.
	- * It will add both requested entitlement as well as the 'beta' entitlement
	+ * Assign 'meet' entitlement to a user.
	*
	* @param string\|\App\User $user The user
	- * @param string $sku The beta SKU title
	*/
	- protected function assignBetaEntitlement($user, $sku): void
	+ protected function assignMeetEntitlement($user): void
	{
	if (is_string($user)) {
	$user = $this->getTestUser($user);
	}

	- $user->assignSku(\App\Sku::where('title', 'beta')->first());
	- $user->assignSku(\App\Sku::where('title', $sku)->first());
	+ $user->assignSku(\App\Sku::where('title', 'meet')->first());
	}

	protected function assertUserEntitlements($user, $expected)
	{
	// Assert the user entitlements
	$skus = $user->entitlements()->get()
	->map(function ($ent) {
	return $ent->sku->title;
	})
	->toArray();

	sort($skus);

	Assert::assertSame($expected, $skus);
	}

	/**
	* Removes all beta entitlements from the database
	*/
	protected function clearBetaEntitlements(): void
	{
	- $betas = \App\Sku::where('handler_class', 'like', '%\\Beta%')->pluck('id')->all();
	+ $betas = \App\Sku::where('handler_class', 'like', 'App\\Handlers\\Beta\\%')
	+ ->orWhere('handler_class', 'App\Handlers\Beta')
	+ ->pluck('id')->all();
	+
	\App\Entitlement::whereIn('sku_id', $betas)->delete();
	}

	+ /**
	+ * Removes all 'meet' entitlements from the database
	+ */
	+ protected function clearMeetEntitlements(): void
	+ {
	+ $meet_sku = \App\Sku::where('title', 'meet')->first();
	+ \App\Entitlement::where('sku_id', $meet_sku->id)->delete();
	+ }
	+
	/**
	* Creates the application.
	*
	* @return \Illuminate\Foundation\Application
	*/
	public function createApplication()
	{
	$app = require __DIR__ . '/../bootstrap/app.php';

	$app->make(Kernel::class)->bootstrap();

	return $app;
	}

	/**
	* Create a set of transaction log entries for a wallet
	*/
	protected function createTestTransactions($wallet)
	{
	$result = [];
	$date = Carbon::now();
	$debit = 0;
	$entitlementTransactions = [];
	foreach ($wallet->entitlements as $entitlement) {
	if ($entitlement->cost) {
	$debit += $entitlement->cost;
	$entitlementTransactions[] = $entitlement->createTransaction(
	Transaction::ENTITLEMENT_BILLED,
	$entitlement->cost
	);
	}
	}

	$transaction = Transaction::create([
	'user_email' => 'jeroen@jeroen.jeroen',
	'object_id' => $wallet->id,
	'object_type' => \App\Wallet::class,
	'type' => Transaction::WALLET_DEBIT,
	'amount' => $debit,
	'description' => 'Payment',
	]);
	$result[] = $transaction;

	Transaction::whereIn('id', $entitlementTransactions)->update(['transaction_id' => $transaction->id]);

	$transaction = Transaction::create([
	'user_email' => null,
	'object_id' => $wallet->id,
	'object_type' => \App\Wallet::class,
	'type' => Transaction::WALLET_CREDIT,
	'amount' => 2000,
	'description' => 'Payment',
	]);
	$transaction->created_at = $date->next(Carbon::MONDAY);
	$transaction->save();
	$result[] = $transaction;

	$types = [
	Transaction::WALLET_AWARD,
	Transaction::WALLET_PENALTY,
	];

	// The page size is 10, so we generate so many to have at least two pages
	$loops = 10;
	while ($loops-- > 0) {
	$transaction = Transaction::create([
	'user_email' => 'jeroen.@jeroen.jeroen',
	'object_id' => $wallet->id,
	'object_type' => \App\Wallet::class,
	'type' => $types[count($result) % count($types)],
	'amount' => 11 * (count($result) + 1),
	'description' => 'TRANS' . $loops,
	]);
	$transaction->created_at = $date->next(Carbon::MONDAY);
	$transaction->save();
	$result[] = $transaction;
	}

	return $result;
	}

	protected function deleteTestDomain($name)
	{
	Queue::fake();

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

	if (!$domain) {
	return;
	}

	$job = new \App\Jobs\Domain\DeleteJob($domain->id);
	$job->handle();

	$domain->forceDelete();
	}

	protected function deleteTestGroup($email)
	{
	Queue::fake();

	$group = Group::withTrashed()->where('email', $email)->first();

	if (!$group) {
	return;
	}

	$job = new \App\Jobs\Group\DeleteJob($group->id);
	$job->handle();

	$group->forceDelete();
	}

	protected function deleteTestUser($email)
	{
	Queue::fake();

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

	if (!$user) {
	return;
	}

	$job = new \App\Jobs\User\DeleteJob($user->id);
	$job->handle();

	$user->forceDelete();
	}

	/**
	* Get Domain object by namespace, create it if needed.
	* Skip LDAP jobs.
	*/
	protected function getTestDomain($name, $attrib = [])
	{
	// Disable jobs (i.e. skip LDAP oprations)
	Queue::fake();
	return Domain::firstOrCreate(['namespace' => $name], $attrib);
	}

	/**
	* Get Group object by email, create it if needed.
	* Skip LDAP jobs.
	*/
	protected function getTestGroup($email, $attrib = [])
	{
	// Disable jobs (i.e. skip LDAP oprations)
	Queue::fake();
	return Group::firstOrCreate(['email' => $email], $attrib);
	}

	/**
	* Get User object by email, create it if needed.
	* Skip LDAP jobs.
	*/
	protected function getTestUser($email, $attrib = [])
	{
	// Disable jobs (i.e. skip LDAP oprations)
	Queue::fake();
	$user = User::withTrashed()->where('email', $email)->first();

	if (!$user) {
	return User::firstOrCreate(['email' => $email], $attrib);
	}

	if ($user->deleted_at) {
	$user->restore();
	}

	return $user;
	}

	/**
	* Helper to access protected property of an object
	*/
	protected static function getObjectProperty($object, $property_name)
	{
	$reflection = new \ReflectionClass($object);
	$property = $reflection->getProperty($property_name);
	$property->setAccessible(true);

	return $property->getValue($object);
	}

	/**
	* Call protected/private method of a class.
	*
	* @param object $object Instantiated object that we will run method on.
	* @param string $methodName Method name to call
	* @param array $parameters Array of parameters to pass into method.
	*
	* @return mixed Method return.
	*/
	protected function invokeMethod($object, $methodName, array $parameters = array())
	{
	$reflection = new \ReflectionClass(get_class($object));
	$method = $reflection->getMethod($methodName);
	$method->setAccessible(true);

	return $method->invokeArgs($object, $parameters);
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Apr 4, 8:24 AM (1 w, 6 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 18823214
Default Alt Text: (268 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions