Mail::getPlainTextBody() - Code Metrics - Inspection of "v2.0" - dacastro4/laravel-gmail - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#87)

by Daniel
created 2019-06-25 18:00 UTC
Mail::getPlainTextBody() A

↳ Parent: Mail
Complexity

Conditions	2
Paths	2
Size

Total Lines	5
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	2
eloc	2
c	1
b	0
f	0
nc	2
nop	1
dl	0
loc	5
rs	10
<?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,

		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());
          __construct(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'));
		return $this->getFrom(/** @scrutinizer ignore-type */ $replyTo ? $replyTo : $this->getHeader('From'));
	}

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

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


		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());

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

					'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());

						}
					}

					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());

					}
				}

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

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

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

}

dacastro4 / laravel-gmail

Pull Request — master (#87)

Mail::getPlainTextBody() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
