Replyable::markdown() - Code Metrics - Inspection of "Merge pull request #234 from TheMyintOo/features/m..." - dacastro4/laravel-gmail - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3bea0d...2ba6bf )

by Daniel

created 2022-08-31 15:32 UTC

Replyable::markdown() A

↳ Parent: Replyable

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	5
nc	2
nop	2
dl	0
loc	11
rs	10
c	0
b	0
f	0

<?php

namespace Dacastro4\LaravelGmail\Traits;

use Dacastro4\LaravelGmail\Services\Message\Mail;
use Google_Service_Gmail;
use Google_Service_Gmail_Message;
use Illuminate\Container\Container;
use Illuminate\Mail\Markdown;
use Swift_Attachment;
use Swift_Message;
use Symfony\Component\HttpFoundation\File\Exception\FileNotFoundException;

/**
 * @property Google_Service_Gmail $service
 */
trait Replyable
{
	use HasHeaders;

	private $swiftMessage;

	/**
	 * Gmail optional parameters
	 *
	 * @var array
	 */
	private $parameters = [];

	/**
	 * Text or html message to send
	 *
	 * @var string
	 */
	private $message;

	/**
	 * Subject of the email
	 *
	 * @var string
	 */
	private $subject;

	/**
	 * Sender's email
	 *
	 * @var string
	 */
	private $from;

	/**
	 * Sender's name
	 *
	 * @var  string
	 */
	private $nameFrom;

	/**
	 * Email of the recipient
	 *
	 * @var string|array
	 */
	private $to;

	/**
	 * Name of the recipient
	 *
	 * @var string
	 */
	private $nameTo;

	/**
	 * Single email or array of email for a carbon copy
	 *
	 * @var array|string
	 */
	private $cc;

	/**
	 * Name of the recipient
	 *
	 * @var string
	 */
	private $nameCc;

	/**
	 * Single email or array of email for a blind carbon copy
	 *
	 * @var array|string
	 */
	private $bcc;

	/**
	 * Name of the recipient
	 *
	 * @var string
	 */
	private $nameBcc;

	/**
	 * List of attachments
	 *
	 * @var array
	 */
	private $attachments = [];

	private $priority = 2;

	public function __construct()
	{
		$this->swiftMessage = new Swift_Message();
	}

	/**
	 * Receives the recipient's
	 * If multiple recipients will receive the message an array should be used.
	 * Example: array('[email protected]', '[email protected]' => 'A name')
	 *
	 * If $name is passed and the first parameter is a string, this name will be
	 * associated with the address.
	 *
	 * @param  string|array  $to
	 *
	 * @param  string|null  $name
	 *
	 * @return Replyable
	 */
	public function to($to, $name = null)
	{
		$this->to = $to;
		$this->nameTo = $name;

		return $this;
	}

	public function from($from, $name = null)
	{
		$this->from = $from;
		$this->nameFrom = $name;

		return $this;
	}

	/**
	 * @param  array|string  $cc
	 *
	 * @param  string|null  $name
	 *
	 * @return Replyable
	 */
	public function cc($cc, $name = null)
	{
		$this->cc = $this->emailList($cc, $name);
		$this->nameCc = $name;

		return $this;
	}

	private function emailList($list, $name = null)
	{
		if (is_array($list)) {
			return $this->convertEmailList($list, $name);
		} else {
			return $list;
		}
	}

	private function convertEmailList($emails, $name = null)
	{
		$newList = [];
		$count = 0;
		foreach ($emails as $key => $email) {
			$emailName = isset($name[$count]) ? $name[$count] : explode('@', $email)[0];
			$newList[$email] = $emailName;
			$count = $count + 1;
		}

		return $newList;
	}

	/**
	 * @param  array|string  $bcc
	 *
	 * @param  string|null  $name
	 *
	 * @return Replyable
	 */
	public function bcc($bcc, $name = null)
	{
		$this->bcc = $this->emailList($bcc, $name);
		$this->nameBcc = $name;

		return $this;
	}

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

		return $this;
	}

	/**
	 * @param  string  $view
	 * @param  array  $data
	 * @param  array  $mergeData
	 *
	 * @return Replyable
	 * @throws \Throwable
	 */
	public function view($view, $data = [], $mergeData = [])
	{
		$this->message = view($view, $data, $mergeData)->render();

		return $this;
	}

    /**
     * loads markdown file for message body
     *
     * @throws \Throwable
     * @return Replyable
     */
    public function markdown(string $markdown_view, array $data = [])
    {
        $markdown = Container::getInstance()->make(Markdown::class);

        if (config('mail.markdown.theme')) {
            $markdown->theme(config('mail.markdown.theme'));
        }

        $this->message = $markdown->render($markdown_view, $data);

        return $this;
    }

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

		return $this;
	}

	/**
	 * Attaches new file to the email from the Storage folder
	 *
	 * @param  array  $files  comma separated of files
	 *
	 * @return Replyable
	 * @throws \Exception
	 */
	public function attach(...$files)
	{

		foreach ($files as $file) {

			if (!file_exists($file)) {
				throw new FileNotFoundException($file);
			}

			array_push($this->attachments, $file);
		}

		return $this;
	}

	/**
	 * The value is an integer where 1 is the highest priority and 5 is the lowest.
	 *
	 * @param  int  $priority
	 *
	 * @return Replyable
	 */
	public function priority($priority)
	{
		$this->priority = $priority;

		return $this;
	}

	/**
	 * @param  array  $parameters
	 *
	 * @return Replyable
	 */
	public function optionalParameters(array $parameters)
	{
		$this->parameters = $parameters;

		return $this;
	}

	/**
	 * Reply to a specific email
	 *
	 * @return Mail
	 * @throws \Exception
	 */
	public function reply()
	{
		if (!$this->getId()) {
			throw new \Exception('This is a new email. Use send().');
		}

		$this->setReplyThread();
		$this->setReplySubject();
		$this->setReplyTo();
		$this->setReplyFrom();
		$body = $this->getMessageBody();
		$body->setThreadId($this->getThreadId());

		return new Mail($this->service->users_messages->send('me', $body, $this->parameters));
	}

	public abstract function getId();

	private function setReplyThread()
	{
		$threadId = $this->getThreadId();
		if ($threadId) {
			$this->setHeader('In-Reply-To', $this->getMessageIdHeader());
			$this->setHeader('References', $this->getHeader('References'));
			$this->setHeader('Message-ID', $this->getMessageIdHeader());
		}
	}
	
	private function getMessageIdHeader() {
		if($this->getHeader('Message-ID')) {
			return $this->getHeader('Message-ID');
		}
		if($this->getHeader('Message-Id')) {
			return $this->getHeader('Message-Id');
		}
		return null;
	}

	public abstract function getThreadId();

	/**
	 * Add a header to the email
	 *
	 * @param  string  $header
	 * @param  string  $value
	 */
	public function setHeader($header, $value)
	{
		$headers = $this->swiftMessage->getHeaders();

		$headers->addTextHeader($header, $value);

	}

	private function setReplySubject()
	{
		if (!$this->subject) {
			$this->subject = $this->getSubject();
		}
	}

	private function setReplyTo()
	{
		if (!$this->to) {
			$replyTo = $this->getReplyTo();

			$this->to = $replyTo['email'];
			$this->nameTo = $replyTo['name'];
		}
	}

	private function setReplyFrom()
	{
		if (!$this->from) {
			$this->from = $this->getUser();
			if(!$this->from) {
				throw new \Exception('Reply from is not defined');
			}
		}
	}

	public abstract function getSubject();

	public abstract function getReplyTo();

	public abstract function getUser();

	/**
	 * @return Google_Service_Gmail_Message
	 */
	private function getMessageBody()
	{
		$body = new Google_Service_Gmail_Message();

		$this->swiftMessage
			->setSubject($this->subject)
			->setFrom($this->from, $this->nameFrom)
			->setTo($this->to, $this->nameTo)
			->setCc($this->cc, $this->nameCc)
			->setBcc($this->bcc, $this->nameBcc)
			->setBody($this->message, 'text/html')
			->setPriority($this->priority);

		foreach ($this->attachments as $file) {
			$this->swiftMessage
				->attach(Swift_Attachment::fromPath($file));
		}

		$body->setRaw($this->base64_encode($this->swiftMessage->toString()));

		return $body;
	}

	private function base64_encode($data)
	{
		return rtrim(strtr(base64_encode($data), ['+' => '-', '/' => '_']), '=');
	}

	/**
	 * Sends a new email
	 *
	 * @return self|Mail
	 */
	public function send()
	{
		$body = $this->getMessageBody();

		$this->setMessage($this->service->users_messages->send('me', $body, $this->parameters));

		return $this;
	}

	protected abstract function setMessage(\Google_Service_Gmail_Message $message);
}


1			<?php
2
3			namespace Dacastro4\LaravelGmail\Traits;
4
5			use Dacastro4\LaravelGmail\Services\Message\Mail;
6			use Google_Service_Gmail;
7			use Google_Service_Gmail_Message;
8			use Illuminate\Container\Container;
9			use Illuminate\Mail\Markdown;
10			use Swift_Attachment;
11			use Swift_Message;
12			use Symfony\Component\HttpFoundation\File\Exception\FileNotFoundException;
13
14			/**
15			* @property Google_Service_Gmail $service
16			*/
17			trait Replyable
18			{
19			use HasHeaders;
20
21			private $swiftMessage;
22
23			/**
24			* Gmail optional parameters
25			*
26			* @var array
27			*/
28			private $parameters = [];
29
30			/**
31			* Text or html message to send
32			*
33			* @var string
34			*/
35			private $message;
36
37			/**
38			* Subject of the email
39			*
40			* @var string
41			*/
42			private $subject;
43
44			/**
45			* Sender's email
46			*
47			* @var string
48			*/
49			private $from;
50
51			/**
52			* Sender's name
53			*
54			* @var string
55			*/
56			private $nameFrom;
57
58			/**
59			* Email of the recipient
60			*
61			* @var string\|array
62			*/
63			private $to;
64
65			/**
66			* Name of the recipient
67			*
68			* @var string
69			*/
70			private $nameTo;
71
72			/**
73			* Single email or array of email for a carbon copy
74			*
75			* @var array\|string
76			*/
77			private $cc;
78
79			/**
80			* Name of the recipient
81			*
82			* @var string
83			*/
84			private $nameCc;
85
86			/**
87			* Single email or array of email for a blind carbon copy
88			*
89			* @var array\|string
90			*/
91			private $bcc;
92
93			/**
94			* Name of the recipient
95			*
96			* @var string
97			*/
98			private $nameBcc;
99
100			/**
101			* List of attachments
102			*
103			* @var array
104			*/
105			private $attachments = [];
106
107			private $priority = 2;
108
109			public function __construct()
110			{
111			$this->swiftMessage = new Swift_Message();
112			}
113
114			/**
115			* Receives the recipient's
116			* If multiple recipients will receive the message an array should be used.
117			* Example: array('[email protected]', '[email protected]' => 'A name')
118			*
119			* If $name is passed and the first parameter is a string, this name will be
120			* associated with the address.
121			*
122			* @param string\|array $to
123			*
124			* @param string\|null $name
125			*
126			* @return Replyable
127			*/
128			public function to($to, $name = null)
129			{
130			$this->to = $to;
131			$this->nameTo = $name;
132
133			return $this;
134			}
135
136			public function from($from, $name = null)
137			{
138			$this->from = $from;
139			$this->nameFrom = $name;
140
141			return $this;
142			}
143
144			/**
145			* @param array\|string $cc
146			*
147			* @param string\|null $name
148			*
149			* @return Replyable
150			*/
151			public function cc($cc, $name = null)
152			{
153			$this->cc = $this->emailList($cc, $name);
154			$this->nameCc = $name;
155
156			return $this;
157			}
158
159			private function emailList($list, $name = null)
160			{
161			if (is_array($list)) {
162			return $this->convertEmailList($list, $name);
163			} else {
164			return $list;
165			}
166			}
167
168			private function convertEmailList($emails, $name = null)
169			{
170			$newList = [];
171			$count = 0;
172			foreach ($emails as $key => $email) {
173			$emailName = isset($name[$count]) ? $name[$count] : explode('@', $email)[0];
174			$newList[$email] = $emailName;
175			$count = $count + 1;
176			}
177
178			return $newList;
179			}
180
181			/**
182			* @param array\|string $bcc
183			*
184			* @param string\|null $name
185			*
186			* @return Replyable
187			*/
188			public function bcc($bcc, $name = null)
189			{
190			$this->bcc = $this->emailList($bcc, $name);
191			$this->nameBcc = $name;
192
193			return $this;
194			}
195
196			/**
197			* @param string $subject
198			*
199			* @return Replyable
200			*/
201			public function subject($subject)
202			{
203			$this->subject = $subject;
204
205			return $this;
206			}
207
208			/**
209			* @param string $view
210			* @param array $data
211			* @param array $mergeData
212			*
213			* @return Replyable
214			* @throws \Throwable
215			*/
216			public function view($view, $data = [], $mergeData = [])
217			{
218			$this->message = view($view, $data, $mergeData)->render();
219
220			return $this;
221			}
222
223			/**
224			* loads markdown file for message body
225			*
226			* @throws \Throwable
227			* @return Replyable
228			*/
229			public function markdown(string $markdown_view, array $data = [])
230			{
231			$markdown = Container::getInstance()->make(Markdown::class);
232
233			if (config('mail.markdown.theme')) {
234			$markdown->theme(config('mail.markdown.theme'));
235			}
236
237			$this->message = $markdown->render($markdown_view, $data);
238
239			return $this;
240			}
241
242			/**
243			* @param string $message
244			*
245			* @return Replyable
246			*/
247			public function message($message)
248			{
249			$this->message = $message;
250
251			return $this;
252			}
253
254			/**
255			* Attaches new file to the email from the Storage folder
256			*
257			* @param array $files comma separated of files
258			*
259			* @return Replyable
260			* @throws \Exception
261			*/
262			public function attach(...$files)
263			{
264
265			foreach ($files as $file) {
266
267			if (!file_exists($file)) {
268			throw new FileNotFoundException($file);
269			}
270
271			array_push($this->attachments, $file);
272			}
273
274			return $this;
275			}
276
277			/**
278			* The value is an integer where 1 is the highest priority and 5 is the lowest.
279			*
280			* @param int $priority
281			*
282			* @return Replyable
283			*/
284			public function priority($priority)
285			{
286			$this->priority = $priority;
287
288			return $this;
289			}
290
291			/**
292			* @param array $parameters
293			*
294			* @return Replyable
295			*/
296			public function optionalParameters(array $parameters)
297			{
298			$this->parameters = $parameters;
299
300			return $this;
301			}
302
303			/**
304			* Reply to a specific email
305			*
306			* @return Mail
307			* @throws \Exception
308			*/
309			public function reply()
310			{
311			if (!$this->getId()) {
312			throw new \Exception('This is a new email. Use send().');
313			}
314
315			$this->setReplyThread();
316			$this->setReplySubject();
317			$this->setReplyTo();
318			$this->setReplyFrom();
319			$body = $this->getMessageBody();
320			$body->setThreadId($this->getThreadId());
321
322			return new Mail($this->service->users_messages->send('me', $body, $this->parameters));
323			}
324
325			public abstract function getId();
326
327			private function setReplyThread()
328			{
329			$threadId = $this->getThreadId();
330			if ($threadId) {
331			$this->setHeader('In-Reply-To', $this->getMessageIdHeader());
332			$this->setHeader('References', $this->getHeader('References'));
333			$this->setHeader('Message-ID', $this->getMessageIdHeader());
334			}
335			}
336
337			private function getMessageIdHeader() {
338			if($this->getHeader('Message-ID')) {
339			return $this->getHeader('Message-ID');
340			}
341			if($this->getHeader('Message-Id')) {
342			return $this->getHeader('Message-Id');
343			}
344			return null;
345			}
346
347			public abstract function getThreadId();
348
349			/**
350			* Add a header to the email
351			*
352			* @param string $header
353			* @param string $value
354			*/
355			public function setHeader($header, $value)
356			{
357			$headers = $this->swiftMessage->getHeaders();
358
359			$headers->addTextHeader($header, $value);
360
361			}
362
363			private function setReplySubject()
364			{
365			if (!$this->subject) {
366			$this->subject = $this->getSubject();
367			}
368			}
369
370			private function setReplyTo()
371			{
372			if (!$this->to) {
373			$replyTo = $this->getReplyTo();
374
375			$this->to = $replyTo['email'];
376			$this->nameTo = $replyTo['name'];
377			}
378			}
379
380			private function setReplyFrom()
381			{
382			if (!$this->from) {
383			$this->from = $this->getUser();
384			if(!$this->from) {
385			throw new \Exception('Reply from is not defined');
386			}
387			}
388			}
389
390			public abstract function getSubject();
391
392			public abstract function getReplyTo();
393
394			public abstract function getUser();
395
396			/**
397			* @return Google_Service_Gmail_Message
398			*/
399			private function getMessageBody()
400			{
401			$body = new Google_Service_Gmail_Message();
402
403			$this->swiftMessage
404			->setSubject($this->subject)
405			->setFrom($this->from, $this->nameFrom)
406			->setTo($this->to, $this->nameTo)
407			->setCc($this->cc, $this->nameCc)
408			->setBcc($this->bcc, $this->nameBcc)
409			->setBody($this->message, 'text/html')
410			->setPriority($this->priority);
411
412			foreach ($this->attachments as $file) {
413			$this->swiftMessage
414			->attach(Swift_Attachment::fromPath($file));
415			}
416
417			$body->setRaw($this->base64_encode($this->swiftMessage->toString()));
418
419			return $body;
420			}
421
422			private function base64_encode($data)
423			{
424			return rtrim(strtr(base64_encode($data), ['+' => '-', '/' => '_']), '=');
425			}
426
427			/**
428			* Sends a new email
429			*
430			* @return self\|Mail
431			*/
432			public function send()
433			{
434			$body = $this->getMessageBody();
435
436			$this->setMessage($this->service->users_messages->send('me', $body, $this->parameters));
437
438			return $this;
439			}
440
441			protected abstract function setMessage(\Google_Service_Gmail_Message $message);
442			}
443

dacastro4 / laravel-gmail

Push — master ( 3bea0d...2ba6bf )

Replyable::markdown() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like