Stand: SMTP-Test, Admin-Mail-Tab, Notifiable-Fix, Lazy-Quill

- Fix: Notifiable-Trait zum User-Model hinzugefuegt (behebt notify()-500er)
- Installer: SMTP-Verbindungstest mit EsmtpTransport + Ueberspringen-Link
- Admin: Neuer E-Mail-Tab mit SMTP-Konfiguration + Verbindungstest
- Admin: Lazy Quill-Initialisierung (nur sichtbare Locale wird geladen)
- Uebersetzungen: 17 neue Mail-Keys in allen 6 Sprachen

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

vendor/egulias/email-validator/src/Validation/DNSCheckValidation.php

@@ -0,0 +1,211 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\DomainAcceptsNoMail;
+use Egulias\EmailValidator\Result\Reason\LocalOrReservedDomain;
+use Egulias\EmailValidator\Result\Reason\NoDNSRecord as ReasonNoDNSRecord;
+use Egulias\EmailValidator\Result\Reason\UnableToGetDNSRecord;
+use Egulias\EmailValidator\Warning\NoDNSMXRecord;
+use Egulias\EmailValidator\Warning\Warning;
+
+class DNSCheckValidation implements EmailValidation
+{
+
+    /**
+     * Reserved Top Level DNS Names (https://tools.ietf.org/html/rfc2606#section-2),
+     * mDNS and private DNS Namespaces (https://tools.ietf.org/html/rfc6762#appendix-G)
+     * 
+     * @var string[]
+     */
+    public const RESERVED_DNS_TOP_LEVEL_NAMES = [
+        // Reserved Top Level DNS Names
+        'test',
+        'example',
+        'invalid',
+        'localhost',
+
+        // mDNS
+        'local',
+
+        // Private DNS Namespaces
+        'intranet',
+        'internal',
+        'private',
+        'corp',
+        'home',
+        'lan',
+    ];
+
+    /**
+     * @var Warning[]
+     */
+    private $warnings = [];
+
+    /**
+     * @var InvalidEmail|null
+     */
+    private $error;
+
+    /**
+     * @var array
+     */
+    private $mxRecords = [];
+
+    /**
+     * @var DNSGetRecordWrapper
+     */
+    private $dnsGetRecord;
+
+    public function __construct(?DNSGetRecordWrapper $dnsGetRecord = null)
+    {
+        if (!function_exists('idn_to_ascii')) {
+            throw new \LogicException(sprintf('The %s class requires the Intl extension.', __CLASS__));
+        }
+
+        if ($dnsGetRecord == null) {
+            $dnsGetRecord = new DNSGetRecordWrapper();
+        }
+
+        $this->dnsGetRecord = $dnsGetRecord;
+    }
+
+    public function isValid(string $email, EmailLexer $emailLexer): bool
+    {
+        // use the input to check DNS if we cannot extract something similar to a domain
+        $host = $email;
+
+        // Arguable pattern to extract the domain. Not aiming to validate the domain nor the email
+        if (false !== $lastAtPos = strrpos($email, '@')) {
+            $host = substr($email, $lastAtPos + 1);
+        }
+
+        // Get the domain parts
+        $hostParts = explode('.', $host);
+
+        $isLocalDomain = count($hostParts) <= 1;
+        $isReservedTopLevel = in_array($hostParts[(count($hostParts) - 1)], self::RESERVED_DNS_TOP_LEVEL_NAMES, true);
+
+        // Exclude reserved top level DNS names
+        if ($isLocalDomain || $isReservedTopLevel) {
+            $this->error = new InvalidEmail(new LocalOrReservedDomain(), $host);
+            return false;
+        }
+
+        return $this->checkDns($host);
+    }
+
+    public function getError(): ?InvalidEmail
+    {
+        return $this->error;
+    }
+
+    /**
+     * @return Warning[]
+     */
+    public function getWarnings(): array
+    {
+        return $this->warnings;
+    }
+
+    /**
+     * @param string $host
+     *
+     * @return bool
+     */
+    protected function checkDns($host)
+    {
+        $variant = INTL_IDNA_VARIANT_UTS46;
+
+        $host = rtrim(idn_to_ascii($host, IDNA_DEFAULT, $variant), '.');
+
+        $hostParts = explode('.', $host);
+        $host = array_pop($hostParts);
+
+        while (count($hostParts) > 0) {
+            $host = array_pop($hostParts) . '.' . $host;
+
+            if ($this->validateDnsRecords($host)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+    /**
+     * Validate the DNS records for given host.
+     *
+     * @param string $host A set of DNS records in the format returned by dns_get_record.
+     *
+     * @return bool True on success.
+     */
+    private function validateDnsRecords($host): bool
+    {
+        $dnsRecordsResult = $this->dnsGetRecord->getRecords($host, DNS_A + DNS_MX);
+
+        if ($dnsRecordsResult->withError()) {
+            $this->error = new InvalidEmail(new UnableToGetDNSRecord(), '');
+            return false;
+        }
+
+        $dnsRecords = $dnsRecordsResult->getRecords();
+
+        // Combined check for A+MX+AAAA can fail with SERVFAIL, even in the presence of valid A/MX records
+        $aaaaRecordsResult = $this->dnsGetRecord->getRecords($host, DNS_AAAA);
+
+        if (! $aaaaRecordsResult->withError()) {
+            $dnsRecords = array_merge($dnsRecords, $aaaaRecordsResult->getRecords());
+        }
+
+        // No MX, A or AAAA DNS records
+        if ($dnsRecords === []) {
+            $this->error = new InvalidEmail(new ReasonNoDNSRecord(), '');
+            return false;
+        }
+
+        // For each DNS record
+        foreach ($dnsRecords as $dnsRecord) {
+            if (!$this->validateMXRecord($dnsRecord)) {
+                // No MX records (fallback to A or AAAA records)
+                if (empty($this->mxRecords)) {
+                    $this->warnings[NoDNSMXRecord::CODE] = new NoDNSMXRecord();
+                }
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Validate an MX record
+     *
+     * @param array $dnsRecord Given DNS record.
+     *
+     * @return bool True if valid.
+     */
+    private function validateMxRecord($dnsRecord): bool
+    {
+        if (!isset($dnsRecord['type'])) {
+            $this->error = new InvalidEmail(new ReasonNoDNSRecord(), '');
+            return false;
+        }
+
+        if ($dnsRecord['type'] !== 'MX') {
+            return true;
+        }
+
+        // "Null MX" record indicates the domain accepts no mail (https://tools.ietf.org/html/rfc7505)
+        if (empty($dnsRecord['target']) || $dnsRecord['target'] === '.') {
+            $this->error = new InvalidEmail(new DomainAcceptsNoMail(), "");
+            return false;
+        }
+
+        $this->mxRecords[] = $dnsRecord;
+
+        return true;
+    }
+}

vendor/egulias/email-validator/src/Validation/DNSGetRecordWrapper.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation;
+
+class DNSGetRecordWrapper
+{
+    /**
+     * @param string $host
+     * @param int $type
+     *
+     * @return DNSRecords
+     */
+    public function getRecords(string $host, int $type): DNSRecords
+    {
+        // A workaround to fix https://bugs.php.net/bug.php?id=73149
+        set_error_handler(
+            static function (int $errorLevel, string $errorMessage): never {
+                throw new \RuntimeException("Unable to get DNS record for the host: $errorMessage");
+            }
+        );
+        try {
+            // Get all MX, A and AAAA DNS records for host
+            return new DNSRecords(dns_get_record($host, $type));
+        } catch (\RuntimeException $exception) {
+            return new DNSRecords([], true);
+        } finally {
+            restore_error_handler();
+        }
+    }
+}

vendor/egulias/email-validator/src/Validation/DNSRecords.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation;
+
+class DNSRecords
+{
+    /**
+     * @param list<array<array-key, mixed>> $records
+     * @param bool $error
+     */
+    public function __construct(private readonly array $records, private readonly bool $error = false)
+    {
+    }
+
+    /**
+     * @return list<array<array-key, mixed>>
+     */
+    public function getRecords(): array
+    {
+        return $this->records;
+    }
+
+    public function withError(): bool
+    {
+        return $this->error;
+    }
+}

vendor/egulias/email-validator/src/Validation/EmailValidation.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Warning\Warning;
+
+interface EmailValidation
+{
+    /**
+     * Returns true if the given email is valid.
+     *
+     * @param string     $email      The email you want to validate.
+     * @param EmailLexer $emailLexer The email lexer.
+     *
+     * @return bool
+     */
+    public function isValid(string $email, EmailLexer $emailLexer) : bool;
+
+    /**
+     * Returns the validation error.
+     *
+     * @return InvalidEmail|null
+     */
+    public function getError() : ?InvalidEmail;
+
+    /**
+     * Returns the validation warnings.
+     *
+     * @return Warning[]
+     */
+    public function getWarnings() : array;
+}

vendor/egulias/email-validator/src/Validation/Exception/EmptyValidationList.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation\Exception;
+
+use Exception;
+
+class EmptyValidationList extends \InvalidArgumentException
+{
+    /**
+    * @param int $code
+    */
+    public function __construct($code = 0, ?Exception $previous = null)
+    {
+        parent::__construct("Empty validation list is not allowed", $code, $previous);
+    }
+}

vendor/egulias/email-validator/src/Validation/Extra/SpoofCheckValidation.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation\Extra;
+
+use \Spoofchecker;
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\SpoofEmail;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Validation\EmailValidation;
+
+class SpoofCheckValidation implements EmailValidation
+{
+    /**
+     * @var InvalidEmail|null
+     */
+    private $error;
+
+    public function __construct()
+    {
+        if (!extension_loaded('intl')) {
+            throw new \LogicException(sprintf('The %s class requires the Intl extension.', __CLASS__));
+        }
+    }
+
+    public function isValid(string $email, EmailLexer $emailLexer) : bool
+    {
+        $checker = new Spoofchecker();
+        $checker->setChecks(Spoofchecker::SINGLE_SCRIPT);
+
+        if ($checker->isSuspicious($email)) {
+            $this->error = new SpoofEmail();
+        }
+
+        return $this->error === null;
+    }
+
+    public function getError() : ?InvalidEmail
+    {
+        return $this->error;
+    }
+
+    public function getWarnings() : array
+    {
+        return [];
+    }
+}

vendor/egulias/email-validator/src/Validation/MessageIDValidation.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\MessageIDParser;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\ExceptionFound;
+use Egulias\EmailValidator\Warning\Warning;
+
+class MessageIDValidation implements EmailValidation
+{
+
+    /**
+     * @var Warning[]
+     */
+    private $warnings = [];
+
+    /**
+     * @var ?InvalidEmail
+     */
+    private $error;
+
+    public function isValid(string $email, EmailLexer $emailLexer): bool
+    {
+        $parser = new MessageIDParser($emailLexer);
+        try {
+            $result = $parser->parse($email);
+            $this->warnings = $parser->getWarnings();
+            if ($result->isInvalid()) {
+                /** @psalm-suppress PropertyTypeCoercion */
+                $this->error = $result;
+                return false;
+            }
+        } catch (\Exception $invalid) {
+            $this->error = new InvalidEmail(new ExceptionFound($invalid), '');
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * @return Warning[]
+     */
+    public function getWarnings(): array
+    {
+        return $this->warnings;
+    }
+
+    public function getError(): ?InvalidEmail
+    {
+        return $this->error;
+    }
+}

vendor/egulias/email-validator/src/Validation/MultipleValidationWithAnd.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Validation\Exception\EmptyValidationList;
+use Egulias\EmailValidator\Result\MultipleErrors;
+use Egulias\EmailValidator\Warning\Warning;
+
+class MultipleValidationWithAnd implements EmailValidation
+{
+    /**
+     * If one of validations fails, the remaining validations will be skipped.
+     * This means MultipleErrors will only contain a single error, the first found.
+     */
+    public const STOP_ON_ERROR = 0;
+
+    /**
+     * All of validations will be invoked even if one of them got failure.
+     * So MultipleErrors will contain all causes.
+     */
+    public const ALLOW_ALL_ERRORS = 1;
+
+    /**
+     * @var Warning[]
+     */
+    private $warnings = [];
+
+    /**
+     * @var MultipleErrors|null
+     */
+    private $error;
+
+    /**
+     * @param EmailValidation[] $validations The validations.
+     * @param int               $mode        The validation mode (one of the constants).
+     */
+    public function __construct(private readonly array $validations, private readonly int $mode = self::ALLOW_ALL_ERRORS)
+    {
+        if (count($validations) == 0) {
+            throw new EmptyValidationList();
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isValid(string $email, EmailLexer $emailLexer): bool
+    {
+        $result = true;
+        foreach ($this->validations as $validation) {
+            $emailLexer->reset();
+            $validationResult = $validation->isValid($email, $emailLexer);
+            $result = $result && $validationResult;
+            $this->warnings = [...$this->warnings, ...$validation->getWarnings()];
+            if (!$validationResult) {
+                $this->processError($validation);
+            }
+
+            if ($this->shouldStop($result)) {
+                break;
+            }
+        }
+
+        return $result;
+    }
+
+    private function initErrorStorage(): void
+    {
+        if (null === $this->error) {
+            $this->error = new MultipleErrors();
+        }
+    }
+
+    private function processError(EmailValidation $validation): void
+    {
+        if (null !== $validation->getError()) {
+            $this->initErrorStorage();
+            /** @psalm-suppress PossiblyNullReference */
+            $this->error->addReason($validation->getError()->reason());
+        }
+    }
+
+    private function shouldStop(bool $result): bool
+    {
+        return !$result && $this->mode === self::STOP_ON_ERROR;
+    }
+
+    /**
+     * Returns the validation errors.
+     */
+    public function getError(): ?InvalidEmail
+    {
+        return $this->error;
+    }
+
+    /**
+     * @return Warning[]
+     */
+    public function getWarnings(): array
+    {
+        return $this->warnings;
+    }
+}

vendor/egulias/email-validator/src/Validation/NoRFCWarningsValidation.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\RFCWarnings;
+
+class NoRFCWarningsValidation extends RFCValidation
+{
+    /**
+     * @var InvalidEmail|null
+     */
+    private $error;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isValid(string $email, EmailLexer $emailLexer) : bool
+    {
+        if (!parent::isValid($email, $emailLexer)) {
+            return false;
+        }
+
+        if (empty($this->getWarnings())) {
+            return true;
+        }
+
+        $this->error = new InvalidEmail(new RFCWarnings(), '');
+
+        return false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getError() : ?InvalidEmail
+    {
+        return $this->error ?: parent::getError();
+    }
+}

vendor/egulias/email-validator/src/Validation/RFCValidation.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Egulias\EmailValidator\Validation;
+
+use Egulias\EmailValidator\EmailLexer;
+use Egulias\EmailValidator\EmailParser;
+use Egulias\EmailValidator\Result\InvalidEmail;
+use Egulias\EmailValidator\Result\Reason\ExceptionFound;
+use Egulias\EmailValidator\Warning\Warning;
+
+class RFCValidation implements EmailValidation
+{
+    /**
+     * @var Warning[]
+     */
+    private array $warnings = [];
+
+    /**
+     * @var ?InvalidEmail
+     */
+    private $error;
+
+    public function isValid(string $email, EmailLexer $emailLexer): bool
+    {
+        $parser = new EmailParser($emailLexer);
+        try {
+            $result = $parser->parse($email);
+            $this->warnings = $parser->getWarnings();
+            if ($result->isInvalid()) {
+                /** @psalm-suppress PropertyTypeCoercion */
+                $this->error = $result;
+                return false;
+            }
+        } catch (\Exception $invalid) {
+            $this->error = new InvalidEmail(new ExceptionFound($invalid), '');
+            return false;
+        }
+
+        return true;
+    }
+
+    public function getError(): ?InvalidEmail
+    {
+        return $this->error;
+    }
+
+    /**
+     * @return Warning[]
+     */
+    public function getWarnings(): array
+    {
+        return $this->warnings;
+    }
+}