DigiSign::setCache() - Code Metrics - digitalcz/digisign - Measure and Improve Code Quality continuously with Scrutinizer

DigiSign::setCache() A
last analyzed 2022-12-14 07:12 UTC

↳ Parent: DigiSign

Complexity

Conditions	2
Paths	2

Size

Total Lines	10
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	4
c	0
b	0
f	0
dl	0
loc	10
rs	10
cc	2
nc	2
nop	1

<?php

declare(strict_types=1);

namespace DigitalCz\DigiSign;

use DigitalCz\DigiSign\Auth\ApiKeyCredentials;
use DigitalCz\DigiSign\Auth\CachedCredentials;
use DigitalCz\DigiSign\Auth\Credentials;
use DigitalCz\DigiSign\Endpoint\AccountEndpoint;
use DigitalCz\DigiSign\Endpoint\AuthEndpoint;
use DigitalCz\DigiSign\Endpoint\DeliveriesEndpoint;
use DigitalCz\DigiSign\Endpoint\EndpointInterface;
use DigitalCz\DigiSign\Endpoint\EnumsEndpoint;
use DigitalCz\DigiSign\Endpoint\EnvelopesEndpoint;
use DigitalCz\DigiSign\Endpoint\EnvelopeTemplatesEndpoint;
use DigitalCz\DigiSign\Endpoint\FilesEndpoint;
use DigitalCz\DigiSign\Endpoint\ImagesEndpoint;
use DigitalCz\DigiSign\Endpoint\LabelsEndpoint;
use DigitalCz\DigiSign\Endpoint\MyEndpoint;
use DigitalCz\DigiSign\Endpoint\ReportEndpoint;
use DigitalCz\DigiSign\Endpoint\WebhooksEndpoint;
use DigitalCz\DigiSign\Exception\InvalidSignatureException;
use InvalidArgumentException;
use LogicException;
use Psr\Http\Message\ResponseInterface;
use Psr\SimpleCache\CacheInterface;

final class DigiSign implements EndpointInterface
{
    public const VERSION = '1.11.0';
    public const API_BASE = 'https://api.digisign.org';
    public const API_BASE_TESTING = 'https://api.digisign.digital.cz';

    /** @var string The base URL for requests */
    private $apiBase = self::API_BASE;

    /** @var Credentials The credentials used to authenticate to API */
    private $credentials;

    /** @var DigiSignClientInterface The client used to send requests */
    private $client;

    /** @var array<string, string> */
    private $versions = [];

    /** @var int The tolerance for webhook signature age validation (in seconds) */
    private $signatureTolerance = 300;

    /**
     * Available options:
     *  access_key          - string; ApiKey access key
     *  secret_key          - string; ApiKey secret key
     *  credentials         - DigitalCz\DigiSign\Auth\Credentials instance
     *  client              - DigitalCz\DigiSign\DigiSignClient instance with your custom PSR17/18 objects
     *  http_client         - Psr\Http\Client\ClientInterface instance of your custom PSR18 client
     *  cache               - Psr\SimpleCache\CacheInterface for caching Credentials auth Tokens
     *  testing             - bool; whether to use testing or production API
     *  api_base            - string; override the base API url
     *  signature_tolerance - int; The tolerance for webhook signature age validation (in seconds)
     *
     * @param mixed[] $options
     */
    public function __construct(array $options = [])
    {
        $httpClient = $options['http_client'] ?? null;
        $this->setClient($options['client'] ?? new DigiSignClient($httpClient));
        $this->useTesting($options['testing'] ?? false);
        $this->addVersion('digitalcz/digisign', self::VERSION);
        $this->addVersion('PHP', PHP_VERSION);

        if (isset($options['api_base'])) {
            if (!is_string($options['api_base'])) {
                throw new InvalidArgumentException('Invalid value for "api_base" option');
            }

            $this->setApiBase($options['api_base']);
        }

        if (isset($options['access_key'], $options['secret_key'])) {
            $this->setCredentials(new ApiKeyCredentials($options['access_key'], $options['secret_key']));
        }

        if (isset($options['credentials'])) {
            if (!$options['credentials'] instanceof Credentials) {
                throw new InvalidArgumentException('Invalid value for "credentials" option');
            }

            $this->setCredentials($options['credentials']);
        }

        // if cache is provided, wrap Credentials with cache decorator
        if (isset($options['cache'])) {
            if (!$options['cache'] instanceof CacheInterface) {
                throw new InvalidArgumentException('Invalid value for "cache" option');
            }

            $this->setCache($options['cache']);
        }

        if (isset($options['signature_tolerance'])) {
            if (!is_int($options['signature_tolerance'])) {
                throw new InvalidArgumentException('Invalid value for "signature_tolerance" option');
            }

            $this->setSignatureTolerance($options['signature_tolerance']);
        }
    }

    /**
     * @throws InvalidSignatureException
     */
    public function validateSignature(string $payload, string $header, string $secret): void
    {
        if (preg_match('/t=(?<t>\d+),s=(?<s>\w+)/', $header, $matches) !== 1) {
            throw new InvalidSignatureException('Unable to parse signature header');
        }

        $ts = (int)($matches['t'] ?? 0);
        $signature = $matches['s'] ?? '';

        if ($ts < time() - $this->signatureTolerance) {
            throw new InvalidSignatureException("Request is older than {$this->signatureTolerance} seconds");
        }

        $expected = hash_hmac('sha256', $ts . '.' . $payload, $secret);

        if (hash_equals($expected, $signature) === false) {
            throw new InvalidSignatureException('Signature is invalid');
        }
    }

    public function setCache(CacheInterface $cache): void
    {
        $credentials = $this->getCredentials();

        // if credentials are already decorated, do not double wrap, but get inner
        if ($credentials instanceof CachedCredentials) {
            $credentials = $credentials->getInner();
        }

        $this->setCredentials(new CachedCredentials($credentials, $cache));
    }

    public function getCredentials(): Credentials
    {
        if (!isset($this->credentials)) {
            throw new LogicException(
                'No credentials were provided, Please use setCredentials() ' .
                'or constructor options to set them.'
            );
        }

        return $this->credentials;
    }

    public function setCredentials(Credentials $credentials): void
    {
        $this->credentials = $credentials;
    }

    public function setClient(DigiSignClientInterface $client): void
    {
        $this->client = $client;
    }

    public function useTesting(bool $bool = true): void
    {
        if ($bool) {
            $this->setApiBase(self::API_BASE_TESTING);
        } else {
            $this->setApiBase(self::API_BASE);
        }
    }

    public function setApiBase(string $apiBase): void
    {
        $this->apiBase = rtrim(trim($apiBase), '/');
    }

    public function addVersion(string $tool, string $version = ''): void
    {
        $this->versions[$tool] = $version;
    }

    public function removeVersion(string $tool): void
    {
        unset($this->versions[$tool]);
    }

    public function setSignatureTolerance(int $signatureTolerance): void
    {
        $this->signatureTolerance = $signatureTolerance;
    }

    /** @inheritDoc */
    public function request(string $method, string $path = '', array $options = []): ResponseInterface
    {
        $options['user-agent'] = $this->createUserAgent();

        // disable authorization header if options[no_auth]=true
        if (($options['no_auth'] ?? false) !== true) {
            $options['auth_bearer'] = $options['auth_bearer'] ?? $this->createBearer();
        }

        return $this->client->request($method, $this->apiBase . $path, $options);
    }

    public function auth(): AuthEndpoint
    {
        return new AuthEndpoint($this);
    }

    public function account(): AccountEndpoint
    {
        return new AccountEndpoint($this);
    }

    public function envelopes(): EnvelopesEndpoint
    {
        return new EnvelopesEndpoint($this);
    }

    public function envelopeTemplates(): EnvelopeTemplatesEndpoint
    {
        return new EnvelopeTemplatesEndpoint($this);
    }

    public function deliveries(): DeliveriesEndpoint
    {
        return new DeliveriesEndpoint($this);
    }

    public function files(): FilesEndpoint
    {
        return new FilesEndpoint($this);
    }

    public function images(): ImagesEndpoint
    {
        return new ImagesEndpoint($this);
    }

    public function labels(): LabelsEndpoint
    {
        return new LabelsEndpoint($this);
    }

    public function webhooks(): WebhooksEndpoint
    {
        return new WebhooksEndpoint($this);
    }

    public function enums(): EnumsEndpoint
    {
        return new EnumsEndpoint($this);
    }

    public function my(): MyEndpoint
    {
        return new MyEndpoint($this);
    }

    public function report(): ReportEndpoint
    {
        return new ReportEndpoint($this);
    }

    private function createUserAgent(): string
    {
        $userAgent = '';

        foreach ($this->versions as $tool => $version) {
            $userAgent .= $tool;
            $userAgent .= $version !== '' ? ":$version" : '';
            $userAgent .= ' ';
        }

        return $userAgent;
    }

    private function createBearer(): string
    {
        return $this->getCredentials()->provide($this)->getToken();
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace DigitalCz\DigiSign;
6
7			use DigitalCz\DigiSign\Auth\ApiKeyCredentials;
8			use DigitalCz\DigiSign\Auth\CachedCredentials;
9			use DigitalCz\DigiSign\Auth\Credentials;
10			use DigitalCz\DigiSign\Endpoint\AccountEndpoint;
11			use DigitalCz\DigiSign\Endpoint\AuthEndpoint;
12			use DigitalCz\DigiSign\Endpoint\DeliveriesEndpoint;
13			use DigitalCz\DigiSign\Endpoint\EndpointInterface;
14			use DigitalCz\DigiSign\Endpoint\EnumsEndpoint;
15			use DigitalCz\DigiSign\Endpoint\EnvelopesEndpoint;
16			use DigitalCz\DigiSign\Endpoint\EnvelopeTemplatesEndpoint;
17			use DigitalCz\DigiSign\Endpoint\FilesEndpoint;
18			use DigitalCz\DigiSign\Endpoint\ImagesEndpoint;
19			use DigitalCz\DigiSign\Endpoint\LabelsEndpoint;
20			use DigitalCz\DigiSign\Endpoint\MyEndpoint;
21			use DigitalCz\DigiSign\Endpoint\ReportEndpoint;
22			use DigitalCz\DigiSign\Endpoint\WebhooksEndpoint;
23			use DigitalCz\DigiSign\Exception\InvalidSignatureException;
24			use InvalidArgumentException;
25			use LogicException;
26			use Psr\Http\Message\ResponseInterface;
27			use Psr\SimpleCache\CacheInterface;
28
29			final class DigiSign implements EndpointInterface
30			{
31			public const VERSION = '1.11.0';
32			public const API_BASE = 'https://api.digisign.org';
33			public const API_BASE_TESTING = 'https://api.digisign.digital.cz';
34
35			/** @var string The base URL for requests */
36			private $apiBase = self::API_BASE;
37
38			/** @var Credentials The credentials used to authenticate to API */
39			private $credentials;
40
41			/** @var DigiSignClientInterface The client used to send requests */
42			private $client;
43
44			/** @var array<string, string> */
45			private $versions = [];
46
47			/** @var int The tolerance for webhook signature age validation (in seconds) */
48			private $signatureTolerance = 300;
49
50			/**
51			* Available options:
52			* access_key - string; ApiKey access key
53			* secret_key - string; ApiKey secret key
54			* credentials - DigitalCz\DigiSign\Auth\Credentials instance
55			* client - DigitalCz\DigiSign\DigiSignClient instance with your custom PSR17/18 objects
56			* http_client - Psr\Http\Client\ClientInterface instance of your custom PSR18 client
57			* cache - Psr\SimpleCache\CacheInterface for caching Credentials auth Tokens
58			* testing - bool; whether to use testing or production API
59			* api_base - string; override the base API url
60			* signature_tolerance - int; The tolerance for webhook signature age validation (in seconds)
61			*
62			* @param mixed[] $options
63			*/
64			public function __construct(array $options = [])
65			{
66			$httpClient = $options['http_client'] ?? null;
67			$this->setClient($options['client'] ?? new DigiSignClient($httpClient));
68			$this->useTesting($options['testing'] ?? false);
69			$this->addVersion('digitalcz/digisign', self::VERSION);
70			$this->addVersion('PHP', PHP_VERSION);
71
72			if (isset($options['api_base'])) {
73			if (!is_string($options['api_base'])) {
74			throw new InvalidArgumentException('Invalid value for "api_base" option');
75			}
76
77			$this->setApiBase($options['api_base']);
78			}
79
80			if (isset($options['access_key'], $options['secret_key'])) {
81			$this->setCredentials(new ApiKeyCredentials($options['access_key'], $options['secret_key']));
82			}
83
84			if (isset($options['credentials'])) {
85			if (!$options['credentials'] instanceof Credentials) {
86			throw new InvalidArgumentException('Invalid value for "credentials" option');
87			}
88
89			$this->setCredentials($options['credentials']);
90			}
91
92			// if cache is provided, wrap Credentials with cache decorator
93			if (isset($options['cache'])) {
94			if (!$options['cache'] instanceof CacheInterface) {
95			throw new InvalidArgumentException('Invalid value for "cache" option');
96			}
97
98			$this->setCache($options['cache']);
99			}
100
101			if (isset($options['signature_tolerance'])) {
102			if (!is_int($options['signature_tolerance'])) {
103			throw new InvalidArgumentException('Invalid value for "signature_tolerance" option');
104			}
105
106			$this->setSignatureTolerance($options['signature_tolerance']);
107			}
108			}
109
110			/**
111			* @throws InvalidSignatureException
112			*/
113			public function validateSignature(string $payload, string $header, string $secret): void
114			{
115			if (preg_match('/t=(?<t>\d+),s=(?<s>\w+)/', $header, $matches) !== 1) {
116			throw new InvalidSignatureException('Unable to parse signature header');
117			}
118
119			$ts = (int)($matches['t'] ?? 0);
120			$signature = $matches['s'] ?? '';
121
122			if ($ts < time() - $this->signatureTolerance) {
123			throw new InvalidSignatureException("Request is older than {$this->signatureTolerance} seconds");
124			}
125
126			$expected = hash_hmac('sha256', $ts . '.' . $payload, $secret);
127
128			if (hash_equals($expected, $signature) === false) {
129			throw new InvalidSignatureException('Signature is invalid');
130			}
131			}
132
133			public function setCache(CacheInterface $cache): void
134			{
135			$credentials = $this->getCredentials();
136
137			// if credentials are already decorated, do not double wrap, but get inner
138			if ($credentials instanceof CachedCredentials) {
139			$credentials = $credentials->getInner();
140			}
141
142			$this->setCredentials(new CachedCredentials($credentials, $cache));
143			}
144
145			public function getCredentials(): Credentials
146			{
147			if (!isset($this->credentials)) {
148			throw new LogicException(
149			'No credentials were provided, Please use setCredentials() ' .
150			'or constructor options to set them.'
151			);
152			}
153
154			return $this->credentials;
155			}
156
157			public function setCredentials(Credentials $credentials): void
158			{
159			$this->credentials = $credentials;
160			}
161
162			public function setClient(DigiSignClientInterface $client): void
163			{
164			$this->client = $client;
165			}
166
167			public function useTesting(bool $bool = true): void
168			{
169			if ($bool) {
170			$this->setApiBase(self::API_BASE_TESTING);
171			} else {
172			$this->setApiBase(self::API_BASE);
173			}
174			}
175
176			public function setApiBase(string $apiBase): void
177			{
178			$this->apiBase = rtrim(trim($apiBase), '/');
179			}
180
181			public function addVersion(string $tool, string $version = ''): void
182			{
183			$this->versions[$tool] = $version;
184			}
185
186			public function removeVersion(string $tool): void
187			{
188			unset($this->versions[$tool]);
189			}
190
191			public function setSignatureTolerance(int $signatureTolerance): void
192			{
193			$this->signatureTolerance = $signatureTolerance;
194			}
195
196			/** @inheritDoc */
197			public function request(string $method, string $path = '', array $options = []): ResponseInterface
198			{
199			$options['user-agent'] = $this->createUserAgent();
200
201			// disable authorization header if options[no_auth]=true
202			if (($options['no_auth'] ?? false) !== true) {
203			$options['auth_bearer'] = $options['auth_bearer'] ?? $this->createBearer();
204			}
205
206			return $this->client->request($method, $this->apiBase . $path, $options);
207			}
208
209			public function auth(): AuthEndpoint
210			{
211			return new AuthEndpoint($this);
212			}
213
214			public function account(): AccountEndpoint
215			{
216			return new AccountEndpoint($this);
217			}
218
219			public function envelopes(): EnvelopesEndpoint
220			{
221			return new EnvelopesEndpoint($this);
222			}
223
224			public function envelopeTemplates(): EnvelopeTemplatesEndpoint
225			{
226			return new EnvelopeTemplatesEndpoint($this);
227			}
228
229			public function deliveries(): DeliveriesEndpoint
230			{
231			return new DeliveriesEndpoint($this);
232			}
233
234			public function files(): FilesEndpoint
235			{
236			return new FilesEndpoint($this);
237			}
238
239			public function images(): ImagesEndpoint
240			{
241			return new ImagesEndpoint($this);
242			}
243
244			public function labels(): LabelsEndpoint
245			{
246			return new LabelsEndpoint($this);
247			}
248
249			public function webhooks(): WebhooksEndpoint
250			{
251			return new WebhooksEndpoint($this);
252			}
253
254			public function enums(): EnumsEndpoint
255			{
256			return new EnumsEndpoint($this);
257			}
258
259			public function my(): MyEndpoint
260			{
261			return new MyEndpoint($this);
262			}
263
264			public function report(): ReportEndpoint
265			{
266			return new ReportEndpoint($this);
267			}
268
269			private function createUserAgent(): string
270			{
271			$userAgent = '';
272
273			foreach ($this->versions as $tool => $version) {
274			$userAgent .= $tool;
275			$userAgent .= $version !== '' ? ":$version" : '';
276			$userAgent .= ' ';
277			}
278
279			return $userAgent;
280			}
281
282			private function createBearer(): string
283			{
284			return $this->getCredentials()->provide($this)->getToken();
285			}
286			}
287

digitalcz / digisign

DigiSign::setCache() A last analyzed 2022-12-14 07:12 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DigiSign::setCache() A
last analyzed 2022-12-14 07:12 UTC