Botonomous\Slackbot

Complexity

Total Complexity

55

Size/Duplication

Total Lines	431
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	16

Test Coverage

Coverage

92.52%

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	getCommands()	0	8	2
A	setCommands()	0	4	1
A	getLastError()	0	4	1
A	setLastError()	0	4	1
A	getCurrentCommand()	0	4	1
A	setCurrentCommand()	0	4	1
A	__construct()	0	8	2
A	setTimezone()	0	5	1
A	getRequest()	0	4	1
A	handleMessageActions()	0	15	2
B	handleSendResponse()	0	41	5
B	checkAccessControl()	0	23	4
A	run()	0	13	4
A	handleOAuth()	0	4	1
A	handleUrlVerification()	0	10	2
A	preProcessRequest()	0	14	2
B	respond()	0	24	4
A	getPluginClassByCommand()	0	14	2
B	getCommandByMessage()	0	22	4
B	getCommandObjectByMessage()	0	22	4
A	getCommandObjectByCommand()	0	14	3
A	validateCommandObject()	0	18	3
A	youTalkingToMe()	0	16	4

<?php

namespace Botonomous;

use Botonomous\listener\EventListener;
use Botonomous\plugin\AbstractPlugin;

/**
 * Class Botonomous.
 */
class Slackbot extends AbstractBot
{
    private $commands;
    private $lastError;
    private $currentCommand;

    /**
     * Botonomous constructor.
     *
     * @param Config|null $config
     *
     * @throws \Exception
     */
    public function __construct(Config $config = null)
    {
        if ($config !== null) {
            $this->setConfig($config);
        }

        $this->setTimezone();
    }

    /**
     * Set the timezone.
     */
    private function setTimezone()
    {
        // set timezone
        date_default_timezone_set($this->getConfig()->get('timezone'));
    }

    /**
     * @param null|string $key
     *
     * @return mixed
     */
    public function getRequest($key = null)
    {
        return $this->getListener()->getRequest($key);
    }

    /**
     * @return AbstractBaseSlack|null|void
     */
    private function handleMessageActions()
    {
        $post = $this->getRequestUtility()->getPost();

        // ignore if payload is not set
        if (!isset($post['payload'])) {
            /* @noinspection PhpInconsistentReturnPointsInspection */
            return;
        }

        // posted payload is in JSON
        $payload = json_decode($post['payload'], true);

        return (new MessageAction())->load($payload);
    }

    /**
     * @throws \Exception
     */
    private function handleSendResponse()
    {
        // 1. Start listening
        $this->getListener()->listen();

        // 2. verify the request
        try {
            $verificationResult = $this->getListener()->verifyRequest();

            if ($verificationResult['success'] !== true) {
                throw new \Exception($verificationResult['message']);
            }
        } catch (\Exception $e) {
            throw $e;
        }

        // 3. pre process the request
        $this->preProcessRequest();

        // 4. check access control
        if ($this->checkAccessControl() !== true) {
            return;
        }

        // 5. set the current command
        $message = $this->getListener()->getMessage();
        $this->setCurrentCommand($this->getMessageUtility()->extractCommandName($message));

        // 6. log the message
        $this->getLoggerUtility()->logChat(__METHOD__, $message);

        // 7. send confirmation message if is enabled
        $this->getSender()->sendConfirmation();

        // 8. And send the response to the channel, only if the response is not empty
        $response = $this->respond($message);

        if (!empty($response)) {
            $this->getSender()->send($response);
        }
    }

    /**
     * @return bool
     */
    private function checkAccessControl()
    {
        // if accessControlEnabled is not set true ignore the check and return true
        if ($this->getConfig()->get('accessControlEnabled') !== true) {
            return true;
        }

        if ($this->getBlackList()->isBlackListed() !== false) {
            // found in blacklist
            $this->getSender()->send($this->getDictionary()->get('generic-messages')['blacklistedMessage']);

            return false;
        }

        if ($this->getWhiteList()->isWhiteListed() !== true) {
            // not found in whitelist
            $this->getSender()->send($this->getDictionary()->get('generic-messages')['whitelistedMessage']);

            return false;
        }

        return true;
    }

    /**
     * @throws \Exception
     */
    public function run()
    {
        switch ($this->getListener()->determineAction()) {
            case 'oauth':
                return $this->handleOAuth();
            case 'message_actions':
                return $this->handleMessageActions();
            case 'url_verification':
                return $this->handleUrlVerification();
            default:
                return $this->handleSendResponse();
        }
    }

    /**
     * handle OAuth.
     */
    private function handleOAuth()
    {
        return $this->getOauth()->doOauth();
    }

    /**
     * @throws \Exception
     */
    private function handleUrlVerification()
    {
        $request = $this->getRequestUtility()->getPostedBody();

        if (empty($request['challenge'])) {
            throw new \Exception('Challenge is missing for URL verification');
        }

        echo $request['challenge'];
    }

    /**
     * Pre-process the request.
     */
    private function preProcessRequest()
    {
        $request = $this->getListener()->getRequest();

        // remove the trigger_word from beginning of the message
        if (!empty($request['trigger_word'])) {
            $request['text'] = $this->getMessageUtility()->removeTriggerWord(
                $request['text'],
                $request['trigger_word']
            );

            $this->getListener()->setRequest($request);
        }
    }

    /**
     * @param null $message
     *
     * @throws \Exception
     *
     * @return mixed
     */
    public function respond($message = null)
    {
        try {
            $command = $this->getCommandByMessage($message);

            if (!$command instanceof Command) {
                // something went wrong, error will tell us!
                return $this->getLastError();
            }

            $pluginClass = $this->getPluginClassByCommand($command);

            // check action exists
            $action = $command->getAction();
            if (!method_exists($pluginClass, $action)) {
                $className = get_class($pluginClass);
                throw new \Exception("Action / function: '{$action}' does not exist in '{$className}'");
            }

            return $pluginClass->$action();
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * Get plugin class by command.
     *
     * @param Command $command
     *
     * @throws \Exception
     *
     * @return AbstractPlugin
     */
    private function getPluginClassByCommand(Command $command)
    {
        // create the class
        $pluginClassFile = $command->getClass();
        $pluginClass = new $pluginClassFile($this);

        // check class is valid
        if (!$pluginClass instanceof AbstractPlugin) {
            $className = get_class($pluginClass);
            throw new \Exception("Couldn't create class: '{$className}'");
        }

        return $pluginClass;
    }

    /**
     * @param null $message
     *
     * @throws \Exception
     *
     * @return bool|Command|void
     */
    public function getCommandByMessage($message = null)
    {
        // If message is not set, get it from the current request
        if ($message === null) {
            $message = $this->getListener()->getMessage();
        }

        if (empty($message)) {
            $this->setLastError('Message is empty');

            return false;
        }

        /*
         * Process the message.
         */
        try {
            return $this->getCommandObjectByMessage($message);
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * @param $message
     *
     * @throws \Exception
     *
     * @return bool|Command|void
     */
    private function getCommandObjectByMessage($message)
    {
        $command = $this->getMessageUtility()->extractCommandName($message);

        // check command name
        if (empty($command)) {
            // get the default command if no command is find in the message
            $command = $this->getConfig()->get('defaultCommand');

            if (empty($command)) {
                $this->setLastError($this->getDictionary()->get('generic-messages')['noCommandMessage']);

                return false;
            }
        }

        try {
            return $this->getCommandObjectByCommand($command);
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * @param $command
     *
     * @throws \Exception
     *
     * @return bool|Command|void
     */
    private function getCommandObjectByCommand($command)
    {
        try {
            $commandObject = $this->getCommandContainer()->getAsObject($command);

            if ($this->validateCommandObject($commandObject) !== true) {
                return false;
            }

            return $commandObject;
        } catch (\Exception $e) {
            throw $e;
        }
    }

    /**
     * Validate the command object.
     *
     * @param Command|null $commandObject
     *
     * @throws \Exception
     *
     * @return bool
     */
    private function validateCommandObject($commandObject)
    {
        // check command details
        if (empty($commandObject)) {
            $this->setLastError(
                $this->getDictionary()->getValueByKey('generic-messages', 'unknownCommandMessage')
            );

            return false;
        }

        // check the plugin for the command
        if (empty($commandObject->getPlugin())) {
            throw new \Exception('Plugin is not set for this command');
        }

        return true;
    }

    /**
     * @return array
     */
    public function getCommands()
    {
        if (!isset($this->commands)) {
            $this->setCommands($this->getCommandContainer()->getAllAsObject());
        }

        return $this->commands;
    }

    /**
     * @param array $commands
     */
    public function setCommands(array $commands)
    {
        $this->commands = $commands;
    }

    /**
     * @return string
     */
    public function getLastError()
    {
        return $this->lastError;
    }

    /**
     * @param string $lastError
     */
    public function setLastError($lastError)
    {
        $this->lastError = $lastError;
    }

    /**
     * Return the current command.
     *
     * @return string
     */
    public function getCurrentCommand()
    {
        return $this->currentCommand;
    }

    /**
     * @param string $currentCommand
     */
    public function setCurrentCommand($currentCommand)
    {
        $this->currentCommand = $currentCommand;
    }

    /**
     * Determine if bot user id is mentioned in the message.
     *
     * @return bool
     */
    public function youTalkingToMe()
    {
        $message = $this->getListener()->getMessage();

        if (empty($message)) {
            return false;
        }

        if ($this->getMessageUtility()->isBotMentioned($message) === true) {
            return true;
        }

        $listener = $this->getListener();
        // check direct messages
        return $listener instanceof EventListener && $listener->getEvent()->isDirectMessage() === true;
    }
}