Added closer integration with DiscordPHP

- Listening for INTEGRATION_CREATE event

Author: davidcole1340

README.md

@@ -66,12 +66,20 @@ $client->deleteCommand($command);
 
 ### `Discord\Slash\Client`
 
+There are two ways to set up the slash client:
+- Webhook method
+- Gateway method (recommended)
+
+Please read both sections as both have important information and both have advantages/disadvantages.
+
+#### Webhook method
+
 Now that you have registered commands, you can set up an HTTP server to listen for requests from Discord.
 
 There are a few ways to set up an HTTP server to listen for requests:
 - The built-in ReactPHP HTTP server.
-- Using an external HTTP server such as Apache or nginx.
 - Using the built-in ReactPHP HTTP server without HTTPS and using Apache or nginx as a reverse proxy (recommended).
+- Using an external HTTP server such as Apache or nginx.
 
 Whatever path you choose, the server **must** be protected with HTTPS - Discord will not accept regular HTTP.
 
@@ -122,7 +130,7 @@ $client->registerCommand('hello', function (Interaction $interaction, Choices $c
 $client->run();
 ```
 
-This library only handles slash commands, and there is no support for any other interactions with Discord such as creating channels, sending other messages etc. You can easily combine the DiscordPHP library with this library to have a much larger collection of tools. All you must do is ensure both clients share the same ReactPHP event loop. In the future, there will be more integration between the libraries. Here is an example:
+This library only handles slash commands, and there is no support for any other interactions with Discord such as creating channels, sending other messages etc. You can easily combine the DiscordPHP library with this library to have a much larger collection of tools. All you must do is ensure both clients share the same ReactPHP event loop. Here is an example:
 
 ```php
 <?php
@@ -145,11 +153,20 @@ $client = new Client([
     'loop' =>  $discord->getLoop(),
 ]);
 
+$client->linkDiscord($discord, false); // false signifies that we still want to use the HTTP server - default is true, which will use gateway
+
 $discord->on('ready', function (Discord $discord) {
     // DiscordPHP is ready
 });
 
 $client->registerCommand('my_cool_command', function (Interaction $interaction, Choices $choices) use ($discord) {
+    // there are a couple fields in $interaction that will return DiscordPHP parts:
+    $interaction->guild;
+    $interaction->channel;
+    $interaction->member;
+
+    // if you don't link DiscordPHP, it will simply return raw arrays
+
     $discord->guilds->get('id', 'coolguild')->members->ban(); // do something ?
     $interaction->acknowledge();
 });
@@ -212,12 +229,50 @@ $ vim /etc/apache2/sites-available/000-default.conf # default site
         SSLCertificateFile      /path/to/ssl/cert.crt           # change to your cert path
         SSLCertificateKeyFile   /path/to/ssl/cert.key           # change to your key path
 </VirtualHost>
-``` 
+```
 3. Restart apache - the code below works on Debian-based systems:
 ```shell
 $ sudo service apache2 restart
 ```
 
+#### Gateway method (recommended)
+
+The client can connect with a regular [DiscordPHP](https://github.com/discord-php/DiscordPHP) client to listen for interactions over gateway.
+To use this method, make sure there is no interactions endpoint set in your Discord developer application.
+
+Make sure you have included DiscordPHP into your project (at the time of writing, only DiscordPHP `develop` branch is supported):
+
+```sh
+$ composer require team-reflex/discord-php dev-develop
+```
+
+You can then create both clients and link them:
+
+```php
+<?php
+
+include 'vendor/autoload.php';
+
+use Discord\Discord;
+use Discord\Slash\Client;
+
+$discord = new Discord([
+    'token' => 'abcd.efdgh.asdas',
+]);
+
+$client = new Client([
+    'loop' => $discord->getLoop(), // Discord and Client MUST share event loops
+]);
+
+$client->linkDiscord($discord);
+
+$client->registerCommand(...);
+
+$discord->run();
+```
+
+The gateway method is much easier to set up as you do not have to worry about SSL certificates.
+
 ## License
 
 This software is licensed under the GNU General Public License v3.0 which can be viewed in the LICENSE.md file.

composer.json

@@ -15,17 +15,20 @@
         "symfony/options-resolver": "^5.2",
         "monolog/monolog": "^2.2",
         "guzzlehttp/guzzle": "^7.2",
-        "discord/interactions": "^1.0"
+        "discord/interactions": "^1.0",
+        "discord-php/http": "^8.0"
     },
     "autoload": {
         "psr-4": {
             "Discord\\Slash\\": "src/Discord"
         }
     },
     "require-dev": {
-        "symfony/var-dumper": "^5.2"
+        "symfony/var-dumper": "^5.2",
+        "team-reflex/discord-php": "dev-develop"
     },
     "suggest": {
-        "kambo/httpmessage": "Required for hosting the command server behind a CGI/FPM server."
+        "kambo/httpmessage": "Required for hosting the command server behind a CGI/FPM server.",
+        "team-reflex/discord-php": "Provides an easier interface, where interactions are sent via websocket rather than a webhook."
     }
 }

src/Discord/Client.php

@@ -11,11 +11,15 @@
 
 namespace Discord\Slash;
 
+use Discord\Discord;
+use Discord\Http\Drivers\React;
+use Discord\Http\Http;
 use Discord\Interaction as DiscordInteraction;
 use Discord\InteractionResponseType;
 use Discord\InteractionType;
 use Discord\Slash\Parts\Interaction;
 use Discord\Slash\Parts\RegisteredCommand;
+use Discord\WebSockets\Event;
 use Exception;
 use InvalidArgumentException;
 use Kambo\Http\Message\Environment\Environment;
@@ -32,6 +36,7 @@
 use React\Promise\Promise;
 use React\Socket\Server as SocketServer;
 use Symfony\Component\OptionsResolver\OptionsResolver;
+use Throwable;
 
 /**
  * The Client class acts as an HTTP web server to handle requests from Discord when a command
@@ -72,18 +77,90 @@ class Client
      */
     private $commands;
 
+    /**
+     * ReactPHP event loop.
+     *
+     * @var LoopInterface
+     */
+    private $loop;
+
     /**
      * Logger for client.
      *
      * @var LoggerInterface
      */
     private $logger;
 
+    /**
+     * Optional Discord client.
+     *
+     * @var \Discord\Discord
+     */
+    private $discord;
+
+    /**
+     * Will we listen for gateway events or start HTTP server?
+     *
+     * @var bool
+     */
+    private $interactionsOverGateway = false;
+
+    /**
+     * HTTP client.
+     *
+     * @var Http
+     */
+    private $http;
+
     public function __construct(array $options = [])
     {
         $this->options = $this->resolveOptions($options);
+        $this->loop = $this->options['loop'];
         $this->logger = $this->options['logger'];
-        $this->registerServer();
+
+        $this->loop->futureTick(function () {
+            if ($this->interactionsOverGateway) {
+                $this->logger->info('not starting http server - will wait for gateway events');
+
+                return;
+            }
+
+            $this->registerServer();
+        });
+    }
+
+    /**
+     * Links the slash command client with a DiscordPHP client.
+     * This will do a couple things:
+     * - Interactions will be provided as "rich", meaning that the properties will be parts from DiscordPHP.
+     * - If the `$interactionsOverGateway` parameter is true, the client will listen for interactions via
+     *   gateway and the HTTP server will not be started.
+     *
+     * @param Discord $discord
+     * @param bool    $interactionsOverGateway
+     */
+    public function linkDiscord(Discord $discord, bool $interactionsOverGateway = true)
+    {
+        $this->discord = $discord;
+        $this->interactionsOverGateway = $interactionsOverGateway;
+
+        if ($this->discord->getLoop() !== $this->loop) {
+            throw new \RuntimeException('The Discord and slash client do not share the same event loop.');
+        }
+
+        $this->http = $discord->getHttp();
+
+        if ($interactionsOverGateway) {
+            $discord->on(Event::INTERACTION_CREATE, function ($interaction) {
+                // possibly the laziest thing ive ever done - stdClass -> array
+                $interaction = json_decode(json_encode($interaction), true);
+                $interaction = new Interaction($interaction, $this->discord, $this->http, $this->options['application_id'] ?? null);
+
+                $this->handleInteraction($interaction)->done(function ($response) use ($interaction) {
+                    $this->handleGatewayInteractionResponse($response, $interaction);
+                });
+            });
+        }
     }
 
     /**
@@ -104,14 +181,16 @@ private function resolveOptions(array $options): array
                 'loop',
                 'public_key',
                 'socket_options',
+                'application_id',
+                'token',
             ])
             ->setDefaults([
                 'uri' => '0.0.0.0:80',
                 'loop' => Factory::create(),
                 'socket_options' => [],
-            ])
-            ->setRequired([
-                'public_key',
+                'public_key' => null,
+                'application_id' => null,
+                'token' => null,
             ]);
 
         $options = $resolver->resolve($options);
@@ -130,12 +209,41 @@ private function registerServer()
     {
         // no uri => cgi/fpm
         if (is_null($this->options['uri'])) {
+            $this->logger->info('running in CGI/FPM mode - follow up messages will not work');
+
             return;
         }
 
-        $this->server = new HttpServer($this->getLoop(), [$this, 'handleRequest']);
+        $this->server = new HttpServer($this->getLoop(), function (ServerRequestInterface $request) {
+            $identifier = sprintf('%s %s %s', $request->getMethod(), $request->getRequestTarget(), $request->getHeaderLine('User-Agent'));
+
+            return $this->handleRequest($request)->then(function (Response $response) use ($identifier) {
+                $this->logger->info("{$identifier} {$response->getStatusCode()} {$response->getReasonPhrase()}");
+
+                return $response;
+            }, function (Throwable $e) use ($identifier) {
+                $this->logger->warning("{$identifier} {$e->getMessage()}");
+            });
+        });
         $this->socket = new SocketServer($this->options['uri'], $this->getLoop(), $this->options['socket_options']);
         $this->server->listen($this->socket);
+
+        // already provided HTTP client through DiscordPHP
+        if (! is_null($this->http)) {
+            $this->logger->info('using DiscordPHP http client');
+
+            return;
+        }
+
+        if (! isset($this->options['token'])) {
+            $this->logger->warning('no token provided - http client will not work');
+        }
+
+        if (! isset($this->options['application_id'])) {
+            $this->logger->warning('no application id provided - some methods may not work');
+        }
+
+        $this->http = new Http('Bot '.$this->options['token'], $this->loop, $this->logger, new React($this->loop, $this->options['socket_options']));
     }
 
     /**
@@ -145,6 +253,12 @@ private function registerServer()
      */
     public function handleRequest(ServerRequestInterface $request)
     {
+        if (! isset($this->options['public_key'])) {
+            $this->logger->warning('A public key was not given to the slash client. Unable to validate request.');
+
+            return \React\Promise\Resolve(new Response(401, [0], 'Not verified'));
+        }
+
         // validate request with public key
         $signature = $request->getHeaderLine('X-Signature-Ed25519');
         $timestamp = $request->getHeaderLine('X-Signature-Timestamp');
@@ -153,7 +267,7 @@ public function handleRequest(ServerRequestInterface $request)
             return \React\Promise\Resolve(new Response(401, [0], 'Not verified'));
         }
 
-        $interaction = new Interaction(json_decode($request->getBody(), true));
+        $interaction = new Interaction(json_decode($request->getBody(), true), $this->discord, $this->http, $this->options['application_id'] ?? null);
 
         $this->logger->info('received interaction', $interaction->jsonSerialize());
 
@@ -211,6 +325,18 @@ private function handleApplicationCommand(Interaction $interaction): void
         $checkCommand($interaction->data);
     }
 
+    /**
+     * Handles the user response from the command when the interaction
+     * originates from the gateway.
+     *
+     * @param array       $response
+     * @param Interaction $interaction
+     */
+    public function handleGatewayInteractionResponse(array $response, Interaction $interaction)
+    {
+        $this->discord->getHttp()->post("interactions/{$interaction->id}/{$interaction->token}/callback", $response)->done();
+    }
+
     /**
      * Registeres a command with the client.
      *
@@ -230,7 +356,7 @@ public function registerCommand($name, callable $callback = null): RegisteredCom
             if (isset($this->commands[$name])) {
                 throw new InvalidArgumentException("The command `{$name}` already exists.");
             }
-            
+
             return $this->commands[$name] = new RegisteredCommand($name, $callback);
         }
 
@@ -251,14 +377,14 @@ public function runCgi()
         if (empty($_SERVER['REMOTE_ADDR'])) {
             throw new Exception('The `runCgi()` method must only be called from PHP-CGI/FPM.');
         }
-        
+
         if (! class_exists(Environment::class)) {
             throw new Exception('The `kambo/httpmessage` package must be installed to handle slash command interactions with a CGI/FPM server.');
         }
 
         $environment = new Environment($_SERVER, fopen('php://input', 'w+'), $_POST, $_COOKIE, $_FILES);
         $serverRequest = (new ServerRequestFactory())->create($environment);
-    
+
         $this->handleRequest($serverRequest)->then(function (Response $response) {
             http_response_code($response->getStatusCode());
             echo (string) $response->getBody();
@@ -280,6 +406,6 @@ public function run()
      */
     public function getLoop(): LoopInterface
     {
-        return $this->options['loop'];
+        return $this->loop;
     }
 }