Botonomous\Sender

Complexity

Total Complexity

31

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

80%

Importance

Changes	4
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getSlackbot()	0	4	1
A	setSlackbot()	0	4	1
A	getLoggerUtility()	0	8	2
A	setLoggerUtility()	0	4	1
A	getConfig()	0	8	2
A	setConfig()	0	4	1
A	getApiClient()	0	8	2
A	setApiClient()	0	4	1
A	getClient()	0	8	2
A	setClient()	0	4	1
C	send()	0	36	8
A	respondToSlashCommand()	0	16	1
A	respondToSlack()	0	4	1
A	respondAsJSON()	0	9	2
A	getResponseType()	0	21	4

<?php

namespace Botonomous;

use Botonomous\client\ApiClient;
use Botonomous\utility\LoggerUtility;
use /* @noinspection PhpUndefinedClassInspection */
    GuzzleHttp\Client;
use /* @noinspection PhpUndefinedClassInspection */
    GuzzleHttp\Psr7\Request;

class Sender
{
    private $slackbot;
    private $loggerUtility;
    private $config;
    private $apiClient;
    private $client;

    /**
     * Sender constructor.
     *
     * @param AbstractBot $slackbot
     */
    public function __construct(AbstractBot $slackbot)
    {
        $this->setSlackbot($slackbot);
    }

    /**
     * @return Slackbot
     */
    public function getSlackbot()
    {
        return $this->slackbot;
    }

    /**
     * @param AbstractBot $slackbot
     */
    public function setSlackbot(AbstractBot $slackbot)
    {
        $this->slackbot = $slackbot;
    }

    /**
     * Final endpoint for the response.
     *
     * @param $channel
     * @param $response
     * @param $attachments
     *
     * @throws \Exception
     *
     * @return bool
     */
    public function send($channel, $response, $attachments = null)
    {
        // @codeCoverageIgnoreStart
        if ($this->getSlackbot()->getListener()->isThisBot() !== false) {
            return false;
        }
        // @codeCoverageIgnoreEnd

        $responseType = $this->getResponseType();
        $debug = (bool) $this->getSlackbot()->getRequest('debug');

        if (empty($channel)) {
            $channel = $this->getConfig()->get('channel');
        }

        $data = [
            'text'    => $response,
            'channel' => $channel,
        ];

        if ($attachments !== null) {
            $data['attachments'] = json_encode($attachments);
        }

        $this->getLoggerUtility()->logChat(__METHOD__, $response, $channel);

        if ($responseType === 'slack') {
            $this->respondToSlack($data);
        } elseif ($responseType === 'slashCommand') {
            $this->respondToSlashCommand($response);
        } elseif ($responseType === 'json' || $debug === true) {
            $this->respondAsJSON($data);
        }

        return true;
    }

    /**
     * @param $response
     */
    private function respondToSlashCommand($response)
    {
        /** @noinspection PhpUndefinedClassInspection */
        $request = new Request(
            'POST',
            $this->getSlackbot()->getRequest('response_url'),
            ['Content-Type' => 'application/json'],
            json_encode([
                'text'          => $response,
                'response_type' => 'in_channel',
            ])
        );

        /* @noinspection PhpUndefinedClassInspection */
        $this->getClient()->send($request);
    }

    /**
     * @param $data
     */
    private function respondToSlack($data)
    {
        $this->getApiClient()->chatPostMessage($data);
    }

    /**
     * @param $data
     */
    private function respondAsJSON($data)
    {
        // headers_sent is used to avoid issue in the test
        if (!headers_sent()) {
            header('Content-type:application/json;charset=utf-8');
        }

        echo json_encode($data);
    }

    /**
     * @return LoggerUtility
     */
    public function getLoggerUtility()
    {
        if (!isset($this->loggerUtility)) {
            $this->setLoggerUtility(new LoggerUtility());
        }

        return $this->loggerUtility;
    }

    /**
     * @param LoggerUtility $loggerUtility
     */
    public function setLoggerUtility(LoggerUtility $loggerUtility)
    {
        $this->loggerUtility = $loggerUtility;
    }

    /**
     * @return Config
     */
    public function getConfig()
    {
        if (!isset($this->config)) {
            $this->config = (new Config());
        }

        return $this->config;
    }

    /**
     * @param Config $config
     */
    public function setConfig(Config $config)
    {
        $this->config = $config;
    }

    /**
     * @return ApiClient
     */
    public function getApiClient()
    {
        if (!isset($this->apiClient)) {
            $this->setApiClient(new ApiClient());
        }

        return $this->apiClient;
    }

    /**
     * @param ApiClient $apiClient
     */
    public function setApiClient(ApiClient $apiClient)
    {
        $this->apiClient = $apiClient;
    }

    /**
     * @return Client
     */
    public function getClient()
    {
        if (!isset($this->client)) {
            $this->setClient(new Client());
        }

        return $this->client;
    }

    /**
     * @param Client $client
     */
    public function setClient(Client $client)
    {
        $this->client = $client;
    }

    /**
     * Specify the response type
     * If response in config is set to empty, it will be considered based on listenerType
     *
     * @return mixed|string
     */
    private function getResponseType()
    {
        $responseType = $this->getConfig()->get('response');

        if (!empty($responseType)) {
            // Maybe later add a check for response type validation
            return $responseType;
        }

        // response type in the config is empty, so choose it based on listener type

        $listenerType = $this->getConfig()->get('listenerType');
        switch ($listenerType) {
            case 'slashCommand':
                return 'slashCommand';
            case 'event':
                return 'slack';
            default:
                return 'json';
        }
    }
}