SchulIT\IdpExchange\Client

Complexity

Total Complexity

11

Size/Duplication

Total Lines	146
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	request()	0	23	2
A	getUpdatedUsers()	0	20	2
A	__construct()	0	6	1
A	getEndpointFor()	0	2	1
A	getUsers()	0	19	2
A	deserialize()	0	3	1
A	getUser()	0	19	2

<?php

namespace SchulIT\IdpExchange;

use GuzzleHttp\Client as GuzzleClient;
use GuzzleHttp\Exception\GuzzleException;
use JMS\Serializer\DeserializationContext;
use JMS\Serializer\SerializationContext;
use JMS\Serializer\SerializerInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use SchulIT\IdpExchange\Request\Builder\UpdatedUsersRequestBuilder;
use SchulIT\IdpExchange\Request\Builder\UserRequestBuilder;
use SchulIT\IdpExchange\Request\Builder\UsersRequestBuilder;
use SchulIT\IdpExchange\Response\UpdatedUsersResponse;
use SchulIT\IdpExchange\Response\UserResponse;
use SchulIT\IdpExchange\Response\UsersResponse;

class Client {
    private const TOKEN_HEADER = 'X-Token';
    private const UPDATED_USERS_ENDPOINT = '/exchange/updated_users';
    private const USERS_ENDPOINT = '/exchange/users';
    private const USER_ENDPOINT = '/exchange/user';

    private $endpoint;
    private $token;
    private $guzzle;
    private $serializer;
    private $logger;

    public function __construct(string $endpoint, string $token, GuzzleClient $guzzle, SerializerInterface $serializer, LoggerInterface $logger = null) {
        $this->endpoint = $endpoint;
        $this->token = $token;
        $this->guzzle = $guzzle;
        $this->serializer = $serializer;
        $this->logger = $logger ?? new NullLogger();
    }

    /**
     * @param $request
     * @param string $endpoint
     * @return mixed|\Psr\Http\Message\ResponseInterface
     * @throws ClientException
     * @throws GuzzleException
     */
    private function request($request, string $endpoint) {
        $context = (new SerializationContext())
            ->setSerializeNull(true);

        $jsonBody = $this->serializer->serialize($request, 'json', $context);

        $response = $this->guzzle->request('POST', $this->getEndpointFor($endpoint), [
            'headers' => [
                static::TOKEN_HEADER => $this->token
            ],
            'accept' => 'application/json',
            'body' => $jsonBody
        ]);

        if($response->getStatusCode() !== 200) {
            $this->logger->debug(sprintf('Request failed with response code %d', $response->getStatusCode()), [
                'response' => $response->getBody()->getContents()
            ]);

            throw new ClientException(sprintf('Request failed with response code %d', $response->getStatusCode()));
        }

        return $response;
    }

    /**
     * @param string $json
     * @param string $type
     * @return array|\JMS\Serializer\scalar|mixed|object

The type JMS\Serializer\scalar was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    private function deserialize(string $json, string $type) {
        $object = $this->serializer->deserialize($json, $type, 'json');
        return $object;
    }

    private function getEndpointFor(string $endpoint): string {
        return sprintf('%s%s', $this->endpoint, $endpoint);
    }

    /**
     * @param string[] $users
     * @param \DateTime $since
     * @return UpdatedUsersResponse
     * @throws ClientException
     */
    public function getUpdatedUsers(array $users, \DateTime $since): UpdatedUsersResponse {
        $this->logger->debug('getUpdatedUsers() started');

        try {
            $request = (new UpdatedUsersRequestBuilder())
                ->addUsers($users)
                ->since($since)
                ->build();

            $response = $this->request($request, static::UPDATED_USERS_ENDPOINT);

            return $this->deserialize($response->getBody()->getContents(), UpdatedUsersResponse::class);

The expression return $this->deserialize($response->getBody()->getContents(), SchulIT\IdpExchange\Response\UpdatedUsersResponse::class) could return the type array which is incompatible with the type-hinted return SchulIT\IdpExchange\Response\UpdatedUsersResponse. Consider adding an additional type-check to rule them out.

        } catch (GuzzleException $e) {
            $this->logger->error('Request failed with exception', [
                'exception' => $e
            ]);

            throw new ClientException($e->getMessage(), $e->getCode(), $e);
        } finally {
            $this->logger->debug('getUpdatedUsers() finished');

In this branch, the function will implicitly return null which is incompatible with the type-hinted return SchulIT\IdpExchange\Response\UpdatedUsersResponse. Consider adding a return statement or allowing null as return value.

        }
    }

    /**
     * @param string[] $users
     * @return UsersResponse
     * @throws ClientException
     */
    public function getUsers(array $users): UsersResponse {
        $this->logger->debug('getUsers() started');

        try {
            $request = (new UsersRequestBuilder())
                ->addUsers($users)
                ->build();

            $response = $this->request($request, static::USERS_ENDPOINT);

            return $this->deserialize($response->getBody()->getContents(), UsersResponse::class);

The expression return $this->deserialize($response->getBody()->getContents(), SchulIT\IdpExchange\Response\UsersResponse::class) could return the type array which is incompatible with the type-hinted return SchulIT\IdpExchange\Response\UsersResponse. Consider adding an additional type-check to rule them out.

        } catch (GuzzleException $e) {
            $this->logger->error('Request failed with exception', [
                'exception' => $e
            ]);

            throw new ClientException($e->getMessage(), $e->getCode(), $e);
        } finally {
            $this->logger->debug('getUsers() finished');

In this branch, the function will implicitly return null which is incompatible with the type-hinted return SchulIT\IdpExchange\Response\UsersResponse. Consider adding a return statement or allowing null as return value.

        }
    }

    /**
     * @param string $username
     * @return UserResponse
     * @throws ClientException
     */
    public function getUser(string $username): UserResponse {
        $this->logger->debug('getUser() started');

        try {
            $request = (new UserRequestBuilder())
                ->setUsername($username)
                ->build();

            $response = $this->request($request, static::USER_ENDPOINT);

            return $this->deserialize($response->getBody()->getContents(), UserResponse::class);

The expression return $this->deserialize($response->getBody()->getContents(), SchulIT\IdpExchange\Response\UserResponse::class) could return the type array which is incompatible with the type-hinted return SchulIT\IdpExchange\Response\UserResponse. Consider adding an additional type-check to rule them out.

        } catch (GuzzleException $e) {
            $this->logger->error('Request failed with exception', [
                'exception' => $e
            ]);

            throw new ClientException($e->getMessage(), $e->getCode(), $e);
        } finally {
            $this->logger->debug('getUser() finished');

In this branch, the function will implicitly return null which is incompatible with the type-hinted return SchulIT\IdpExchange\Response\UserResponse. Consider adding a return statement or allowing null as return value.

        }
    }
}