SendgridTransport::createApi() - Code Metrics - Inspection of "fix exception message" - bytic/mail - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 9803c1...d3b367 )

by Gabriel
created 2020-08-11 12:42 UTC
SendgridTransport::createApi() A

↳ Parent: SendgridTransport
Complexity

Conditions	2
Paths	2
Size

Total Lines	10
Code Lines	4
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	6
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	4
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	10
ccs	0
cts	5
cp	0
crap	6
rs	10
<?php

namespace Nip\Mail\Transport;

use Exception;
use Html2Text\Html2Text;
use Nip\Mail\Message;
use SendGrid;
use SendGrid\Attachment;
use SendGrid\Content;
use SendGrid\Email;
use SendGrid\Mail;
use SendGrid\Personalization;
use SendGrid\ReplyTo;
use Swift_Attachment;
use Swift_Image;
use Swift_Mime_Message as MessageInterface;
use Swift_MimePart;
use Swift_TransportException;

/**
 * Class SendgridTransport
 * @package Nip\Mail\Transport
 */
class SendgridTransport extends AbstractTransport
{
    /** @var string|null */
    protected $apiKey;

    /**
     * @var null|Mail|MessageInterface
     */
    protected $mail = null;

    /**
     * {@inheritdoc}
     */
    public function send(\Swift_Mime_Message $message, &$failedRecipients = null)
    {
        $this->initMail();

        $this->populateSenders($message);
        $this->populatePersonalization($message);
        $this->populateContent($message);
        $this->populateCustomArg($message);

        $sg = $this->createApi();

        /** @var SendGrid\Response $response */
        $response = $sg->client->mail()->send()->post($this->getMail());
        $response = $sg->client->mail()->send()->/** @scrutinizer ignore-call */ post($this->getMail());

        if ($response->statusCode() == '202') {
            return 1;
        } else {
            throw new Swift_TransportException(
                'Error sending email Code [' . $response->statusCode() . ']. '
                . 'HEADERS [' . print_r($response->headers())
                . $response->body()
            );
        }
    }

    public function initMail()
    {
        $this->setMail(new Mail());
    }

    /**
     * @param Message|MessageInterface $message
     */
    protected function populateSenders($message)
    {
        $from = $message->getFrom();
        foreach ($from as $address => $name) {
            $email = new Email($name, $address);
            $this->getMail()->setFrom($email);

            $reply_to = new ReplyTo($address);
            $this->getMail()->setReplyTo($reply_to);
        }
    }

    /**
     * @return null|Mail
     */
    public function getMail()
    {
        return $this->mail;

    }

    /**
     * @param null|Mail $mail
     */
    public function setMail($mail)
    {
        $this->mail = $mail;
    }

    /**
     * @param Message|MessageInterface $message
     * @throws Exception
     */
    protected function populatePersonalization($message)
    {
        $emailsTos = $message->getTo();
        if (!is_array($emailsTos) or count($emailsTos) < 1) {

            throw new Exception('Cannot send email withought reciepients');
        }
        $i = 0;
        foreach ($emailsTos as $emailTo => $nameTo) {
            $personalization = $this->generatePersonalization($emailTo, $nameTo, $message, $i);
            $this->getMail()->addPersonalization($personalization);
            $i++;
        }
    }

    /**
     * @param $emailTo
     * @param $nameTo
     * @param Message $message
     * @param integer $i
     * @return Personalization
     */
    protected function generatePersonalization($emailTo, $nameTo, $message, $i)
    {
        $personalization = new Personalization();

        $email = new Email($nameTo, $emailTo);
        $personalization->addTo($email);

        $personalization->setSubject($message->getSubject());

        $mergeTags = $message->getMergeTags();
        foreach ($mergeTags as $varKey => $value) {
            if (is_array($value)) {
                $value = $value[$i];
            }
            $value = (string) $value;
            $personalization->addSubstitution('{{' . $varKey . '}}', $value);
        }

        return $personalization;
    }

    /**
     * @param Message|MessageInterface $message
     */
    protected function populateContent($message)
    {
        $contentType = $this->getMessagePrimaryContentType($message);

        $bodyHtml = $bodyText = null;

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

        foreach ($message->getChildren() as $child) {
            if ($child instanceof Swift_Image) {
                $images[] = [
                    'type' => $child->getContentType(),
                    'name' => $child->getId(),
                    'content' => base64_encode($child->getBody()),
                ];
            } elseif ($child instanceof Swift_Attachment && !($child instanceof Swift_Image)) {
                $this->addAttachment($child);
            } 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();
                }
            }
        }

        $content = new Content("text/plain", $bodyText);
        $this->getMail()->addContent($content);

        $content = new Content("text/html", $bodyHtml);
        $this->getMail()->addContent($content);
    }

    /**
     * @param MessageInterface $message
     * @return string
     */
    protected function getMessagePrimaryContentType(MessageInterface $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;
    }

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

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

    /**
     * @param Swift_Attachment $attachment
     */
    protected function addAttachment($attachment)
    {
        $sgAttachment = new Attachment();
        $sgAttachment->setContent(base64_encode($attachment->getBody()));
        $sgAttachment->setType($attachment->getContentType());
        $sgAttachment->setFilename($attachment->getFilename());
        $sgAttachment->setDisposition("attachment");
        $sgAttachment->setContentID($attachment->getId());
        $this->getMail()->addAttachment($sgAttachment);
    }

    /**
     * @param Message|MessageInterface $message
     */
    protected function populateCustomArg($message)
    {
        $args = $message->getCustomArgs();
        $args = $message->getCustomArgs();
        foreach ($args as $key => $value) {
            if ($key == 'category') {
                $this->getMail()->addCategory($value);
            } else {
                $this->getMail()->addCustomArg($key, (string) $value);
            }
        }
    }

    /**
     * @return SendGrid
     * @throws Swift_TransportException
     */
    protected function createApi()
    {
        if ($this->getApiKey() === null) {
            throw new Swift_TransportException('Cannot create instance of \Mandrill while API key is NULL');
        }


        $sg = new SendGrid($this->getApiKey());

        return $sg;
    }

    /**
     * @return null|string
     */
    public function getApiKey()
    {
        return $this->apiKey;
    }

    /**
     * @param string $apiKey
     * @return $this
     */
    public function setApiKey($apiKey)
    {
        $this->apiKey = $apiKey;

        return $this;
    }
}

bytic / mail

Push — master ( 9803c1...d3b367 )

SendgridTransport::createApi() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
