BEditaClient::getStatusCode() - Code Metrics - Inspection of "Merge pull request #17 from bedita/refactor/save-m..." - bedita/php-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( aa4f42...34ff25 )

by Dante

created 2018-08-01 06:04 UTC

BEditaClient::getStatusCode() A

↳ Parent: BEditaClient

Complexity

Conditions	2
Paths	2

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
eloc	1
nc	2
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php
/**
 * BEdita, API-first content management framework
 * Copyright 2018 ChannelWeb Srl, Chialab Srl
 *
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 */

namespace BEdita\SDK;

use GuzzleHttp\Psr7\Request;
use GuzzleHttp\Psr7\Uri;
use Http\Adapter\Guzzle6\Client;
use Psr\Http\Message\ResponseInterface;
use WoohooLabs\Yang\JsonApi\Client\JsonApiClient;

/**
 * BEdita4 API Client class
 */
class BEditaClient
{

    /**
     * Last response.
     *
     * @var \Psr\Http\Message\ResponseInterface
     */
    private $response = null;

    /**
     * BEdita4 API base URL
     *
     * @var string
     */
    private $apiBaseUrl = null;

    /**
     * BEdita4 API KEY
     *
     * @var string
     */
    private $apiKey = null;

    /**
     * Default headers in request
     *
     * @var array
     */
    private $defaultHeaders = [
        'Accept' => 'application/vnd.api+json',
    ];

    /**
     * Default headers in request
     *
     * @var array
     */
    private $defaultContentTypeHeader = [
        'Content-Type' => 'application/json',
    ];

    /**
     * JWT Auth tokens
     *
     * @var array
     */
    private $tokens = [];

    /**
     * JSON API BEdita4 client
     *
     * @var \WoohooLabs\Yang\JsonApi\Client\JsonApiClient
     */
    private $jsonApiClient = null;

    /**
     * Setup main client options:
     *  - API base URL
     *  - API KEY
     *  - Auth tokens 'jwt' and 'renew' (optional)
     *
     * @param string $apiUrl API base URL
     * @param string $apiKey API key
     * @param array $tokens JWT Autorization tokens as associative array ['jwt' => '###', 'renew' => '###']
     * @return void
     */
    public function __construct(string $apiUrl, ?string $apiKey = null, array $tokens = [])
    {
        $this->apiBaseUrl = $apiUrl;
        $this->apiKey = $apiKey;

        $this->defaultHeaders['X-Api-Key'] = $this->apiKey;
        $this->setupTokens($tokens);

        // setup an asynchronous JSON API client
        $guzzleClient = Client::createWithConfig([]);
        $this->jsonApiClient = new JsonApiClient($guzzleClient);
    }

    /**
     * Setup JWT access and refresh tokens.
     *
     * @param array $tokens JWT tokens as associative array ['jwt' => '###', 'renew' => '###']
     * @return void
     */
    public function setupTokens(array $tokens) : void
    {
        $this->tokens = $tokens;
        if (!empty($tokens['jwt'])) {
            $this->defaultHeaders['Authorization'] = sprintf('Bearer %s', $tokens['jwt']);
        } else {
            unset($this->defaultHeaders['Authorization']);
        }
    }

    /**
     * Get default headers in use on every request
     *
     * @return array Default headers
     * @codeCoverageIgnore
     */
    public function getDefaultHeaders() : array
    {
        return $this->defaultHeaders;
    }

    /**
     * Get API base URL used tokens
     *
     * @return string API base URL
     * @codeCoverageIgnore
     */
    public function getApiBaseUrl() : string
    {
        return $this->apiBaseUrl;
    }

    /**
     * Get current used tokens
     *
     * @return array Current tokens
     * @codeCoverageIgnore
     */
    public function getTokens() : array
    {
        return $this->tokens;
    }

    /**
     * Get last HTTP response
     *
     * @return ResponseInterface|null Response PSR interface
     * @codeCoverageIgnore
     */
    public function getResponse() : ?ResponseInterface
    {
        return $this->response;
    }

    /**
     * Get HTTP response status code
     * Return null if no response is available
     *
     * @return int|null Status code.
     */
    public function getStatusCode() : ?int
    {
        return $this->response ? $this->response->getStatusCode() : null;
    }

    /**
     * Get HTTP response status message
     * Return null if no response is available
     *
     * @return string|null Message related to status code.
     */
    public function getStatusMessage() : ?string
    {
        return $this->response ? $this->response->getReasonPhrase() : null;
    }

    /**
     * Get response body serialized into a PHP array
     *
     * @return array|null Response body as PHP array.
     */
    public function getResponseBody() : ?array
    {
        $response = $this->getResponse();
        if (empty($response)) {
            return null;
        }
        $responseBody = json_decode((string)$response->getBody(), true);
        if (!is_array($responseBody)) {
            return null;
        }

        return $responseBody;
    }

    /**
     * Classic authentication via POST /auth using username and password
     *
     * @param string $username username
     * @param string $password password
     * @return array|null Response in array format
     */
    public function authenticate(string $username, string $password) : ?array
    {
        $body = json_encode(compact('username', 'password'));

        return $this->post('/auth', $body, ['Content-Type' => 'application/json']);
    }

    /**
     * Send a GET request a list of resources or objects or a single resource or object
     *
     * @param string $path Endpoint URL path to invoke
     * @param array|null $query Optional query string
     * @param array|null $headers Headers
     * @return array|null Response in array format
     */
    public function get(string $path, ?array $query = null, ?array $headers = null) : ?array
    {
        $this->sendRequestRetry('GET', $path, $query, $headers);

        return $this->getResponseBody();
    }

    /**
     * GET a list of resources or objects of a given type
     *
     * @param string $type Object type name
     * @param array|null $query Optional query string
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function getObjects(string $type = 'objects', ?array $query = null, ?array $headers = null) : ?array
    {
        return $this->get(sprintf('/%s', $type), $query, $headers);
    }

    /**
     * GET a single object of a given type
     *
     * @param int|string $id Object id
     * @param string $type Object type name
     * @param array|null $query Optional query string
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function getObject($id, string $type = 'objects', ?array $query = null, ?array $headers = null) : ?array
    {
        return $this->get(sprintf('/%s/%s', $type, $id), $query, $headers);
    }

    /**
     * Get a list of related resources or objects
     *
     * @param int|string $id Resource id or object uname/id
     * @param string $type Type name
     * @param string $relation Relation name
     * @param array|null $query Optional query string
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function getRelated($id, string $type, string $relation, ?array $query = null, ?array $headers = null) : ?array
    {
        return $this->get(sprintf('/%s/%s/%s', $type, $id, $relation), $query, $headers);
    }

    /**
     * Add a list of related resources or objects
     *
     * @param int|string $id Resource id or object uname/id
     * @param string $type Type name
     * @param string $relation Relation name
     * @param string $data Related resources or objects to add, MUST contain id and type
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function addRelated($id, string $type, string $relation, array $data, ?array $headers = null) : ?array
    {
        $body = compact('data');

        return $this->post(sprintf('/%s/%s/relationships/%s', $type, $id, $relation), json_encode($body), $headers);
    }

    /**
     * Remove a list of related resources or objects
     *
     * @param int|string $id Resource id or object uname/id
     * @param string $type Type name
     * @param string $relation Relation name
     * @param string $data Related resources or objects to remove from relation
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function removeRelated($id, string $type, string $relation, array $data, ?array $headers = null) : ?array
    {
        $body = compact('data');

        return $this->delete(sprintf('/%s/%s/relationships/%s', $type, $id, $relation), json_encode($body), $headers);
    }

    /**
     * Replace a list of related resources or objects: previuosly related are removed and replaced with these.
     *
     * @param int|string $id Object id
     * @param string $type Object type name
     * @param string $relation Relation name
     * @param string $data Related resources or objects to insert
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function replaceRelated($id, string $type, string $relation, array $data, ?array $headers = null) : ?array
    {
        $body = compact('data');

        return $this->patch(sprintf('/%s/%s/relationships/%s', $type, $id, $relation), json_encode($body), $headers);
    }

    /**
     * Create a new object or resource (POST) or modify an existing one (PATCH)
     *
     * @param string $type Object or resource type name
     * @param array $data Object or resource data to save
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function save(string $type, array $data, ?array $headers = null) : ?array
    {
        $id = null;
        if (array_key_exists('id', $data)) {
            $id = $data['id'];
            unset($data['id']);
        }

        $body = [
            'data' => [
                'type' => $type,
                'attributes' => $data,
            ],
        ];
        if (!$id) {
            return $this->post(sprintf('/%s', $type), json_encode($body), $headers);
        }
        $body['data']['id'] = $id;

        return $this->patch(sprintf('/%s/%s', $type, $id), json_encode($body), $headers);
    }

    /**
     * [DEPRECATED] Create a new object (POST) or modify an existing one (PATCH)
     *
     * @param string $type Object type name
     * @param array $data Object data to save
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     * @deprecated Use `save()` method instead
     * @codeCoverageIgnore
     */
    public function saveObject(string $type, array $data, ?array $headers = null) : ?array
    {
        return $this->save($type, $data, $headers);
    }

    /**
     * Delete an object (DELETE) => move to trashcan.
     *
     * @param int|string $id Object id
     * @param string $type Object type name
     * @return array|null Response in array format
     */
    public function deleteObject($id, string $type) : ?array
    {
        return $this->delete(sprintf('/%s/%s', $type, $id));
    }

    /**
     * Remove an object => permanently remove object from trashcan.
     *
     * @param int|string $id Object id
     * @return array|null Response in array format
     */
    public function remove($id) : ?array
    {
        return $this->delete(sprintf('/trash/%s', $id));
    }

    /**
     * Upload file (POST)
     *
     * @param string $filename The file name
     * @param string $filepath File full path: could be on a local filesystem or a remote reachable URL
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     * @throws BEditaClientException
     */
    public function upload(string $filename, string $filepath, ?array $headers = null) : ?array
    {
        if (!file_exists($filepath)) {
            throw new BEditaClientException('File not found', 500);
        }
        $file = file_get_contents($filepath);
        if (!$file) {
            throw new BEditaClientException('File get contents failed', 500);
        }
        if (empty($headers['Content-Type'])) {
            $headers['Content-Type'] = mime_content_type($filepath);
        }

        return $this->post(sprintf('/streams/upload/%s', $filename), $file, $headers);
    }

    /**
     * Create media by type and body data and link it to a stream:
     *  - `POST /:type` with `$body` as payload, create media object
     *  - `PATCH /streams/:stream_id/relationships/object` modify stream adding relation to media
     *  - `GET /:type/:id` get media data
     *
     * @param string $streamId The stream identifier
     * @param string $type The type
     * @param array $body The body data
     * @return array|null Response in array format
     * @throws BEditaClientException
     */
    public function createMediaFromStream($streamId, string $type, array $body) : ?array
    {
        $response = $this->post(sprintf('/%s', $type), json_encode($body));
        if (empty($response)) {
            throw new BEditaClientException('Invalid response from POST ' . sprintf('/%s', $type));
        }
        $id = $response['data']['id'];
        $data = compact('id', 'type');
        $body = compact('data');
        $response = $this->patch(sprintf('/streams/%s/relationships/object', $streamId), json_encode($body));
        if (empty($response)) {
            throw new BEditaClientException('Invalid response from PATCH ' . sprintf('/streams/%s/relationships/object', $id));
        }

        return $this->getObject($data['id'], $data['type']);
    }

    /**
     * Thumbnail request using `GET /media/thumbs` endpoint
     *
     *  Usage:
     *          thumbs(123) => `GET /media/thumbs/123`
     *          thumbs(123, ['preset' => 'glide']) => `GET /media/thumbs/123&preset=glide`
     *          thumbs(null, ['ids' => '123,124,125']) => `GET /media/thumbs?ids=123,124,125`
     *          thumbs(null, ['ids' => '123,124,125', 'preset' => 'async']) => `GET /media/thumbs?ids=123,124,125&preset=async`
     *          thumbs(123, ['options' => ['w' => 100, 'h' => 80, 'fm' => 'jpg']]) => `GET /media/thumbs/123/options[w]=100&options[h]=80&options[fm]=jpg` (these options could be not available... just set in preset(s))
     *
     * @param int|null $id the media Id.
     * @param array $query The query params for thumbs call.
     * @return array|null Response in array format
     */
    public function thumbs($id = null, $query = []) : ?array
    {
        if (empty($id) && empty($query['ids'])) {
            throw new BEditaClientException('Invalid empty id|ids for thumbs');
        }
        $endpoint = '/media/thumbs';
        if (!empty($id)) {
            $endpoint .= sprintf('/%d', $id);
        }

        return $this->get($endpoint, $query);
    }

    /**
     * Get JSON SCHEMA of a resource or object
     *
     * @param string $type Object or resource type name
     * @return array|null JSON SCHEMA in array format
     */
    public function schema(string $type) : ?array
    {
        $h = ['Accept' => 'application/schema+json'];

        return $this->get(sprintf('/model/schema/%s', $type), null, $h);
    }

    /**
     * Restore object from trash
     *
     * @param int|string $id Object id
     * @param string $type Object type name
     * @return array|null Response in array format
     */
    public function restoreObject($id, string $type) : ?array
    {
        $body = [
            'data' => [
                'id' => $id,
                'type' => $type,
            ],
        ];

        return $this->patch(sprintf('/%s/%s', 'trash', $id), json_encode($body));
    }

    /**
     * Send a PATCH request to modify a single resource or object
     *
     * @param string $path Endpoint URL path to invoke
     * @param mixed $body Request body
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function patch(string $path, $body, ?array $headers = null) : ?array
    {
        $this->sendRequestRetry('PATCH', $path, null, $headers, $body);

        return $this->getResponseBody();
    }

    /**
     * Send a POST request for creating resources or objects or other operations like /auth
     *
     * @param string $path Endpoint URL path to invoke
     * @param mixed $body Request body
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format
     */
    public function post(string $path, $body, ?array $headers = null) : ?array
    {
        $this->sendRequestRetry('POST', $path, null, $headers, $body);

        return $this->getResponseBody();
    }

    /**
     * Send a DELETE request
     *
     * @param string $path Endpoint URL path to invoke.
     * @param mixed $body Request body
     * @param array|null $headers Custom request headers
     * @return array|null Response in array format.
     */
    public function delete(string $path, $body = null, ?array $headers = null) : ?array
    {
        $this->sendRequestRetry('DELETE', $path, null, $headers, $body);

        return $this->getResponseBody();
    }

    /**
     * Send a generic JSON API request with a basic retry policy on expired token exception.
     *
     * @param string $method HTTP Method.
     * @param string $path Endpoint URL path.
     * @param array|null $query Query string parameters.
     * @param string[]|null $headers Custom request headers.
     * @param string|resource|\Psr\Http\Message\StreamInterface|null $body Request body.
     * @return \Psr\Http\Message\ResponseInterface
     */
    protected function sendRequestRetry(string $method, string $path, ?array $query = null, ?array $headers = null, $body = null) : ResponseInterface
    {
        try {
            return $this->sendRequest($method, $path, $query, $headers, $body);
        } catch (BEditaClientException $e) {
            // Handle error.
            $attributes = $e->getAttributes();
            if ($e->getCode() !== 401 || empty($attributes['code']) || $attributes['code'] !== 'be_token_expired') {
                // Not an expired token's fault.
                throw $e;
            }

            // Refresh and retry.
            $this->refreshTokens();
            unset($headers['Authorization']);

            return $this->sendRequest($method, $path, $query, $headers, $body);
        }
    }

    /**
     * Send a generic JSON API request and retrieve response $this->response
     *
     * @param string $method HTTP Method.
     * @param string $path Endpoint URL path (with or without starting `/`) or absolute API path
     * @param array|null $query Query string parameters.
     * @param string[]|null $headers Custom request headers.
     * @param string|resource|\Psr\Http\Message\StreamInterface|null $body Request body.
     * @return \Psr\Http\Message\ResponseInterface
     * @throws BEditaClientException Throws an exception if server response code is not 20x.
     */
    protected function sendRequest(string $method, string $path, ?array $query = null, ?array $headers = null, $body = null) : ResponseInterface
    {
        $uri = $this->requestUri($path, $query);
        $headers = array_merge($this->defaultHeaders, (array)$headers);

        // set default `Content-Type` if not set and $body not empty
        if (!empty($body)) {
            $headers = array_merge($this->defaultContentTypeHeader, $headers);
        }

        // Send the request synchronously to retrieve the response.
        $this->response = $this->jsonApiClient->sendRequest(new Request($method, $uri, $headers, $body));
        if ($this->getStatusCode() >= 400) {
            // Something bad just happened.
            $response = $this->getResponseBody();
            // Message will be 'error` array, if absent use status massage
            $message = empty($response['error']) ? $this->getStatusMessage() : $response['error'];
            throw new BEditaClientException($message, $this->getStatusCode());
        }

        return $this->response;
    }

    /**
     * Create request URI from path
     *
     * @param string $path Endpoint URL path (with or without starting `/`) or absolute API path
     * @param array|null $query Query string parameters.
     * @return Uri
     */
    protected function requestUri(string $path, ?array $query = null) : Uri
    {
        if (strpos($path, $this->apiBaseUrl) !== 0) {
            if (substr($path, 0, 1) !== '/') {
                $path = '/' . $path;
            }
            $path = $this->apiBaseUrl . $path;
        }
        $uri = new Uri($path);

        // if path contains query strings, remove them from path and add them to query filter
        parse_str($uri->getQuery(), $uriQuery);
        if ($query) {
            $query = array_merge((array)$uriQuery, (array)$query);
            $uri = $uri->withQuery(http_build_query($query));
        }

        return $uri;
    }

    /**
     * Refresh JWT access token.
     *
     * On success `$this->tokens` data will be updated with new access and renew tokens.
     *
     * @throws \BadMethodCallException Throws an exception if client has no renew token available.
     * @throws \Cake\Network\Exception\ServiceUnavailableException Throws an exception if server response doesn't
     *      include the expected data.
     * @return void
     * @throws BEditaClientException Throws an exception if server response code is not 20x.
     */
    public function refreshTokens() : void
    {
        if (empty($this->tokens['renew'])) {
            throw new \BadMethodCallException('You must be logged in to renew token');
        }

        $headers = [
            'Authorization' => sprintf('Bearer %s', $this->tokens['renew']),
        ];

        $this->sendRequest('POST', '/auth', [], $headers);
        $body = $this->getResponseBody();
        if (empty($body['meta']['jwt'])) {
            throw new BEditaClientException('Invalid response from server');
        }

        $this->setupTokens($body['meta']);
    }
}


1			<?php
2			/**
3			* BEdita, API-first content management framework
4			* Copyright 2018 ChannelWeb Srl, Chialab Srl
5			*
6			* Licensed under The MIT License
7			* For full copyright and license information, please see the LICENSE.txt
8			* Redistributions of files must retain the above copyright notice.
9			*/
10
11			namespace BEdita\SDK;
12
13			use GuzzleHttp\Psr7\Request;
14			use GuzzleHttp\Psr7\Uri;
15			use Http\Adapter\Guzzle6\Client;
16			use Psr\Http\Message\ResponseInterface;
17			use WoohooLabs\Yang\JsonApi\Client\JsonApiClient;
18
19			/**
20			* BEdita4 API Client class
21			*/
22			class BEditaClient
23			{
24
25			/**
26			* Last response.
27			*
28			* @var \Psr\Http\Message\ResponseInterface
29			*/
30			private $response = null;
31
32			/**
33			* BEdita4 API base URL
34			*
35			* @var string
36			*/
37			private $apiBaseUrl = null;
38
39			/**
40			* BEdita4 API KEY
41			*
42			* @var string
43			*/
44			private $apiKey = null;
45
46			/**
47			* Default headers in request
48			*
49			* @var array
50			*/
51			private $defaultHeaders = [
52			'Accept' => 'application/vnd.api+json',
53			];
54
55			/**
56			* Default headers in request
57			*
58			* @var array
59			*/
60			private $defaultContentTypeHeader = [
61			'Content-Type' => 'application/json',
62			];
63
64			/**
65			* JWT Auth tokens
66			*
67			* @var array
68			*/
69			private $tokens = [];
70
71			/**
72			* JSON API BEdita4 client
73			*
74			* @var \WoohooLabs\Yang\JsonApi\Client\JsonApiClient
75			*/
76			private $jsonApiClient = null;
77
78			/**
79			* Setup main client options:
80			* - API base URL
81			* - API KEY
82			* - Auth tokens 'jwt' and 'renew' (optional)
83			*
84			* @param string $apiUrl API base URL
85			* @param string $apiKey API key
86			* @param array $tokens JWT Autorization tokens as associative array ['jwt' => '###', 'renew' => '###']
87			* @return void
88			*/
89			public function __construct(string $apiUrl, ?string $apiKey = null, array $tokens = [])
90			{
91			$this->apiBaseUrl = $apiUrl;
92			$this->apiKey = $apiKey;
93
94			$this->defaultHeaders['X-Api-Key'] = $this->apiKey;
95			$this->setupTokens($tokens);
96
97			// setup an asynchronous JSON API client
98			$guzzleClient = Client::createWithConfig([]);
99			$this->jsonApiClient = new JsonApiClient($guzzleClient);
100			}
101
102			/**
103			* Setup JWT access and refresh tokens.
104			*
105			* @param array $tokens JWT tokens as associative array ['jwt' => '###', 'renew' => '###']
106			* @return void
107			*/
108			public function setupTokens(array $tokens) : void
109			{
110			$this->tokens = $tokens;
111			if (!empty($tokens['jwt'])) {
112			$this->defaultHeaders['Authorization'] = sprintf('Bearer %s', $tokens['jwt']);
113			} else {
114			unset($this->defaultHeaders['Authorization']);
115			}
116			}
117
118			/**
119			* Get default headers in use on every request
120			*
121			* @return array Default headers
122			* @codeCoverageIgnore
123			*/
124			public function getDefaultHeaders() : array
125			{
126			return $this->defaultHeaders;
127			}
128
129			/**
130			* Get API base URL used tokens
131			*
132			* @return string API base URL
133			* @codeCoverageIgnore
134			*/
135			public function getApiBaseUrl() : string
136			{
137			return $this->apiBaseUrl;
138			}
139
140			/**
141			* Get current used tokens
142			*
143			* @return array Current tokens
144			* @codeCoverageIgnore
145			*/
146			public function getTokens() : array
147			{
148			return $this->tokens;
149			}
150
151			/**
152			* Get last HTTP response
153			*
154			* @return ResponseInterface\|null Response PSR interface
155			* @codeCoverageIgnore
156			*/
157			public function getResponse() : ?ResponseInterface
158			{
159			return $this->response;
160			}
161
162			/**
163			* Get HTTP response status code
164			* Return null if no response is available
165			*
166			* @return int\|null Status code.
167			*/
168			public function getStatusCode() : ?int
169			{
170			return $this->response ? $this->response->getStatusCode() : null;
171			}
172
173			/**
174			* Get HTTP response status message
175			* Return null if no response is available
176			*
177			* @return string\|null Message related to status code.
178			*/
179			public function getStatusMessage() : ?string
180			{
181			return $this->response ? $this->response->getReasonPhrase() : null;
182			}
183
184			/**
185			* Get response body serialized into a PHP array
186			*
187			* @return array\|null Response body as PHP array.
188			*/
189			public function getResponseBody() : ?array
190			{
191			$response = $this->getResponse();
192			if (empty($response)) {
193			return null;
194			}
195			$responseBody = json_decode((string)$response->getBody(), true);
196			if (!is_array($responseBody)) {
197			return null;
198			}
199
200			return $responseBody;
201			}
202
203			/**
204			* Classic authentication via POST /auth using username and password
205			*
206			* @param string $username username
207			* @param string $password password
208			* @return array\|null Response in array format
209			*/
210			public function authenticate(string $username, string $password) : ?array
211			{
212			$body = json_encode(compact('username', 'password'));
213
214			return $this->post('/auth', $body, ['Content-Type' => 'application/json']);
215			}
216
217			/**
218			* Send a GET request a list of resources or objects or a single resource or object
219			*
220			* @param string $path Endpoint URL path to invoke
221			* @param array\|null $query Optional query string
222			* @param array\|null $headers Headers
223			* @return array\|null Response in array format
224			*/
225			public function get(string $path, ?array $query = null, ?array $headers = null) : ?array
226			{
227			$this->sendRequestRetry('GET', $path, $query, $headers);
228
229			return $this->getResponseBody();
230			}
231
232			/**
233			* GET a list of resources or objects of a given type
234			*
235			* @param string $type Object type name
236			* @param array\|null $query Optional query string
237			* @param array\|null $headers Custom request headers
238			* @return array\|null Response in array format
239			*/
240			public function getObjects(string $type = 'objects', ?array $query = null, ?array $headers = null) : ?array
241			{
242			return $this->get(sprintf('/%s', $type), $query, $headers);
243			}
244
245			/**
246			* GET a single object of a given type
247			*
248			* @param int\|string $id Object id
249			* @param string $type Object type name
250			* @param array\|null $query Optional query string
251			* @param array\|null $headers Custom request headers
252			* @return array\|null Response in array format
253			*/
254			public function getObject($id, string $type = 'objects', ?array $query = null, ?array $headers = null) : ?array
255			{
256			return $this->get(sprintf('/%s/%s', $type, $id), $query, $headers);
257			}
258
259			/**
260			* Get a list of related resources or objects
261			*
262			* @param int\|string $id Resource id or object uname/id
263			* @param string $type Type name
264			* @param string $relation Relation name
265			* @param array\|null $query Optional query string
266			* @param array\|null $headers Custom request headers
267			* @return array\|null Response in array format
268			*/
269			public function getRelated($id, string $type, string $relation, ?array $query = null, ?array $headers = null) : ?array
270			{
271			return $this->get(sprintf('/%s/%s/%s', $type, $id, $relation), $query, $headers);
272			}
273
274			/**
275			* Add a list of related resources or objects
276			*
277			* @param int\|string $id Resource id or object uname/id
278			* @param string $type Type name
279			* @param string $relation Relation name
280			* @param string $data Related resources or objects to add, MUST contain id and type
281			* @param array\|null $headers Custom request headers
282			* @return array\|null Response in array format
283			*/
284			public function addRelated($id, string $type, string $relation, array $data, ?array $headers = null) : ?array
285			{
286			$body = compact('data');
287
288			return $this->post(sprintf('/%s/%s/relationships/%s', $type, $id, $relation), json_encode($body), $headers);
289			}
290
291			/**
292			* Remove a list of related resources or objects
293			*
294			* @param int\|string $id Resource id or object uname/id
295			* @param string $type Type name
296			* @param string $relation Relation name
297			* @param string $data Related resources or objects to remove from relation
298			* @param array\|null $headers Custom request headers
299			* @return array\|null Response in array format
300			*/
301			public function removeRelated($id, string $type, string $relation, array $data, ?array $headers = null) : ?array
302			{
303			$body = compact('data');
304
305			return $this->delete(sprintf('/%s/%s/relationships/%s', $type, $id, $relation), json_encode($body), $headers);
306			}
307
308			/**
309			* Replace a list of related resources or objects: previuosly related are removed and replaced with these.
310			*
311			* @param int\|string $id Object id
312			* @param string $type Object type name
313			* @param string $relation Relation name
314			* @param string $data Related resources or objects to insert
315			* @param array\|null $headers Custom request headers
316			* @return array\|null Response in array format
317			*/
318			public function replaceRelated($id, string $type, string $relation, array $data, ?array $headers = null) : ?array
319			{
320			$body = compact('data');
321
322			return $this->patch(sprintf('/%s/%s/relationships/%s', $type, $id, $relation), json_encode($body), $headers);
323			}
324
325			/**
326			* Create a new object or resource (POST) or modify an existing one (PATCH)
327			*
328			* @param string $type Object or resource type name
329			* @param array $data Object or resource data to save
330			* @param array\|null $headers Custom request headers
331			* @return array\|null Response in array format
332			*/
333			public function save(string $type, array $data, ?array $headers = null) : ?array
334			{
335			$id = null;
336			if (array_key_exists('id', $data)) {
337			$id = $data['id'];
338			unset($data['id']);
339			}
340
341			$body = [
342			'data' => [
343			'type' => $type,
344			'attributes' => $data,
345			],
346			];
347			if (!$id) {
348			return $this->post(sprintf('/%s', $type), json_encode($body), $headers);
349			}
350			$body['data']['id'] = $id;
351
352			return $this->patch(sprintf('/%s/%s', $type, $id), json_encode($body), $headers);
353			}
354
355			/**
356			* [DEPRECATED] Create a new object (POST) or modify an existing one (PATCH)
357			*
358			* @param string $type Object type name
359			* @param array $data Object data to save
360			* @param array\|null $headers Custom request headers
361			* @return array\|null Response in array format
362			* @deprecated Use `save()` method instead
363			* @codeCoverageIgnore
364			*/
365			public function saveObject(string $type, array $data, ?array $headers = null) : ?array
366			{
367			return $this->save($type, $data, $headers);
368			}
369
370			/**
371			* Delete an object (DELETE) => move to trashcan.
372			*
373			* @param int\|string $id Object id
374			* @param string $type Object type name
375			* @return array\|null Response in array format
376			*/
377			public function deleteObject($id, string $type) : ?array
378			{
379			return $this->delete(sprintf('/%s/%s', $type, $id));
380			}
381
382			/**
383			* Remove an object => permanently remove object from trashcan.
384			*
385			* @param int\|string $id Object id
386			* @return array\|null Response in array format
387			*/
388			public function remove($id) : ?array
389			{
390			return $this->delete(sprintf('/trash/%s', $id));
391			}
392
393			/**
394			* Upload file (POST)
395			*
396			* @param string $filename The file name
397			* @param string $filepath File full path: could be on a local filesystem or a remote reachable URL
398			* @param array\|null $headers Custom request headers
399			* @return array\|null Response in array format
400			* @throws BEditaClientException
401			*/
402			public function upload(string $filename, string $filepath, ?array $headers = null) : ?array
403			{
404			if (!file_exists($filepath)) {
405			throw new BEditaClientException('File not found', 500);
406			}
407			$file = file_get_contents($filepath);
408			if (!$file) {
409			throw new BEditaClientException('File get contents failed', 500);
410			}
411			if (empty($headers['Content-Type'])) {
412			$headers['Content-Type'] = mime_content_type($filepath);
413			}
414
415			return $this->post(sprintf('/streams/upload/%s', $filename), $file, $headers);
416			}
417
418			/**
419			* Create media by type and body data and link it to a stream:
420			* - `POST /:type` with `$body` as payload, create media object
421			* - `PATCH /streams/:stream_id/relationships/object` modify stream adding relation to media
422			* - `GET /:type/:id` get media data
423			*
424			* @param string $streamId The stream identifier
425			* @param string $type The type
426			* @param array $body The body data
427			* @return array\|null Response in array format
428			* @throws BEditaClientException
429			*/
430			public function createMediaFromStream($streamId, string $type, array $body) : ?array
431			{
432			$response = $this->post(sprintf('/%s', $type), json_encode($body));
433			if (empty($response)) {
434			throw new BEditaClientException('Invalid response from POST ' . sprintf('/%s', $type));
435			}
436			$id = $response['data']['id'];
437			$data = compact('id', 'type');
438			$body = compact('data');
439			$response = $this->patch(sprintf('/streams/%s/relationships/object', $streamId), json_encode($body));
440			if (empty($response)) {
441			throw new BEditaClientException('Invalid response from PATCH ' . sprintf('/streams/%s/relationships/object', $id));
442			}
443
444			return $this->getObject($data['id'], $data['type']);
445			}
446
447			/**
448			* Thumbnail request using `GET /media/thumbs` endpoint
449			*
450			* Usage:
451			* thumbs(123) => `GET /media/thumbs/123`
452			* thumbs(123, ['preset' => 'glide']) => `GET /media/thumbs/123&preset=glide`
453			* thumbs(null, ['ids' => '123,124,125']) => `GET /media/thumbs?ids=123,124,125`
454			* thumbs(null, ['ids' => '123,124,125', 'preset' => 'async']) => `GET /media/thumbs?ids=123,124,125&preset=async`
455			* thumbs(123, ['options' => ['w' => 100, 'h' => 80, 'fm' => 'jpg']]) => `GET /media/thumbs/123/options[w]=100&options[h]=80&options[fm]=jpg` (these options could be not available... just set in preset(s))
456			*
457			* @param int\|null $id the media Id.
458			* @param array $query The query params for thumbs call.
459			* @return array\|null Response in array format
460			*/
461			public function thumbs($id = null, $query = []) : ?array
462			{
463			if (empty($id) && empty($query['ids'])) {
464			throw new BEditaClientException('Invalid empty id\|ids for thumbs');
465			}
466			$endpoint = '/media/thumbs';
467			if (!empty($id)) {
468			$endpoint .= sprintf('/%d', $id);
469			}
470
471			return $this->get($endpoint, $query);
472			}
473
474			/**
475			* Get JSON SCHEMA of a resource or object
476			*
477			* @param string $type Object or resource type name
478			* @return array\|null JSON SCHEMA in array format
479			*/
480			public function schema(string $type) : ?array
481			{
482			$h = ['Accept' => 'application/schema+json'];
483
484			return $this->get(sprintf('/model/schema/%s', $type), null, $h);
485			}
486
487			/**
488			* Restore object from trash
489			*
490			* @param int\|string $id Object id
491			* @param string $type Object type name
492			* @return array\|null Response in array format
493			*/
494			public function restoreObject($id, string $type) : ?array
495			{
496			$body = [
497			'data' => [
498			'id' => $id,
499			'type' => $type,
500			],
501			];
502
503			return $this->patch(sprintf('/%s/%s', 'trash', $id), json_encode($body));
504			}
505
506			/**
507			* Send a PATCH request to modify a single resource or object
508			*
509			* @param string $path Endpoint URL path to invoke
510			* @param mixed $body Request body
511			* @param array\|null $headers Custom request headers
512			* @return array\|null Response in array format
513			*/
514			public function patch(string $path, $body, ?array $headers = null) : ?array
515			{
516			$this->sendRequestRetry('PATCH', $path, null, $headers, $body);
517
518			return $this->getResponseBody();
519			}
520
521			/**
522			* Send a POST request for creating resources or objects or other operations like /auth
523			*
524			* @param string $path Endpoint URL path to invoke
525			* @param mixed $body Request body
526			* @param array\|null $headers Custom request headers
527			* @return array\|null Response in array format
528			*/
529			public function post(string $path, $body, ?array $headers = null) : ?array
530			{
531			$this->sendRequestRetry('POST', $path, null, $headers, $body);
532
533			return $this->getResponseBody();
534			}
535
536			/**
537			* Send a DELETE request
538			*
539			* @param string $path Endpoint URL path to invoke.
540			* @param mixed $body Request body
541			* @param array\|null $headers Custom request headers
542			* @return array\|null Response in array format.
543			*/
544			public function delete(string $path, $body = null, ?array $headers = null) : ?array
545			{
546			$this->sendRequestRetry('DELETE', $path, null, $headers, $body);
547
548			return $this->getResponseBody();
549			}
550
551			/**
552			* Send a generic JSON API request with a basic retry policy on expired token exception.
553			*
554			* @param string $method HTTP Method.
555			* @param string $path Endpoint URL path.
556			* @param array\|null $query Query string parameters.
557			* @param string[]\|null $headers Custom request headers.
558			* @param string\|resource\|\Psr\Http\Message\StreamInterface\|null $body Request body.
559			* @return \Psr\Http\Message\ResponseInterface
560			*/
561			protected function sendRequestRetry(string $method, string $path, ?array $query = null, ?array $headers = null, $body = null) : ResponseInterface
562			{
563			try {
564			return $this->sendRequest($method, $path, $query, $headers, $body);
565			} catch (BEditaClientException $e) {
566			// Handle error.
567			$attributes = $e->getAttributes();
568			if ($e->getCode() !== 401 \|\| empty($attributes['code']) \|\| $attributes['code'] !== 'be_token_expired') {
569			// Not an expired token's fault.
570			throw $e;
571			}
572
573			// Refresh and retry.
574			$this->refreshTokens();
575			unset($headers['Authorization']);
576
577			return $this->sendRequest($method, $path, $query, $headers, $body);
578			}
579			}
580
581			/**
582			* Send a generic JSON API request and retrieve response $this->response
583			*
584			* @param string $method HTTP Method.
585			* @param string $path Endpoint URL path (with or without starting `/`) or absolute API path
586			* @param array\|null $query Query string parameters.
587			* @param string[]\|null $headers Custom request headers.
588			* @param string\|resource\|\Psr\Http\Message\StreamInterface\|null $body Request body.
589			* @return \Psr\Http\Message\ResponseInterface
590			* @throws BEditaClientException Throws an exception if server response code is not 20x.
591			*/
592			protected function sendRequest(string $method, string $path, ?array $query = null, ?array $headers = null, $body = null) : ResponseInterface
593			{
594			$uri = $this->requestUri($path, $query);
595			$headers = array_merge($this->defaultHeaders, (array)$headers);
596
597			// set default `Content-Type` if not set and $body not empty
598			if (!empty($body)) {
599			$headers = array_merge($this->defaultContentTypeHeader, $headers);
600			}
601
602			// Send the request synchronously to retrieve the response.
603			$this->response = $this->jsonApiClient->sendRequest(new Request($method, $uri, $headers, $body));
604			if ($this->getStatusCode() >= 400) {
605			// Something bad just happened.
606			$response = $this->getResponseBody();
607			// Message will be 'error` array, if absent use status massage
608			$message = empty($response['error']) ? $this->getStatusMessage() : $response['error'];
609			throw new BEditaClientException($message, $this->getStatusCode());
610			}
611
612			return $this->response;
613			}
614
615			/**
616			* Create request URI from path
617			*
618			* @param string $path Endpoint URL path (with or without starting `/`) or absolute API path
619			* @param array\|null $query Query string parameters.
620			* @return Uri
621			*/
622			protected function requestUri(string $path, ?array $query = null) : Uri
623			{
624			if (strpos($path, $this->apiBaseUrl) !== 0) {
625			if (substr($path, 0, 1) !== '/') {
626			$path = '/' . $path;
627			}
628			$path = $this->apiBaseUrl . $path;
629			}
630			$uri = new Uri($path);
631
632			// if path contains query strings, remove them from path and add them to query filter
633			parse_str($uri->getQuery(), $uriQuery);
634			if ($query) {
635			$query = array_merge((array)$uriQuery, (array)$query);
636			$uri = $uri->withQuery(http_build_query($query));
637			}
638
639			return $uri;
640			}
641
642			/**
643			* Refresh JWT access token.
644			*
645			* On success `$this->tokens` data will be updated with new access and renew tokens.
646			*
647			* @throws \BadMethodCallException Throws an exception if client has no renew token available.
648			* @throws \Cake\Network\Exception\ServiceUnavailableException Throws an exception if server response doesn't
649			* include the expected data.
650			* @return void
651			* @throws BEditaClientException Throws an exception if server response code is not 20x.
652			*/
653			public function refreshTokens() : void
654			{
655			if (empty($this->tokens['renew'])) {
656			throw new \BadMethodCallException('You must be logged in to renew token');
657			}
658
659			$headers = [
660			'Authorization' => sprintf('Bearer %s', $this->tokens['renew']),
661			];
662
663			$this->sendRequest('POST', '/auth', [], $headers);
664			$body = $this->getResponseBody();
665			if (empty($body['meta']['jwt'])) {
666			throw new BEditaClientException('Invalid response from server');
667			}
668
669			$this->setupTokens($body['meta']);
670			}
671			}
672

bedita / php-sdk

Push — master ( aa4f42...34ff25 )

BEditaClient::getStatusCode() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like