talismanfr\psbbank\ApiService

Complexity

Total Complexity

16

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	cities()	0	12	3
A	__construct()	0	3	1
A	deserializationResponse()	0	3	1
A	login()	0	8	3
A	orders()	0	16	5
A	createOrder()	0	8	3

<?php


namespace talismanfr\psbbank;


use Exception;
use talismanfr\psbbank\api\Api;
use talismanfr\psbbank\api\vo\LoginRequest;
use talismanfr\psbbank\api\vo\OrderRequest;
use talismanfr\psbbank\vo\City;
use talismanfr\psbbank\vo\Login;
use talismanfr\psbbank\vo\Order;

class ApiService
{
    /** @var Api */
    private $api;

    /**
     * ApiService constructor.
     * @param Api $api
     */
    public function __construct(Api $api)
    {
        $this->api = $api;
    }

    /**
     * Auth method. Getting token.
     * @param string $email
     * @param $password
     * @return Login|null
     * @throws Exception
     */
    public function login(string $email, $password): ?Login
    {
        $response = $this->api->login(new LoginRequest($email, $password));
        if ($response->getCode() !== 200 || $response->getBody() == null) {

It seems like you are loosely comparing $response->getBody() of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            return null;
        }

        return Login::fromResponseData($this->deserializationResponse($response->getBody()));
    }

    /**
     * @param string $token
     * @return City[]|null
     * @throws Exception
     */
    public function cities(string $token): ?array
    {
        $response = $this->api->cities($token);
        $response = $this->deserializationResponse($response->getBody());

It seems like $response->getBody() can also be of type null; however, parameter $body of talismanfr\psbbank\ApiService::deserializationResponse() does only seem to accept string, maybe add an additional type check?

        if (isset($response['data'])) {
            $cities = [];
            foreach ($response['data'] as $datum) {
                $cities[] = City::fromResponseData($datum);
            }
            return $cities;
        } else {
            return [City::fromResponseData($response)];
        }
    }

    /**
     * @param string $token
     * @param OrderRequest $orderRequest
     * @return Order|null
     * @throws Exception
     */
    public function createOrder(string $token, OrderRequest $orderRequest): ?Order
    {
        $response = $this->api->createOrder($token, $orderRequest);
        if ($response->getCode() == 503 || $response->getBody() == null) {

It seems like you are loosely comparing $response->getBody() of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            return null;
        }

        return Order::fromResponseData($this->deserializationResponse($response->getBody()));
    }

    /**
     * @param string $token
     * @param int $page
     * @return Order[]|null
     * @throws Exception
     */
    public function orders(string $token, int $page = 1): ?array
    {
        $response = $this->api->orders($token, $page);
        if ($response->getCode() == 503 || $response->getBody() == null) {

It seems like you are loosely comparing $response->getBody() of type null|string against null; this is ambiguous if the string can be empty. Consider using a strict comparison === instead.

            return null;
        }
        $response = $this->deserializationResponse($response->getBody());

        if (isset($response['data'])) {
            $cities = [];
            foreach ($response['data'] as $datum) {
                $cities[] = Order::fromResponseData($datum);
            }
            return $cities;
        } else {
            return [Order::fromResponseData($response)];
        }
    }

    /**
     * @param string $body
     * @return array
     */
    private function deserializationResponse(string $body): array
    {
        return json_decode($body, true);
    }
}