Client::getPublicId() - Code Metrics - Inspection of "Events restored" - OAuth2-Framework/oauth2-framework - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( c24b3a...b512e9 )

by Florent

created 2018-05-24 20:40 UTC

Client::getPublicId() A

↳ Parent: Client

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	4
nc	2
nop	0

<?php

declare(strict_types=1);

/*
 * The MIT License (MIT)
 *
 * Copyright (c) 2014-2018 Spomky-Labs
 *
 * This software may be modified and distributed under the terms
 * of the MIT license.  See the LICENSE file for details.
 */

namespace OAuth2Framework\Component\Core\Client;

use OAuth2Framework\Component\Core\Client\Event as ClientEvent;
use OAuth2Framework\Component\Core\DataBag\DataBag;
use OAuth2Framework\Component\Core\Event\Event;
use OAuth2Framework\Component\Core\ResourceOwner\ResourceOwnerId;
use OAuth2Framework\Component\Core\ResourceOwner\ResourceOwner;
use OAuth2Framework\Component\Core\UserAccount\UserAccountId;
use OAuth2Framework\Component\Core\Domain\DomainObject;
use SimpleBus\Message\Recorder\ContainsRecordedMessages;
use SimpleBus\Message\Recorder\PrivateMessageRecorderCapabilities;

/**
 * Class ClientCredentials.
 *
 * This class is used for every client types.
 * A client is a resource owner with a set of allowed grant types and can perform requests against
 * available endpoints.
 */
class Client implements ResourceOwner, ContainsRecordedMessages, DomainObject

{
    use PrivateMessageRecorderCapabilities;

    /**
     * @var bool
     */
    private $deleted = false;

    /**
     * @var UserAccountId|null
     */
    private $ownerId = null;

    /**
     * @var ClientId|null
     */
    private $clientId = null;

    /**
     * @var DataBag
     */
    protected $parameters;

    /**
     * ClientCredentials constructor.
     */
    private function __construct()
    {
        $this->parameters = DataBag::create([]);
    }

    /**
     * {@inheritdoc}
     */
    public static function getSchema(): string
    {
        return 'https://oauth2-framework.spomky-labs.com/schemas/model/client/1.0/schema';
    }

    /**
     * @return Client
     */
    public static function createEmpty(): self
    {
        return new self();
    }

    /**
     * @param ClientId           $clientId
     * @param DataBag            $parameters
     * @param UserAccountId|null $ownerId
     *
     * @return Client
     */
    public function create(ClientId $clientId, DataBag $parameters, ? UserAccountId $ownerId): self
    {
        $clone = clone $this;
        $clone->clientId = $clientId;
        $clone->parameters = $parameters;
        $clone->ownerId = $ownerId;

        $event = ClientEvent\ClientCreatedEvent::create($clone->clientId, $parameters, $ownerId);
        $clone->record($event);

        return $clone;
    }

    /**
     * @return UserAccountId|null
     */
    public function getOwnerId(): ? UserAccountId
    {
        return $this->ownerId;
    }

    /**
     * @param UserAccountId $ownerId
     *
     * @return Client
     */
    public function withOwnerId(UserAccountId $ownerId): self
    {
        if ($this->getOwnerId()->getValue() === $ownerId->getValue()) {
            return $this;
        }

        $clone = clone $this;
        $clone->ownerId = $ownerId;
        $event = ClientEvent\ClientOwnerChangedEvent::create($clone->getPublicId(), $ownerId);
        $clone->record($event);

        return $clone;
    }

    /**
     * @param DataBag $parameters
     *
     * @return Client
     */
    public function withParameters(DataBag $parameters): self
    {
        $clone = clone $this;
        $clone->parameters = $parameters;
        $event = ClientEvent\ClientParametersUpdatedEvent::create($clone->getPublicId(), $parameters);
        $clone->record($event);

        return $clone;
    }

    /**
     * @return Client
     */
    public function markAsDeleted(): self
    {
        $clone = clone $this;
        $clone->deleted = true;
        $event = ClientEvent\ClientDeletedEvent::create($clone->getPublicId());
        $clone->record($event);

        return $clone;
    }

    /**
     * @return bool
     */
    public function isDeleted(): bool
    {
        return $this->deleted;
    }

    /**
     * @param string $grant_type
     *
     * @return bool
     */
    public function isGrantTypeAllowed(string $grant_type): bool
    {
        $grant_types = $this->has('grant_types') ? $this->get('grant_types') : [];
        if (!is_array($grant_types)) {
            throw new \InvalidArgumentException('The metadata "grant_types" must be an array.');
        }

        return in_array($grant_type, $grant_types);
    }

    /**
     * @param string $response_type
     *
     * @return bool
     */
    public function isResponseTypeAllowed(string $response_type): bool
    {
        $response_types = $this->has('response_types') ? $this->get('response_types') : [];
        if (!is_array($response_types)) {
            throw new \InvalidArgumentException('The metadata "response_types" must be an array.');
        }

        return in_array($response_type, $response_types);
    }

    /**
     * @return bool
     */
    public function isPublic(): bool
    {
        return 'none' === $this->getTokenEndpointAuthenticationMethod();
    }

    /**
     * @return string
     */
    public function getTokenEndpointAuthenticationMethod(): string
    {
        if ($this->has('token_endpoint_auth_method')) {
            return $this->get('token_endpoint_auth_method');
        }

        return 'client_secret_basic';
    }

    /**
     * @return int
     */
    public function getClientCredentialsExpiresAt(): int
    {
        if ($this->has('client_secret_expires_at')) {
            return $this->get('client_secret_expires_at');
        }

        return 0;
    }

    /**
     * @return bool
     */
    public function areClientCredentialsExpired(): bool
    {
        if (0 === $this->getClientCredentialsExpiresAt()) {
            return false;
        }

        return time() > $this->getClientCredentialsExpiresAt();
    }

    /**
     * {@inheritdoc}
     */
    public function getPublicId(): ResourceOwnerId
    {
        if (null === $this->clientId) {
            throw new \RuntimeException('Client not initialized.');
        }

        return $this->clientId;
    }

    /**
     * {@inheritdoc}
     */
    public function has(string $key): bool
    {
        return $this->parameters->has($key);
    }

    /**
     * {@inheritdoc}
     */
    public function get(string $key)
    {
        if (!$this->has($key)) {
            throw new \InvalidArgumentException(sprintf('Configuration value with key "%s" does not exist.', $key));
        }

        return $this->parameters->get($key);
    }

    /**
     * @return array
     */
    public function all(): array
    {
        $all = $this->parameters->all();
        $all['client_id'] = $this->getPublicId()->getValue();

        return $all;
    }

    /**
     * {@inheritdoc}
     */
    public function jsonSerialize()
    {
        $data = [
            '$schema' => $this->getSchema(),
            'type' => get_class($this),
            'client_id' => $this->getPublicId()->getValue(),
            'owner_id' => $this->getOwnerId() ? $this->getOwnerId()->getValue() : null,
            'parameters' => (object) $this->all(),
            'is_deleted' => $this->isDeleted(),
        ];

        return $data;
    }

    /**
     * {@inheritdoc}
     */
    public static function createFromJson(\stdClass $json): DomainObject
    {
        $clientId = ClientId::create($json->client_id);
        $ownerId = null !== $json->owner_id ? UserAccountId::create($json->owner_id) : null;
        $parameters = DataBag::create((array) $json->parameters);
        $deleted = $json->is_deleted;

        $client = new self();
        $client->clientId = $clientId;
        $client->ownerId = $ownerId;
        $client->parameters = $parameters;
        $client->deleted = $deleted;

        return $client;
    }

    /**
     * @param Event $event
     *
     * @return Client
     */
    public function apply(Event $event): self
    {
        $map = $this->getEventMap();
        if (!array_key_exists($event->getType(), $map)) {
            throw new \InvalidArgumentException('Unsupported event.');
        }
        if (null !== $this->clientId && $this->clientId->getValue() !== $event->getDomainId()->getValue()) {
            throw new \InvalidArgumentException('Event not applicable for this client.');
        }
        $method = $map[$event->getType()];

        return $this->$method($event);
    }

    /**
     * @return array
     */
    private function getEventMap(): array
    {
        return [
            ClientEvent\ClientCreatedEvent::class => 'applyClientCreatedEvent',
            ClientEvent\ClientOwnerChangedEvent::class => 'applyClientOwnerChangedEvent',
            ClientEvent\ClientDeletedEvent::class => 'applyClientDeletedEvent',
            ClientEvent\ClientParametersUpdatedEvent::class => 'applyClientParametersUpdatedEvent',
        ];
    }

    /**
     * @param ClientEvent\ClientCreatedEvent $event
     *
     * @return Client
     */
    protected function applyClientCreatedEvent(ClientEvent\ClientCreatedEvent $event): self
    {
        $clone = clone $this;
        $clone->clientId = $event->getClientId();
        $clone->ownerId = $event->getOwnerId();
        $clone->parameters = $event->getParameters();

        return $clone;
    }

    /**
     * @param ClientEvent\ClientOwnerChangedEvent $event
     *
     * @return Client
     */
    protected function applyClientOwnerChangedEvent(ClientEvent\ClientOwnerChangedEvent $event): self
    {
        $clone = clone $this;
        $clone->ownerId = $event->getNewOwnerId();

        return $clone;
    }

    /**
     * @param ClientEvent\ClientDeletedEvent $event
     *
     * @return Client
     */
    protected function applyClientDeletedEvent(ClientEvent\ClientDeletedEvent $event): self
    {
        $clone = clone $this;
        $clone->deleted = true;

        return $clone;
    }

    /**
     * @param ClientEvent\ClientParametersUpdatedEvent $event
     *
     * @return Client
     */
    protected function applyClientParametersUpdatedEvent(ClientEvent\ClientParametersUpdatedEvent $event): self
    {
        $clone = clone $this;
        $clone->parameters = $event->getParameters();

        return $clone;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* The MIT License (MIT)
7			*
8			* Copyright (c) 2014-2018 Spomky-Labs
9			*
10			* This software may be modified and distributed under the terms
11			* of the MIT license. See the LICENSE file for details.
12			*/
13
14			namespace OAuth2Framework\Component\Core\Client;
15
16			use OAuth2Framework\Component\Core\Client\Event as ClientEvent;
17			use OAuth2Framework\Component\Core\DataBag\DataBag;
18			use OAuth2Framework\Component\Core\Event\Event;
19			use OAuth2Framework\Component\Core\ResourceOwner\ResourceOwnerId;
20			use OAuth2Framework\Component\Core\ResourceOwner\ResourceOwner;
21			use OAuth2Framework\Component\Core\UserAccount\UserAccountId;
22			use OAuth2Framework\Component\Core\Domain\DomainObject;
23			use SimpleBus\Message\Recorder\ContainsRecordedMessages;
24			use SimpleBus\Message\Recorder\PrivateMessageRecorderCapabilities;
25
26			/**
27			* Class ClientCredentials.
28			*
29			* This class is used for every client types.
30			* A client is a resource owner with a set of allowed grant types and can perform requests against
31			* available endpoints.
32			*/
33			class Client implements ResourceOwner, ContainsRecordedMessages, DomainObject
			0 ignored issues – show Coding Style introduced 2018-02-06 20:36 UTC by Report Bug Copy Issue Report Since you have declared the constructor as private, maybe you should also declare the class as final. Loading history...
34			{
35			use PrivateMessageRecorderCapabilities;
36
37			/**
38			* @var bool
39			*/
40			private $deleted = false;
41
42			/**
43			* @var UserAccountId\|null
44			*/
45			private $ownerId = null;
46
47			/**
48			* @var ClientId\|null
49			*/
50			private $clientId = null;
51
52			/**
53			* @var DataBag
54			*/
55			protected $parameters;
56
57			/**
58			* ClientCredentials constructor.
59			*/
60			private function __construct()
61			{
62			$this->parameters = DataBag::create([]);
63			}
64
65			/**
66			* {@inheritdoc}
67			*/
68			public static function getSchema(): string
69			{
70			return 'https://oauth2-framework.spomky-labs.com/schemas/model/client/1.0/schema';
71			}
72
73			/**
74			* @return Client
75			*/
76			public static function createEmpty(): self
77			{
78			return new self();
79			}
80
81			/**
82			* @param ClientId $clientId
83			* @param DataBag $parameters
84			* @param UserAccountId\|null $ownerId
85			*
86			* @return Client
87			*/
88			public function create(ClientId $clientId, DataBag $parameters, ? UserAccountId $ownerId): self
89			{
90			$clone = clone $this;
91			$clone->clientId = $clientId;
92			$clone->parameters = $parameters;
93			$clone->ownerId = $ownerId;
94
95			$event = ClientEvent\ClientCreatedEvent::create($clone->clientId, $parameters, $ownerId);
96			$clone->record($event);
97
98			return $clone;
99			}
100
101			/**
102			* @return UserAccountId\|null
103			*/
104			public function getOwnerId(): ? UserAccountId
105			{
106			return $this->ownerId;
107			}
108
109			/**
110			* @param UserAccountId $ownerId
111			*
112			* @return Client
113			*/
114			public function withOwnerId(UserAccountId $ownerId): self
115			{
116			if ($this->getOwnerId()->getValue() === $ownerId->getValue()) {
117			return $this;
118			}
119
120			$clone = clone $this;
121			$clone->ownerId = $ownerId;
122			$event = ClientEvent\ClientOwnerChangedEvent::create($clone->getPublicId(), $ownerId);
123			$clone->record($event);
124
125			return $clone;
126			}
127
128			/**
129			* @param DataBag $parameters
130			*
131			* @return Client
132			*/
133			public function withParameters(DataBag $parameters): self
134			{
135			$clone = clone $this;
136			$clone->parameters = $parameters;
137			$event = ClientEvent\ClientParametersUpdatedEvent::create($clone->getPublicId(), $parameters);
138			$clone->record($event);
139
140			return $clone;
141			}
142
143			/**
144			* @return Client
145			*/
146			public function markAsDeleted(): self
147			{
148			$clone = clone $this;
149			$clone->deleted = true;
150			$event = ClientEvent\ClientDeletedEvent::create($clone->getPublicId());
151			$clone->record($event);
152
153			return $clone;
154			}
155
156			/**
157			* @return bool
158			*/
159			public function isDeleted(): bool
160			{
161			return $this->deleted;
162			}
163
164			/**
165			* @param string $grant_type
166			*
167			* @return bool
168			*/
169			public function isGrantTypeAllowed(string $grant_type): bool
170			{
171			$grant_types = $this->has('grant_types') ? $this->get('grant_types') : [];
172			if (!is_array($grant_types)) {
173			throw new \InvalidArgumentException('The metadata "grant_types" must be an array.');
174			}
175
176			return in_array($grant_type, $grant_types);
177			}
178
179			/**
180			* @param string $response_type
181			*
182			* @return bool
183			*/
184			public function isResponseTypeAllowed(string $response_type): bool
185			{
186			$response_types = $this->has('response_types') ? $this->get('response_types') : [];
187			if (!is_array($response_types)) {
188			throw new \InvalidArgumentException('The metadata "response_types" must be an array.');
189			}
190
191			return in_array($response_type, $response_types);
192			}
193
194			/**
195			* @return bool
196			*/
197			public function isPublic(): bool
198			{
199			return 'none' === $this->getTokenEndpointAuthenticationMethod();
200			}
201
202			/**
203			* @return string
204			*/
205			public function getTokenEndpointAuthenticationMethod(): string
206			{
207			if ($this->has('token_endpoint_auth_method')) {
208			return $this->get('token_endpoint_auth_method');
209			}
210
211			return 'client_secret_basic';
212			}
213
214			/**
215			* @return int
216			*/
217			public function getClientCredentialsExpiresAt(): int
218			{
219			if ($this->has('client_secret_expires_at')) {
220			return $this->get('client_secret_expires_at');
221			}
222
223			return 0;
224			}
225
226			/**
227			* @return bool
228			*/
229			public function areClientCredentialsExpired(): bool
230			{
231			if (0 === $this->getClientCredentialsExpiresAt()) {
232			return false;
233			}
234
235			return time() > $this->getClientCredentialsExpiresAt();
236			}
237
238			/**
239			* {@inheritdoc}
240			*/
241			public function getPublicId(): ResourceOwnerId
242			{
243			if (null === $this->clientId) {
244			throw new \RuntimeException('Client not initialized.');
245			}
246
247			return $this->clientId;
248			}
249
250			/**
251			* {@inheritdoc}
252			*/
253			public function has(string $key): bool
254			{
255			return $this->parameters->has($key);
256			}
257
258			/**
259			* {@inheritdoc}
260			*/
261			public function get(string $key)
262			{
263			if (!$this->has($key)) {
264			throw new \InvalidArgumentException(sprintf('Configuration value with key "%s" does not exist.', $key));
265			}
266
267			return $this->parameters->get($key);
268			}
269
270			/**
271			* @return array
272			*/
273			public function all(): array
274			{
275			$all = $this->parameters->all();
276			$all['client_id'] = $this->getPublicId()->getValue();
277
278			return $all;
279			}
280
281			/**
282			* {@inheritdoc}
283			*/
284			public function jsonSerialize()
285			{
286			$data = [
287			'$schema' => $this->getSchema(),
288			'type' => get_class($this),
289			'client_id' => $this->getPublicId()->getValue(),
290			'owner_id' => $this->getOwnerId() ? $this->getOwnerId()->getValue() : null,
291			'parameters' => (object) $this->all(),
292			'is_deleted' => $this->isDeleted(),
293			];
294
295			return $data;
296			}
297
298			/**
299			* {@inheritdoc}
300			*/
301			public static function createFromJson(\stdClass $json): DomainObject
302			{
303			$clientId = ClientId::create($json->client_id);
304			$ownerId = null !== $json->owner_id ? UserAccountId::create($json->owner_id) : null;
305			$parameters = DataBag::create((array) $json->parameters);
306			$deleted = $json->is_deleted;
307
308			$client = new self();
309			$client->clientId = $clientId;
310			$client->ownerId = $ownerId;
311			$client->parameters = $parameters;
312			$client->deleted = $deleted;
313
314			return $client;
315			}
316
317			/**
318			* @param Event $event
319			*
320			* @return Client
321			*/
322			public function apply(Event $event): self
323			{
324			$map = $this->getEventMap();
325			if (!array_key_exists($event->getType(), $map)) {
326			throw new \InvalidArgumentException('Unsupported event.');
327			}
328			if (null !== $this->clientId && $this->clientId->getValue() !== $event->getDomainId()->getValue()) {
329			throw new \InvalidArgumentException('Event not applicable for this client.');
330			}
331			$method = $map[$event->getType()];
332
333			return $this->$method($event);
334			}
335
336			/**
337			* @return array
338			*/
339			private function getEventMap(): array
340			{
341			return [
342			ClientEvent\ClientCreatedEvent::class => 'applyClientCreatedEvent',
343			ClientEvent\ClientOwnerChangedEvent::class => 'applyClientOwnerChangedEvent',
344			ClientEvent\ClientDeletedEvent::class => 'applyClientDeletedEvent',
345			ClientEvent\ClientParametersUpdatedEvent::class => 'applyClientParametersUpdatedEvent',
346			];
347			}
348
349			/**
350			* @param ClientEvent\ClientCreatedEvent $event
351			*
352			* @return Client
353			*/
354			protected function applyClientCreatedEvent(ClientEvent\ClientCreatedEvent $event): self
355			{
356			$clone = clone $this;
357			$clone->clientId = $event->getClientId();
358			$clone->ownerId = $event->getOwnerId();
359			$clone->parameters = $event->getParameters();
360
361			return $clone;
362			}
363
364			/**
365			* @param ClientEvent\ClientOwnerChangedEvent $event
366			*
367			* @return Client
368			*/
369			protected function applyClientOwnerChangedEvent(ClientEvent\ClientOwnerChangedEvent $event): self
370			{
371			$clone = clone $this;
372			$clone->ownerId = $event->getNewOwnerId();
373
374			return $clone;
375			}
376
377			/**
378			* @param ClientEvent\ClientDeletedEvent $event
379			*
380			* @return Client
381			*/
382			protected function applyClientDeletedEvent(ClientEvent\ClientDeletedEvent $event): self
383			{
384			$clone = clone $this;
385			$clone->deleted = true;
386
387			return $clone;
388			}
389
390			/**
391			* @param ClientEvent\ClientParametersUpdatedEvent $event
392			*
393			* @return Client
394			*/
395			protected function applyClientParametersUpdatedEvent(ClientEvent\ClientParametersUpdatedEvent $event): self
396			{
397			$clone = clone $this;
398			$clone->parameters = $event->getParameters();
399
400			return $clone;
401			}
402			}
403

OAuth2-Framework / oauth2-framework

Push — master ( c24b3a...b512e9 )

Client::getPublicId() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like