FondBot\Conversation\ConversationManager

Complexity

Total Complexity

32

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	10

Test Coverage

Coverage

24.39%

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	registerFallbackIntent()	0	4	1
B	matchIntent()	0	18	5
B	resolveContext()	0	24	3
A	saveContext()	0	7	1
A	flushContext()	0	6	1
A	getContext()	0	8	2
A	setReceivedMessage()	0	4	1
A	markAsTransitioned()	0	4	1
A	transitioned()	0	4	1
A	converse()	0	8	2
A	transition()	0	12	2
A	restart()	0	12	3
B	__destruct()	0	18	5
A	getCacheKeyForContext()	0	4	1
A	registerIntent()	0	4	1
A	getIntents()	0	4	1

<?php

declare(strict_types=1);

namespace FondBot\Conversation;

use FondBot\Channels\Chat;
use FondBot\Channels\User;
use FondBot\Channels\Channel;
use InvalidArgumentException;
use Illuminate\Cache\Repository;
use FondBot\Events\MessageReceived;
use FondBot\Contracts\Conversation\Manager;
use FondBot\Contracts\Conversation\Conversable;
use Illuminate\Contracts\Foundation\Application;

class ConversationManager implements Manager
{
    private $intents = [];
    private $fallbackIntent;

    private $application;
    private $cache;

    private $transitioned = false;

    private $messageReceived;

    public function __construct(Application $application, Repository $cache)
    {
        $this->application = $application;
        $this->cache = $cache;
    }

    /** {@inheritdoc} */
    public function registerIntent(string $class): void
    {
        $this->intents[] = $class;
    }

    /** {@inheritdoc} */
    public function registerFallbackIntent(string $class): void
    {
        $this->fallbackIntent = $class;
    }

    /** {@inheritdoc} */
    public function getIntents(): array
    {
        return $this->intents;
    }

    /** {@inheritdoc} */
    public function matchIntent(MessageReceived $messageReceived): ?Intent
    {
        foreach ($this->intents as $intent) {
            /** @var Intent $intent */
            $intent = resolve($intent);

$intent is of type object<FondBot\Conversation\Intent>, but the function expects a string.

            $activators = (new ActivatorParser($intent->activators()))->getResult();

            foreach ($activators as $activator) {
                if ($activator->matches($messageReceived) && $intent->passesAuthorization($messageReceived)) {
                    return $intent;
                }
            }
        }

        // Otherwise, return fallback intent
        return resolve($this->fallbackIntent);
    }

    /** {@inheritdoc} */
    public function resolveContext(Channel $channel, Chat $chat, User $user): Context
    {
        $value = $this->cache->get($this->getCacheKeyForContext($channel, $chat, $user), [
            'chat' => $chat,
            'user' => $user,
            'intent' => null,
            'interaction' => null,
        ]);

        $context = new Context($channel, $chat, $user);

        if ($value['intent'] !== null) {
            $context->setIntent(resolve($value['intent']));
        }

        if ($value['interaction'] !== null) {
            $context->setInteraction(resolve($value['interaction']));
        }

        // Bind resolved instance to the container
        $this->application->instance('fondbot.conversation.context', $context);

        return $context;
    }

    /** {@inheritdoc} */
    public function saveContext(Context $context): void
    {
        $this->cache->forever(
            $this->getCacheKeyForContext($context->getChannel(), $context->getChat(), $context->getUser()),
            $context->toArray()
        );
    }

    /** {@inheritdoc} */
    public function flushContext(Context $context): void
    {
        $this->cache->forget(
            $this->getCacheKeyForContext($context->getChannel(), $context->getChat(), $context->getUser())
        );
    }

    /** {@inheritdoc} */
    public function getContext(): ?Context
    {
        if (!$this->application->has('fondbot.conversation.context')) {
            return null;
        }

        return $this->application->get('fondbot.conversation.context');
    }

    /** {@inheritdoc} */
    public function setReceivedMessage(MessageReceived $messageReceived): void
    {
        $this->messageReceived = $messageReceived;
    }

    /** {@inheritdoc} */
    public function markAsTransitioned(): void
    {
        $this->transitioned = true;
    }

    /** {@inheritdoc} */
    public function transitioned(): bool
    {
        return $this->transitioned;
    }

    /** {@inheritdoc} */
    public function converse(Conversable $conversable): void
    {
        if ($conversable instanceof Intent) {
            context()->setIntent($conversable)->setInteraction(null);
        }

        $conversable->handle($this->messageReceived);
    }

    /** {@inheritdoc} */
    public function transition(string $conversable): void
    {
        /** @var Interaction $instance */
        $instance = resolve($conversable);

        if (!$instance instanceof Conversable) {
            throw new InvalidArgumentException('Invalid conversable `'.$conversable.'`');
        }

        $this->converse($instance, $this->messageReceived);

The call to ConversationManager::converse() has too many arguments starting with $this->messageReceived.

        $this->markAsTransitioned();
    }

    /** {@inheritdoc} */
    public function restart(Conversable $conversable): void
    {
        if ($conversable instanceof Intent) {
            $this->markAsTransitioned();
        }

        $this->converse($conversable);

        if ($conversable instanceof Interaction) {
            $this->markAsTransitioned();
        }
    }

    public function __destruct()
    {
        $context = $this->getContext();

        if ($context === null) {
            return;
        }

        // Close session if conversation has not been transitioned
        if (!$this->transitioned()) {
            $this->flushContext($context);
        }

        // Save context if exists
        if ($this->transitioned() && $context = context()) {
            $this->saveContext($context);
        }
    }

    private function getCacheKeyForContext(Channel $channel, Chat $chat, User $user): string
    {
        return implode('.', ['context', $channel->getName(), $chat->getId(), $user->getId()]);
    }
}