Client::applyClientCreatedEvent() - Code Metrics - Inspection of "Tests added" - OAuth2-Framework/oauth2-framework - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — ng ( 7370de...a36c25 )

by Florent

created 2018-01-05 22:07 UTC

Client::applyClientCreatedEvent() A

↳ Parent: Client

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	6
nc	1
nop	1

<?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\Server\Core\Client;

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

/**
 * Class Client.
 *
 * 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.
 */
final 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;

    /**
     * Client 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_type)) {
            throw new \InvalidArgumentException('The metadata "response_types" must be an array.');
        }

        return in_array($response_type, $response_types);
    }

    /**
     * @param string $token_type
     *
     * @return bool
     */
    public function isTokenTypeAllowed(string $token_type): bool
    {
        if (!$this->has('token_types')) {
            return true;
        }
        $token_types = $this->get('token_types');
        if (!is_array($token_types)) {
            throw new \InvalidArgumentException('The metadata "token_types" must be an array.');
        }

        return in_array($token_type, $token_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();
    }

    /**
     * @return bool
     */
    public function hasPublicKeySet(): bool
    {
        return $this->has('jwks') || $this->has('jwks_uri') || $this->has('client_secret');
    }

    /**
     * @return JWKSet
     */
    public function getPublicKeySet(): JWKSet
    {
        if (!$this->hasPublicKeySet()) {
            throw new \LogicException('The client has no public key set');
        }

        $jwkset = null;
        if ($this->has('jwks')) {
            $jwkset = JWKSet::createFromJson($this->get('jwks'));
        }
        //FIXME: find a way to allow jku
        /*if ($this->has('jwks_uri')) {

            $jwkset = JKUFactory::createFromJKU($this->get('jwks_uri'));
        }*/
        if ($this->has('client_secret')) {
            $key = JWK::create([
                'kty' => 'oct',
                'use' => 'sig',
                'k' => $this->get('client_secret'),
            ]);
            if (null === $jwkset) {
                $jwkset = JWKSet::createFromKeys([]);
                $jwkset = $jwkset->with($key);

                return $jwkset;
            } else {
                $jwkset = $jwkset->with($key);
            }
        }

        return $jwkset;
    }

    /**
     * {@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\Server\Core\Client;
15
16			use Jose\Component\Core\JWK;
17			use Jose\Component\Core\JWKSet;
18			use OAuth2Framework\Component\Server\Core\Client\Event as ClientEvent;
19			use OAuth2Framework\Component\Server\Core\DataBag\DataBag;
20			use OAuth2Framework\Component\Server\Core\Event\Event;
21			use OAuth2Framework\Component\Server\Core\ResourceOwner\ResourceOwnerId;
22			use OAuth2Framework\Component\Server\Core\ResourceOwner\ResourceOwner;
23			use OAuth2Framework\Component\Server\Core\UserAccount\UserAccountId;
24			use OAuth2Framework\Component\Server\Core\DomainObject;
25			use SimpleBus\Message\Recorder\ContainsRecordedMessages;
26			use SimpleBus\Message\Recorder\PrivateMessageRecorderCapabilities;
27
28			/**
29			* Class Client.
30			*
31			* This class is used for every client types.
32			* A client is a resource owner with a set of allowed grant types and can perform requests against
33			* available endpoints.
34			*/
35			final class Client implements ResourceOwner, ContainsRecordedMessages, DomainObject
36			{
37			use PrivateMessageRecorderCapabilities;
38
39			/**
40			* @var bool
41			*/
42			private $deleted = false;
43
44			/**
45			* @var UserAccountId\|null
46			*/
47			private $ownerId = null;
48
49			/**
50			* @var ClientId\|null
51			*/
52			private $clientId = null;
53
54			/**
55			* @var DataBag
56			*/
57			protected $parameters;
58
59			/**
60			* Client constructor.
61			*/
62			private function __construct()
63			{
64			$this->parameters = DataBag::create([]);
65			}
66
67			/**
68			* {@inheritdoc}
69			*/
70			public static function getSchema(): string
71			{
72			return 'https://oauth2-framework.spomky-labs.com/schemas/model/client/1.0/schema';
73			}
74
75			/**
76			* @return Client
77			*/
78			public static function createEmpty(): self
79			{
80			return new self();
81			}
82
83			/**
84			* @param ClientId $clientId
85			* @param DataBag $parameters
86			* @param UserAccountId\|null $ownerId
87			*
88			* @return Client
89			*/
90			public function create(ClientId $clientId, DataBag $parameters, ? UserAccountId $ownerId): self
91			{
92			$clone = clone $this;
93			$clone->clientId = $clientId;
94			$clone->parameters = $parameters;
95			$clone->ownerId = $ownerId;
96
97			$event = ClientEvent\ClientCreatedEvent::create($clone->clientId, $parameters, $ownerId);
98			$clone->record($event);
99
100			return $clone;
101			}
102
103			/**
104			* @return UserAccountId\|null
105			*/
106			public function getOwnerId(): ? UserAccountId
107			{
108			return $this->ownerId;
109			}
110
111			/**
112			* @param UserAccountId $ownerId
113			*
114			* @return Client
115			*/
116			public function withOwnerId(UserAccountId $ownerId): self
117			{
118			if ($this->getOwnerId()->getValue() === $ownerId->getValue()) {
119			return $this;
120			}
121
122			$clone = clone $this;
123			$clone->ownerId = $ownerId;
124			$event = ClientEvent\ClientOwnerChangedEvent::create($clone->getPublicId(), $ownerId);
125			$clone->record($event);
126
127			return $clone;
128			}
129
130			/**
131			* @param DataBag $parameters
132			*
133			* @return Client
134			*/
135			public function withParameters(DataBag $parameters): self
136			{
137			$clone = clone $this;
138			$clone->parameters = $parameters;
139			$event = ClientEvent\ClientParametersUpdatedEvent::create($clone->getPublicId(), $parameters);
140			$clone->record($event);
141
142			return $clone;
143			}
144
145			/**
146			* @return Client
147			*/
148			public function markAsDeleted(): self
149			{
150			$clone = clone $this;
151			$clone->deleted = true;
152			$event = ClientEvent\ClientDeletedEvent::create($clone->getPublicId());
153			$clone->record($event);
154
155			return $clone;
156			}
157
158			/**
159			* @return bool
160			*/
161			public function isDeleted(): bool
162			{
163			return $this->deleted;
164			}
165
166			/**
167			* @param string $grant_type
168			*
169			* @return bool
170			*/
171			public function isGrantTypeAllowed(string $grant_type): bool
172			{
173			$grant_types = $this->has('grant_types') ? $this->get('grant_types') : [];
174			if (!is_array($grant_types)) {
175			throw new \InvalidArgumentException('The metadata "grant_types" must be an array.');
176			}
177
178			return in_array($grant_type, $grant_types);
179			}
180
181			/**
182			* @param string $response_type
183			*
184			* @return bool
185			*/
186			public function isResponseTypeAllowed(string $response_type): bool
187			{
188			$response_types = $this->has('response_types') ? $this->get('response_types') : [];
189			if (!is_array($response_type)) {
190			throw new \InvalidArgumentException('The metadata "response_types" must be an array.');
191			}
192
193			return in_array($response_type, $response_types);
194			}
195
196			/**
197			* @param string $token_type
198			*
199			* @return bool
200			*/
201			public function isTokenTypeAllowed(string $token_type): bool
202			{
203			if (!$this->has('token_types')) {
204			return true;
205			}
206			$token_types = $this->get('token_types');
207			if (!is_array($token_types)) {
208			throw new \InvalidArgumentException('The metadata "token_types" must be an array.');
209			}
210
211			return in_array($token_type, $token_types);
212			}
213
214			/**
215			* @return bool
216			*/
217			public function isPublic(): bool
218			{
219			return 'none' === $this->getTokenEndpointAuthenticationMethod();
220			}
221
222			/**
223			* @return string
224			*/
225			public function getTokenEndpointAuthenticationMethod(): string
226			{
227			if ($this->has('token_endpoint_auth_method')) {
228			return $this->get('token_endpoint_auth_method');
229			}
230
231			return 'client_secret_basic';
232			}
233
234			/**
235			* @return int
236			*/
237			public function getClientCredentialsExpiresAt(): int
238			{
239			if ($this->has('client_secret_expires_at')) {
240			return $this->get('client_secret_expires_at');
241			}
242
243			return 0;
244			}
245
246			/**
247			* @return bool
248			*/
249			public function areClientCredentialsExpired(): bool
250			{
251			if (0 === $this->getClientCredentialsExpiresAt()) {
252			return false;
253			}
254
255			return time() > $this->getClientCredentialsExpiresAt();
256			}
257
258			/**
259			* @return bool
260			*/
261			public function hasPublicKeySet(): bool
262			{
263			return $this->has('jwks') \|\| $this->has('jwks_uri') \|\| $this->has('client_secret');
264			}
265
266			/**
267			* @return JWKSet
268			*/
269			public function getPublicKeySet(): JWKSet
270			{
271			if (!$this->hasPublicKeySet()) {
272			throw new \LogicException('The client has no public key set');
273			}
274
275			$jwkset = null;
276			if ($this->has('jwks')) {
277			$jwkset = JWKSet::createFromJson($this->get('jwks'));
278			}
279			//FIXME: find a way to allow jku
280			/*if ($this->has('jwks_uri')) {
			0 ignored issues – show Unused Code Comprehensibility introduced 2017-09-30 12:55 UTC by Report Bug Copy Issue Report `65%` of this comment could be valid code. Did you maybe forget this after debugging? Sometimes obsolete code just ends up commented out instead of removed. In this case it is better to remove the code once you have checked you do not need it. The code might also have been commented out for debugging purposes. In this case it is vital that someone uncomments it again or your project may behave in very unexpected ways in production. This check looks for comments that seem to be mostly valid code and reports them. Loading history...
281			$jwkset = JKUFactory::createFromJKU($this->get('jwks_uri'));
282			}*/
283			if ($this->has('client_secret')) {
284			$key = JWK::create([
285			'kty' => 'oct',
286			'use' => 'sig',
287			'k' => $this->get('client_secret'),
288			]);
289			if (null === $jwkset) {
290			$jwkset = JWKSet::createFromKeys([]);
291			$jwkset = $jwkset->with($key);
292
293			return $jwkset;
294			} else {
295			$jwkset = $jwkset->with($key);
296			}
297			}
298
299			return $jwkset;
300			}
301
302			/**
303			* {@inheritdoc}
304			*/
305			public function getPublicId(): ResourceOwnerId
306			{
307			if (null === $this->clientId) {
308			throw new \RuntimeException('Client not initialized.');
309			}
310
311			return $this->clientId;
312			}
313
314			/**
315			* {@inheritdoc}
316			*/
317			public function has(string $key): bool
318			{
319			return $this->parameters->has($key);
320			}
321
322			/**
323			* {@inheritdoc}
324			*/
325			public function get(string $key)
326			{
327			if (!$this->has($key)) {
328			throw new \InvalidArgumentException(sprintf('Configuration value with key "%s" does not exist.', $key));
329			}
330
331			return $this->parameters->get($key);
332			}
333
334			/**
335			* @return array
336			*/
337			public function all(): array
338			{
339			$all = $this->parameters->all();
340			$all['client_id'] = $this->getPublicId()->getValue();
341
342			return $all;
343			}
344
345			/**
346			* {@inheritdoc}
347			*/
348			public function jsonSerialize()
349			{
350			$data = [
351			'$schema' => $this->getSchema(),
352			'type' => get_class($this),
353			'client_id' => $this->getPublicId()->getValue(),
354			'owner_id' => $this->getOwnerId() ? $this->getOwnerId()->getValue() : null,
355			'parameters' => (object) $this->all(),
356			'is_deleted' => $this->isDeleted(),
357			];
358
359			return $data;
360			}
361
362			/**
363			* {@inheritdoc}
364			*/
365			public static function createFromJson(\stdClass $json): DomainObject
366			{
367			$clientId = ClientId::create($json->client_id);
368			$ownerId = null !== $json->owner_id ? UserAccountId::create($json->owner_id) : null;
369			$parameters = DataBag::create((array) $json->parameters);
370			$deleted = $json->is_deleted;
371
372			$client = new self();
373			$client->clientId = $clientId;
374			$client->ownerId = $ownerId;
375			$client->parameters = $parameters;
376			$client->deleted = $deleted;
377
378			return $client;
379			}
380
381			/**
382			* @param Event $event
383			*
384			* @return Client
385			*/
386			public function apply(Event $event): self
387			{
388			$map = $this->getEventMap();
389			if (!array_key_exists($event->getType(), $map)) {
390			throw new \InvalidArgumentException('Unsupported event.');
391			}
392			if (null !== $this->clientId && $this->clientId->getValue() !== $event->getDomainId()->getValue()) {
393			throw new \InvalidArgumentException('Event not applicable for this client.');
394			}
395			$method = $map[$event->getType()];
396
397			return $this->$method($event);
398			}
399
400			/**
401			* @return array
402			*/
403			private function getEventMap(): array
404			{
405			return [
406			ClientEvent\ClientCreatedEvent::class => 'applyClientCreatedEvent',
407			ClientEvent\ClientOwnerChangedEvent::class => 'applyClientOwnerChangedEvent',
408			ClientEvent\ClientDeletedEvent::class => 'applyClientDeletedEvent',
409			ClientEvent\ClientParametersUpdatedEvent::class => 'applyClientParametersUpdatedEvent',
410			];
411			}
412
413			/**
414			* @param ClientEvent\ClientCreatedEvent $event
415			*
416			* @return Client
417			*/
418			protected function applyClientCreatedEvent(ClientEvent\ClientCreatedEvent $event): self
419			{
420			$clone = clone $this;
421			$clone->clientId = $event->getClientId();
422			$clone->ownerId = $event->getOwnerId();
423			$clone->parameters = $event->getParameters();
424
425			return $clone;
426			}
427
428			/**
429			* @param ClientEvent\ClientOwnerChangedEvent $event
430			*
431			* @return Client
432			*/
433			protected function applyClientOwnerChangedEvent(ClientEvent\ClientOwnerChangedEvent $event): self
434			{
435			$clone = clone $this;
436			$clone->ownerId = $event->getNewOwnerId();
437
438			return $clone;
439			}
440
441			/**
442			* @param ClientEvent\ClientDeletedEvent $event
443			*
444			* @return Client
445			*/
446			protected function applyClientDeletedEvent(ClientEvent\ClientDeletedEvent $event): self
447			{
448			$clone = clone $this;
449			$clone->deleted = true;
450
451			return $clone;
452			}
453
454			/**
455			* @param ClientEvent\ClientParametersUpdatedEvent $event
456			*
457			* @return Client
458			*/
459			protected function applyClientParametersUpdatedEvent(ClientEvent\ClientParametersUpdatedEvent $event): self
460			{
461			$clone = clone $this;
462			$clone->parameters = $event->getParameters();
463
464			return $clone;
465			}
466			}
467

OAuth2-Framework / oauth2-framework

Push — ng ( 7370de...a36c25 )

Client::applyClientCreatedEvent() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like