AbstractUserEmailFactory::populatePathVariables() - Code Metrics - Inspection of "WIP: Refactored UserMailer + Created Email Factori..." - components-web-app/api-components-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — feature/unit-tests (#37)

by Daniel

created 2020-04-21 16:30 UTC

AbstractUserEmailFactory::populatePathVariables() A

↳ Parent: AbstractUserEmailFactory

Complexity

Conditions	3
Paths	3

Size

Total Lines	10
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	5
dl	0
loc	10
ccs	6
cts	6
cp	1
rs	10
c	1
b	0
f	0
cc	3
nc	3
nop	2
crap	3

<?php

/*
 * This file is part of the Silverback API Component Bundle Project
 *
 * (c) Daniel West <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace Silverback\ApiComponentBundle\Factory\Mailer\User;

use Psr\Container\ContainerInterface;
use Silverback\ApiComponentBundle\Entity\User\AbstractUser;
use Silverback\ApiComponentBundle\Event\UserEmailMessageEvent;
use Silverback\ApiComponentBundle\Exception\BadMethodCallException;
use Silverback\ApiComponentBundle\Exception\InvalidArgumentException;
use Silverback\ApiComponentBundle\Exception\RfcComplianceException;
use Silverback\ApiComponentBundle\Exception\UnexpectedValueException;
use Silverback\ApiComponentBundle\Url\RefererUrlHelper;
use Symfony\Bridge\Twig\Mime\TemplatedEmail;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\Mime\Address;
use Symfony\Component\Mime\Exception\RfcComplianceException as SymfonyRfcComplianceException;
use Symfony\Component\Mime\RawMessage;
use Symfony\Contracts\Service\ServiceSubscriberInterface;
use Twig\Environment;

/**
 * @author Daniel West <[email protected]>
 */
abstract class AbstractUserEmailFactory implements ServiceSubscriberInterface
{
    protected ContainerInterface $container;
    private EventDispatcherInterface $eventDispatcher;
    protected bool $enabled;
    protected string $template;
    protected string $subject;
    protected array $emailContext;
    protected ?string $defaultRedirectPath;
    protected ?string $redirectPathQueryKey;
    protected ?RawMessage $message;
    private ?AbstractUser $user;

    public function __construct(
        ContainerInterface $container,
        EventDispatcherInterface $eventDispatcher,
        string $subject,
        bool $enabled = true,
        ?string $defaultRedirectPath = null,
        ?string $redirectPathQueryKey = null,
        array $emailContext = []
    ) {
        $this->container = $container;
        $this->eventDispatcher = $eventDispatcher;
        $this->subject = $subject;
        $this->enabled = $enabled;
        $this->emailContext = $emailContext;
        $this->defaultRedirectPath = $defaultRedirectPath;
        $this->redirectPathQueryKey = $redirectPathQueryKey;
    }

    public static function getSubscribedServices(): array
    {
        return [
            RequestStack::class,
            RefererUrlHelper::class,
            Environment::class,
        ];
    }

    abstract public function create(AbstractUser $user, array $context = []): ?RawMessage;

    abstract protected function getTemplate(): string;

    protected static function getRequiredContextKeys(): ?array
    {
        return [
            'website_name',
            'user',
        ];
    }

    protected function createEmailMessage(array $context = []): TemplatedEmail
    {
        if (!$this->user) {
            throw new BadMethodCallException('You must call the method `initUser` before `createEmailMessage`');
        }

        try {
            $toEmailAddress = Address::fromString((string) $this->user->getEmailAddress());
        } catch (SymfonyRfcComplianceException $exception) {
            $exception = new RfcComplianceException($exception->getMessage());
            throw $exception;
        }

        $context = array_replace_recursive([
            'user' => $this->user,
        ], $this->emailContext, $context);
        $this->validateContext($context);

        $twig = $this->container->get(Environment::class);
        $template = $twig->createTemplate($this->subject);
        $subject = $template->render($context);

        $email = (new TemplatedEmail())
            ->to($toEmailAddress)
            ->subject($subject)
            ->htmlTemplate('@SilverbackApiComponent/emails/' . $this->getTemplate())
            ->context($context);

        $event = new UserEmailMessageEvent(static::class, $email);
        $this->eventDispatcher->dispatch($event);

        return $event->getEmail();
    }

    protected function initUser(AbstractUser $user): void
    {
        if (null === $user->getUsername()) {
            throw new InvalidArgumentException('The user must have a username set to send them any email');
        }

        if (null === $user->getEmailAddress()) {
            throw new InvalidArgumentException('The user must have a username set to send them any email');
        }

        $this->user = $user;
    }

    protected function getTokenUrl(string $token, string $username): string
    {
        $path = $this->populatePathVariables($this->getTokenPath(), [
            'token' => $token,
            'username' => $username,
        ]);

        $refererUrlHelper = $this->container->get(RefererUrlHelper::class);

        return $refererUrlHelper->getAbsoluteUrl($path);
    }

    private function getTokenPath(): string
    {
        if (null === $this->defaultRedirectPath && null === $this->redirectPathQueryKey) {
            throw new InvalidArgumentException('The `defaultRedirectPath` or `redirectPathQueryKey` must be set');
        }

        $requestStack = $this->container->get(RequestStack::class);
        $request = $requestStack->getMasterRequest();

        $path = ($request && $this->redirectPathQueryKey) ?
            $request->query->get($this->redirectPathQueryKey, $this->defaultRedirectPath) :
            $this->defaultRedirectPath;

        if (null === $path) {
            throw new UnexpectedValueException(sprintf('The querystring key `%s` could not be found in the request to generate a token URL', $this->redirectPathQueryKey));
        }

        return $path;
    }

    private function populatePathVariables(string $path, array $variables): string
    {
        preg_match_all('/{{[\s]*(\w+)[\s]*}}/', $path, $matches);
        foreach ($matches[0] as $matchIndex => $fullMatch) {
            if (\array_key_exists($varKey = $matches[1][$matchIndex], $variables)) {
                $path = str_replace($fullMatch, $variables[$varKey], $path);
            }
        }

        return $path;
    }

    private function validateContext(array $context): void
    {
        $requiredKeys = self::getRequiredContextKeys();
        foreach ($requiredKeys as $requiredKey) {
            if (!\array_key_exists($requiredKey, $context)) {
                throw new InvalidArgumentException(sprintf('The context key `%s` is required to create the email message', $requiredKey));
            }
        }
    }
}


1		<?php
2
3		/*
4		* This file is part of the Silverback API Component Bundle Project
5		*
6		* (c) Daniel West <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		declare(strict_types=1);
13
14		namespace Silverback\ApiComponentBundle\Factory\Mailer\User;
15
16		use Psr\Container\ContainerInterface;
17		use Silverback\ApiComponentBundle\Entity\User\AbstractUser;
18		use Silverback\ApiComponentBundle\Event\UserEmailMessageEvent;
19		use Silverback\ApiComponentBundle\Exception\BadMethodCallException;
20		use Silverback\ApiComponentBundle\Exception\InvalidArgumentException;
21		use Silverback\ApiComponentBundle\Exception\RfcComplianceException;
22		use Silverback\ApiComponentBundle\Exception\UnexpectedValueException;
23		use Silverback\ApiComponentBundle\Url\RefererUrlHelper;
24		use Symfony\Bridge\Twig\Mime\TemplatedEmail;
25		use Symfony\Component\EventDispatcher\EventDispatcherInterface;
26		use Symfony\Component\HttpFoundation\RequestStack;
27		use Symfony\Component\Mime\Address;
28		use Symfony\Component\Mime\Exception\RfcComplianceException as SymfonyRfcComplianceException;
29		use Symfony\Component\Mime\RawMessage;
30		use Symfony\Contracts\Service\ServiceSubscriberInterface;
31		use Twig\Environment;
32
33		/**
34		* @author Daniel West <[email protected]>
35		*/
36		abstract class AbstractUserEmailFactory implements ServiceSubscriberInterface
37		{
38		protected ContainerInterface $container;
39		private EventDispatcherInterface $eventDispatcher;
40		protected bool $enabled;
41		protected string $template;
42		protected string $subject;
43		protected array $emailContext;
44		protected ?string $defaultRedirectPath;
45		protected ?string $redirectPathQueryKey;
46		protected ?RawMessage $message;
47		private ?AbstractUser $user;
48
49	5	public function __construct(
50		ContainerInterface $container,
51		EventDispatcherInterface $eventDispatcher,
52		string $subject,
53		bool $enabled = true,
54		?string $defaultRedirectPath = null,
55		?string $redirectPathQueryKey = null,
56		array $emailContext = []
57		) {
58	5	$this->container = $container;
59	5	$this->eventDispatcher = $eventDispatcher;
60	5	$this->subject = $subject;
61	5	$this->enabled = $enabled;
62	5	$this->emailContext = $emailContext;
63	5	$this->defaultRedirectPath = $defaultRedirectPath;
64	5	$this->redirectPathQueryKey = $redirectPathQueryKey;
65	5	}
66
67	1	public static function getSubscribedServices(): array
68		{
69		return [
70	1	RequestStack::class,
71		RefererUrlHelper::class,
72		Environment::class,
73		];
74		}
75
76		abstract public function create(AbstractUser $user, array $context = []): ?RawMessage;
77
78		abstract protected function getTemplate(): string;
79
80	5	protected static function getRequiredContextKeys(): ?array
81		{
82		return [
83	5	'website_name',
84		'user',
85		];
86		}
87
88	5	protected function createEmailMessage(array $context = []): TemplatedEmail
89		{
90	5	if (!$this->user) {
91		throw new BadMethodCallException('You must call the method `initUser` before `createEmailMessage`');
92		}
93
94		try {
95	5	$toEmailAddress = Address::fromString((string) $this->user->getEmailAddress());
96		} catch (SymfonyRfcComplianceException $exception) {
97		$exception = new RfcComplianceException($exception->getMessage());
98		throw $exception;
99		}
100
101	5	$context = array_replace_recursive([
102	5	'user' => $this->user,
103	5	], $this->emailContext, $context);
104	5	$this->validateContext($context);
105
106	5	$twig = $this->container->get(Environment::class);
107	5	$template = $twig->createTemplate($this->subject);
108	5	$subject = $template->render($context);
109
110	5	$email = (new TemplatedEmail())
111	5	->to($toEmailAddress)
112	5	->subject($subject)
113	5	->htmlTemplate('@SilverbackApiComponent/emails/' . $this->getTemplate())
114	5	->context($context);
115
116	5	$event = new UserEmailMessageEvent(static::class, $email);
117	5	$this->eventDispatcher->dispatch($event);
118
119	5	return $event->getEmail();
120		}
121
122	5	protected function initUser(AbstractUser $user): void
123		{
124	5	if (null === $user->getUsername()) {
125		throw new InvalidArgumentException('The user must have a username set to send them any email');
126		}
127
128	5	if (null === $user->getEmailAddress()) {
129		throw new InvalidArgumentException('The user must have a username set to send them any email');
130		}
131
132	5	$this->user = $user;
133	5	}
134
135	1	protected function getTokenUrl(string $token, string $username): string
136		{
137	1	$path = $this->populatePathVariables($this->getTokenPath(), [
138	1	'token' => $token,
139	1	'username' => $username,
140		]);
141
142	1	$refererUrlHelper = $this->container->get(RefererUrlHelper::class);
143
144	1	return $refererUrlHelper->getAbsoluteUrl($path);
145		}
146
147	1	private function getTokenPath(): string
148		{
149	1	if (null === $this->defaultRedirectPath && null === $this->redirectPathQueryKey) {
150		throw new InvalidArgumentException('The `defaultRedirectPath` or `redirectPathQueryKey` must be set');
151		}
152
153	1	$requestStack = $this->container->get(RequestStack::class);
154	1	$request = $requestStack->getMasterRequest();
155
156	1	$path = ($request && $this->redirectPathQueryKey) ?
157		$request->query->get($this->redirectPathQueryKey, $this->defaultRedirectPath) :
158	1	$this->defaultRedirectPath;
159
160	1	if (null === $path) {
161		throw new UnexpectedValueException(sprintf('The querystring key `%s` could not be found in the request to generate a token URL', $this->redirectPathQueryKey));
162		}
163
164	1	return $path;
165		}
166
167	1	private function populatePathVariables(string $path, array $variables): string
168		{
169	1	preg_match_all('/{{[\s](\w+)[\s]}}/', $path, $matches);
170	1	foreach ($matches[0] as $matchIndex => $fullMatch) {
171	1	if (\array_key_exists($varKey = $matches[1][$matchIndex], $variables)) {
172	1	$path = str_replace($fullMatch, $variables[$varKey], $path);
173		}
174		}
175
176	1	return $path;
177		}
178
179	5	private function validateContext(array $context): void
180		{
181	5	$requiredKeys = self::getRequiredContextKeys();
182	5	foreach ($requiredKeys as $requiredKey) {
183	5	if (!\array_key_exists($requiredKey, $context)) {
184		throw new InvalidArgumentException(sprintf('The context key `%s` is required to create the email message', $requiredKey));
185		}
186		}
187	5	}
188		}
189

components-web-app / api-components-bundle

Pull Request — feature/unit-tests (#37)

AbstractUserEmailFactory::populatePathVariables() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like