Dacastro4\LaravelGmail\Services\Message\Mail

Complexity

Total Complexity

80

Size/Duplication

Total Lines	584
Duplicated Lines	0 %

Importance

Changes	7
Bugs	0	Features	0

35 Methods

Rating	Name	Duplication	Size	Complexity
A	getInternalDate()	0	3	1
A	hasNoParts()	0	6	2
A	getPlainTextBody()	0	5	2
A	setMessage()	0	8	1
A	getFromEmail()	0	7	2
B	extractFromBody()	0	39	11
A	load()	0	5	1
A	__construct()	0	18	4
A	formatEmailList()	0	26	5
A	getDeliveredTo()	0	3	1
A	getSubject()	0	3	1
A	setMetadata()	0	8	3
A	getAttachmentsWithData()	0	3	1
A	getRawPlainTextBody()	0	3	1
A	getLabels()	0	3	1
B	traverseData()	0	25	7
A	getId()	0	3	1
A	buildHeaders()	0	16	2
A	getUser()	0	3	1
A	getBody()	0	15	3
A	getHeaders()	0	3	1
A	getHtmlBody()	0	5	2
A	getTo()	0	5	1
A	getDecodedBody()	0	5	1
A	getRawHtmlBody()	0	3	1
A	getDate()	0	3	1
A	hasAttachments()	0	15	3
A	getReplyTo()	0	5	2
A	getFromName()	0	7	1
A	using()	0	5	1
A	getThreadId()	0	3	1
A	getAttachments()	0	23	4
A	getSize()	0	3	1
A	getFrom()	0	11	3
A	getBodyPart()	0	20	6

<?php

namespace Dacastro4\LaravelGmail\Services\Message;

use Carbon\Carbon;
use Dacastro4\LaravelGmail\GmailConnection;
use Dacastro4\LaravelGmail\Traits\HasDecodableBody;
use Dacastro4\LaravelGmail\Traits\Modifiable;
use Dacastro4\LaravelGmail\Traits\Replyable;
use Google_Service_Gmail;
use Illuminate\Support\Collection;

/**
 * Class SingleMessage
 * @package Dacastro4\LaravelGmail\services
 */
class Mail extends GmailConnection
{
	use HasDecodableBody,

The trait Dacastro4\LaravelGmail\Traits\Modifiable requires the property $users_messages which is not provided by Dacastro4\LaravelGmail\Services\Message\Mail.

The trait Dacastro4\LaravelGmail\Traits\Replyable requires the property $users_messages which is not provided by Dacastro4\LaravelGmail\Services\Message\Mail.

		Modifiable,
		Replyable {
		Replyable::__construct as private __rConstruct;
		Modifiable::__construct as private __mConstruct;
	}

	/**
	 * @var
	 */
	public $id;

	/**
	 * @var
	 */
	public $internalDate;

	/**
	 * @var
	 */
	public $labels;

	/**
	 * @var
	 */
	public $size;

	/**
	 * @var
	 */
	public $threadId;

	/**
	 * @var \Google_Service_Gmail_MessagePart
	 */
	public $payload;

	/**
	 * @var Google_Service_Gmail
	 */
	public $service;

	/**
	 * SingleMessage constructor.
	 *
	 * @param  \Google_Service_Gmail_Message  $message
	 * @param  bool  $preload
	 * @param  bool  $setMessage
	 */
	public function __construct(\Google_Service_Gmail_Message $message = null, $preload = false)
	{

		$this->service = new Google_Service_Gmail($this);

		$this->__rConstruct();
		$this->__mConstruct();
		parent::__construct(config());

The call to Dacastro4\LaravelGmail\Traits\Modifiable::__construct() has too many arguments starting with config().

		if (!is_null($message)) {
			if ($preload) {
				$message = $this->service->users_messages->get('me', $message->getId());
			}

			$this->setMessage($message);

			if($preload) {
				$this->setMetadata();
			}
		}
	}

	protected function setMessage(\Google_Service_Gmail_Message $message)
	{
		$this->id = $message->getId();
		$this->internalDate = $message->getInternalDate();
		$this->labels = $message->getLabelIds();
		$this->size = $message->getSizeEstimate();
		$this->threadId = $message->getThreadId();
		$this->payload = $message->getPayload();
	}

	protected function setMetadata()
	{
		$this->to = $this->getTo();
		$from = $this->getFrom();
		$this->from = isset($from['email']) ? $from['email'] : null;
		$this->nameFrom = isset($from['email']) ? $from['email'] : null;

		$this->subject = $this->getSubject();
	}

	/**
	 * Return a UNIX version of the date
	 *
	 * @return int UNIX date
	 */
	public function getInternalDate()
	{
		return $this->internalDate;
	}

	/**
	 * Returns the labels of the email
	 * Example: INBOX, STARRED, UNREAD
	 *
	 * @return array
	 */
	public function getLabels()
	{
		return $this->labels;
	}

	/**
	 * Returns approximate size of the email
	 *
	 * @return mixed
	 */
	public function getSize()
	{
		return $this->size;
	}

	/**
	 * Returns thread ID of the email
	 *
	 * @return string
	 */
	public function getThreadId()
	{
		return $this->threadId;
	}

	/**
	 * Returns all the headers of the email
	 *
	 * @return Collection
	 */
	public function getHeaders()
	{
		return $this->buildHeaders($this->payload->getHeaders());
	}

	private function buildHeaders($emailHeaders)
	{
		$headers = [];

		foreach ($emailHeaders as $header) {
			/** @var \Google_Service_Gmail_MessagePartHeader $header */

			$head = new \stdClass();

			$head->key = $header->getName();
			$head->value = $header->getValue();

			$headers[] = $head;
		}

		return collect($headers);

	}

	/**
	 * Returns the subject of the email
	 *
	 * @return string
	 */
	public function getSubject()
	{
		return $this->getHeader('Subject');
	}

	/**
	 * Returns the subject of the email
	 *
	 * @return array|string
	 */
	public function getReplyTo()
	{
		$replyTo = $this->getHeader('Reply-To');

		return $this->getFrom($replyTo ? $replyTo : $this->getHeader('From'));

It seems like $replyTo ? $replyTo : $this->getHeader('From') can also be of type string; however, parameter $email of Dacastro4\LaravelGmail\Services\Message\Mail::getFrom() does only seem to accept null, maybe add an additional type check?

	}

	/**
	 * Returns array of name and email of each recipient
	 *
	 * @param  null  $email

Are you sure the doc-type for parameter $email is correct as it would always require null to be passed?

	 * @return array
	 */
	public function getFrom($email = null)
	{
		$from = $email ? $email : $this->getHeader('From');

$email is of type null, thus it always evaluated to false.

		preg_match('/<(.*)>/', $from, $matches);

		$name = preg_replace('/ <(.*)>/', '', $from);

		return [
			'name' => $name,
			'email' => isset($matches[1]) ? $matches[1] : null,
		];
	}

	/**
	 * Returns email of sender
	 *
	 * @return string|null
	 */
	public function getFromEmail()
	{
		$from = $this->getHeader('From');

		preg_match('/<(.*)>/', $from, $matches);

		return isset($matches[1]) ? $matches[1] : null;
	}

	/**
	 * Returns name of the sender
	 *
	 * @return string|null
	 */
	public function getFromName()
	{
		$from = $this->getHeader('From');

		$name = preg_replace('/ <(.*)>/', '', $from);

		return $name;
	}

	/**
	 * Returns array list of recipients
	 *
	 * @return array
	 */
	public function getTo()
	{
		$allTo = $this->getHeader('To');

		return $this->formatEmailList($allTo);
	}

	/**
	 * Returns an array of emails from an string in RFC 822 format
	 *
	 * @param  string  $emails  email list in RFC 822 format
	 *
	 * @return array
	 */
	public function formatEmailList($emails)
	{
		$all = [];
		$explodedEmails = explode(',', $emails);

		foreach ($explodedEmails as $email) {

			$item = [];

			preg_match('/<(.*)>/', $email, $matches);

			$item['email'] = str_replace(' ', '', isset($matches[1]) ? $matches[1] : $email);

			$name = preg_replace('/ <(.*)>/', '', $email);

			if (starts_with($name, ' ')) {
				$name = substr($name, 1);
			}

			$item['name'] = str_replace("\"", '', $name ?: null);

			$all[] = $item;

		}

		return $all;
	}

	/**
	 * Returns the original date that the email was sent
	 *
	 * @return Carbon
	 */
	public function getDate()
	{
		return Carbon::parse($this->getHeader('Date'));
	}

	/**
	 * Returns email of the original recipient
	 *
	 * @return string
	 */
	public function getDeliveredTo()
	{
		return $this->getHeader('Delivered-To');
	}

	/**
	 * @return string base64 version of the body
	 */
	public function getRawPlainTextBody()
	{
		return $this->getPlainTextBody(true);
	}

	/**
	 * @param  bool  $raw
	 *
	 * @return string
	 */
	public function getPlainTextBody($raw = false)
	{
		$content = $this->getBody();

		return $raw ? $content : $this->getDecodedBody($content);
	}

	/**
	 * Returns a specific body part from an email
	 *
	 * @param  string  $type
	 *
	 * @return null|string
	 */
	public function getBody($type = 'text/plain')
	{
		$part = $this->getBodyPart($type);

		if ($part) {
			$body = $part->getBody();

			return $body->getData();

			//if there are no parts in payload, try to get data from body->data
		} elseif ($this->payload->body->data) {
			return $this->payload->body->data;
		}

		return null;
	}

	/**
	 * @param  string  $type
	 *
	 * @return \Google_Service_Gmail_MessagePart|null
	 */
	private function getBodyPart($type = 'text/plain')
	{
		$body = $this->payload->getParts();

		if ($this->hasAttachments()) {
			//Get the first attachment that is the main body
			$body = isset($body[0]) ? $body[0] : [];
			$parts = $body->getParts();
		} else {
			$parts = $body;
		}

		/** @var \Google_Service_Gmail_MessagePart $part */
		foreach ($parts as $part) {
			if ($part->getMimeType() === $type) {
				break;
			}
		}

		return isset($part) ? $part : null;

	}

	/**
	 * @return boolean
	 */
	public function hasAttachments()
	{
		$attachments = 0;
		$parts = $this->payload->getParts();

		/**  @var \Google_Service_Gmail_MessagePart $part */
		foreach ($parts as $part) {
			$body = $part->getBody();
			if ($body->getAttachmentId()) {
				$attachments++;
				break;
			}
		}

		return !!$attachments;
	}

	public function getDecodedBody($content)
	{
		$content = str_replace('_', '/', str_replace('-', '+', $content));

		return base64_decode($content);
	}

	/**
	 * @return string base64 version of the body
	 */
	public function getRawHtmlBody()
	{
		return $this->getHtmlBody(true);
	}

	/**
	 * @param  bool  $raw
	 *
	 * @return string
	 */
	public function getHtmlBody($raw = false)
	{
		$content = $this->getBody('text/html');

		return $raw ? $content : $this->getDecodedBody($content);
	}

	/**
	 * @return Collection
	 * @throws \Exception
	 */
	public function getAttachmentsWithData()
	{
		return $this->getAttachments(true);
	}

	/**
	 * Returns a collection of attachments
	 *
	 * @param  bool  $preload  Preload the attachment's data
	 *
	 * @return Collection
	 * @throws \Exception
	 */
	public function getAttachments($preload = false)
	{
		$attachments = new Collection([]);
		$parts = $this->payload->getParts();

		/** @var \Google_Service_Gmail_MessagePart $part */
		foreach ($parts as $part) {

			$body = $part->getBody();

			if ($body->getAttachmentId()) {
				$attachment = (new Attachment($this->getId(), $part));
				if ($preload) {
					$attachment = $attachment->getData();
				}
				$attachments->push(
					$attachment
				);
			}

		}

		return $attachments;

	}

	/**
	 * Returns ID of the email
	 *
	 * @return string
	 */
	public function getId()
	{
		return $this->id;
	}


	public function getUser()
	{
		return $this->config('email');
	}

	/* added by buckfuddey */

	/**
	 * Get's the gmail information from the Mail
	 *
	 * @return Mail
	 */
	public function load()
	{
		$message = $this->service->users_messages->get('me', $this->getId());

		return new self($message);
	}

	/**
	 * Sets the access token in case we wanna use a different token
	 *
	 * @param  string  $token
	 *
	 * @return Mail
	 */
	public function using($token)
	{
		$this->setToken($token);

		return $this;
	}

	public function extractFromBody()
	{

		if ($this->hasNoParts()) {
			$type = $this->payload->getMimeType();
			$body = $this->payload->getBody();
			if ($type == 'text/html' || $type == 'text/plain') {
				$this->bodyArr[$type] = $this->getDecodedBody($body->getData());

The property bodyArr does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

			}
			if ($body->getAttachmentId()) {
				$this->attachmentData[] = [

The property attachmentData does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

					'id' => $body->getAttachmentId(),
					'mimeType' => $type,
				];
			}
		} else {
			$parts = $this->payload->getParts();
			foreach ($parts as $part) {
				if (empty($part->getParts())) {
					$type = $part->getMimeType();
					$body = $part->getBody();
					if ($type == 'text/html' || $type == 'text/plain') {
						if (isset($this->messageBodyArr[$type])) {
							$this->messageBodyArr[$type] .= $this->getDecodedBody($body->getData());
						} else {
							$this->messageBodyArr[$type] = $this->getDecodedBody($body->getData());

The property messageBodyArr does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

						}
					}

					if ($body->getAttachmentId()) {
						$this->attachmentData[] = [
							'id' => $body->getAttachmentId(),
							'fileName' => $part->getFilename(),
							'mimeType' => $type,
						];
					}
				} else {
					$subParts = $part->getParts();
					$this->traverseData($subParts);
				}
			}
		}
	}

	public function hasNoParts()
	{
		if (empty($this->payload->getParts())) {
			return true;
		} else {
			return false;
		}
	}

	public function traverseData($parts)
	{
		foreach ($parts as $part) {
			if (empty($part->getParts())) {
				$type = $part->getMimeType();
				$body = $part->getBody();
				if ($type == 'text/html' || $type == 'text/plain') {
					if (isset($this->messageBodyArr[$type])) {
						$this->messageBodyArr[$type] .= $this->getDecodedBody($body->getData());
					} else {
						$this->messageBodyArr[$type] = $this->getDecodedBody($body->getData());

The property messageBodyArr does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

					}
				}

				if ($body->getAttachmentId()) {
					$this->attachmentData[] = [

The property attachmentData does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

						'id' => $body->getAttachmentId(),
						'fileName' => $part->getFilename(),
						'mimeType' => $type,
					];

				}
			} else {
				$subParts = $part->getParts();
				$this->traverseData($subParts);
			}
		}
	}

}