LeKoala\SparkPost\SparkPostHelper

Complexity

Total Complexity

75

Size/Duplication

Total Lines	431
Duplicated Lines	0 %

Importance

Changes	7
Bugs	1	Features	2

29 Methods

Rating	Name	Duplication	Size	Complexity
A	getMailer()	0	3	1
A	getClient()	0	20	6
A	isAdminEmail()	0	9	3
B	resolveDefaultFromEmail()	0	28	9
A	getHeaders()	0	3	2
A	getMasterClient()	0	8	2
A	getEnvForceSender()	0	3	1
A	getEnvSendingDisabled()	0	3	1
A	getApiKey()	0	3	1
A	getLogFolder()	0	7	2
A	createDefaultEmail()	0	10	2
A	getEnvEnableLogging()	0	3	1
A	getEnvSubaccountId()	0	3	1
A	getLoggingEnabled()	0	6	2
A	forceAdminEmailOverride()	0	3	1
A	getSendingEnabled()	0	6	2
A	isDefaultEmail()	0	4	1
A	getEnvApiKey()	0	3	1
A	getWebhookPassword()	0	3	1
A	getSubaccountId()	0	3	1
B	resolveDefaultToEmail()	0	22	8
A	resolveDefaultFromEmailType()	0	11	3
A	getTransportFromMailer()	0	6	1
A	getSenderFromSiteConfig()	0	8	3
A	registerTransport()	0	8	1
B	init()	0	33	8
A	getWebhookUsername()	0	3	1
A	getEnvMasterApiKey()	0	3	1
B	isEmailDomainReady()	0	28	8

<?php

namespace LeKoala\SparkPost;

use Exception;
use ReflectionObject;
use SilverStripe\Control\Director;
use SilverStripe\Core\Environment;
use SilverStripe\Core\Config\Config;
use Symfony\Component\Mailer\Mailer;
use SilverStripe\Control\Email\Email;
use SilverStripe\SiteConfig\SiteConfig;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Core\Config\Configurable;
use LeKoala\SparkPost\Api\SparkPostApiClient;
use Symfony\Component\Mailer\MailerInterface;

/**
 * This configurable class helps decoupling the api client from SilverStripe
 */
class SparkPostHelper
{
    use Configurable;

    const FROM_SITECONFIG = "SiteConfig";
    const FROM_ADMIN = "Admin";
    const FROM_DEFAULT = "Default";

    /**
     * Client instance
     *
     * @var SparkPostApiClient
     */
    protected static $client;

    /**
     * Get the mailer instance
     *
     * @return MailerInterface
     */
    public static function getMailer()
    {
        return Injector::inst()->get(MailerInterface::class);
    }

    /**
     * Useful when dealing with legacy code
     *
     * @param Email $Email
     * @return \Symfony\Component\Mime\Header\Headers|Swift_Mime_SimpleHeaderSet

The type LeKoala\SparkPost\Swift_Mime_SimpleHeaderSet was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public static function getHeaders($Email)
    {
        return method_exists($Email, 'getSwiftMessage') ? $Email->getSwiftMessage()->getHeaders() : $Email->getHeaders();
    }

    /**
     * @param MailerInterface $mailer
     * @return AbstractTransport|SparkpostApiTransport

The type LeKoala\SparkPost\AbstractTransport was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    public static function getTransportFromMailer($mailer)
    {
        $r = new ReflectionObject($mailer);
        $p = $r->getProperty('transport');
        $p->setAccessible(true);
        return $p->getValue($mailer);
    }

    /**
     * @return string
     */
    public static function getApiKey()
    {
        return self::config()->api_key;
    }

    /**
     * Get the api client instance
     * @return SparkPostApiClient
     * @throws Exception
     */
    public static function getClient()
    {
        if (!self::$client) {
            $key = self::getApiKey();
            if (empty($key)) {
                throw new \Exception("api_key is not configured for " . __class__);
            }
            self::$client = new SparkPostApiClient($key);
            if (Director::isDev()) {
                self::$client->setCurlOption(CURLOPT_VERBOSE, true);
            }
            if (Environment::getEnv("SPARKPOST_EU")) {
                self::$client->setEuEndpoint(true);

true of type true is incompatible with the type string expected by parameter $euEndpoint of LeKoala\SparkPost\Api\SparkPostApiClient::setEuEndpoint().

            }
            $subaccountId = self::config()->subaccount_id;
            if ($subaccountId) {
                self::$client->setSubaccount($subaccountId);
            }
        }
        return self::$client;
    }

    /**
     * Get the api client instance
     * @return LeKoala\SparkPost\Api\SparkPostApiClient

The type LeKoala\SparkPost\LeKoala\SparkPost\Api\SparkPostApiClient was not found. Did you mean LeKoala\SparkPost\Api\SparkPostApiClient? If so, make sure to prefix the type with \.

     *
     * @throws Exception
     */
    public static function getMasterClient()
    {
        $masterKey = self::config()->master_api_key;
        if (!$masterKey) {
            return self::getClient();

The expression return self::getClient() returns the type LeKoala\SparkPost\Api\SparkPostApiClient which is incompatible with the documented return type LeKoala\SparkPost\LeKoala\SparkPost\Api\SparkPostApiClient.

        }
        $client = new SparkPostApiClient($masterKey);
        return $client;

The expression return $client returns the type LeKoala\SparkPost\Api\SparkPostApiClient which is incompatible with the documented return type LeKoala\SparkPost\LeKoala\SparkPost\Api\SparkPostApiClient.

    }

    /**
     * Get the log folder and create it if necessary
     *
     * @return string
     */
    public static function getLogFolder()
    {
        $logFolder = BASE_PATH . '/' . self::config()->log_folder;
        if (!is_dir($logFolder)) {
            mkdir($logFolder, 0755, true);
        }
        return $logFolder;
    }


    /**
     * Process environment variable to configure this module
     *
     * @return void
     */
    public static function init()
    {
        // Regular api key used for sending emails (including subaccount support)
        $api_key = self::getEnvApiKey();
        if ($api_key) {
            self::config()->api_key = $api_key;
        }

        // Master api key that is used to configure the account. If no api key is defined, the master api key is used
        $master_api_key = self::getEnvMasterApiKey();
        if ($master_api_key) {
            self::config()->master_api_key = $master_api_key;
            if (!self::config()->api_key) {
                self::config()->api_key = $master_api_key;
            }
        }

        $sending_disabled = self::getEnvSendingDisabled();
        if ($sending_disabled) {
            self::config()->disable_sending = $sending_disabled;
        }
        $enable_logging = self::getEnvEnableLogging();
        if ($enable_logging) {
            self::config()->enable_logging = $enable_logging;
        }
        $subaccount_id = self::getEnvSubaccountId();
        if ($subaccount_id) {
            self::config()->subaccount_id = $subaccount_id;
        }

        // We have a key, we can register the transport
        if (self::config()->api_key) {
            self::registerTransport();
        }
    }

    public static function getEnvApiKey()
    {
        return Environment::getEnv('SPARKPOST_API_KEY');
    }

    public static function getEnvMasterApiKey()
    {
        return Environment::getEnv('SPARKPOST_MASTER_API_KEY');
    }

    public static function getEnvSendingDisabled()
    {
        return Environment::getEnv('SPARKPOST_SENDING_DISABLED');
    }

    public static function getEnvEnableLogging()
    {
        return  Environment::getEnv('SPARKPOST_ENABLE_LOGGING');
    }

    public static function getEnvSubaccountId()
    {
        return  Environment::getEnv('SPARKPOST_SUBACCOUNT_ID');
    }

    public static function getSubaccountId()
    {
        return self::config()->subaccount_id;
    }

    public static function getEnvForceSender()
    {
        return Environment::getEnv('SPARKPOST_FORCE_SENDER');
    }

    public static function getWebhookUsername()
    {
        return self::config()->webhook_username;
    }

    public static function getWebhookPassword()
    {
        return self::config()->webhook_password;
    }

    /**
     * Register the transport with the client
     *
     * @return SparkPostApiTransport The updated mailer
     * @throws Exception
     */
    public static function registerTransport()
    {
        $client = self::getClient();
        $mailer = self::getMailer();

The assignment to $mailer is dead and can be removed.

        $transport = new SparkPostApiTransport($client);
        $mailer = new Mailer($transport);
        Injector::inst()->registerService($mailer, MailerInterface::class);
        return $mailer;

The expression return $mailer returns the type Symfony\Component\Mailer\Mailer which is incompatible with the documented return type LeKoala\SparkPost\SparkPostApiTransport.

    }

    /**
     * Update admin email so that we use our config email
     *
     * @return void
     */
    public static function forceAdminEmailOverride()
    {
        Config::modify()->set(Email::class, 'admin_email', self::resolveDefaultFromEmailType());
    }

    /**
     * Check if email is ready to send emails
     *
     * @param string $email
     * @return boolean
     */
    public static function isEmailDomainReady($email)
    {
        if (!$email) {
            return false;
        }
        $parts = explode("@", $email);
        if (count($parts) != 2) {
            return false;
        }
        $client = SparkPostHelper::getClient();
        try {
            $domain = $client->getSendingDomain(strtolower($parts[1]));
        } catch (Exception $ex) {
            return false;
        }
        if (!$domain) {

The expression $domain of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return false;
        }
        if ($domain['status']['dkim_status'] != 'valid') {
            return false;
        }
        if ($domain['status']['compliance_status'] != 'valid') {
            return false;
        }
        if ($domain['status']['ownership_verified'] != true) {
            return false;
        }
        return true;
    }

    /**
     * Resolve default send from address
     *
     * Keep in mind that an email using send() without a from
     * will inject the admin_email. Therefore, SiteConfig
     * will not be used
     * See forceAdminEmailOverride() or use override_admin_email config
     *
     * @param string $from
     * @param bool $createDefault
     * @return string
     */
    public static function resolveDefaultFromEmail($from = null, $createDefault = true)
    {
        $configEmail = self::getSenderFromSiteConfig();
        $original_from = $from;
        if (!empty($from)) {
            // We have a set email but sending from admin => override if flag is set
            if (self::isAdminEmail($from) && $configEmail && self::config()->override_admin_email) {
                return $configEmail;
            }
            // If we have a sender, validate its email
            $from = EmailUtils::get_email_from_rfc_email($from);
            if (filter_var($from, FILTER_VALIDATE_EMAIL)) {
                return $original_from;
            }
        }
        // Look in siteconfig for default sender
        if ($configEmail) {
            return $configEmail;
        }
        // Use admin email if set
        if ($admin = Email::config()->admin_email) {
            return $admin;
        }
        // If we still don't have anything, create something based on the domain
        if ($createDefault) {
            return self::createDefaultEmail();
        }
        return false;

The expression return false returns the type false which is incompatible with the documented return type string.

    }

    /**
     * Returns what type of default email is used
     *
     * @return string
     */
    public static function resolveDefaultFromEmailType()
    {
        // Look in siteconfig for default sender
        if (self::getSenderFromSiteConfig()) {
            return self::FROM_SITECONFIG;
        }
        // Is admin email set ?
        if (Email::config()->admin_email) {
            return self::FROM_ADMIN;
        }
        return self::FROM_DEFAULT;
    }

    /**
     * @return string|false
     */
    public static function getSenderFromSiteConfig()
    {
        $config = SiteConfig::current_site_config();
        $config_field = self::config()->siteconfig_from;
        if ($config_field && !empty($config->$config_field)) {
            return $config->$config_field;
        }
        return false;
    }

    /**
     * @param string $email
     * @return boolean
     */
    public static function isAdminEmail($email)
    {
        $admin_email = Email::config()->admin_email;
        if (!$admin_email && $email) {
            return false;
        }
        $rfc_email = EmailUtils::get_email_from_rfc_email($email);
        $rfc_admin_email = EmailUtils::get_email_from_rfc_email($admin_email);
        return $rfc_email == $rfc_admin_email;
    }

    /**
     * @param string $email
     * @return boolean
     */
    public static function isDefaultEmail($email)
    {
        $rfc_email = EmailUtils::get_email_from_rfc_email($email);
        return $rfc_email == self::createDefaultEmail();
    }

    /**
     * Resolve default send to address
     *
     * @param string $to
     * @return string
     */
    public static function resolveDefaultToEmail($to = null)
    {
        // In case of multiple recipients, do not validate anything
        if (is_array($to) || strpos($to, ',') !== false) {

It seems like $to can also be of type null; however, parameter $haystack of strpos() does only seem to accept string, maybe add an additional type check?

            return $to;
        }
        $original_to = $to;
        if (!empty($to)) {
            $to = EmailUtils::get_email_from_rfc_email($to);
            if (filter_var($to, FILTER_VALIDATE_EMAIL)) {
                return $original_to;
            }
        }
        $config = SiteConfig::current_site_config();
        $config_field = self::config()->siteconfig_to;
        if ($config_field && !empty($config->$config_field)) {
            return $config->$config_field;
        }
        if ($admin = Email::config()->admin_email) {
            return $admin;
        }
        return false;

The expression return false returns the type false which is incompatible with the documented return type string.

    }

    /**
     * Create a sensible default address based on domain name
     *
     * @return string
     */
    public static function createDefaultEmail()
    {
        $fulldom = Director::absoluteBaseURL();
        $host = parse_url($fulldom, PHP_URL_HOST);
        if (!$host) {
            $host = 'localhost';
        }
        $dom = str_replace('www.', '', $host);

        return 'postmaster@' . $dom;
    }

    /**
     * Is logging enabled?
     *
     * @return bool
     */
    public static function getLoggingEnabled()
    {
        if (self::config()->get('enable_logging')) {
            return true;
        }
        return false;
    }

    /**
     * Is sending enabled?
     *
     * @return bool
     */
    public static function getSendingEnabled()
    {
        if (self::config()->get('disable_sending')) {
            return false;
        }
        return true;
    }
}