SparkPostAdmin::DomainTab() - Code Metrics - Inspection of "fix invalid cache key" - lekoala/silverstripe-sparkpost - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( ff48e5...8d8d50 )

by Thomas
created 2024-04-04 15:09 UTC
SparkPostAdmin::DomainTab() B

↳ Parent: SparkPostAdmin
Complexity

Conditions	6
Paths	4
Size

Total Lines	46
Code Lines	30
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	1	Features	0
Metric	Value
cc	6
eloc	30
c	1
b	1
f	0
nc	4
nop	0
dl	0
loc	46
rs	8.8177
<?php

namespace LeKoala\SparkPost;

use Exception;
use SilverStripe\Forms\Tab;
use SilverStripe\Forms\Form;
use SilverStripe\Forms\TabSet;
use SilverStripe\ORM\ArrayLib;
use SilverStripe\ORM\ArrayList;
use SilverStripe\ORM\DataObject;
use SilverStripe\View\ArrayData;
use SilverStripe\Control\Session;
use SilverStripe\Forms\DateField;
use SilverStripe\Forms\FieldList;
use SilverStripe\Forms\FormField;
use SilverStripe\Forms\TextField;
use SilverStripe\Control\Director;
use SilverStripe\Core\Environment;
use SilverStripe\Forms\FormAction;
use SilverStripe\Admin\LeftAndMain;
use SilverStripe\Forms\HiddenField;
use SilverStripe\Security\Security;
use SilverStripe\View\ViewableData;
use SilverStripe\Forms\LiteralField;
use SilverStripe\Control\Email\Email;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Forms\DropdownField;
use SilverStripe\Security\Permission;
use LeKoala\SparkPost\SparkPostHelper;
use SilverStripe\Control\HTTPResponse;
use SilverStripe\Core\Convert;
use SilverStripe\Forms\CompositeField;
use SilverStripe\SiteConfig\SiteConfig;
use SilverStripe\Forms\GridField\GridField;
use SilverStripe\Security\PermissionProvider;
use SilverStripe\Security\DefaultAdminService;
use SilverStripe\Forms\GridField\GridFieldConfig;
use SilverStripe\Forms\GridField\GridFieldConfig_RecordViewer;
use SilverStripe\Forms\GridField\GridFieldFooter;
use SilverStripe\Forms\GridField\GridFieldDetailForm;
use SilverStripe\Forms\GridField\GridFieldDataColumns;
use Symbiote\GridFieldExtensions\GridFieldTitleHeader;
use SilverStripe\Forms\GridField\GridFieldToolbarHeader;
use SilverStripe\Forms\GridField\GridFieldSortableHeader;
use SilverStripe\Forms\GridField\GridFieldFilterHeader;

/**
 * Allow you to see messages sent through the api key used to send messages
 *
 * @author LeKoala <[email protected]>
 */
class SparkPostAdmin extends LeftAndMain implements PermissionProvider
{
    const MESSAGE_CACHE_MINUTES = 5;
    const WEBHOOK_CACHE_MINUTES = 1440; // 1 day
    const SENDINGDOMAIN_CACHE_MINUTES = 1440; // 1 day

    /**
     * @var string
     */
    private static $menu_title = "SparkPost";


    /**
     * @var string
     */
    private static $url_segment = "sparkpost";


    /**
     * @var string
     */
    private static $menu_icon = "sparkpost/images/sparkpost-icon.png";


    /**
     * @var string
     */
    private static $url_rule = '/$Action/$ID/$OtherID';


    /**
     * @var array<string>
     */
    private static $allowed_actions = [

        'settings',
        'SearchForm',
        'doSearch',
        "doInstallHook",
        "doUninstallHook",
        "doInstallDomain",
        "doUninstallDomain",
        "send_test",
    ];

    /**
     * @var boolean
     */
    private static $cache_enabled = true;

    /**
     * @var bool
     */
    protected $subaccountKey = false;

    /**
     * @var Exception|null
     */
    protected $lastException = null;

    /**
     * @var ViewableData|null
     */
    protected $currentMessage = null;

    /**
     * Inject public dependencies into the controller
     *
     * @var array<string,string>
     */
    private static $dependencies = [

        'logger' => '%$Psr\Log\LoggerInterface',
        'cache' => '%$Psr\SimpleCache\CacheInterface.sparkpost', // see _config/cache.yml
    ];

    /**
     * @var \Psr\Log\LoggerInterface
     */
    public $logger;

    /**
     * @var \Psr\SimpleCache\CacheInterface
     */
    public $cache;

    /**
     * @return void
     */
    public function init()
    {
        parent::init();

        if (isset($_GET['refresh'])) {
            $this->getCache()->clear();
        }
    }

    /**
     * @param HTTPRequest $request
     * @return HTTPResponse
     */
    public function settings($request)
    {
        return parent::index($request);
    }

    /**
     * @param HTTPRequest $request
     * @return HTTPResponse|string
     */
    public function send_test($request)
    {
        if (!$this->CanConfigureApi()) {
            return $this->httpError(404);
        }
        $service = DefaultAdminService::create();
        $to = $request->getVar('to');
        if (!$to) {
            $to = $service->findOrCreateDefaultAdmin()->Email;
        }
        $email = Email::create();
        $email->setSubject("Test email");
        $email->setBody("Test " . date('Y-m-d H:i:s'));
        $email->setTo($to);

        $email->send();
        return 'Email sent';
    }

    /**
     * @return Session
     */
    public function getSession()
    {
        return $this->getRequest()->getSession();
    }

    /**
     * Returns a GridField of messages
     * @param mixed $id
     * @param mixed $fields
     * @return null|Form
     */
    public function getEditForm($id = null, $fields = null)
    {
        if (!$id) {
            $id = $this->currentPageID();
        }

        /** @var DataObject|null $record */
        $record = $this->getRecord($id);

        // Check if this record is viewable
        if ($record && !$record->canView()) {
            $response = Security::permissionFailure($this);
            $this->setResponse($response);
            return null;
        }

        // Build gridfield
        $messageListConfig = GridFieldConfig::create()->addComponents(
            new GridFieldSortableHeader(),
            new GridFieldDataColumns(),
            new GridFieldFooter()
        );

        $messages = $this->Messages();
        if (is_string($messages)) {
            // The api returned an error
            $messagesList = new LiteralField("MessageAlert", $this->MessageHelper($messages, 'bad'));
        } else {
            $messagesList = GridField::create(
                'Messages',
                false,
                $messages,
                $messageListConfig
            )->addExtraClass("messages_grid");

            /** @var GridFieldDataColumns $columns  */
            $columns = $messageListConfig->getComponentByType(GridFieldDataColumns::class);
            $columns->setDisplayFields([
                'transmission_id' => _t('SparkPostAdmin.EventTransmissionId', 'Id'),
                'timestamp' => _t('SparkPostAdmin.EventDate', 'Date'),
                'type' => _t('SparkPostAdmin.EventType', 'Type'),
                'rcpt_to' => _t('SparkPostAdmin.EventRecipient', 'Recipient'),
                'subject' => _t('SparkPostAdmin.EventSubject', 'Subject'),
                'friendly_from' => _t('SparkPostAdmin.EventSender', 'Sender'),
            ]);

            $columns->setFieldFormatting([
                'timestamp' => function ($value, &$item) {
                    return date('Y-m-d H:i:s', strtotime($value));
                },
            ]);

            // Validator setup
            $validator = null;
            if ($record && method_exists($record, 'getValidator')) {
                $validator = $record->getValidator();
            }

            if ($validator) {
                /** @var GridFieldDetailForm|null $detailForm  */
                $detailForm = $messageListConfig->getComponentByType(GridFieldDetailForm::class);
                if ($detailForm) {
                    $detailForm->setValidator($validator);
                }
            }
        }

        // Create tabs
        $messagesTab = new Tab(
            'Messages',
            _t('SparkPostAdmin.Messages', 'Messages'),
            $this->SearchFields(),
            $messagesList,
            // necessary for tree node selection in LeftAndMain.EditForm.js
            new HiddenField('ID', null, 0)
        );

        $fields = new FieldList([
            $root = new TabSet('Root', $messagesTab)
        ]);

        $suppressionsTab = new Tab('Suppressions', _t('SparkPostAdmin.Suppressions', 'Suppressions'));

        // Show the summary
        $summary = $this->getCachedData('suppressionSummary');
        if ($summary) {
            $callback = function ($k, $v) {
                return ArrayData::create([
                    'Title' => $k,
                    'Value' => $v,
                ]);
            };
            $summaryArray = array_map($callback, array_keys($summary), array_values($summary));
            $summaryGrid = GridField::create(
                'SuppressionSummary',
                _t('SparkPostAdmin.Suppressionsummary', 'Suppression summary'),
                new ArrayList($summaryArray)
            );
            //@link https://docs.silverstripe.org/en/5/developer_guides/forms/using_gridfield_with_arbitrary_data/
            $summaryGrid->getConfig()->removeComponentsByType(GridFieldFilterHeader::class);
            /** @var GridFieldDataColumns $columns */
            $columns = $summaryGrid->getConfig()->getComponentByType(GridFieldDataColumns::class);
            $columns->setDisplayFields([
                'Title' => _t('SparkPostAdmin.Title', 'Title'),
                'Value' => _t('SparkPostAdmin.Value', 'Value'),
            ]);
            $suppressionsTab->push($summaryGrid);
        }


        // Show recent suppressions
        $client = SparkPostHelper::getClient();
        $suppressions = $this->getCachedData('searchSuppressions', [
            'from' => $client->createValidDatetime('-90 days')
        ]);
        if ($suppressions) {
            $suppressionGrid = GridField::create(
                'RecentSuppressions',
                _t('SparkPostAdmin.RecentSuppressions', 'Recent suppressions'),
                new ArrayList(array_map(function ($item) {
                    return ArrayData::create($item);
                }, $suppressions))
            );
            //@link https://docs.silverstripe.org/en/5/developer_guides/forms/using_gridfield_with_arbitrary_data/
            $suppressionGrid->getConfig()->removeComponentsByType(GridFieldFilterHeader::class);
            /** @var GridFieldDataColumns $columns */
            $columns = $suppressionGrid->getConfig()->getComponentByType(GridFieldDataColumns::class);
            $columns->setDisplayFields([
                'recipient' => _t('SparkPostAdmin.Recipient', 'Recipient'),
                'type' => _t('SparkPostAdmin.Type', 'Type'),
                'source' => _t('SparkPostAdmin.Source', 'Source'),
                'description' => _t('SparkPostAdmin.Description', 'Description'),
                'created' => _t('SparkPostAdmin.Created', 'Created'),
                // 'updated' => _t('SparkPostAdmin.Updated', 'Updated'),
            ]);
            $suppressionsTab->push($suppressionGrid);
        }

        $fields->addFieldToTab('Root', $suppressionsTab);

        $settingsTab = new Tab('Settings', _t('SparkPostAdmin.Settings', 'Settings'));
        if ($this->CanConfigureApi()) {
            $domainTabData = $this->DomainTab();
            $settingsTab->push($domainTabData);

            // Show webhook options if not using a subaccount key
            if (!SparkPostHelper::getSubaccountId() && self::config()->show_webhook_tab) {
                $webhookTabData = $this->WebhookTab();
                $settingsTab->push($webhookTabData);
            }

            $toolsHtml = '<h2>Tools</h2>';

            // Show default from email
            $defaultEmail = SparkPostHelper::resolveDefaultFromEmail();
            $defaultEmailDisplayed = EmailUtils::stringify($defaultEmail);
            $toolsHtml .= "<p>Default sending email: " . Convert::raw2xml($defaultEmailDisplayed) . " (" . SparkPostHelper::resolveDefaultFromEmailType() . ")</p>";
            if (!SparkPostHelper::isEmailDomainReady($defaultEmailDisplayed)) {
                $toolsHtml .= '<p style="color:red">The default email is not ready to send emails</p>';
            }

            // Show constants
            if (SparkPostHelper::getEnvSendingDisabled()) {
                $toolsHtml .= '<p style="color:red">Sending is disabled by .env configuration</p>';
            }
            if (SparkPostHelper::getEnvEnableLogging()) {
                $toolsHtml .= '<p style="color:orange">Logging is enabled by .env configuration</p>';
            }
            if (SparkPostHelper::getSubaccountId()) {
                $toolsHtml .= '<p style="color:orange">Using subaccount id</p>';
            }
            if (SparkPostHelper::getEnvForceSender()) {
                $toolsHtml .= '<p style="color:orange">Sender is forced to ' . SparkPostHelper::getEnvForceSender() . '</p>';
            }

            // Add a refresh button
            $toolsHtml .= $this->ButtonHelper(
                $this->Link() . '?refresh=true',
                _t('SparkPostAdmin.REFRESH', 'Force data refresh from the API')
            );

            $toolsHtml = $this->FormGroupHelper($toolsHtml);
            $Tools = new LiteralField('Tools', $toolsHtml);
            $settingsTab->push($Tools);

            $fields->addFieldToTab('Root', $settingsTab);
        }

        // Tab nav in CMS is rendered through separate template
        $root->setTemplate('SilverStripe\\Forms\\CMSTabSet');

        // Manage tabs state
        $actionParam = $this->getRequest()->param('Action');
        if ($actionParam == 'setting') {
            $settingsTab->addExtraClass('ui-state-active');
        } elseif ($actionParam == 'messages') {
            $messagesTab->addExtraClass('ui-state-active');
        }

        // Build replacement form
        $form = Form::create(
            $this,
            'EditForm',
            $fields,
            new FieldList()
        )->setHTMLID('Form_EditForm');
        $form->addExtraClass('cms-edit-form fill-height');
        $form->setTemplate($this->getTemplatesWithSuffix('_EditForm'));
        $form->addExtraClass('ss-tabset cms-tabset ' . $this->BaseCSSClasses());
        $form->setAttribute('data-pjax-fragment', 'CurrentForm');

        $this->extend('updateEditForm', $form);

        return $form;
    }

    /**
     * Get logger
     *
     * @return \Psr\Log\LoggerInterface
     */
    public function getLogger()
    {
        return $this->logger;
    }

    /**
     * Get the cache
     *
     * @return \Psr\SimpleCache\CacheInterface
     */
    public function getCache()
    {
        return $this->cache;
    }

    /**
     * @return boolean
     */
    public function getCacheEnabled()
    {
        if (isset($_GET['disable_cache'])) {
            return false;
        }
        if (Environment::getEnv('SPARKPOST_DISABLE_CACHE')) {
            return false;
        }
        $v = $this->config()->cache_enabled;
        if ($v === null) {
            $v = self::$cache_enabled;
        }
        return $v;
    }

    /**
     * A simple cache helper
     *
     * @param string $method
     * @param array<mixed>|null|string|bool $params
     * @param int $expireInSeconds
     * @return array<mixed>|false
     */
    protected function getCachedData($method, $params = null, $expireInSeconds = 60)
    {
        $enabled = $this->getCacheEnabled();
        $cacheResult = false;
        $cache = $this->getCache();
        if ($enabled) {
            $key = $method . '_' . md5(serialize($params));
            $cacheResult = $cache->get($key);
        }
        if ($enabled && $cacheResult) {
            $data = unserialize($cacheResult);
        } else {
            try {
                $client = SparkPostHelper::getClient();
                $data = $client->$method($params);
            } catch (Exception $ex) {
                $this->lastException = $ex;
                $this->getLogger()->debug($ex);
                $data = false;
            }

            //5 minutes cache
            if ($enabled) {
                $cache->set($key, serialize($data), $expireInSeconds);

            }
        }

        return $data;
    }

    /**
     * @return array<mixed>
     */
    public function getParams()
    {
        $params = $this->config()->default_search_params;
        if (!$params) {
            $params = [];
        }
        $data = $this->getSession()->get(__class__ . '.Search');
        if (!$data) {
            $data = [];
        }

        $params = array_merge($params, $data);

        // Respect api formats
        if (!empty($params['to'])) {
            //@phpstan-ignore-next-line
            $params['to'] = date('Y-m-d', strtotime(str_replace('/', '-', $params['to']))) . 'T00:00';
        }
        if (!empty($params['from'])) {
            //@phpstan-ignore-next-line
            $params['from'] = date('Y-m-d', strtotime(str_replace('/', '-', $params['from']))) . 'T23:59';
        }

        $params = array_filter($params);

        return $params;
    }

    /**
     * @param string $name
     * @param mixed $default
     * @return mixed
     */
    public function getParam($name, $default = null)
    {
        $data = $this->getSession()->get(__class__ . '.Search');
        if (!$data) {
            return $default;
        }
        return (isset($data[$name]) && strlen($data[$name])) ? $data[$name] : $default;
    }

    /**
     * @return CompositeField
     */
    public function SearchFields()
    {
        $disabled_filters = $this->config()->disabled_search_filters;
        if (!$disabled_filters) {
            $disabled_filters = [];
        }

        $fields = new CompositeField();
        $fields->push($from = new DateField('params[from]', _t('SparkPostAdmin.DATEFROM', 'From'), $this->getParam('from')));
        // $from->setConfig('min', date('Y-m-d', strtotime('-10 days')));

        $fields->push(new DateField('params[to]', _t('SparkPostAdmin.DATETO', 'To'), $to = $this->getParam('to')));

        if (!in_array('friendly_froms', $disabled_filters)) {
            $fields->push($friendly_froms = new TextField('params[friendly_froms]', _t('SparkPostAdmin.FRIENDLYFROM', 'Sender'), $this->getParam('friendly_froms')));
            $friendly_froms->setAttribute('placeholder', '[email protected],[email protected]');
        }

        if (!in_array('recipients', $disabled_filters)) {
            $fields->push($recipients = new TextField('params[recipients]', _t('SparkPostAdmin.RECIPIENTS', 'Recipients'), $this->getParam('recipients')));
            $recipients->setAttribute('placeholder', '[email protected],[email protected]');
        }

        // Only allow filtering by subaccount if a master key is defined
        if (SparkPostHelper::config()->master_api_key && !in_array('subaccounts', $disabled_filters)) {
            $fields->push($subaccounts = new TextField('params[subaccounts]', _t('SparkPostAdmin.SUBACCOUNTS', 'Subaccounts'), $this->getParam('subaccounts')));
            $subaccounts->setAttribute('placeholder', '101,102');
        }

        $fields->push(new DropdownField('params[per_page]', _t('SparkPostAdmin.PERPAGE', 'Number of results'), array(
            100 => 100,
            500 => 500,
            1000 => 1000,
            10000 => 10000,
        ), $this->getParam('per_page', 100)));

        foreach ($fields->FieldList() as $field) {
            $field->addExtraClass('no-change-track');
        }

        // This is a ugly hack to allow embedding a form into another form
        $fields->push($doSearch = new FormAction('doSearch', _t('SparkPostAdmin.DOSEARCH', 'Search')));
        $doSearch->addExtraClass("btn-primary");
        $doSearch->setAttribute('onclick', "jQuery('#Form_SearchForm').append(jQuery('#Form_EditForm input,#Form_EditForm select').clone()).submit();");

        return $fields;
    }

    /**
     * @return Form
     */
    public function SearchForm()
    {
        $SearchForm = new Form($this, 'SearchForm', new FieldList(), new FieldList([
            new FormAction('doSearch')
        ]));
        $SearchForm->setAttribute('style', 'display:none');
        return $SearchForm;
    }

    /**
     * @param array<mixed> $data
     * @param Form $form
     * @return HTTPResponse
     */
    public function doSearch($data, Form $form)
    {
        $post = $this->getRequest()->postVar('params');
        if (!$post) {
            return $this->redirectBack();
        }
        $params = [];

        $validFields = [];
        foreach ($this->SearchFields()->FieldList()->dataFields() as $field) {
            $validFields[] = str_replace(['params[', ']'], '', $field->getName());
        }

        foreach ($post as $k => $v) {
            if (in_array($k, $validFields)) {
                $params[$k] = $v;
            }
        }

        $this->getSession()->set(__class__ . '.Search', $params);
        $this->getSession()->save($this->getRequest());

        return $this->redirectBack();
    }

    /**
     * List of messages events
     *
     * Messages are cached to avoid hammering the api
     *
     * @return ArrayList|string
     */
    public function Messages()
    {
        $params = $this->getParams();

        $messages = $this->getCachedData('searchEvents', $params, 60 * self::MESSAGE_CACHE_MINUTES);
        if ($messages === false || !$messages) {

            if ($this->lastException) {
                return $this->lastException->getMessage();
            }
            return _t('SparkpostAdmin.NO_MESSAGES', 'No messages');
        }

        // Consolidate Subject/Sender for open and click events
        $transmissions = [];
        foreach ($messages as $message) {
            if (empty($message['transmission_id']) || empty($message['subject'])) {
                continue;
            }
            if (isset($transmissions[$message['transmission_id']])) {
                continue;
            }
            $transmissions[$message['transmission_id']] = $message;
        }

        $list = new ArrayList();
        foreach ($messages as $message) {
            // If we have a transmission id but no subject, try to find the transmission details
            if (isset($message['transmission_id']) && empty($message['subject']) && isset($transmissions[$message['transmission_id']])) {
                $message = array_merge($transmissions[$message['transmission_id']], $message);
            }
            // In some case (errors, etc) we don't have a friendly from
            if (empty($message['friendly_from']) && isset($message['msg_from'])) {
                $message['friendly_from'] = $message['msg_from'];
            }
            $m = new ArrayData($message);
            $list->push($m);
        }

        return $list;
    }

    /**
     * Provides custom permissions to the Security section
     *
     * @return array<string,mixed>
     */
    public function providePermissions()
    {
        $title = _t("SparkPostAdmin.MENUTITLE", LeftAndMain::menu_title('SparkPost'));
        return [
            "CMS_ACCESS_SparkPost" => [
                'name' => _t('SparkPostAdmin.ACCESS', "Access to '{title}' section", ['title' => $title]),
                'category' => _t('Permission.CMS_ACCESS_CATEGORY', 'CMS Access'),
                'help' => _t(
                    'SparkPostAdmin.ACCESS_HELP',
                    'Allow use of SparkPost admin section'
                )
            ],
        ];
    }

    /**
     * Message helper
     *
     * @param string $message
     * @param string $status
     * @return string
     */
    protected function MessageHelper($message, $status = 'info')
    {
        return '<div class="message ' . $status . '">' . $message . '</div>';
    }

    /**
     * Button helper
     *
     * @param string $link
     * @param string $text
     * @param boolean $confirm
     * @return string
     */
    protected function ButtonHelper($link, $text, $confirm = false)
    {
        $link = '<a class="btn btn-primary" href="' . $link . '"';
        if ($confirm) {
            $link .= ' onclick="return confirm(\'' . _t('SparkPostAdmin.CONFIRM_MSG', 'Are you sure?') . '\')"';
        }
        $link .= '>' . $text . '</a>';
        return $link;
    }

    /**
     * Wrap html in a form group
     *
     * @param string $html
     * @return string
     */
    protected function FormGroupHelper($html)
    {
        return '<div class="form-group"><div class="form__fieldgroup form__field-holder form__field-holder--no-label">' . $html . '</div></div>';
    }

    /**
     * A template accessor to check the ADMIN permission
     *
     * @return bool
     */
    public function IsAdmin()
    {
        return boolval(Permission::check("ADMIN"));
    }

    /**
     * Check the permission for current user
     *
     * @return bool
     */
    public function canView($member = null)
    {
        $mailer = SparkPostHelper::getMailer();
        $transport = SparkPostHelper::getTransportFromMailer($mailer);
        // Another custom mailer has been set
        if (!($transport instanceof SparkPostApiTransport)) {
            return false;
        }
        return boolval(Permission::check("CMS_ACCESS_SparkPost", 'any', $member));
    }

    /**
     * @return bool
     */
    public function CanConfigureApi()
    {
        return Permission::check('ADMIN') || Director::isDev();
    }

    /**
     * Check if webhook is installed
     *
     * @return array<mixed>|false
     */
    public function WebhookInstalled()
    {
        $list = $this->getCachedData('listAllWebhooks', null, 60 * self::WEBHOOK_CACHE_MINUTES);

        if (empty($list)) {
            return false;
        }
        $url = $this->WebhookUrl();
        foreach ($list as $el) {
            if (!empty($el['target']) && $el['target'] === $url) {
                /*
                ^ array:13 [▼
  "auth_token" => false
  "auth_type" => "basic"
  "name" => "Testing Webhook"
  "auth_credentials" => array:2 [▶]
  "events" => array:19 [▶]
  "target" => "https://mydomain.com/sparkpost/incoming"
  "custom_headers" => []
  "auth_request_details" => []
  "id" => "xxxxxx"
  "last_successful" => null
  "last_failure" => null
  "active" => false
  "links" => array:1 [▼
    0 => array:3 [▶]
  ]
]
*/
                return $el;
            }
        }
        return false;
    }

    /**
     * Hook details for template
     * @return ArrayData|null
     */
    public function WebhookDetails()
    {
        $el = $this->WebhookInstalled();
        if ($el) {
            return new ArrayData($el);
        }
        return null;
    }

    /**
     * Get content of the tab
     *
     * @return FormField
     */
    public function WebhookTab()
    {
        $webhook = $this->WebhookInstalled();
        if ($webhook) {
            return $this->UninstallHookForm($webhook);
        }
        return $this->InstallHookForm();
    }

    /**
     * @return string
     */
    public function WebhookUrl()
    {
        if (self::config()->webhook_base_url) {
            return rtrim(self::config()->webhook_base_url, '/') . '/sparkpost/incoming';
        }
        if (Director::isLive()) {
            $absurl = Director::absoluteURL('/sparkpost/incoming');
            if ($absurl && is_string($absurl)) {
                return $absurl;
            }
        }
        $protocol = Director::protocol();
        $domain = $this->getDomain();
        if (!$domain) {
            throw new Exception("No domain for webhook");
        }
        return $protocol . $domain . '/sparkpost/incoming';
    }

    /**
     * Install hook form
     *
     * @return FormField
     */
    public function InstallHookForm()
    {
        $fields = new CompositeField();
        $fields->push(new LiteralField('Info', $this->MessageHelper(
            _t('SparkPostAdmin.WebhookNotInstalled', 'Webhook is not installed. It should be configured using the following url {url}. This url must be publicly visible to be used as a hook.', ['url' => $this->WebhookUrl()]),
            'bad'
        )));
        $fields->push(new LiteralField('doInstallHook', $this->ButtonHelper(
            $this->Link('doInstallHook'),
            _t('SparkPostAdmin.DOINSTALL_WEBHOOK', 'Install webhook')
        )));
        return $fields;
    }

    /**
     * @return HTTPResponse
     */
    public function doInstallHook()
    {
        if (!$this->CanConfigureApi()) {
            return $this->redirectBack();
        }

        $client = SparkPostHelper::getClient();

        $url = $this->WebhookUrl();
        $description = SiteConfig::current_site_config()->Title;

        $webhookUser = Environment::getEnv('SS_DEFAULT_ADMIN_USERNAME');
        $webhookPassword = Environment::getEnv('SS_DEFAULT_ADMIN_PASSWORD');

        if (SparkPostHelper::getWebhookUsername()) {
            $webhookUser = SparkPostHelper::getWebhookUsername();
            $webhookPassword = SparkPostHelper::getWebhookPassword();
        }

        try {
            if ($webhookUser && $webhookPassword) {
                $client->createSimpleWebhook($description, $url, null, true, ['username' => $webhookUser, 'password' => $webhookPassword]);
            } else {
                $client->createSimpleWebhook($description, $url); // This will add a default credentials that is sparkpost/sparkpost
            }
            $this->getCache()->clear();
        } catch (Exception $ex) {
            $this->getLogger()->debug($ex);
        }

        return $this->redirectBack();
    }

    /**
     * Uninstall hook form
     *
     * @param array<mixed> $data
     * @return FormField
     */
    public function UninstallHookForm($data)
    {
        $fields = new CompositeField();

        if ($data['active']) {
            $fields->push(new LiteralField('Info', $this->MessageHelper(
                _t('SparkPostAdmin.WebhookInstalled', 'Webhook is installed but inactive at the following url {url}.', ['url' => $this->WebhookUrl()]),
                'warning'
            )));
        } else {
            $fields->push(new LiteralField('Info', $this->MessageHelper(
                _t('SparkPostAdmin.WebhookInstalled', 'Webhook is installed and accessible at the following url {url}.', ['url' => $this->WebhookUrl()]),
                'good'
            )));
        }

        if ($data['last_successful']) {
            $fields->push(new LiteralField('LastSuccess', $this->MessageHelper(
                _t('SparkPostAdmin.WebhookLastSuccess', 'Webhook was last called successfully at {date}.', ['date' => $data['last_successful']]),
                'good'
            )));
        }
        if ($data['last_failure']) {
            $fields->push(new LiteralField('LastFailure', $this->MessageHelper(
                _t('SparkPostAdmin.WebhookLastFailure', 'Webhook last failure was at {date}.', ['date' => $data['last_failure']]),
                'bad'
            )));
        }

        $fields->push(new LiteralField('doUninstallHook', $this->ButtonHelper(
            $this->Link('doUninstallHook'),
            _t('SparkPostAdmin.DOUNINSTALL_WEBHOOK', 'Uninstall webhook'),
            true
        )));
        return $fields;
    }

    /**
     * @param array<mixed> $data
     * @param Form $form
     * @return HTTPResponse
     */
    public function doUninstallHook($data, Form $form)
    {
        if (!$this->CanConfigureApi()) {
            return $this->redirectBack();
        }

        $client = SparkPostHelper::getClient();

        try {
            $el = $this->WebhookInstalled();
            if ($el && !empty($el['id'])) {
                $client->deleteWebhook($el['id']);
            }
            $this->getCache()->clear();
        } catch (Exception $ex) {
            $this->getLogger()->debug($ex);
        }

        return $this->redirectBack();
    }

    /**
     * Check if sending domain is installed
     *
     * @return array<mixed>|false
     */
    public function SendingDomainInstalled()
    {
        $domain = $this->getCachedData('getSendingDomain', $this->getDomain(), 60 * self::SENDINGDOMAIN_CACHE_MINUTES);

        if (empty($domain)) {
            return false;
        }
        return $domain;
    }

    /**
     * Trigger request to check if sending domain is verified
     *
     * @return array<mixed>|false
     */
    public function VerifySendingDomain()
    {
        $client = SparkPostHelper::getClient();

        $host = $this->getDomain();
        if (!$host || is_bool($host)) {
            return false;
        }

        $verification = $client->verifySendingDomain($host);
        if (empty($verification)) {
            return false;
        }
        return $verification;
    }

    /**
     * Get content of the tab
     *
     * @return FormField
     */
    public function DomainTab()
    {
        $defaultDomain = $this->getDomain();
        $defaultDomainInfos = null;

        $domains = $this->getCachedData('listAllSendingDomains', null, 60 * self::SENDINGDOMAIN_CACHE_MINUTES);

        $fields = new CompositeField();

        $list = new ArrayList();
        if ($domains) {
            foreach ($domains as $domain) {
                // Sometimes the api or the cache returns invalid data...
                if (!is_array($domain)) {
                    continue;
                }
                $list->push(new ArrayData([
                    'Domain' => $domain['domain'],
                    'SPF' => $domain['status']['spf_status'],
                    'DKIM' => $domain['status']['dkim_status'],
                    'Compliance' => $domain['status']['compliance_status'],
                    'Verified' => $domain['status']['ownership_verified'],
                ]));

                if ($domain['domain'] == $defaultDomain) {
                    $defaultDomainInfos = $domain;
                }
            }
        }

        $config = GridFieldConfig::create();
        $config->addComponent(new GridFieldToolbarHeader());
        $config->addComponent(new GridFieldTitleHeader());
        $config->addComponent($columns = new GridFieldDataColumns());
        $columns->setDisplayFields(ArrayLib::valuekey(['Domain', 'SPF', 'DKIM', 'Compliance', 'Verified']));
        $domainsList = new GridField('SendingDomains', _t('SparkPostAdmin.ALL_SENDING_DOMAINS', 'Configured sending domains'), $list, $config);
        $domainsList->addExtraClass('mb-2');
        $fields->push($domainsList);

        if (!$defaultDomainInfos) {
            $this->InstallDomainForm($fields);
        } else {
            $this->UninstallDomainForm($fields);
        }

        return $fields;
    }

    /**
     * @return ?string
     */
    public function InboundUrl()
    {
        $subdomain = self::config()->inbound_subdomain;
        $domain = $this->getDomain();
        if ($domain) {
            return $subdomain . '.' . $domain;
        }
        return null;
    }

    /**
     * Get domain name from current host
     *
     * @return boolean|string
     */
    public function getDomainFromHost()
    {
        $base = Environment::getEnv('SS_BASE_URL');
        if (!$base) {
            $base = Director::protocolAndHost();
        }
        $host = parse_url($base, PHP_URL_HOST);
        if (!$host) {
            return false;
        }
        $hostParts = explode('.', $host);
        $parts = count($hostParts);
        if ($parts < 2) {
            return false;
        }
        $domain = $hostParts[$parts - 2] . "." . $hostParts[$parts - 1];
        return $domain;
    }

    /**
     * Get domain from admin email
     *
     * @return boolean|string
     */
    public function getDomainFromEmail()
    {
        $email = SparkPostHelper::resolveDefaultFromEmail(null, false);
        if ($email && is_string($email)) {
            $emailat = (string)strrchr($email, "@");
            $domain = substr($emailat, 1);
            if (!$domain) {
                return false;
            }
            return $domain;
        }
        return false;
    }

    /**
     * Get domain
     *
     * @return boolean|string
     */
    public function getDomain()
    {
        $domain = $this->getDomainFromEmail();
        if (!$domain) {
            return $this->getDomainFromHost();
        }
        return $domain;
    }

    /**
     * Install domain form
     *
     * @param CompositeField $fields
     * @return void
     */
    public function InstallDomainForm(CompositeField $fields)
    {
        $host = $this->getDomain();

        $fields->push(new LiteralField('Info', $this->MessageHelper(
            _t('SparkPostAdmin.DomainNotInstalled', 'Default sending domain {domain} is not installed.', ['domain' => $host]),
            "bad"
        )));
        $fields->push(new LiteralField('doInstallDomain', $this->ButtonHelper(
            $this->Link('doInstallDomain'),
            _t('SparkPostAdmin.DOINSTALLDOMAIN', 'Install domain')
        )));
    }

    /**
     * @return HTTPResponse
     */
    public function doInstallDomain()
    {
        if (!$this->CanConfigureApi()) {
            return $this->redirectBack();
        }

        $client = SparkPostHelper::getClient();

        $domain = $this->getDomain();

        if (!$domain || is_bool($domain)) {
            return $this->redirectBack();
        }

        try {
            $client->createSimpleSendingDomain($domain);
            $this->getCache()->clear();
        } catch (Exception $ex) {
            $this->getLogger()->debug($ex);
        }

        return $this->redirectBack();
    }

    /**
     * Uninstall domain form
     *
     * @param CompositeField $fields
     * @return void
     */
    public function UninstallDomainForm(CompositeField $fields)
    {
        $domainInfos = $this->SendingDomainInstalled();

        $domain = $this->getDomain();

        if ($domainInfos && $domainInfos['status']['ownership_verified']) {
            $fields->push(new LiteralField('Info', $this->MessageHelper(
                _t('SparkPostAdmin.DomainInstalled', 'Default domain {domain} is installed.', ['domain' => $domain]),
                'good'
            )));
        } else {
            $fields->push(new LiteralField('Info', $this->MessageHelper(
                _t('SparkPostAdmin.DomainInstalledBut', 'Default domain {domain} is installed, but is not properly configured.'),
                'warning'
            )));
        }
        $fields->push(new LiteralField('doUninstallHook', $this->ButtonHelper(
            $this->Link('doUninstallHook'),
            _t('SparkPostAdmin.DOUNINSTALLDOMAIN', 'Uninstall domain'),
            true
        )));
    }

    /**
     * @param array<mixed> $data
     * @param Form $form
     * @return HTTPResponse
     */
    public function doUninstallDomain($data, Form $form)
    {
        if (!$this->CanConfigureApi()) {
            return $this->redirectBack();
        }

        $client = SparkPostHelper::getClient();

        $domain = $this->getDomain();

        if (!$domain || is_bool($domain)) {
            return $this->redirectBack();
        }

        try {
            $el = $this->SendingDomainInstalled();
            if ($el) {
                $client->deleteSendingDomain($domain);
            }
            $this->getCache()->clear();
        } catch (Exception $ex) {
            $this->getLogger()->debug($ex);
        }

        return $this->redirectBack();
    }
}

lekoala / silverstripe-sparkpost

Push — master ( ff48e5...8d8d50 )

SparkPostAdmin::DomainTab() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
