Message::fillEntity() - Code Metrics - Inspection of "Add phone numbers to contact messages" - abterphp/contact - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 84a999...178a27 )

by Peter
created 2020-02-05 23:57 UTC
Message::fillEntity() A

↳ Parent: Message
Complexity

Conditions	2
Paths	2
Size

Total Lines	22
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	0	Features	0
Metric	Value
eloc	12
c	2
b	0
f	0
dl	0
loc	22
rs	9.8666
cc	2
nc	2
nop	4
<?php

declare(strict_types=1);

namespace AbterPhp\Contact\Service\Execute;

use AbterPhp\Contact\Constant\Event;
use AbterPhp\Contact\Domain\Entities\Form;
.
|-- OtherDir
|   |-- Bar.php
|   `-- Foo.php
`-- SomeDir
    `-- Foo.php
use AbterPhp\Contact\Domain\Entities\Message as Entity;
use AbterPhp\Contact\Orm\FormRepo;
use AbterPhp\Contact\Validation\Factory\Message as ValidatorFactory;
use AbterPhp\Framework\Domain\Entities\IStringerEntity;
use AbterPhp\Framework\Email\Sender;
use AbterPhp\Framework\I18n\ITranslator;
use Opulence\Events\Dispatchers\IEventDispatcher;
use Opulence\Orm\OrmException;

class Message
{
    const FROM_PHONE_LABEL   = 'contact:fromPhone';
    const PHONE_NOT_PROVIDED = 'contact:phoneNotProvided';

    /** @var ValidatorFactory */
    protected $validatorFactory;

    /** @var FormRepo */
    protected $formRepo;

    /** @var Sender */
    protected $sender;

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

    /** @var Form[] */
    protected $forms = [];

    /**
     * Message constructor.
     *
     * @param FormRepo         $formRepo
     * @param ValidatorFactory $validatorFactory
     * @param IEventDispatcher $eventDispatcher
     * @param Sender           $sender
     * @param ITranslator      $translator
     */
    public function __construct(
        FormRepo $formRepo,
        ValidatorFactory $validatorFactory,
        IEventDispatcher $eventDispatcher,
        Sender $sender,
        ITranslator $translator
    ) {
        $this->formRepo         = $formRepo;
        $this->validatorFactory = $validatorFactory;
        $this->eventDispatcher  = $eventDispatcher;
        $this->sender           = $sender;
        $this->translator       = $translator;

    }

    /**
     * @param string $formIdentifier
     *
     * @return Form|null
     * @throws \Opulence\Orm\OrmException
     */
    public function getForm(string $formIdentifier): ?Form
    {
        if (array_key_exists($formIdentifier, $this->forms)) {
            return $this->forms[$formIdentifier];
        }

        try {
            $form = $this->formRepo->getByIdentifier($formIdentifier);
        } catch (OrmException $e) {
            try {
                $form = $this->formRepo->getById($formIdentifier);
            } catch (OrmException $e) {
                return null;
            }
        }

        $this->forms[$form->getIdentifier()] = $form;

        return $form;
    }

    /**
     * @param Entity $message
     *
     * @return int
     */
    public function send(Entity $message): int
    {
        $this->eventDispatcher->dispatch(Event::MESSAGE_READY, $message);

        $form       = $message->getForm();
        $recipients = [$form->getToEmail() => $form->getToName()];

        $replyToAddresses = [$message->getFromEmail() => $message->getFromName()];
        $fromAddresses    = $replyToAddresses;

        $subject = $message->getSubject();
        $text    = $this->getText($message);

        $result = $this->sender->send(
            $subject,
            $text,
            $recipients,
            $fromAddresses,
            $replyToAddresses
        );

        $this->eventDispatcher->dispatch(Event::MESSAGE_SENT, $message);

        return $result;
    }

    /**
     * @param Entity $message
     *
     * @return string
     */
    protected function getText(Entity $message): string
    {
        if ($message->getFromPhone()) {
            return sprintf(
                "%s\n\n%s: %s",
                $message->getBody(),
                $this->translator->translate(static::FROM_PHONE_LABEL),
                $message->getFromPhone()
            );
        }

        return sprintf(
            "%s\n\n%s: %s",
            $message->getBody(),
            $this->translator->translate(static::FROM_PHONE_LABEL),
            $this->translator->translate(static::PHONE_NOT_PROVIDED)
        );
    }

    /**
     * @return array
     */
    public function getFailedRecipients(): array
    {
        return $this->sender->getFailedRecipients();
    }

    /**
     * @param string $formIdentifier
     * @param array  $postData
     *
     * @return array errors
     * @throws OrmException
     */
    public function validateForm(string $formIdentifier, array $postData): array
    {
        /** @var Form $form */
        $form = $this->getForm($formIdentifier);
        if (null === $form) {
            throw new \InvalidArgumentException();
        }

        $validator = $this->validatorFactory
            ->setMaxBodyLength($form->getMaxBodyLength())
            ->createValidator();

        if ($validator->isValid($postData)) {
            return [];
        }

        return $validator->getErrors()->getAll();
    }

    /**
     * @param string $entityId
     *
     * @return Entity|IStringerEntity
     */
    public function createEntity(string $entityId): IStringerEntity
    {
        $form = new Form('', '', '', '', '', '', '', 0);

        $message = new Entity($entityId, $form, '', '', '', '', '');

        return $message;
    }

    /**
     * @SuppressWarnings(PHPMD.UnusedFormalParameter)
     *
     * @param string          $formIdentifier
     * @param IStringerEntity $entity
     * @param array           $postData
     * @param array           $fileData
     *
     * @return IStringerEntity|Entity
     */
    public function fillEntity(
        string $formIdentifier,
        IStringerEntity $entity,
        array $postData,
        array $fileData
        /** @scrutinizer ignore-unused */ array $fileData
    ): IStringerEntity {
        assert($entity instanceof Entity, new \InvalidArgumentException('Invalid entity'));

        $form = $this->getForm($formIdentifier);
        if (null === $form) {
            return $entity;
        }

        $entity
            ->setForm($form)
            ->setSubject($postData['subject'])
            ->setBody($postData['body'])
            ->setFromName($postData['from_name'])
            ->setFromEmail($postData['from_email'])
            ->setFromPhone($postData['from_phone']);

        return $entity;
    }
}

abterphp / contact

Push — master ( 84a999...178a27 )

Message::fillEntity() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
