Symfony Profiler

<?php
namespace BotMan\BotMan;
use BotMan\BotMan\Commands\Command;
use BotMan\BotMan\Commands\ConversationManager;
use BotMan\BotMan\Drivers\DriverManager;
use BotMan\BotMan\Exceptions\Base\BotManException;
use BotMan\BotMan\Exceptions\Core\BadMethodCallException;
use BotMan\BotMan\Exceptions\Core\UnexpectedValueException;
use BotMan\BotMan\Handlers\ExceptionHandler;
use BotMan\BotMan\Interfaces\CacheInterface;
use BotMan\BotMan\Interfaces\DriverEventInterface;
use BotMan\BotMan\Interfaces\DriverInterface;
use BotMan\BotMan\Interfaces\ExceptionHandlerInterface;
use BotMan\BotMan\Interfaces\Middleware\Heard;
use BotMan\BotMan\Interfaces\StorageInterface;
use BotMan\BotMan\Interfaces\UserInterface;
use BotMan\BotMan\Messages\Attachments\Audio;
use BotMan\BotMan\Messages\Attachments\Contact;
use BotMan\BotMan\Messages\Attachments\File;
use BotMan\BotMan\Messages\Attachments\Image;
use BotMan\BotMan\Messages\Attachments\Location;
use BotMan\BotMan\Messages\Attachments\Video;
use BotMan\BotMan\Messages\Conversations\InlineConversation;
use BotMan\BotMan\Messages\Incoming\Answer;
use BotMan\BotMan\Messages\Incoming\IncomingMessage;
use BotMan\BotMan\Messages\Matcher;
use BotMan\BotMan\Messages\Outgoing\OutgoingMessage;
use BotMan\BotMan\Messages\Outgoing\Question;
use BotMan\BotMan\Middleware\MiddlewareManager;
use BotMan\BotMan\Traits\HandlesConversations;
use BotMan\BotMan\Traits\HandlesExceptions;
use BotMan\BotMan\Traits\ProvidesStorage;
use Closure;
use Illuminate\Support\Collection;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
use Symfony\Component\HttpFoundation\Response;
/**
* Class BotMan.
*/
class BotMan
{
use ProvidesStorage,
HandlesConversations,
HandlesExceptions;
/** @var \Illuminate\Support\Collection */
protected $event;
/** @var Command */
protected $command;
/** @var IncomingMessage */
protected $message;
/** @var OutgoingMessage|Question */
protected $outgoingMessage;
/** @var string */
protected $driverName;
/** @var array|null */
protected $currentConversationData;
/** @var ExceptionHandlerInterface */
protected $exceptionHandler;
/**
* IncomingMessage service events.
* @var array
*/
protected $events = [];
/**
* The fallback message to use, if no match
* could be heard.
* @var callable|null
*/
protected $fallbackMessage;
/** @var array */
protected $groupAttributes = [];
/** @var array */
protected $matches = [];
/** @var DriverInterface */
protected $driver;
/** @var array */
protected $config = [];
/** @var MiddlewareManager */
public $middleware;
/** @var ConversationManager */
protected $conversationManager;
/** @var CacheInterface */
private $cache;
/** @var ContainerInterface */
protected $container;
/** @var StorageInterface */
protected $storage;
/** @var Matcher */
protected $matcher;
/** @var bool */
protected $loadedConversation = false;
/** @var bool */
protected $firedDriverEvents = false;
/** @var bool */
protected $runsOnSocket = false;
/**
* BotMan constructor.
* @param CacheInterface $cache
* @param DriverInterface $driver
* @param array $config
* @param StorageInterface $storage
*/
public function __construct(CacheInterface $cache, DriverInterface $driver, $config, StorageInterface $storage, ?Matcher $matcher = null)
{
$this->config = $config;
$this->config['bot_id'] = $this->config['bot_id'] ?? '';
$this->cache = $cache;
$this->message = new IncomingMessage('', '', '', null, $this->config['bot_id']);
$this->driver = $driver;
$this->storage = $storage;
$this->matcher = new Matcher();
$this->middleware = new MiddlewareManager($this);
$this->conversationManager = new ConversationManager($matcher);
$this->exceptionHandler = new ExceptionHandler();
}
/**
* Set a fallback message to use if no listener matches.
*
* @param callable $callback
*/
public function fallback($callback)
{
$this->fallbackMessage = $callback;
}
/**
* @param string $name The Driver name or class
*/
public function loadDriver($name)
{
$this->driver = DriverManager::loadFromName($name, $this->config);
}
/**
* @param DriverInterface $driver
*/
public function setDriver(DriverInterface $driver)
{
$this->driver = $driver;
}
/**
* @return DriverInterface
*/
public function getDriver()
{
return $this->driver;
}
/**
* @param ContainerInterface $container
*/
public function setContainer(ContainerInterface $container)
{
$this->container = $container;
}
/**
* Retrieve the chat message.
*
* @return array
*/
public function getMessages()
{
return $this->getDriver()->getMessages();
}
/**
* Retrieve the chat message that are sent from bots.
*
* @return array
*/
public function getBotMessages()
{
return Collection::make($this->getDriver()->getMessages())->filter(function (IncomingMessage $message) {
return $message->isFromBot();
})->toArray();
}
/**
* @return Answer
*/
public function getConversationAnswer()
{
return $this->getDriver()->getConversationAnswer($this->message);
}
/**
* @param bool $running
* @return bool
*/
public function runsOnSocket($running = null)
{
if (\is_bool($running)) {
$this->runsOnSocket = $running;
}
return $this->runsOnSocket;
}
/**
* @return UserInterface
*/
public function getUser()
{
if ($user = $this->cache->get('user_' . $this->driver->getName() . '_' . $this->getMessage()->getSender())) {
return $user;
}
$user = $this->getDriver()->getUser($this->getMessage());
$this->cache->put(
'user_' . $this->driver->getName() . '_' . $user->getId(),
$user,
$this->config['user_cache_time'] ?? 30
);
return $user;
}
/**
* Get the parameter names for the route.
*
* @param $value
* @return array
*/
protected function compileParameterNames($value)
{
preg_match_all(Matcher::PARAM_NAME_REGEX, $value, $matches);
return array_map(function ($m) {
return trim($m, '?');
}, $matches[1]);
}
/**
* @param array|string $pattern the pattern to listen for
* @param Closure|string $callback the callback to execute. Either a closure or a Class@method notation
* @param string $in the channel type to listen to (either direct message or public channel)
* @return Command
*/
public function hears($pattern, $callback, $in = null)
{
if (is_array($pattern)) {
$pattern = '(?|' . implode('|', $pattern) . ')';
}
$command = new Command($pattern, $callback, $in);
$command->applyGroupAttributes($this->groupAttributes);
$this->conversationManager->listenTo($command);
return $command;
}
/**
* Listen for messaging service events.
*
* @param array|string $names
* @param Closure|string $callback
*/
public function on($names, $callback)
{
if (!is_array($names)) {
$names = [$names];
}
$callable = $this->getCallable($callback);
foreach ($names as $name) {
$this->events[] = [
'name' => $name,
'callback' => $callable,
];
}
}
/**
* Listening for image files.
*
* @param $callback
* @return Command
*/
public function receivesImages($callback)
{
return $this->hears(Image::PATTERN, $callback);
}
/**
* Listening for video files.
*
* @param $callback
* @return Command
*/
public function receivesVideos($callback)
{
return $this->hears(Video::PATTERN, $callback);
}
/**
* Listening for audio files.
*
* @param $callback
* @return Command
*/
public function receivesAudio($callback)
{
return $this->hears(Audio::PATTERN, $callback);
}
/**
* Listening for location attachment.
*
* @param $callback
* @return Command
*/
public function receivesLocation($callback)
{
return $this->hears(Location::PATTERN, $callback);
}
/**
* Listening for contact attachment.
*
* @param $callback
*
* @return Command
*/
public function receivesContact($callback)
{
return $this->hears(Contact::PATTERN, $callback);
}
/**
* Listening for files attachment.
*
* @param $callback
* @return Command
*/
public function receivesFiles($callback)
{
return $this->hears(File::PATTERN, $callback);
}
/**
* Create a command group with shared attributes.
*
* @param array $attributes
* @param \Closure $callback
*/
public function group(array $attributes, Closure $callback)
{
$previousGroupAttributes = $this->groupAttributes;
$this->groupAttributes = array_merge_recursive($previousGroupAttributes, $attributes);
\call_user_func($callback, $this);
$this->groupAttributes = $previousGroupAttributes;
}
/**
* Fire potential driver event callbacks.
*/
protected function fireDriverEvents()
{
$driverEvent = $this->getDriver()->hasMatchingEvent();
if ($driverEvent instanceof DriverEventInterface) {
$this->firedDriverEvents = true;
Collection::make($this->events)->filter(function ($event) use ($driverEvent) {
return $driverEvent->getName() === $event['name'];
})->each(function ($event) use ($driverEvent) {
/**
* Load the message, so driver events can reply.
*/
$messages = $this->getDriver()->getMessages();
if (isset($messages[0])) {
$this->message = $messages[0];
}
\call_user_func_array($event['callback'], [$driverEvent->getPayload(), $this]);
});
}
}
/**
* Try to match messages with the ones we should
* listen to.
*/
public function listen()
{
try {
$isVerificationRequest = $this->verifyServices();
if (!$isVerificationRequest) {
$this->fireDriverEvents();
if ($this->firedDriverEvents === false) {
$this->loadActiveConversation();
if ($this->loadedConversation === false) {
$this->callMatchingMessages();
}
}
/*
* If the driver has a "messagesHandled" method, call it.
* This method can be used to trigger driver methods
* once the messages are handles.
*/
if (method_exists($this->getDriver(), 'messagesHandled')) {
$this->getDriver()->messagesHandled();
}
$this->firedDriverEvents = false;
$this->message = new IncomingMessage('', '', '', null, $this->config['bot_id']);
}
} catch (\Throwable $e) {
$this->exceptionHandler->handleException($e, $this);
}
}
/**
* Call matching message callbacks.
*/
protected function callMatchingMessages()
{
$matchingMessages = $this->conversationManager->getMatchingMessages(
$this->getMessages(),
$this->middleware,
$this->getConversationAnswer(),
$this->getDriver()
);
foreach ($matchingMessages as $matchingMessage) {
$this->command = $matchingMessage->getCommand();
$callback = $this->command->getCallback();
$callback = $this->getCallable($callback);
// Set the message first, so it's available for middlewares
$this->message = $matchingMessage->getMessage();
$commandMiddleware = Collection::make($this->command->getMiddleware())->filter(function ($middleware) {
return $middleware instanceof Heard;
})->toArray();
$this->message = $this->middleware->applyMiddleware(
'heard',
$matchingMessage->getMessage(),
$commandMiddleware
);
$parameterNames = $this->compileParameterNames($this->command->getPattern());
$parameters = $matchingMessage->getMatches();
if (\count($parameterNames) !== \count($parameters)) {
$parameters = array_merge(
//First, all named parameters (eg. function ($a, $b, $c))
array_filter(
$parameters,
'\is_string',
ARRAY_FILTER_USE_KEY
),
//Then, all other unsorted parameters (regex non named results)
array_filter(
$parameters,
'\is_integer',
ARRAY_FILTER_USE_KEY
)
);
}
$this->matches = $parameters;
array_unshift($parameters, $this);
$parameters = $this->conversationManager->addDataParameters($this->message, $parameters);
if (call_user_func_array($callback, array_values($parameters))) {
return;
}
}
if (empty($matchingMessages) && empty($this->getBotMessages()) && !\is_null($this->fallbackMessage)) {
$this->callFallbackMessage();
}
}
/**
* Call the fallback method.
*/
protected function callFallbackMessage()
{
$messages = $this->getMessages();
if (!isset($messages[0])) {
return;
}
$this->message = $messages[0];
$this->fallbackMessage = $this->getCallable($this->fallbackMessage);
\call_user_func($this->fallbackMessage, $this);
}
/**
* Verify service webhook URLs.
*
* @return bool
*/
protected function verifyServices()
{
return DriverManager::verifyServices($this->config);
}
/**
* @param string|Question|OutgoingMessage $message
* @param string|array $recipients
* @param string|DriverInterface|null $driver
* @param array $additionalParameters
* @return Response
* @throws BotManException
*/
public function say($message, $recipients, $driver = null, $additionalParameters = [])
{
if ($driver === null && $this->driver === null) {
throw new BotManException('The current driver can\'t be NULL');
}
$previousDriver = $this->driver;
$previousMessage = $this->message;
if ($driver instanceof DriverInterface) {
$this->setDriver($driver);
} elseif (\is_string($driver)) {
$this->setDriver(DriverManager::loadFromName($driver, $this->config));
}
$recipients = \is_array($recipients) ? $recipients : [$recipients];
foreach ($recipients as $recipient) {
$this->message = new IncomingMessage('', $recipient, '', null, $this->config['bot_id'] ?? '');
$response = $this->reply($message, $additionalParameters);
}
$this->message = $previousMessage;
$this->driver = $previousDriver;
return $response;
}
/**
* @param string|Question $question
* @param array|Closure $next
* @param array $additionalParameters
* @param null|string $recipient
* @param null|string $driver
* @return Response
*/
public function ask($question, $next, $additionalParameters = [], $recipient = null, $driver = null)
{
if (!\is_null($recipient) && !\is_null($driver)) {
if (\is_string($driver)) {
$driver = DriverManager::loadFromName($driver, $this->config);
}
$this->message = new IncomingMessage('', $recipient, '', null, $this->config['bot_id']);
$this->setDriver($driver);
}
$response = $this->reply($question, $additionalParameters);
$this->storeConversation(new InlineConversation, $next, $question, $additionalParameters);
return $response;
}
/**
* @return $this
*/
public function types()
{
$this->getDriver()->types($this->message);
return $this;
}
/**
* @param float $seconds Number of seconds to wait
* @return $this
*/
public function typesAndWaits(float $seconds)
{
$this->getDriver()->typesAndWaits($this->message, $seconds);
return $this;
}
/**
* Low-level method to perform driver specific API requests.
*
* @param string $endpoint
* @param array $additionalParameters
* @return $this
* @throws BadMethodCallException
*/
public function sendRequest($endpoint, $additionalParameters = [])
{
$driver = $this->getDriver();
if (method_exists($driver, 'sendRequest')) {
return $driver->sendRequest($endpoint, $additionalParameters, $this->message);
}
throw new BadMethodCallException('The driver ' . $this->getDriver()->getName() . ' does not support low level requests.');
}
/**
* @param string|OutgoingMessage|Question $message
* @param array $additionalParameters
* @return mixed
*/
public function reply($message, $additionalParameters = [])
{
$this->outgoingMessage = \is_string($message) ? OutgoingMessage::create($message) : $message;
return $this->sendPayload($this->getDriver()->buildServicePayload(
$this->outgoingMessage,
$this->message,
$additionalParameters
));
}
/**
* @param $payload
* @return mixed
*/
public function sendPayload($payload)
{
return $this->middleware->applyMiddleware('sending', $payload, [], function ($payload) {
$this->outgoingMessage = null;
return $this->getDriver()->sendPayload($payload);
});
}
/**
* Return a random message.
* @param array $messages
* @return $this
*/
public function randomReply(array $messages)
{
return $this->reply($messages[array_rand($messages)]);
}
/**
* Make an action for an invokable controller.
*
* @param string $action
* @return string
* @throws UnexpectedValueException
*/
protected function makeInvokableAction($action)
{
if (!method_exists($action, '__invoke')) {
throw new UnexpectedValueException(sprintf(
'Invalid hears action: [%s]',
$action
));
}
return $action . '@__invoke';
}
/**
* @param mixed $callback
* @return mixed
* @throws UnexpectedValueException
* @throws NotFoundExceptionInterface
*/
protected function getCallable($callback)
{
if (is_callable($callback)) {
return $callback;
}
if (strpos($callback, '@') === false) {
$callback = $this->makeInvokableAction($callback);
}
[$class, $method] = explode('@', $callback);
$command = $this->container ? $this->container->get($class) : new $class($this);
return [$command, $method];
}
/**
* @return array
*/
public function getMatches()
{
return $this->matches;
}
/**
* @return IncomingMessage
*/
public function getMessage()
{
return $this->message;
}
/**
* @return OutgoingMessage|Question
*/
public function getOutgoingMessage()
{
return $this->outgoingMessage;
}
/**
* @param string $name
* @param array $arguments
* @return mixed
* @throws BadMethodCallException
*/
public function __call($name, $arguments)
{
if (method_exists($this->getDriver(), $name)) {
// Add the current message to the passed arguments
$arguments[] = $this->getMessage();
$arguments[] = $this;
return \call_user_func_array([$this->getDriver(), $name], array_values($arguments));
}
throw new BadMethodCallException('Method [' . $name . '] does not exist.');
}
/**
* Load driver on wakeup.
*/
public function __wakeup()
{
$this->driver = DriverManager::loadFromName($this->driverName, $this->config);
}
/**
* @return array
*/
public function __sleep()
{
$this->driverName = $this->driver->getName();
return [
'event',
'exceptionHandler',
'driverName',
'storage',
'message',
'cache',
'matches',
'matcher',
'config',
'middleware',
];
}
}

vendor/botman/botman/src/BotMan.php line 430