@fleetbase/fleetops-engine 0.6.67 → 0.6.69

package/server/src/Support/FuelProviders/Providers/SascoFuelProvider.php

@@ -0,0 +1,272 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support\FuelProviders\Providers;
+
+use Fleetbase\FleetOps\Models\FuelProviderConnection;
+use Illuminate\Http\Client\Response;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+
+class SascoFuelProvider extends AbstractFuelProvider
+{
+    public const BASE_URLS = [
+        'sandbox'    => 'https://loyalty-api-qc.sasco.sa',
+        'production' => 'https://loyalty-api.sasco.com.sa',
+    ];
+
+    public const LOGIN_ENDPOINT        = 'apigateway/api/identity/user/b2badmin-login';
+    public const VEHICLES_ENDPOINT     = 'apigateway/api/loyaltycore/b2bexternaladmin/b2bvehicles';
+    public const TRANSACTIONS_ENDPOINT = 'apigateway/api/analytics/v1/b2bexternal/drivers-transactions';
+
+    /** Fallback token lifetime when the JWT carries no readable exp claim. */
+    protected const DEFAULT_TOKEN_TTL = 3600;
+
+    public function key(): string
+    {
+        return 'sasco';
+    }
+
+    public function name(): string
+    {
+        return 'SASCO';
+    }
+
+    public function authenticate(FuelProviderConnection $connection): array
+    {
+        $credentials = (array) $connection->credentials;
+        $response    = Http::baseUrl($this->baseUrl($connection))
+            ->timeout((int) data_get($credentials, 'timeout', 30))
+            ->acceptJson()
+            ->asJson()
+            ->post(self::LOGIN_ENDPOINT, [
+                'username' => trim((string) data_get($credentials, 'username')),
+                'password' => (string) data_get($credentials, 'password'),
+            ]);
+
+        $token = $response->json('accessToken');
+        if (!$response->successful() || !is_string($token) || $token === '') {
+            return [
+                'success' => false,
+                'message' => $this->errorMessage($response, 'SASCO login failed. Check the B2B admin username and password.'),
+                'status'  => $response->status(),
+            ];
+        }
+
+        Cache::put($this->tokenCacheKey($connection), $token, $this->tokenTtl($token));
+
+        return ['success' => true, 'message' => 'SASCO login successful.', 'token' => $token];
+    }
+
+    public function testConnection(FuelProviderConnection $connection): array
+    {
+        $metadata = [
+            'environment' => $connection->environment ?? 'production',
+            'host'        => parse_url($this->baseUrl($connection), PHP_URL_HOST),
+        ];
+
+        try {
+            $response           = $this->get($connection, self::VEHICLES_ENDPOINT, ['Page_size' => 1, 'Current_page' => 1]);
+            $metadata['status'] = $response->status();
+
+            if (!$response->successful() || !is_array($response->json('vehicles'))) {
+                return [
+                    'success'  => false,
+                    'message'  => $this->errorMessage($response, 'Unable to connect to SASCO.'),
+                    'metadata' => $metadata,
+                ];
+            }
+
+            return [
+                'success'  => true,
+                'message'  => 'SASCO connection successful.',
+                'metadata' => array_merge($metadata, ['total_vehicles' => $response->json('totalItems')]),
+            ];
+        } catch (\Throwable $e) {
+            return ['success' => false, 'message' => $e->getMessage(), 'metadata' => $metadata];
+        }
+    }
+
+    public function listVehicles(FuelProviderConnection $connection, array $options = []): Collection
+    {
+        return $this->paginatedGet($connection, self::VEHICLES_ENDPOINT, 'vehicles', $options);
+    }
+
+    public function listTransactions(FuelProviderConnection $connection, Carbon $from, Carbon $to, array $options = []): Collection
+    {
+        $params = [
+            'FromDate' => $from->toDateString(),
+            'ToDate'   => $to->toDateString(),
+        ];
+
+        if (array_key_exists('is_trip', $options)) {
+            $params['IsTrip'] = $options['is_trip'] ? 'true' : 'false';
+        }
+
+        return $this->paginatedGet($connection, self::TRANSACTIONS_ENDPOINT, 'driverTransactions', array_merge($options, $params))
+            ->map(fn ($payload) => $this->normalizeTransaction($payload));
+    }
+
+    protected function baseUrl(FuelProviderConnection $connection): string
+    {
+        $credentials = (array) $connection->credentials;
+        $override    = trim((string) data_get($credentials, 'base_url', ''));
+
+        return rtrim($override ?: self::BASE_URLS[$connection->environment ?? 'production'], '/');
+    }
+
+    protected function headers(FuelProviderConnection $connection): array
+    {
+        return ['Authorization' => 'Bearer ' . $this->token($connection)];
+    }
+
+    /**
+     * Returns a cached access token, logging in when none is cached.
+     */
+    protected function token(FuelProviderConnection $connection): string
+    {
+        $token = Cache::get($this->tokenCacheKey($connection));
+        if (is_string($token) && $token !== '') {
+            return $token;
+        }
+
+        $result = $this->authenticate($connection);
+        if (!$result['success']) {
+            throw new \RuntimeException($result['message']);
+        }
+
+        return $result['token'];
+    }
+
+    /**
+     * Keyed by host and username rather than connection uuid so unsaved
+     * connections built for credential tests share the same cache entry.
+     */
+    protected function tokenCacheKey(FuelProviderConnection $connection): string
+    {
+        $credentials = (array) $connection->credentials;
+
+        return 'fuel-provider:sasco:token:' . hash('sha256', $this->baseUrl($connection) . '|' . trim((string) data_get($credentials, 'username')));
+    }
+
+    protected function tokenTtl(string $token): int
+    {
+        $segments = explode('.', $token);
+        $payload  = isset($segments[1]) ? json_decode((string) base64_decode(strtr($segments[1], '-_', '+/')), true) : null;
+        $expires  = (int) data_get($payload, 'exp', 0);
+
+        if ($expires <= 0) {
+            return self::DEFAULT_TOKEN_TTL;
+        }
+
+        // Refresh a minute early so a request never goes out with a token about to lapse.
+        return max(1, $expires - now()->timestamp - 60);
+    }
+
+    /**
+     * Sends an authenticated GET, re-authenticating once when SASCO rejects a cached token.
+     */
+    protected function get(FuelProviderConnection $connection, string $endpoint, array $params = []): Response
+    {
+        $response = $this->client($connection)->get($endpoint, $params);
+
+        if ($response->status() === 401) {
+            Cache::forget($this->tokenCacheKey($connection));
+            $response = $this->client($connection)->get($endpoint, $params);
+        }
+
+        return $response;
+    }
+
+    protected function paginatedGet(FuelProviderConnection $connection, string $endpoint, string $dataKey, array $params = []): Collection
+    {
+        $page     = max(1, (int) data_get($params, 'page', 1));
+        $pageSize = max(1, (int) data_get($params, 'page_size', 100));
+        $maxPages = (int) data_get($params, 'max_pages', 100);
+        $query    = collect($params)->except(['page', 'page_size', 'max_pages', 'is_trip'])->all();
+
+        $items = collect();
+
+        do {
+            $response = $this->get($connection, $endpoint, array_merge($query, ['Page_size' => $pageSize, 'Current_page' => $page]));
+
+            if (!$response->successful()) {
+                throw new \RuntimeException($this->errorMessage($response, "SASCO {$endpoint} request failed."));
+            }
+
+            $data = $response->json($dataKey);
+            if (!is_array($data)) {
+                throw new \RuntimeException("SASCO {$endpoint} returned an invalid response.");
+            }
+            $items = $items->merge($data);
+
+            $total   = (int) $response->json('totalItems', 0);
+            $hasMore = count($data) > 0 && $items->count() < $total;
+            $page++;
+        } while ($hasMore && $page <= $maxPages);
+
+        if ($hasMore) {
+            throw new \RuntimeException('SASCO returned more pages than the sync limit. Choose a shorter date range and retry; the import was not marked complete.');
+        }
+
+        return $items;
+    }
+
+    protected function errorMessage(Response $response, string $fallback): string
+    {
+        $message = $response->json('message') ?? $response->json('title') ?? $response->json('error');
+
+        return is_string($message) && $message !== '' ? $message : $fallback;
+    }
+
+    /**
+     * Saudi plates are printed as three letters and up to four digits, e.g. "NXD 1240".
+     */
+    protected function plateNumber(array $plate): ?string
+    {
+        $number  = $this->compactIdentifier($plate['plateNumber'] ?? null);
+        $letters = collect([$plate['firstPlateLetter'] ?? null, $plate['secondPlateLetter'] ?? null, $plate['thirdPlateLetter'] ?? null])
+            ->map(fn ($letter) => $this->compactIdentifier($letter))
+            ->filter()
+            ->implode('');
+
+        return $this->compactIdentifier(trim($letters . ' ' . $number));
+    }
+
+    protected function normalizeTransaction(array $transaction): array
+    {
+        $plate      = (array) ($transaction['vehiclePlate'] ?? []);
+        $providerId = $this->compactIdentifier($transaction['transactionNumber'] ?? null);
+        $fallbackId = $this->transactionHash([
+            $transaction['createdAt'] ?? null,
+            $plate,
+            $transaction['stationName'] ?? null,
+            $transaction['noOfLitters'] ?? null,
+            $transaction['amount'] ?? null,
+            $transaction['driverPhone'] ?? null,
+        ]);
+
+        return [
+            'provider'                => $this->key(),
+            'provider_transaction_id' => (string) ($providerId ?: $fallbackId),
+            'plate_number'            => $this->plateNumber($plate),
+            'trip_number'             => $this->compactIdentifier($transaction['tripId'] ?? null),
+            'station_name'            => $this->compactIdentifier($transaction['stationName'] ?? null),
+            'transaction_at'          => $this->dateFrom($transaction['createdAt'] ?? null),
+            'volume'                  => $transaction['noOfLitters'] ?? null,
+            'metric_unit'             => 'l',
+            'amount'                  => $this->minorCurrencyUnit($transaction['amount'] ?? null),
+            'currency'                => 'SAR',
+            'normalized_payload'      => [
+                'fuel_type'       => $transaction['fuelType'] ?? null,
+                'driver_name'     => $transaction['driverName'] ?? null,
+                'driver_phone'    => $transaction['driverPhone'] ?? null,
+                'type'            => $transaction['type'] ?? null,
+                'period'          => $transaction['period'] ?? null,
+                'fuel_image_url'  => $transaction['fuelImageUrl'] ?? null,
+            ],
+            'raw_payload' => $transaction,
+        ];
+    }
+}

package/server/src/Support/ProfileAccountManager.php

@@ -0,0 +1,405 @@
+<?php
+
+namespace Fleetbase\FleetOps\Support;
+
+use Fleetbase\FleetOps\Exceptions\ProfileIdentityConflictException;
+use Fleetbase\FleetOps\Mail\CustomerCredentialsMail;
+use Fleetbase\FleetOps\Mail\DriverCredentialsMail;
+use Fleetbase\FleetOps\Models\Contact;
+use Fleetbase\FleetOps\Models\Driver;
+use Fleetbase\Models\Company;
+use Fleetbase\Models\CompanyUser;
+use Fleetbase\Models\User;
+use Fleetbase\Services\SmsService;
+use Illuminate\Support\Facades\Mail;
+use Illuminate\Support\Str;
+
+/**
+ * Manages the login accounts behind driver, contact and customer profiles.
+ *
+ * A profile either owns a managed account (user type `driver`, `contact` or
+ * `customer`), which it creates, updates and deletes, or it is linked to a
+ * staff account (type `user` or `admin`) of the same organization. A staff
+ * account is managed in IAM, so a profile never changes its email or phone,
+ * resets its password, deactivates it or deletes it.
+ */
+class ProfileAccountManager
+{
+    /**
+     * User types owned by a profile.
+     */
+    public const MANAGED_TYPES = ['driver', 'contact', 'customer'];
+
+    /**
+     * The organization role given to each managed account type.
+     */
+    public const ROLES = [
+        'driver'   => 'Driver',
+        'contact'  => 'Fleet-Ops Contact',
+        'customer' => 'Fleet-Ops Customer',
+    ];
+
+    /**
+     * Whether the account is owned by a driver, contact or customer profile.
+     */
+    public static function isManagedAccount(?object $user): bool
+    {
+        return $user !== null && in_array(data_get($user, 'type'), static::MANAGED_TYPES, true);
+    }
+
+    /**
+     * Whether the account is a team member's account managed in IAM.
+     */
+    public static function isStaffAccount(?object $user): bool
+    {
+        return $user !== null && !static::isManagedAccount($user);
+    }
+
+    /**
+     * Find the active account holding the given email or phone.
+     */
+    public static function findAccountByIdentity(?string $email, ?string $phone, ?string $ignoreUserUuid = null): ?User
+    {
+        $email = static::normalizeEmail($email);
+        $phone = static::normalizePhone($phone);
+
+        if (!$email && !$phone) {
+            return null;
+        }
+
+        return User::where(function ($query) use ($email, $phone) {
+            if ($email) {
+                $query->orWhere('email', $email);
+            }
+
+            if ($phone) {
+                $query->orWhere('phone', $phone);
+            }
+        })
+            ->when($ignoreUserUuid, fn ($query) => $query->where('uuid', '!=', $ignoreUserUuid))
+            ->whereNull('deleted_at')
+            ->first();
+    }
+
+    /**
+     * Describe what would happen to an email/phone entered on a new or existing
+     * profile: `staff` is the team member the profile would link to, `conflict`
+     * is why the email/phone cannot be used.
+     *
+     * @return array{account: ?User, staff: ?User, conflict: ?string}
+     */
+    public static function lookup(string $companyUuid, string $type, ?string $email, ?string $phone, ?User $currentUser = null): array
+    {
+        $result  = ['account' => null, 'staff' => null, 'conflict' => null];
+        $account = static::findAccountByIdentity($email, $phone, $currentUser?->uuid);
+
+        if (!$account) {
+            return $result;
+        }
+
+        $result['account'] = $account;
+        $field             = static::matchedField($account, $email);
+
+        // An existing profile can't swap its account for another one
+        if ($currentUser) {
+            $result['conflict'] = static::takenMessage($field);
+
+            return $result;
+        }
+
+        try {
+            static::assertAccountCanHoldProfile($account, $companyUuid, $type, $field);
+        } catch (ProfileIdentityConflictException $e) {
+            $result['conflict'] = $e->getMessage();
+
+            return $result;
+        }
+
+        if (static::isStaffAccount($account)) {
+            $result['staff'] = $account;
+        }
+
+        return $result;
+    }
+
+    /**
+     * Resolve the account for a new profile. A staff member of the organization
+     * or a managed account of the same type with the email/phone is linked;
+     * otherwise a managed account is created.
+     *
+     * @param array $attributes extra user attributes: password, status, timezone, avatar_uuid, country, ip_address, meta
+     *
+     * @throws ProfileIdentityConflictException
+     */
+    public static function resolveForProfile(string $companyUuid, string $type, ?string $name, ?string $email, ?string $phone, array $attributes = []): User
+    {
+        $account = static::findAccountByIdentity($email, $phone);
+
+        if ($account) {
+            static::assertAccountCanHoldProfile($account, $companyUuid, $type, static::matchedField($account, $email));
+
+            if (static::isManagedAccount($account)) {
+                static::attachToCompany($account, $companyUuid, $type);
+            }
+
+            return $account;
+        }
+
+        return static::createManagedAccount($companyUuid, $type, $name, $email, $phone, $attributes);
+    }
+
+    /**
+     * Create a managed account and add it to the organization without an invite.
+     */
+    public static function createManagedAccount(string $companyUuid, string $type, ?string $name, ?string $email, ?string $phone, array $attributes = []): User
+    {
+        $company  = Company::where('uuid', $companyUuid)->first();
+        $password = $attributes['password'] ?? null;
+        $userData = array_filter([
+            'company_uuid' => $companyUuid,
+            'name'         => $name,
+            'email'        => static::normalizeEmail($email),
+            'phone'        => static::normalizePhone($phone),
+            'username'     => User::generateUsername($name ?: Str::random(6)),
+            'timezone'     => $attributes['timezone'] ?? $company?->timezone ?? date_default_timezone_get(),
+            'status'       => $attributes['status'] ?? 'pending',
+            'avatar_uuid'  => $attributes['avatar_uuid'] ?? null,
+            'country'      => $attributes['country'] ?? null,
+            'ip_address'   => $attributes['ip_address'] ?? null,
+            'meta'         => $attributes['meta'] ?? null,
+        ], fn ($value) => $value !== null);
+
+        $user           = new User($userData);
+        $user->password = $password ?: Str::random(16);
+        $user->save();
+        $user->setType($type);
+
+        static::attachToCompany($user, $companyUuid, $type);
+
+        return $user;
+    }
+
+    /**
+     * Push the profile's proxy fields to its account. A staff account only
+     * takes the name: its email and phone are its console identity.
+     *
+     * @throws ProfileIdentityConflictException
+     */
+    public static function syncProxyFields(?User $user, array $attributes): bool
+    {
+        if (!$user) {
+            return false;
+        }
+
+        $fields = static::isStaffAccount($user) ? ['name'] : ['name', 'email', 'phone', 'timezone', 'avatar_uuid', 'password'];
+        $input  = array_intersect_key($attributes, array_flip($fields));
+
+        if (array_key_exists('email', $input)) {
+            $input['email'] = static::normalizeEmail($input['email']);
+        }
+
+        if (array_key_exists('phone', $input)) {
+            $input['phone'] = static::normalizePhone($input['phone']);
+        }
+
+        $input = array_filter($input, fn ($value, $key) => $value !== null || in_array($key, ['email', 'phone'], true), ARRAY_FILTER_USE_BOTH);
+        $input = array_filter($input, fn ($value, $key) => $key === 'password' || $user->{$key} !== $value, ARRAY_FILTER_USE_BOTH);
+
+        if (empty($input)) {
+            return false;
+        }
+
+        $changedEmail = array_key_exists('email', $input) ? $input['email'] : null;
+        $changedPhone = array_key_exists('phone', $input) ? $input['phone'] : null;
+        $taken        = static::findAccountByIdentity($changedEmail, $changedPhone, $user->uuid);
+        if ($taken) {
+            throw new ProfileIdentityConflictException(static::takenMessage(static::matchedField($taken, $changedEmail)), static::matchedField($taken, $changedEmail));
+        }
+
+        if (isset($input['password'])) {
+            $user->password = $input['password'];
+            unset($input['password']);
+        }
+
+        $user->fill($input);
+
+        return $user->save();
+    }
+
+    /**
+     * Release a profile's account after the profile is deleted. A managed
+     * account with no other profile is deleted, which frees its email and
+     * phone; one still used by another organization's profile only leaves this
+     * organization. Staff accounts are never touched.
+     */
+    public static function releaseForProfile(?User $user, ?string $companyUuid = null): void
+    {
+        if (!static::isManagedAccount($user) || $user->trashed()) {
+            return;
+        }
+
+        $remainingProfiles = static::profileCompanies($user);
+        if ($remainingProfiles->isEmpty()) {
+            $user->delete();
+
+            return;
+        }
+
+        if ($companyUuid && !$remainingProfiles->contains($companyUuid)) {
+            CompanyUser::where(['company_uuid' => $companyUuid, 'user_uuid' => $user->uuid])->delete();
+        }
+    }
+
+    /**
+     * Generate a new password for the account and send it to the profile.
+     *
+     * @return string how the credentials were sent: `email` or `sms`
+     */
+    public static function sendCredentials(Driver|Contact $profile, User $user, ?string $password = null): string
+    {
+        $password ??= Str::random(12);
+        $user->changePassword($password);
+
+        if ($user->status !== 'active') {
+            $user->activate();
+        }
+
+        return static::deliverCredentials($profile, $user, $password);
+    }
+
+    /**
+     * Send already set credentials to the profile by email, or by SMS when the
+     * account has no email.
+     */
+    public static function deliverCredentials(Driver|Contact $profile, User $user, string $password): string
+    {
+        if ($user->email) {
+            Mail::to($user)->send($profile instanceof Driver ? new DriverCredentialsMail($password, $profile, $user) : new CustomerCredentialsMail($password, $profile));
+
+            return 'email';
+        }
+
+        if ($user->phone) {
+            $profile->loadMissing('company');
+            $companyName = $profile->company?->name ?? config('app.name');
+            $identity    = $user->phone;
+            $result      = app(SmsService::class)->send($user->phone, "Your {$companyName} sign-in details. Login: {$identity} Password: {$password}");
+
+            if (is_array($result) && array_key_exists('success', $result) && !$result['success']) {
+                throw new \Exception('The credentials could not be texted: ' . ($result['error'] ?? $result['message'] ?? 'the SMS provider refused it.'));
+            }
+
+            return 'sms';
+        }
+
+        throw new \Exception('This profile has no email or phone to send credentials to.');
+    }
+
+    /**
+     * Throw when the account can't hold the kind of profile being created.
+     *
+     * @throws ProfileIdentityConflictException
+     */
+    public static function assertAccountCanHoldProfile(User $account, string $companyUuid, string $type, string $field = 'email'): void
+    {
+        if (static::isStaffAccount($account)) {
+            if (!static::isCompanyMember($account, $companyUuid)) {
+                throw new ProfileIdentityConflictException(static::takenMessage($field), $field);
+            }
+        } elseif ($account->type !== $type) {
+            throw new ProfileIdentityConflictException('This ' . static::fieldLabel($field) . ' is already used by a ' . $account->type . '.', $field);
+        }
+
+        if (static::hasProfileInCompany($account, $companyUuid, $type)) {
+            throw new ProfileIdentityConflictException('A ' . $type . ' with this ' . static::fieldLabel($field) . ' already exists.', $field);
+        }
+    }
+
+    public static function hasProfileInCompany(User $user, string $companyUuid, string $type): bool
+    {
+        if ($type === 'driver') {
+            return Driver::withoutGlobalScopes()->where(['user_uuid' => $user->uuid, 'company_uuid' => $companyUuid])->whereNull('deleted_at')->exists();
+        }
+
+        return Contact::withoutGlobalScopes()->where(['user_uuid' => $user->uuid, 'company_uuid' => $companyUuid])->whereNull('deleted_at')->exists();
+    }
+
+    /**
+     * The organizations the account still has a driver or contact profile in.
+     */
+    public static function profileCompanies(User $user): \Illuminate\Support\Collection
+    {
+        $drivers  = Driver::withoutGlobalScopes()->where('user_uuid', $user->uuid)->whereNull('deleted_at')->pluck('company_uuid');
+        $contacts = Contact::withoutGlobalScopes()->where('user_uuid', $user->uuid)->whereNull('deleted_at')->pluck('company_uuid');
+
+        return $drivers->merge($contacts)->filter()->unique()->values();
+    }
+
+    public static function isCompanyMember(User $user, ?string $companyUuid): bool
+    {
+        if (!$companyUuid) {
+            return false;
+        }
+
+        return $user->company_uuid === $companyUuid || CompanyUser::where(['company_uuid' => $companyUuid, 'user_uuid' => $user->uuid])->exists();
+    }
+
+    /**
+     * Add a managed account to the organization with its profile role, without
+     * sending an organization invite.
+     */
+    public static function attachToCompany(User $user, string $companyUuid, string $type): ?CompanyUser
+    {
+        $company = Company::where('uuid', $companyUuid)->first();
+        if (!$company) {
+            return null;
+        }
+
+        $role        = static::ROLES[$type] ?? static::ROLES['contact'];
+        $companyUser = CompanyUser::where(['company_uuid' => $companyUuid, 'user_uuid' => $user->uuid])->first();
+        if (!$companyUser) {
+            $companyUser = $company->addUser($user, $role);
+        } elseif (static::isManagedAccount($user)) {
+            $companyUser->assignSingleRole($role);
+        }
+
+        if (!$user->company_uuid) {
+            $user->forceFill(['company_uuid' => $companyUuid])->saveQuietly();
+        }
+
+        $user->setRelation('companyUser', $companyUser);
+
+        return $companyUser;
+    }
+
+    public static function normalizeEmail(?string $email): ?string
+    {
+        $email = is_string($email) ? strtolower(trim($email)) : null;
+
+        return $email ?: null;
+    }
+
+    public static function normalizePhone(?string $phone): ?string
+    {
+        $phone = is_string($phone) ? trim($phone) : null;
+
+        return $phone ? Utils::formatPhoneNumber($phone) : null;
+    }
+
+    private static function matchedField(User $account, ?string $email): string
+    {
+        $email = static::normalizeEmail($email);
+
+        return $email && strtolower((string) $account->email) === $email ? 'email' : 'phone';
+    }
+
+    private static function fieldLabel(string $field): string
+    {
+        return $field === 'phone' ? 'phone number' : 'email';
+    }
+
+    private static function takenMessage(string $field): string
+    {
+        return 'This ' . static::fieldLabel($field) . ' is already in use by another account.';
+    }
+}