CwsOps\LivePerson\Services\AbstractService

Complexity

Total Complexity

14

Size/Duplication

Total Lines	165
Duplicated Lines	0 %

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	handle()	0	21	6
A	log()	0	3	1
A	dateTimeToMilliseconds()	0	3	1
A	getStatus()	0	8	1
A	__construct()	0	15	2
A	arrayToList()	0	3	1
A	getResponse()	0	8	2

<?php
/**
 * Created by PhpStorm.
 * User: james
 * Date: 19/07/2018
 * Time: 12:17
 */

namespace CwsOps\LivePerson\Services;

use CwsOps\LivePerson\Account\Config;
use CwsOps\LivePerson\Rest\Request;
use CwsOps\LivePerson\Rest\UrlBuilder;
use CwsOps\LivePerson\Traits\HasLoggerTrait;
use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;

/**
 * Class AbstractService
 *
 * @package CwsOps\LivePerson\Services
 */
abstract class AbstractService
{
    use HasLoggerTrait;

    const REQUEST_TYPE_V1 = 1;
    const REQUEST_TYPE_V2 = 2;

    const GLUE_CHAR = ',';

    /** @var UrlBuilder */
    protected $urlBuilder;
    /** @var Config */
    protected $config;
    /** @var LoggerInterface */
    private $logger;
    /** @var int */
    private $retryLimit;
    /** @var Request */
    protected $request;
    /** @var bool $responseSent */
    private $responseSent;
    /** @var \stdClass */
    protected $response;

    /**
     * AbstractService constructor.
     *
     * @param Config $config
     * @param int $retryLimit
     * @param LoggerInterface|null $logger
     */
    public function __construct(Config $config, int $retryLimit = 3, LoggerInterface $logger = null)
    {
        if ($retryLimit > 5) {
            throw new \InvalidArgumentException(
                sprintf('Maximum $retryLimit is 5 you tried setting %d, try setting a value between 0 and 5',
                    $retryLimit)
            );
        }


        $this->config = $config;
        $this->retryLimit = $retryLimit;
        $this->logger = $this->hasLogger($logger);

        $this->request = new Request($config, $retryLimit, $logger);
    }


    /**
     * @codeCoverageIgnore
     * Gets the current status of the account api.
     * @return array|\stdClass
     */
    public function getStatus()
    {
        // @codeCoverageIgnore
        $url = "https://status.liveperson.com/json?site={$this->config->getAccountId()}";

        $response = $this->request->v1($url, Request::METHOD_GET);

        return $response;
    }

    /**
     * Gets the response.
     *
     * @return \stdClass
     *
     * @throws RequestNotSentException
     */
    public function getResponse()
    {
        if (!$this->responseSent) {
            throw new RequestNotSentException();
        }


        return $this->response; //@codeCoverageIgnore
    }

    /**
     * Should provide the Live person domain id, this service will query against
     *
     * @return string
     */
    abstract protected function getDomain(): string;

    /**
     * Should provide the Live Person service the service will query against.
     *
     * @return string
     */
    abstract protected function getService(): string;


    /**
     * @codeCoverageIgnore
     * Handles the request and sets the response property.
     *
     * @param array $data Any data to pass in the request
     * @param string $method the HTTP request type.
     * @param int $type what type of request to make.
     *
     */
    protected function handle($data = [], $method = Request::METHOD_GET, $type = AbstractService::REQUEST_TYPE_V1)
    {
        // Check if the URL was built.
        if (!$this->urlBuilder->isUrlBuilt()) {
            $this->urlBuilder->build();
            $this->logger->debug("The URL was not built when trying to handle the request");
        }

        if ($type === self::REQUEST_TYPE_V1) {
            try {
                $this->response = $this->request->v1($this->urlBuilder->getUrl(), $method, $data);

It seems like $this->request->v1($this->urlBuilder->getUrl(), $method, $data) can also be of type array. However, the property $response is declared as type stdClass. Maybe add an additional type check?

                $this->responseSent = true;
            } catch (\Exception $exception) {
                $this->logger->error("An exception occurred while the request took place: %s", $exception->getMessage());

$exception->getMessage() of type string is incompatible with the type array expected by parameter $context of Psr\Log\LoggerInterface::error().

            }
        } elseif ($type === self::REQUEST_TYPE_V2) {
            try {
                $this->response = $this->request->v2($this->urlBuilder->getUrl(), $method, $data);
                $this->responseSent = true;
            } catch (\Exception $exception) {
                $this->logger->error("An exception occurred while the request took place: %s", $exception->getMessage());
            }
        }
    }

    /**
     * Converts a datetime obj into a int represents milliseconds since the epoc.
     *
     * @param \DateTime $dateTime
     *
     * @return int
     */
    protected function dateTimeToMilliseconds(\DateTime $dateTime)
    {
        return strtotime($dateTime->format('Y-m-d H:i:sP'));
    }

    /**
     * Converts a array to a string separated by a glue character.
     *
     * @param array $list the array to separate.
     * @param string $glueChar the character to glue the values together with.
     *
     * @return string the generated string.
     */
    protected function arrayToList(array $list, $glueChar = AbstractService::GLUE_CHAR)
    {
        return rtrim(implode($glueChar, $list), $glueChar);
    }

    /**
     * Logs an entry to the logger.
     *
     * @param string $message the message to log.
     * @param string $logLevel the level to log at.
     * @param array $context any additional context.
     */
    protected function log(string $message, string $logLevel = LogLevel::DEBUG, array $context = [])
    {
        $this->logger->log($logLevel, $message, $context);
    }
}