Omnimail\Mailjet

Complexity

Total Complexity

39

Size/Duplication

Total Lines	190
Duplicated Lines	37.89 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

0%

Importance

Changes	3
Bugs	1	Features	2

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
D	send()	0	54	11
B	mapAttachments()	19	19	7
B	mapInlineAttachments()	19	19	7
A	mapAttachment()	18	18	4
A	mapEmails()	0	8	2
A	mapEmail()	8	8	2
A	mapEmailsString()	8	8	3
A	mapEmailString()	0	4	2

<?php

namespace Omnimail;

use Omnimail\Exception\InvalidRequestException;
use Psr\Log\LoggerInterface;
use Mailjet\Resources;
use Mailjet\Client;

class Mailjet implements EmailSenderInterface
{
    private $apikey;
    private $apisecret;
    private $logger;
    private $mailjet;

    /**
     * @param string $apikey
     * @param string $apisecret
     * @param LoggerInterface|null $logger
     */
    public function __construct($apikey, $apisecret, LoggerInterface $logger = null)
    {
        $this->apikey = $apikey;
        $this->apisecret = $apisecret;
        $this->logger = $logger;
        $this->mailjet = new Client($apikey, $apisecret);
    }

    public function send(EmailInterface $email)
    {
        $from = $email->getFrom();

        $body = [
            'FromEmail' => $from['email'],
            'Subject' => $email->getSubject(),
            'To' => $this->mapEmails($email->getTos())
        ];

        if (!empty($from['name'])) {
            $body['FromName'] = $from['name'];
        }

        if ($email->getReplyTos()) {
            $body['Headers'] = [
                'Reply-To' => $this->mapEmailsString($email->getReplyTos())
            ];
        }

        if ($email->getCcs()) {
            $body['Cc'] = $this->mapEmails($email->getCcs());
        }

        if ($email->getBccs()) {
            $body['Bcc'] = $this->mapEmails($email->getBccs());
        }

        if ($email->getTextBody()) {
            $body['Text-part'] = $email->getTextBody();
        }

        if ($email->getHtmlBody()) {
            $body['Html-part'] = $email->getHtmlBody();
        }

        if ($email->getAttachments()) {
            $body['Attachments'] = $this->mapAttachments($email->getAttachments());
            $body['Inline_attachments'] = $this->mapInlineAttachments($email->getAttachments());
        }

        $response = $this->mailjet->post(Resources::$Email, ['body' => $body]);

        if ($response->success()) {
            if ($this->logger) {
                $this->logger->info("Email sent: '{$email->getSubject()}'", $email);

$email is of type object<Omnimail\EmailInterface>, but the function expects a array.

            }
        } else {
            if ($this->logger) {
                $this->logger->error("Email error: '{$response->getReasonPhrase()}'", $email);

$email is of type object<Omnimail\EmailInterface>, but the function expects a array.

            }
            throw new InvalidRequestException($response->getReasonPhrase());
        }
    }

    /**
     * @param array|null $attachments
     * @return array|null
     */
    private function mapAttachments(array $attachments)

This method seems to be duplicated in your project.

    {
        if (null === $attachments || !is_array($attachments) || !count($attachments)) {
            return null;
        }

        $finalAttachments = [];
        /** @var AttachmentInterface $attachment */
        foreach ($attachments as $attachment) {
            if ($attachment->getContentId()) {
                continue;
            }
            $finalAttachment = $this->mapAttachment($attachment);
            if ($finalAttachment) {

The expression $finalAttachment of type array<string,string|null> 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.

                $finalAttachments[] = $finalAttachment;
            }
        }
        return $finalAttachments;
    }

    /**
     * @param array|null $attachments
     * @return array|null
     */
    private function mapInlineAttachments(array $attachments)

This method seems to be duplicated in your project.

    {
        if (null === $attachments || !is_array($attachments) || !count($attachments)) {
            return null;
        }

        $finalAttachments = [];
        /** @var AttachmentInterface $attachment */
        foreach ($attachments as $attachment) {
            if (!$attachment->getContentId()) {
                continue;
            }
            $finalAttachment = $this->mapAttachment($attachment);
            if ($finalAttachment) {

The expression $finalAttachment of type array<string,string|null> 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.

                $finalAttachments[] = $finalAttachment;
            }
        }
        return $finalAttachments;
    }

    private function mapAttachment(AttachmentInterface $attachment)

This method seems to be duplicated in your project.

    {
        $finalAttachment = [
            'Content-type' => $attachment->getMimeType(),
            'Filename' => $attachment->getName()
        ];
        if ($attachment->getPath()) {

The expression $attachment->getPath() of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $finalAttachment['content'] = base64_encode(file_get_contents($attachment->getPath()));
        } elseif ($attachment->getContent()) {

The expression $attachment->getContent() of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $finalAttachment['content'] = base64_encode($attachment->getContent());
        }

        if ($attachment->getContentId()) {

The expression $attachment->getContentId() of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            $finalAttachment['Filename'] = $attachment->getContentId();
        }

        return $finalAttachment;
    }

    /**
     * @param array $emails
     * @return array
     */
    private function mapEmails(array $emails)
    {
        $returnValue = [];
        foreach ($emails as $email) {
            $returnValue[] = $this->mapEmail($email);
        }
        return $returnValue;
    }

    /**
     * @param array $email
     * @return array
     */
    private function mapEmail(array $email)

This method seems to be duplicated in your project.

    {
        $returnValue = ['Email' => $email['email']];
        if ($email['name']) {
            $returnValue['Name'] = $email['name'];
        }
        return $returnValue;
    }

    /**
     * @param array $emails
     * @return string
     */
    private function mapEmailsString(array $emails)

This method seems to be duplicated in your project.

    {
        $returnValue = '';
        foreach ($emails as $email) {
            $returnValue .= $this->mapEmailString($email) . ', ';
        }
        return $returnValue ? substr($returnValue, 0, -2) : '';
    }

    /**
     * @param array $email
     * @return string
     */
    private function mapEmailString(array $email)
    {
        return !empty($email['name']) ? "'{$email['name']}' <{$email['email']}>" : $email['email'];
    }
}