各位条子，大家上午好！
今天由小编来教大家 如何利用PHP制作一个奇葩聊天机器人！
小提示！小白可能比较难懂哦！
由于源码比较长，需要的朋友可以私聊小编哦！
废话不多说，上源码！
<?php
namespace BotMan\BotMan;
use Closure;
use Illuminate\Support\Collection;
use BotMan\BotMan\Commands\Command;
use BotMan\BotMan\ message s\Matcher;
use BotMan\BotMan\Drivers\DriverManager;
use BotMan\BotMan\Traits\ProvidesStorage;
use BotMan\BotMan\Interfaces\UserInterface;
use BotMan\BotMan\Messages\Incoming\Answer;
use BotMan\BotMan\Traits\HandlesExceptions;
use BotMan\BotMan\Handlers\ExceptionHandler;
use BotMan\BotMan\Interfaces\CacheInterface;
use BotMan\BotMan\Messages\Attachments\File;
use BotMan\BotMan\Interfaces\DriverInterface;
use BotMan\BotMan\Messages\Attachments\Audio;
use BotMan\BotMan\Messages\Attachments\Image;
use BotMan\BotMan\Messages\Attachments\Video;
use BotMan\BotMan\Messages\Outgoing\Question;
use BotMan\BotMan\Interfaces\StorageInterface;
use BotMan\BotMan\Traits\HandlesConversations;
use Symfony\Component\HttpFoundation\Response;
use BotMan\BotMan\Commands\ConversationManager;
use BotMan\BotMan\Middleware\MiddlewareManager;
use BotMan\BotMan\Messages\Attachments\Location;
use BotMan\BotMan\Exceptions\Base\BotManException;
use BotMan\BotMan\Interfaces\DriverEventInterface;
use BotMan\BotMan\Messages\Incoming\IncomingMessage;
use BotMan\BotMan\Messages\Outgoing\OutgoingMessage;
use BotMan\BotMan\Interfaces\ExceptionHandlerInterface;
use BotMan\BotMan\Exceptions\Core\BadMethodCallException;
use BotMan\BotMan\Exceptions\Core\UnexpectedValueException;
use BotMan\BotMan\Messages\Conversations\InlineConversation;
/**
* 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 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)
{
$this->cache = $cache;
$this->message = new IncomingMessage(”, ”, ”);
$this->driver = $driver;
$this->config = $config;
$this->storage = $storage;
$this->matcher = new Matcher();
$this->middleware = new MiddlewareManager($this);
$this->conversationManager = new ConversationManager();
$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;
}
/**
* Retrieve the chat message.
*
* @return array
*/
public function getMessages()
{
return $this->getDriver()-> getMessage s();
}
/**
* 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 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)
{
$command = new Command($pattern, $callback, $in);
$command->applyGroupAttributes($this->groupAttributes);
$this->conversationManager->listenTo($command);
return $command;
}
/**
* Listen for messaging service events.
*
* @param string $name
* @param Closure|string $callback
*/
public function on($name, $callback)
{
$this->events[] = [
‘name’ => $name,
‘callback’ => $this->getCallable($callback),
];
}
/**
* Listening for image files.
*
* @param $callback
* @return Command
*/
public function receivesImages($callback)
{
return $this->hears(Image::PATTERN, $callback);
}
/**
* Listening for image 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 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 {
$this->verifyServices();
$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;
} 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();
$this->message = $this->middleware->applyMiddleware(‘heard’, $matchingMessage->getMessage(), $this->command->getMiddleware());
$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
)
);
}
