Spatie\WebhookServer\CallWebhookJob

Complexity

Total Complexity

6

Size/Duplication

Total Lines	111
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	handle()	0	40	4
A	dispatchEvent()	0	15	1
A	tags()	0	4	1

<?php

namespace Spatie\WebhookServer;

use Exception;
use GuzzleHttp\Client;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Illuminate\Support\Str;
use Spatie\WebhookServer\Events\FinalWebhookCallFailedEvent;
use Spatie\WebhookServer\Events\WebhookCallFailedEvent;
use Spatie\WebhookServer\Events\WebhookCallSucceededEvent;

class CallWebhookJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

    /** @var string */
    public $webhookUrl;

    /** @var string */
    public $httpVerb;

    /** @var int */
    public $tries;

    /** @var int */
    public $requestTimeout;

    /** @var string */
    public $backoffStrategyClass;

    /** @var string */
    public $signerClass;

    /** @var array */
    public $headers = [];

    /** @var bool */
    public $verifySsl;

    /** @var string */
    public $queue;

    /** @var array */
    public $payload = [];

    /** @var array */
    public $meta = [];

    /** @var array */
    public $tags = [];

    /** @var \GuzzleHttp\Psr7\Response|null */
    private $response;

    /** @var int|null */
    private $responseStatusCode;

    /** @var string */
    private $responseBody;

    public function handle()
    {
        /** @var \GuzzleHttp\Client $client */
        $client = app(Client::class);

        try {
            $this->response = $client->request($this->httpVerb, $this->webhookUrl, [

It seems like $client->request($this->httpVerb, $this->webhookUrl, array('timeout' => $this->requestTimeout, 'body' => json_encode($this->payload), 'verify' => $this->verifySsl, 'headers' => $this->headers)) of type object<Psr\Http\Message\ResponseInterface> is incompatible with the declared type object<GuzzleHttp\Psr7\Response>|null of property $response.

                'timeout' => $this->requestTimeout,
                'body' => json_encode($this->payload),
                'verify' => $this->verifySsl,
                'headers' => $this->headers,
            ]);

            $this->responseStatusCode = $this->response->getStatusCode();
            $this->responseBody = $this->response->getBody()->getContents();

            if (!Str::startsWith($this->responseStatusCode, 2)) {
                throw new Exception('Webhook call failed');
            }

            $this->dispatchEvent(WebhookCallSucceededEvent::class);

            return;
        } catch (Exception $exception) {
            /** @var \Spatie\WebhookServer\BackoffStrategy\BackoffStrategy $backoffStrategy */
            $backoffStrategy = app($this->backoffStrategyClass);

            $waitInSeconds = $backoffStrategy->waitInSecondsAfterAttempt($this->attempts());

            $this->dispatchEvent(WebhookCallFailedEvent::class);

            $this->release($waitInSeconds);
        }

        if ($this->attempts() >= $this->tries) {
            $this->dispatchEvent(FinalWebhookCallFailedEvent::class);

            $this->delete();
        }
    }

    private function dispatchEvent(string $eventClass)
    {
        event(new $eventClass(
            $this->httpVerb,
            $this->webhookUrl,
            $this->payload,
            $this->headers,
            $this->meta,
            $this->tags,
            $this->attempts(),
            $this->response,
            $this->responseStatusCode,
            $this->responseBody
        ));
    }

    public function tags()
    {
        return $this->tags;
    }
}