MailgunSwiftTransport::logMessageContent() - Code Metrics - lekoala/silverstripe-mailgun - Measure and Improve Code Quality continuously with Scrutinizer

MailgunSwiftTransport::logMessageContent() B
last analyzed 2019-12-13 09:12 UTC

↳ Parent: MailgunSwiftTransport
Complexity

Conditions	10
Paths	64
Size

Total Lines
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	54
rs	7.1369
c	0
b	0
f	0
cc	10
nc	64
nop	2
How to fix Long Method Complexity

<?php

namespace LeKoala\Mailgun;

use \Exception;
use \Swift_MimePart;
use \Swift_Transport;
use \Swift_Attachment;
use \Swift_Mime_Message;
use \Swift_Events_SendEvent;
use \Swift_Events_EventListener;
use Psr\Log\LoggerInterface;
use SilverStripe\Control\Director;
use SilverStripe\Assets\FileNameFilter;
use SilverStripe\Core\Injector\Injector;
use Mailgun\Mailgun;

/**
 * A Mailgun transport for Swift Mailer using the official client
 *
 * @author LeKoala <[email protected]>
 */
class MailgunSwiftTransport implements Swift_Transport
{

    /**
     * @var Swift_Transport_SimpleMailInvoker
     */
    protected $invoker;

    /**
     * @var Swift_Events_SimpleEventDispatcher
     */
    protected $eventDispatcher;

    /**
     * @var Mailgun
     */
    protected $client;

    /**
     * @var array
     */
    protected $resultApi;

    /**
     * @var string
     */
    protected $fromEmail;

    /**
     * @var boolean
     */
    protected $isStarted = false;

    public function __construct(Mailgun $client)
    {
        $this->client = $client;

        $this->invoker = new \Swift_Transport_SimpleMailInvoker();

        $this->eventDispatcher = new \Swift_Events_SimpleEventDispatcher();

    }

    /**
     * Not used
     */
    public function isStarted()
    {
        return $this->isStarted;
    }

    /**
     * Not used
     */
    public function start()
    {
        $this->isStarted = true;
    }

    /**
     * Not used
     */
    public function stop()
    {
        $this->isStarted = false;
    }

    /**
     * @param Swift_Mime_Message $message
     * @param null $failedRecipients
     * @return int Number of messages sent
     */
    public function send(Swift_Mime_Message $message, &$failedRecipients = null)
    {
        $this->resultApi = null;

        if ($event = $this->eventDispatcher->createSendEvent($this, $message)) {
            $this->eventDispatcher->dispatchEvent($event, 'beforeSendPerformed');
            if ($event->bubbleCancelled()) {
                return 0;
            }
        }

        $sendCount = 0;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $disableSending = $message->getHeaders()->has('X-SendingDisabled') || MailgunHelper::config()->disable_sending;

        $emailData = $this->buildMessage($message);

        $client = $this->client;

        if ($disableSending) {
            $result = [
                'message' => 'Disabled',
                'id' => uniqid(),
            ];
            $queued = true;
        } else {
            $resultResponse = $client->messages()->send(MailgunHelper::getDomain(), $emailData);
            if ($resultResponse) {
                $result = [
                    'message' => $resultResponse->getMessage(),
                    'id' => $resultResponse->getId(),
                ];
                $queued = strpos($result['message'], 'Queued') !== false;
            }
        }
        $this->resultApi = $result;
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}

        if (MailgunHelper::config()->enable_logging) {
            $this->logMessageContent($message, $result);
        }

        // Mailgun does not tell us how many messages are sent
        $sendCount = 1;

        // We don't know which recipients failed, so simply add fromEmail since it's the only one we know
        if (!$queued) {
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
            $failedRecipients[] = $this->fromEmail;
            $sendCount = 0;
        }

        if ($event) {
            if ($sendCount > 0) {
                $event->setResult(Swift_Events_SendEvent::RESULT_SUCCESS);
            } else {
                $event->setResult(Swift_Events_SendEvent::RESULT_FAILED);
            }

            $this->eventDispatcher->dispatchEvent($event, 'sendPerformed');
        }

        return $sendCount;
    }

    /**
     * Log message content
     *
     * @param Swift_Mime_Message $message
     * @param array $results Results from the api
     * @return void
     */
    protected function logMessageContent(Swift_Mime_Message $message, $results = [])
    {
        $subject = $message->getSubject();
        $body = $message->getBody();
        $contentType = $this->getMessagePrimaryContentType($message);

        $logContent = $body;

        // Append some extra information at the end
        $logContent .= '<hr><pre>Debug infos:' . "\n\n";
        $logContent .= 'To : ' . print_r($message->getTo(), true) . "\n";
        $logContent .= 'Subject : ' . $subject . "\n";
        $logContent .= 'From : ' . print_r($message->getFrom(), true) . "\n";
        $logContent .= 'Headers:' . "\n";
        foreach ($message->getHeaders()->getAll() as $header) {
            $logContent .= '  ' . $header->getFieldName() . ': ' . $header->getFieldBody() . "\n";
        }
        if (!empty($message->getTo())) {
            $logContent .= 'Recipients : ' . print_r($message->getTo(), true) . "\n";
        }
        $logContent .= 'Results:' . "\n";
        foreach ($results as $resultKey => $resultValue) {
            $logContent .= '  ' . $resultKey . ': ' . $resultValue . "\n";
        }
        $logContent .= '</pre>';

        $logFolder = MailgunHelper::getLogFolder();

        // Generate filename
        $filter = new FileNameFilter();
        $title = substr($filter->filter($subject), 0, 35);
        $logName = date('Ymd_His') . '_' . $title;

        // Store attachments if any
        $attachments = $message->getChildren();
        if (!empty($attachments)) {
            $logContent .= '<hr />';
            foreach ($attachments as $attachment) {
                if ($attachment instanceof Swift_Attachment) {
                    $attachmentDestination = $logFolder . '/' . $logName . '_' . $attachment->getFilename();
                    file_put_contents($attachmentDestination, $attachment->getBody());
                    $logContent .= 'File : <a href="' . $attachmentDestination . '">' . $attachment->getFilename() . '</a><br/>';
                }
            }
        }

        // Store it
        $ext = ($contentType == 'text/html') ? 'html' : 'txt';
        $r = file_put_contents($logFolder . '/' . $logName . '.' . $ext, $logContent);

        if (!$r && Director::isDev()) {
            throw new Exception('Failed to store email in ' . $logFolder);
        }
    }

    /**
     * @return LoggerInterface
     */
    public function getLogger()
    {
        return Injector::inst()->get(LoggerInterface::class)->withName('Mailgun');
    }

    /**
     * @param Swift_Events_EventListener $plugin
     */
    public function registerPlugin(Swift_Events_EventListener $plugin)
    {
        $this->eventDispatcher->bindEventListener($plugin);
    }

    /**
     * @return array
     */
    protected function getSupportedContentTypes()
    {
        return array(
            'text/plain',
            'text/html'
        );
    }

    /**
     * @param string $contentType
     * @return bool
     */
    protected function supportsContentType($contentType)
    {
        return in_array($contentType, $this->getSupportedContentTypes());
    }

    /**
     * @param Swift_Mime_Message $message
     * @return string
     */
    protected function getMessagePrimaryContentType(Swift_Mime_Message $message)
    {
        $contentType = $message->getContentType();

        if ($this->supportsContentType($contentType)) {
            return $contentType;
        }

        // SwiftMailer hides the content type set in the constructor of Swift_Mime_Message as soon
        // as you add another part to the message. We need to access the protected property
        // _userContentType to get the original type.
        $messageRef = new \ReflectionClass($message);
        if ($messageRef->hasProperty('_userContentType')) {
            $propRef = $messageRef->getProperty('_userContentType');
            $propRef->setAccessible(true);
            $contentType = $propRef->getValue($message);
        }

        return $contentType;
    }

    /**
     * Convert a Swift Message for the api
     *
     * @param Swift_Mime_Message $message
     * @return array Mailgun Send Message
     * @throws \Swift_SwiftException
     */
    public function buildMessage(Swift_Mime_Message $message)
    {
        $contentType = $this->getMessagePrimaryContentType($message);

        $fromAddresses = $message->getFrom();
        $fromEmails = array_keys($fromAddresses);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $fromFirstEmail = key($fromAddresses);
        $fromFirstName = current($fromAddresses);

        if ($fromFirstName) {
            $this->fromEmail = sprintf('%s <%s>', $fromFirstName, $fromFirstEmail);
        } else {
            $this->fromEmail = $fromFirstEmail;
        }

        $toAddresses = $message->getTo();
        $ccAddresses = $message->getCc() ? $message->getCc() : [];
        $bccAddresses = $message->getBcc() ? $message->getBcc() : [];
        $replyToAddresses = $message->getReplyTo() ? $message->getReplyTo() : [];

        $recipients = array();
        $cc = array();
        $bcc = array();
        $attachments = array();
        $headers = array();
        $tags = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $metadata = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        $inlineCss = null;

        // Mandrill compatibility
        // Data is merge with transmission and removed from headers
        // @link https://mandrill.zendesk.com/hc/en-us/articles/205582467-How-to-Use-Tags-in-Mandrill
        if ($message->getHeaders()->has('X-MC-Tags')) {

            $tagsHeader = $message->getHeaders()->get('X-MC-Tags');
            $tags = explode(',', $tagsHeader->getValue());
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $message->getHeaders()->remove('X-MC-Tags');
        }
        if ($message->getHeaders()->has('X-MC-Metadata')) {

            $metadataHeader = $message->getHeaders()->get('X-MC-Metadata');
            $metadata = json_decode($metadataHeader->getValue(), JSON_OBJECT_AS_ARRAY);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $message->getHeaders()->remove('X-MC-Metadata');
        }
        if ($message->getHeaders()->has('X-MC-InlineCSS')) {
            $inlineCss = $message->getHeaders()->get('X-MC-InlineCSS')->getValue();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            $message->getHeaders()->remove('X-MC-InlineCSS');
        }

        // Handle mailgun headers
        // Data is merge with message and removed from headers
        // @link https://documentation.mailgun.com/en/latest/user_manual.html#sending-via-smtp
        if ($message->getHeaders()->has('X-Mailgun-Tag')) {

            $tagsHeader = $message->getHeaders()->get('X-Mailgun-Tag');
            $tags = explode(',', $tagsHeader->getValue());
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $message->getHeaders()->remove('X-Mailgun-Tag');
        }
        // @link https://documentation.mailgun.com/en/latest/user_manual.html#attaching-data-to-messages
        if ($message->getHeaders()->has('X-Mailgun-Variables')) {

            $metadataHeader = $message->getHeaders()->get('X-Mailgun-Variables');
            $metadata = json_decode($metadataHeader->getValue(), JSON_OBJECT_AS_ARRAY);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $message->getHeaders()->remove('X-Mailgun-Variables');
        }

        // Build recipients
        $primaryEmail = null;
        foreach ($toAddresses as $toEmail => $toName) {
            if ($primaryEmail === null) {
                $primaryEmail = $toEmail;
            }
            if (!$toName) {
                $toName = $toEmail;
            }
            if ($toName) {
                $recipients[] = sprintf('%s <%s>', $toName, $toEmail);
            } else {
                $recipients[] = $toEmail;
            }
        }

        $reply_to = null;
        foreach ($replyToAddresses as $replyToEmail => $replyToName) {
            if ($replyToName) {
                $reply_to = sprintf('%s <%s>', $replyToName, $replyToEmail);
            } else {
                $reply_to = $replyToEmail;
            }
        }

        foreach ($ccAddresses as $ccEmail => $ccName) {
            if ($ccName) {
                $cc[] = sprintf('%s <%s>', $ccName, $ccEmail);
            } else {
                $cc[] = $ccEmail;
            }
        }

        foreach ($bccAddresses as $bccEmail => $bccName) {
            if ($bccName) {
                $bcc[] = sprintf('%s <%s>', $bccName, $bccEmail);
            } else {
                $bcc[] = $bccEmail;
            }
        }

        $bodyHtml = $bodyText = null;

        if ($contentType === 'text/plain') {
            $bodyText = $message->getBody();
        } elseif ($contentType === 'text/html') {
            $bodyHtml = $message->getBody();
        } else {
            $bodyHtml = $message->getBody();
        }

        foreach ($message->getChildren() as $child) {
            // File attachment. You can post multiple attachment values.
            // Important: You must use multipart/form-data encoding when sending attachments.
            if ($child instanceof Swift_Attachment) {
                // eg: 'attachment' => array('/path/to/file.txt', '/path/to/file.txt')
                $attachments[] = $child->getFilename();
            } elseif ($child instanceof Swift_MimePart && $this->supportsContentType($child->getContentType())) {
                if ($child->getContentType() == "text/html") {
                    $bodyHtml = $child->getBody();
                } elseif ($child->getContentType() == "text/plain") {
                    $bodyText = $child->getBody();
                }
            }
        }

        // If we ask to provide plain, use our custom method instead of the provided one
        if ($bodyHtml && MailgunHelper::config()->provide_plain) {
''   == false // true
''   == null  // true
'ab' == false // false
'ab' == null  // false

// It is often better to use strict comparison
'' === false // false
'' === null  // false
            $bodyText = EmailUtils::convert_html_to_text($bodyHtml);
        }

        // Should we inline css
        if (!$inlineCss && MailgunHelper::config()->inline_styles) {
            $bodyHtml = EmailUtils::inline_styles($bodyHtml);
        }

        // Custom unsubscribe list
        if ($message->getHeaders()->has('List-Unsubscribe')) {
            $headers['List-Unsubscribe'] = $message->getHeaders()->get('List-Unsubscribe')->getValue();
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
        }

        // Mailgun params format does not work well in yml, so we map them
        $rawParams = MailgunHelper::config()->default_params;
        $defaultParams =  [];
        foreach ($rawParams as $rawParamKey => $rawParamValue) {
            switch ($rawParamKey) {
                case 'inline':
                    $defaultParams['inline'] = $rawParamValue;
                    break;
                case 'tracking_opens':
                    $defaultParams['o:tracking-opens'] = $rawParamValue;
                    break;
                case 'tracking_clicks':
                    $defaultParams['o:tracking-clicks'] = $rawParamValue;
                    break;
                case 'testmode':
                    $defaultParams['o:testmode'] = $rawParamValue;
                    break;
                default:
                    $defaultParams[$rawParamKey] = $rawParamValue;
                    break;
            }
        }

        // Build base transmission
        $mailgunMessage = array(
            'to' => implode(',', $recipients),
            'from' => $this->fromEmail,
            'subject' => $message->getSubject(),
            'html' => $bodyHtml,
            'text' => $bodyText,
        );
        if ($reply_to) {
            $mailgunMessage['h:Reply-To'] = $reply_to;
        }

        // Add default params
        $mailgunMessage = array_merge($defaultParams, $mailgunMessage);

        // Add remaining elements
        if (!empty($cc)) {
            $mailgunMessage['cc'] = $cc;
        }
        if (!empty($bcc)) {
            $mailgunMessage['bcc'] = $bcc;
        }
        if (!empty($headers)) {
            foreach ($headers as $headerKey => $headerValue) {
                $mailgunMessage['h:' . $headerKey] = $headerValue;
            }
        }
        if (count($attachments) > 0) {
            $mailgunMessage['attachment'] = $attachments;
        }

        return $mailgunMessage;
    }

    /**
     * @return null|array
     */
    public function getResultApi()
    {
        return $this->resultApi;
    }
}

MailgunSwiftTransport::logMessageContent() B
last analyzed 2019-12-13 09:12 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

lekoala / silverstripe-mailgun

MailgunSwiftTransport::logMessageContent() B last analyzed 2019-12-13 09:12 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

MailgunSwiftTransport::logMessageContent() B
last analyzed 2019-12-13 09:12 UTC
