Zanzara\Listener\ListenerResolver::resolveListeners()

Complexity

Conditions	12
Paths	6

Size

Total Lines	68
Code Lines	45

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	0

<?php
    public function resolveListeners(Update $update): PromiseInterface
    {
        $deferred = new Deferred();
        $listeners = [];
        $updateType = $update->getUpdateType();
        $this->mergeListenersByType($listeners, $updateType);
        $this->mergeListenersByType($listeners, Update::class);

        switch ($updateType) {

            case CallbackQuery::class:
                $chatId = $update->getEffectiveChat() ? $update->getEffectiveChat()->getId() : null;
                $callbackQuery = $update->getCallbackQuery();
                $text = $callbackQuery->getMessage() ? $callbackQuery->getMessage()->getText() : null;
                $this->conversationManager->getConversationHandler($chatId)
                    ->then(function ($handlerInfo) use ($deferred, $callbackQuery, $text, &$listeners) {
                        if (!$handlerInfo) { // if we are not in a conversation, call the listeners as usual
                            if ($text) {
                                $this->findListenerAndPush($listeners, 'cb_query_texts', $text);
                            }
                            if ($callbackQuery->getData()) {
                                $this->findListenerAndPush($listeners, 'cb_query_data', $callbackQuery->getData());
                            }
                        } else { // if we are in a conversation, redirect it only to the conversation step
                            $listeners[] = new Listener($handlerInfo[0], $this->container);
                        }
                        $deferred->resolve($listeners);
                    })->otherwise(function ($e) use ($deferred) {

The method otherwise() does not exist on React\Promise\PromiseInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Zanzara\Test\PromiseWrapper\ZanzaraPromise or React\Promise\CancellablePromiseInterface. Are you sure you never get one of those?

                        // if something goes wrong, reject the promise
                        $deferred->reject($e);
                    });
                break;

            case Message::class:
                $text = $update->getMessage()->getText();
                $chatId = $update->getEffectiveChat()->getId();
                $this->conversationManager->getConversationHandler($chatId)
                    ->then(function ($handlerInfo) use ($chatId, $text, $deferred, &$listeners) {
                        if (!$handlerInfo) { // if we are not in a conversation, call the listeners as usual
                            $this->findListenerAndPush($listeners, 'messages', $text);
                        } elseif (!$handlerInfo[1] && $text) {
                            // if we are in a conversation, and listeners are not skipped by the step call,
                            // try to call the matching listeners
                            $listener = $this->findListenerAndPush($listeners, 'messages', $text, true);
                            if (!$listener) {
                                // if no listeners are found, call the next conversation step
                                $listeners[] = new Listener($handlerInfo[0], $this->container);
                            } else {
                                // if listener is found, escape the conversation
                                $this->conversationManager->deleteConversationCache($chatId);
                            }
                        } else {
                            // if the coversation is forcing only the conversation handlers,
                            // skip the other listeners
                            $listeners[] = new Listener($handlerInfo[0], $this->container);
                        }
                        $deferred->resolve($listeners);
                    })->otherwise(function ($e) use ($deferred) {
                        // if something goes wrong, reject the promise
                        $deferred->reject($e);
                    });
                break;

            default:
                $deferred->resolve($listeners);
        }

        return $deferred->promise();
    }