MailConfigChecker/Application/Controller/Admin/SpfChecker.php

<?php

/**
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * https://www.d3data.de
 *
 * @copyright (C) D3 Data Development (Inh. Thomas Dartsch)
 * @author    D3 Data Development - Daniel Seifert <info@shopmodule.com>
 * @link      https://www.oxidmodule.com
 */

declare(strict_types=1);

namespace D3\MailConfigChecker\Application\Controller\Admin;

use Assert\InvalidArgumentException;
use D3\MailAuthenticationCheck\DMARCCheck;
use D3\MailAuthenticationCheck\Model\DMARCResult;
use D3\MailConfigChecker\Application\Model\DmarcResult as OxDmarcResult;
use D3\MailConfigChecker\Application\Model\SpfResult;
use Mika56\SPFCheck\DNS\DNSRecordGetter;
use Mika56\SPFCheck\Model\Query;
use Mika56\SPFCheck\Model\Result;
use Mika56\SPFCheck\SPFCheck;
use OxidEsales\Eshop\Application\Controller\Admin\AdminDetailsController;
use OxidEsales\Eshop\Application\Model\Shop;
use OxidEsales\Eshop\Core\Registry;

class SpfChecker extends AdminDetailsController
{
    protected $_sThisTemplate = 'spfCheck.tpl';

    public function render()
    {
        $this->checkSpf();
        $this->checkDmarc();
        return parent::render();
    }

    protected function checkSpf()
    {
        $result = [];
        $mailDomains = $this->getMailDomains();
        array_walk(
            $mailDomains,
            function ($domain) use (&$result) {
                $this->checkSpfByDomain($domain, $result);
            }
        );

        $this->addTplParam('spf_result', $result);
    }

    protected function checkDmarc()
    {
        $result = [];
        $mailDomains = $this->getMailDomains();
        array_walk(
            $mailDomains,
            function ($domain) use (&$result) {
                $this->checkDmarcByDomain($domain, $result);
            }
        );

        $this->addTplParam('dmarc_result', $result);
    }

    protected function getMailDomains(): array
    {
        /** @var Shop $shop */
        $shop = Registry::getConfig()->getActiveShop();

        return
            array_filter(
                array_unique(
                    array_map(
                        function ($mailAddress) {
                            $mailAddress = trim($mailAddress);
                            try {
                                if (! strstr($mailAddress, '@')) {
                                    throw oxNew(InvalidArgumentException::class);
                                }
                                $addressChunks = explode('@', $mailAddress);

                                return array_pop($addressChunks);
                            } catch (InvalidArgumentException $e) {
                                return '';
                            }
                        },
                        [
                            $shop->getFieldData('oxinfoemail'),
                            $shop->getFieldData('oxorderemail'),
                            $shop->getFieldData('oxowneremail'),
                        ]
                    )
                )
            );
    }

    protected function checkSpfByDomain($domain, &$summarize)
    {
        $checker = new SPFCheck(new DNSRecordGetter());
        $query = new Query('', $domain);

        $result = $checker->getResult($query);
        switch ($result->getResult()) {
            case Result::FAIL:
            case Result::NEUTRAL:
            case Result::PASS:
            case Result::SOFTFAIL:
                $status = SpfResult::SET;
                break;
            case Result::NONE:
                $status = SpfResult::MISSING;
                break;
            default:
                $status = SpfResult::ERROR;
        }

        $rawRecord = ($record = $result->getRecord()) ?
            $record->getRawRecord() :
            null;

        $summarize[$domain] = oxNew(SpfResult::class, $status, $rawRecord);
    }

    public function getSpfStatusColor(SpfResult $result)
    {
        switch ($result->getStatus()) {
            case SpfResult::SET:
                return 'success';
            case SpfResult::ERROR:
                return 'warning';
            default:
                return 'danger';
        }
    }

    public function checkDmarcByDomain($domain, &$summarize)
    {
        try {
            $check = new DMARCCheck(new DNSRecordGetter());
            $query = new Query('', $domain);
            $record = $check->getResult($query)->getRecord();

            switch ( $record->getRejectPolicy()->getValue() ) {
                case DMARCResult::REJECT_QUARANTINE:
                case DMARCResult::REJECT_REJECT:
                    $status = OxDmarcResult::SET;
                    break;
                case DMARCResult::REJECT_NONE:
                    $status = OxDmarcResult::MISSING;
                    break;
                default:
                    $status = OxDmarcResult::ERROR;
            }

            $summarize[$domain] = oxNew( OxDmarcResult::class, $status, $record->getRawRecord());
        } catch (\LogicException) {
            $summarize[$domain] = oxNew( OxDmarcResult::class, OxDmarcResult::MISSING, '');
        }
    }

    public function getDmarcStatusColor(OxDmarcResult $result)
    {
        switch ($result->getStatus()) {
            case SpfResult::SET:
                return 'success';
            case SpfResult::ERROR:
                return 'warning';
            default:
                return 'danger';
        }
    }
}