EmailByKey::execute() - Code Metrics - Inspection of "EmailByKey job" - flipboxfactory/craft-ember - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( c9d3f4...e2b57f )

by Nate

created 2019-03-30 15:41 UTC

EmailByKey::execute() B

↳ Parent: EmailByKey

Complexity

Conditions	5
Paths	12

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	30

Importance

Changes

Metric	Value
dl	0
loc	73
ccs	0
cts	64
cp	0
rs	8.2779
c	0
b	0
f	0
cc	5
nc	12
nop	1
crap	30

How to fix Long Method

<?php

/**
 * @copyright  Copyright (c) Flipbox Digital Limited
 * @license    https://github.com/flipboxfactory/craft-ember/blob/master/LICENSE
 * @link       https://github.com/flipboxfactory/craft-ember/
 */

namespace flipbox\craft\ember\queries;

use Craft;
use craft\elements\User;
use craft\helpers\ArrayHelper;
use craft\helpers\StringHelper;
use craft\queue\BaseJob;
use yii\helpers\Json;

/**
 * @author Flipbox Factory <[email protected]>
 * @since 2.3.2
 */
class EmailByKey extends BaseJob implements \Serializable
{
    /**
     *  The email key
     *
     * @var string
     */
    public $key;

    /**
     * The recipients
     *
     * @var array
     */
    protected $recipients = [];

    /**
     * The email params
     *
     * @var array
     */
    protected $params;

    /**
     * @inheritdoc
     * @return string|null
     */
    protected function defaultDescription()
    {
        return 'Sending an email by key.';
    }

    /**
     * @inheritdoc
     * @throws \Exception
     */
    public function execute($queue)
    {
        // A random tracking string
        $id = StringHelper::randomString();

        try {
            Craft::info(
                sprintf(
                    "[Sending email via job '%s'.] %s",
                    (string)$id,
                    (string)Json::encode(
                        [
                            'tracking' => $id,
                            'key' => $this->key,
                            'recipients' => $this->recipients
                        ]
                    )
                ), __METHOD__
            );

            foreach ($this->recipients as $recipient) {
                if (null === ($recipient = $this->resolveUser($recipient))) {
                    continue;
                }

                /** @var User $recipient */

                if (!Craft::$app->getMailer()
                    ->composeFromKey(
                        $this->key,
                        array_merge(
                            ['recipient' => $recipient],
                            $this->params
                        )
                    )->setTo($recipient)
                    ->send()
                ) {
                    Craft::error(
                        sprintf(
                            "Failed to send email via job '%s'",
                            (string)$id
                        ), __METHOD__
                    );
                    continue;
                }

                Craft::info(
                    sprintf(
                        "Successfully sent email via job '%s'",
                        (string)$id
                    ), __METHOD__
                );
            }

        } catch (\Exception $e) {
            Craft::error(
                sprintf(
                    "Exception caught while trying to run '%s' (Id: %s) job. Exception: [%s].",
                    (string)get_class($this),
                    $id,
                    (string)Json::encode([
                        'Trace' => $e->getTraceAsString(),
                        'File' => $e->getFile(),
                        'Line' => $e->getLine(),
                        'Code' => $e->getCode(),
                        'Message' => $e->getMessage()
                    ])
                ), __METHOD__
            );

            throw $e;
        }
    }

    /**
     * @param array $recipients
     * @return $this
     */
    public function setRecipients(array $recipients)
    {
        foreach ($recipients as $recipient) {
            $this->addRecipient($recipient);
        }
        return $this;
    }

    /**
     * @param $recipient
     * @return $this
     */
    public function addRecipient($recipient)
    {
        if ($recipient instanceof User) {
            $recipient = [$recipient->email];
        }

        $this->recipients[] = $recipient;
        return $this;
    }

    /**
     * @param $params
     * @return $this
     */
    public function setParams($params)
    {
        $this->params = ArrayHelper::toArray($params);
        return $this;
    }

    /**
     * @param User|int|string|array $user
     * @return User
     */
    function resolveUser($user)

    {
        if ($user instanceof User) {
            return $user;
        }

        // An Id
        if (is_numeric($user)) {
            return Craft::$app->getUsers()->getUserById($user);
        }

        // An email
        if (is_string($user)) {
            if (!$element = Craft::$app->getUsers()->getUserByUsernameOrEmail($user)) {
                $element = new User([
                    'email' => $user
                ]);
            }

            return $element;
        }

        if (is_array($user)) {
            $email = key($user);
            $user = reset($user);

            // $user was an array [email => name]
            if (is_string($email)) {
                @list($firstName, $lastName) = explode(' ', $user);
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}

                // Resolve user (and set name)
                if ($element = $this->resolveUser($email)) {
                    $element->firstName = $firstName ?: $element->firstName;
                    $element->lastName = $lastName ?: $element->lastName;
                    return $element;
                }

                return new User([
                    'email' => $email,
                    'firstName' => $firstName,
                    'lastName' => $lastName
                ]);
            }

            // An array of [$user]
            if (!$element = $this->resolveUser($user)) {
                return new User([
                    'email' => $user
                ]);
            }

            return $element;
        }

        return null;
    }

    /**
     * @inheritdoc
     */
    public function serialize()
    {
        return serialize([
            'key' => $this->key,
            'recipients' => $this->recipients,
            'params' => $this->params
        ]);
    }

    /**
     * @inheritdoc
     */
    public function unserialize($serialized)
    {
        Craft::configure(
            $this,
            unserialize($serialized)
        );
    }
}


1			<?php
2
3			/**
4			* @copyright Copyright (c) Flipbox Digital Limited
5			* @license https://github.com/flipboxfactory/craft-ember/blob/master/LICENSE
6			* @link https://github.com/flipboxfactory/craft-ember/
7			*/
8
9			namespace flipbox\craft\ember\queries;
10
11			use Craft;
12			use craft\elements\User;
13			use craft\helpers\ArrayHelper;
14			use craft\helpers\StringHelper;
15			use craft\queue\BaseJob;
16			use yii\helpers\Json;
17
18			/**
19			* @author Flipbox Factory <[email protected]>
20			* @since 2.3.2
21			*/
22			class EmailByKey extends BaseJob implements \Serializable
23			{
24			/**
25			* The email key
26			*
27			* @var string
28			*/
29			public $key;
30
31			/**
32			* The recipients
33			*
34			* @var array
35			*/
36			protected $recipients = [];
37
38			/**
39			* The email params
40			*
41			* @var array
42			*/
43			protected $params;
44
45			/**
46			* @inheritdoc
47			* @return string\|null
48			*/
49			protected function defaultDescription()
50			{
51			return 'Sending an email by key.';
52			}
53
54			/**
55			* @inheritdoc
56			* @throws \Exception
57			*/
58			public function execute($queue)
59			{
60			// A random tracking string
61			$id = StringHelper::randomString();
62
63			try {
64			Craft::info(
65			sprintf(
66			"[Sending email via job '%s'.] %s",
67			(string)$id,
68			(string)Json::encode(
69			[
70			'tracking' => $id,
71			'key' => $this->key,
72			'recipients' => $this->recipients
73			]
74			)
75			), __METHOD__
76			);
77
78			foreach ($this->recipients as $recipient) {
79			if (null === ($recipient = $this->resolveUser($recipient))) {
80			continue;
81			}
82
83			/** @var User $recipient */
84
85			if (!Craft::$app->getMailer()
86			->composeFromKey(
87			$this->key,
88			array_merge(
89			['recipient' => $recipient],
90			$this->params
91			)
92			)->setTo($recipient)
93			->send()
94			) {
95			Craft::error(
96			sprintf(
97			"Failed to send email via job '%s'",
98			(string)$id
99			), __METHOD__
100			);
101			continue;
102			}
103
104			Craft::info(
105			sprintf(
106			"Successfully sent email via job '%s'",
107			(string)$id
108			), __METHOD__
109			);
110			}
111
112			} catch (\Exception $e) {
113			Craft::error(
114			sprintf(
115			"Exception caught while trying to run '%s' (Id: %s) job. Exception: [%s].",
116			(string)get_class($this),
117			$id,
118			(string)Json::encode([
119			'Trace' => $e->getTraceAsString(),
120			'File' => $e->getFile(),
121			'Line' => $e->getLine(),
122			'Code' => $e->getCode(),
123			'Message' => $e->getMessage()
124			])
125			), __METHOD__
126			);
127
128			throw $e;
129			}
130			}
131
132			/**
133			* @param array $recipients
134			* @return $this
135			*/
136			public function setRecipients(array $recipients)
137			{
138			foreach ($recipients as $recipient) {
139			$this->addRecipient($recipient);
140			}
141			return $this;
142			}
143
144			/**
145			* @param $recipient
146			* @return $this
147			*/
148			public function addRecipient($recipient)
149			{
150			if ($recipient instanceof User) {
151			$recipient = [$recipient->email];
152			}
153
154			$this->recipients[] = $recipient;
155			return $this;
156			}
157
158			/**
159			* @param $params
160			* @return $this
161			*/
162			public function setParams($params)
163			{
164			$this->params = ArrayHelper::toArray($params);
165			return $this;
166			}
167
168			/**
169			* @param User\|int\|string\|array $user
170			* @return User
171			*/
172			function resolveUser($user)
			0 ignored issues – show Best Practice introduced 2019-03-30 15:48 UTC by Report Bug Copy Issue Report It is generally recommended to explicitly declare the visibility for methods. Adding explicit visibility (`private`, `protected`, or `public`) is generally recommend to communicate to other developers how, and from where this method is intended to be used. Loading history...
173			{
174			if ($user instanceof User) {
175			return $user;
176			}
177
178			// An Id
179			if (is_numeric($user)) {
180			return Craft::$app->getUsers()->getUserById($user);
181			}
182
183			// An email
184			if (is_string($user)) {
185			if (!$element = Craft::$app->getUsers()->getUserByUsernameOrEmail($user)) {
186			$element = new User([
187			'email' => $user
188			]);
189			}
190
191			return $element;
192			}
193
194			if (is_array($user)) {
195			$email = key($user);
196			$user = reset($user);
197
198			// $user was an array [email => name]
199			if (is_string($email)) {
200			@list($firstName, $lastName) = explode(' ', $user);
			0 ignored issues – show Security Best Practice introduced 2019-03-30 15:48 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
201
202			// Resolve user (and set name)
203			if ($element = $this->resolveUser($email)) {
204			$element->firstName = $firstName ?: $element->firstName;
205			$element->lastName = $lastName ?: $element->lastName;
206			return $element;
207			}
208
209			return new User([
210			'email' => $email,
211			'firstName' => $firstName,
212			'lastName' => $lastName
213			]);
214			}
215
216			// An array of [$user]
217			if (!$element = $this->resolveUser($user)) {
218			return new User([
219			'email' => $user
220			]);
221			}
222
223			return $element;
224			}
225
226			return null;
227			}
228
229			/**
230			* @inheritdoc
231			*/
232			public function serialize()
233			{
234			return serialize([
235			'key' => $this->key,
236			'recipients' => $this->recipients,
237			'params' => $this->params
238			]);
239			}
240
241			/**
242			* @inheritdoc
243			*/
244			public function unserialize($serialized)
245			{
246			Craft::configure(
247			$this,
248			unserialize($serialized)
249			);
250			}
251			}
252

flipboxfactory / craft-ember

Push — develop ( c9d3f4...e2b57f )

EmailByKey::execute() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like