ByProjectKeySubscriptionsGet.php

<?php
 
declare(strict_types=1);
namespace Commercetools\Api\Client\Resource;
 
use Commercetools\Api\Models\Error\ErrorResponse;
use Commercetools\Api\Models\Error\ErrorResponseModel;
use Commercetools\Api\Models\Subscription\SubscriptionPagedQueryResponse;
use Commercetools\Api\Models\Subscription\SubscriptionPagedQueryResponseModel;
use Commercetools\Base\JsonObject;
use Commercetools\Base\JsonObjectModel;
use Commercetools\Client\ApiRequest;
use Commercetools\Exception\ApiClientException;
use Commercetools\Exception\ApiServerException;
use Commercetools\Exception\ExceptionFactory;
use Commercetools\Exception\InvalidArgumentException;
use GuzzleHttp\ClientInterface;
use GuzzleHttp\Exception\ClientException;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Exception\ServerException;
use GuzzleHttp\Promise\PromiseInterface;
 
use Psr\Http\Message\ResponseInterface;
 
class ByProjectKeySubscriptionsGet extends ApiRequest implements Sortable, Paging, Query, Errorable, Deprecatable200
{
    public function __construct(string $projectKey, $body = null, array $headers = [], ClientInterface $client = null)
    {
        $uri = str_replace(['{projectKey}'], [$projectKey], '{projectKey}/subscriptions');
        parent::__construct($client, 'GET', $uri, $headers, is_object($body) || is_array($body) ? json_encode($body) : $body);
    }
 
    public function mapFromResponse(?ResponseInterface $response, string $resultType = null)
    {
        if (is_null($response)) {
            return null;
        }
        if (is_null($resultType)) {
            switch ($response->getStatusCode()) {
                case '200':
                    $resultType = SubscriptionPagedQueryResponseModel::class;
 
                    break;
                case '400':
                    $resultType = ErrorResponseModel::class;
 
                    break;
                case '401':
                    $resultType = ErrorResponseModel::class;
 
                    break;
                case '403':
                    $resultType = ErrorResponseModel::class;
 
                    break;
                case '500':
                    $resultType = ErrorResponseModel::class;
 
                    break;
                case '502':
                    $resultType = ErrorResponseModel::class;
 
                    break;
                case '503':
                    $resultType = ErrorResponseModel::class;
 
                    break;
                default:
                    $resultType = JsonObjectModel::class;
 
                    break;
            }
        }
 
        return $resultType::of($this->responseData($response));
    }
 
    public function execute(array $options = [], string $resultType = null)
    {
        try {
            $response = $this->send($options);
        } catch (ServerException $e) {
            $response = $e->getResponse();
            $e = ExceptionFactory::createServerException($e, $this, $response, $this->mapFromResponse($response, $resultType));
            throw $e;
        } catch (ClientException $e) {
            $response = $e->getResponse();
            $e = ExceptionFactory::createClientException($e, $this, $response, $this->mapFromResponse($response, $resultType));
            throw $e;
        }
 
        return $this->mapFromResponse($response, $resultType);
    }
 
    public function executeAsync(array $options = [], string $resultType = null)
    {
        return $this->sendAsync($options)->then(
            function (ResponseInterface $response) use ($resultType) {
                return $this->mapFromResponse($response, $resultType);
            },
            function (RequestException $e) use ($resultType) {
                $response = $e->getResponse();
                if ($e instanceof ServerException) {
                    $e = ExceptionFactory::createServerException($e, $this, $response, $this->mapFromResponse($response, $resultType));
                }
                if ($e instanceof ClientException) {
                    $e = ExceptionFactory::createClientException($e, $this, $response, $this->mapFromResponse($response, $resultType));
                }
                throw $e;
            }
        );
    }
 
    public function withSort($sort): ByProjectKeySubscriptionsGet
    {
        return $this->withQueryParam('sort', $sort);
    }
 
    public function withLimit($limit): ByProjectKeySubscriptionsGet
    {
        return $this->withQueryParam('limit', $limit);
    }
 
    public function withOffset($offset): ByProjectKeySubscriptionsGet
    {
        return $this->withQueryParam('offset', $offset);
    }
 
    public function withWithTotal($withTotal): ByProjectKeySubscriptionsGet
    {
        return $this->withQueryParam('withTotal', $withTotal);
    }
 
    public function withWhere($where): ByProjectKeySubscriptionsGet
    {
        return $this->withQueryParam('where', $where);
    }
 
    public function withPredicateVar(string $varName, $predicateVar): ByProjectKeySubscriptionsGet
    {
        return $this->withQueryParam(sprintf('var.%s', $varName), $predicateVar);
    }
}