Rest::__invoke() - Code Metrics - Inspection of "Fixed REST controller and Response" - bluzphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#357)

by Anton

created 2016-02-01 11:34 UTC

Rest::__invoke() C

↳ Parent: Rest

Complexity

Conditions	8
Paths	8

Size

Total Lines	24
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	17
CRAP Score	8

Importance

Changes	3
Bugs	1	Features	0

Metric	Value
c	3
b	1
f	0
dl	0
loc	24
ccs	17
cts	17
cp	1
rs	5.7377
cc	8
eloc	16
nc	8
nop	0
crap	8

<?php
/**
 * Bluz Framework Component
 *
 * @copyright Bluz PHP Team
 * @link https://github.com/bluzphp/framework
 */

/**
 * @namespace
 */
namespace Bluz\Controller;

use Bluz\Application\Exception\BadRequestException;
use Bluz\Application\Exception\NotFoundException;
use Bluz\Application\Exception\NotImplementedException;
use Bluz\Proxy\Response;
use Bluz\Proxy\Request;
use Bluz\Proxy\Router;
use Bluz\Validator\Exception\ValidatorException;

/**
 * Controller
 *
 * @package  Bluz\Controller
 * @author   Anton Shevchuk
 * @link     https://github.com/bluzphp/framework/wiki/Controller-Rest
 */
class Rest extends AbstractController
{
    /**
     * @var string relation list
     */
    protected $relation;

    /**
     * @var string relation Id
     */
    protected $relationId;

    /**
     * @var array params of query
     */
    protected $params = array();

    /**
     * @var array query data
     */
    protected $data = array();

    /**
     * Prepare request for processing
     */
    public function __construct()
    {
        parent::__construct();

        // get path
        // %module% / %controller% / %id% / %relation% / %id%
        $path = Router::getCleanUri();

        $params = explode('/', rtrim($path, '/'));

        // module
        array_shift($params);

        // controller
        array_shift($params);

        if (sizeof($params)) {
            $this->primary = explode('-', array_shift($params));
        }
        if (sizeof($params)) {
            $this->relation = array_shift($params);
        }
        if (sizeof($params)) {
            $this->relationId = array_shift($params);
        }
    }

    /**
     * {@inheritdoc}
     *
     * Everyone method can return:
     *    401 Unauthorized - if authorization is required
     *    403 Forbidden - if user don't have permissions
     *    501 Not Implemented - if something not exists
     *
     * Methods can return:
     *    HEAD   /module/rest/   -> 200 // return overview of collection
     *    HEAD   /module/rest/id -> 200 // return overview of item
     *                           -> 404 // not found
     *    GET    /module/rest/   -> 200 // return collection or
     *                           -> 206 // return part of collection
     *    GET    /module/rest/id -> 200 // return one item or
     *                           -> 404 // not found
     *    POST   /module/rest/   -> 201 // item created or
     *                           -> 400 // bad request, validation error
     *    POST   /module/rest/id -> 501 // error, not used in REST
     *    PATCH  /module/rest/
     *    PUT    /module/rest/   -> 200 // all items was updated or
     *                           -> 207 // multi-status ?
     *    PATCH  /module/rest/id
     *    PUT    /module/rest/id -> 200 // item was updated or
     *                           -> 304 // item not modified or
     *                           -> 400 // bad request, validation error or
     *                           -> 404 // not found
     *    DELETE /module/rest/   -> 204 // all items was deleted or
     *                           -> 207 // multi-status ?
     *    DELETE /module/rest/id -> 204 // item was deleted
     *                           -> 404 // not found
     *
     * @return mixed
     * @throws NotImplementedException
     * @throws NotFoundException
     * @throws BadRequestException
     */
    public function __invoke()
    {
        switch ($this->method) {
            case Request::METHOD_HEAD:
            case Request::METHOD_GET:
                return $this->methodGet();
                // break
            case Request::METHOD_POST:
                return $this->methodPost();
                // break
            case Request::METHOD_PATCH:
            case Request::METHOD_PUT:
                return $this->methodPut();
                // break
            case Request::METHOD_DELETE:
                return $this->methodDelete();
                // break
            case Request::METHOD_OPTIONS:
                return $this->methodOptions();
                // break
            default:
                throw new NotImplementedException();
        }
    }

    /**
     * Method HEAD and GET
     *
     * @return mixed
     */
    public function methodGet()
    {
        if (!empty($this->primary)) {
            // @throws NotFoundException
            $result = $this->readOne($this->primary);
            return [$result];
        } else {
            // setup default offset and limit - safe way
            $offset = isset($this->params['offset'])?$this->params['offset']:0;
            $limit = isset($this->params['limit'])?$this->params['limit']:10;

            if ($range = Request::getHeader('Range')) {
                list(, $offset, $last) = preg_split('/[-=]/', $range);
                // for better compatibility
                $limit = $last - $offset;
            }
            return $this->readSet($offset, $limit, $this->params);
        }
    }

    /**
     * Method POST
     *
     * @return array|false
     * @throws BadRequestException
     * @throws NotImplementedException
     */
    public function methodPost()
    {
        if (!empty($this->primary)) {
            // POST + ID is incorrect behaviour
            throw new NotImplementedException();
        }

        try {
            $result = $this->createOne($this->data);
            if (!$result) {
                // system can't create record with this data
                throw new BadRequestException();
            }

            if (is_array($result)) {
                $result = join('-', array_values($result));
            }

        } catch (ValidatorException $e) {
            Response::setStatusCode(400);
            return ['errors' => $e->getErrors()];
        }

        Response::setStatusCode(201);
        Response::setHeader(
            'Location',
            Router::getUrl(Request::getModule(), Request::getController()).'/'.$result
        );
        return false; // disable view
    }

    /**
     * Method PUT
     *
     * @return array|false
     * @throws BadRequestException
     */
    public function methodPut()
    {
        if (!sizeof($this->data)) {
            // data not found
            throw new BadRequestException();
        }

        try {
            if (!empty($this->primary)) {
                // update one item
                $result = $this->updateOne($this->primary, $this->data);
            } else {
                // update collection
                $result = $this->updateSet($this->data);
            }
            // if $result === 0 it's means a update is not apply
            // or records not found
            if (0 === $result) {
                Response::setStatusCode(304);
            }
        } catch (ValidatorException $e) {
            Response::setStatusCode(400);
            return ['errors' => $e->getErrors()];
        }
        return false; // disable view
    }

    /**
     * Method DELETE
     *
     * @return false
     * @throws BadRequestException
     */
    public function methodDelete()
    {
        if (!empty($this->primary)) {
            // delete one
            // @throws NotFoundException
            $this->deleteOne($this->primary);
        } else {
            // delete collection
            // @throws NotFoundException
            if (!sizeof($this->data)) {
                // data not exist
                throw new BadRequestException();
            }
            $this->deleteSet($this->data);
        }
        Response::setStatusCode(204);
        return false; // disable view
    }

    /**
     * Method OPTIONS
     *
     * @return false
     */
    public function methodOptions()
    {
        $allow = $this->getMethods(sizeof($this->primary));
        Response::setHeader('Allow', join(',', $allow));
        return false; // no body
    }

    /**
     * Get allowed methods by CRUD
     *
     * @param  bool $primary
     * @return array
     */
    protected function getMethods($primary = false)
    {
        $methods = $this->getCrud()->getMethods();

        $allow = [Request::METHOD_HEAD, Request::METHOD_OPTIONS];

        if ($primary) {
            if (in_array('readOne', $methods)) {
                $allow[] = Request::METHOD_GET;
            }
            if (in_array('updateOne', $methods)) {
                $allow[] = Request::METHOD_PATCH;
                $allow[] = Request::METHOD_PUT;
            }
            if (in_array('deleteOne', $methods)) {
                $allow[] = Request::METHOD_DELETE;
            }
        } else {
            if (in_array('readSet', $methods)) {
                $allow[] = Request::METHOD_GET;
            }
            if (in_array('createOne', $methods)
                || in_array('createSet', $methods)) {
                $allow[] = Request::METHOD_POST;
            }
            if (in_array('updateSet', $methods)) {
                $allow[] = Request::METHOD_PATCH;
                $allow[] = Request::METHOD_PUT;
            }
            if (in_array('deleteSet', $methods)) {
                $allow[] = Request::METHOD_DELETE;
            }
        }
        return $allow;
    }
}


1		<?php
2		/**
3		* Bluz Framework Component
4		*
5		* @copyright Bluz PHP Team
6		* @link https://github.com/bluzphp/framework
7		*/
8
9		/**
10		* @namespace
11		*/
12		namespace Bluz\Controller;
13
14		use Bluz\Application\Exception\BadRequestException;
15		use Bluz\Application\Exception\NotFoundException;
16		use Bluz\Application\Exception\NotImplementedException;
17		use Bluz\Proxy\Response;
18		use Bluz\Proxy\Request;
19		use Bluz\Proxy\Router;
20		use Bluz\Validator\Exception\ValidatorException;
21
22		/**
23		* Controller
24		*
25		* @package Bluz\Controller
26		* @author Anton Shevchuk
27		* @link https://github.com/bluzphp/framework/wiki/Controller-Rest
28		*/
29		class Rest extends AbstractController
30		{
31		/**
32		* @var string relation list
33		*/
34		protected $relation;
35
36		/**
37		* @var string relation Id
38		*/
39		protected $relationId;
40
41		/**
42		* @var array params of query
43		*/
44		protected $params = array();
45
46		/**
47		* @var array query data
48		*/
49		protected $data = array();
50
51		/**
52		* Prepare request for processing
53		*/
54	25	public function __construct()
55		{
56	25	parent::__construct();
57
58		// get path
59		// %module% / %controller% / %id% / %relation% / %id%
60	25	$path = Router::getCleanUri();
61
62	25	$params = explode('/', rtrim($path, '/'));
63
64		// module
65	25	array_shift($params);
66
67		// controller
68	25	array_shift($params);
69
70	25	if (sizeof($params)) {
71	13	$this->primary = explode('-', array_shift($params));
72	13	}
73	25	if (sizeof($params)) {
74	2	$this->relation = array_shift($params);
75	2	}
76	25	if (sizeof($params)) {
77	1	$this->relationId = array_shift($params);
78	1	}
79	25	}
80
81		/**
82		* {@inheritdoc}
83		*
84		* Everyone method can return:
85		* 401 Unauthorized - if authorization is required
86		* 403 Forbidden - if user don't have permissions
87		* 501 Not Implemented - if something not exists
88		*
89		* Methods can return:
90		* HEAD /module/rest/ -> 200 // return overview of collection
91		* HEAD /module/rest/id -> 200 // return overview of item
92		* -> 404 // not found
93		* GET /module/rest/ -> 200 // return collection or
94		* -> 206 // return part of collection
95		* GET /module/rest/id -> 200 // return one item or
96		* -> 404 // not found
97		* POST /module/rest/ -> 201 // item created or
98		* -> 400 // bad request, validation error
99		* POST /module/rest/id -> 501 // error, not used in REST
100		* PATCH /module/rest/
101		* PUT /module/rest/ -> 200 // all items was updated or
102		* -> 207 // multi-status ?
103		* PATCH /module/rest/id
104		* PUT /module/rest/id -> 200 // item was updated or
105		* -> 304 // item not modified or
106		* -> 400 // bad request, validation error or
107		* -> 404 // not found
108		* DELETE /module/rest/ -> 204 // all items was deleted or
109		* -> 207 // multi-status ?
110		* DELETE /module/rest/id -> 204 // item was deleted
111		* -> 404 // not found
112		*
113		* @return mixed
114		* @throws NotImplementedException
115		* @throws NotFoundException
116		* @throws BadRequestException
117		*/
118	25	public function __invoke()
119		{
120	25	switch ($this->method) {
121	25	case Request::METHOD_HEAD:
122	25	case Request::METHOD_GET:
123	8	return $this->methodGet();
124		// break
125	17	case Request::METHOD_POST:
126	4	return $this->methodPost();
127		// break
128	13	case Request::METHOD_PATCH:
129	13	case Request::METHOD_PUT:
130	6	return $this->methodPut();
131		// break
132	7	case Request::METHOD_DELETE:
133	4	return $this->methodDelete();
134		// break
135	3	case Request::METHOD_OPTIONS:
136	2	return $this->methodOptions();
137		// break
138	1	default:
139	1	throw new NotImplementedException();
140	1	}
141		}
142
143		/**
144		* Method HEAD and GET
145		*
146		* @return mixed
147		*/
148	8	public function methodGet()
149		{
150	8	if (!empty($this->primary)) {
151		// @throws NotFoundException
152	4	$result = $this->readOne($this->primary);
153	3	return [$result];
154		} else {
155		// setup default offset and limit - safe way
156	4	$offset = isset($this->params['offset'])?$this->params['offset']:0;
157	4	$limit = isset($this->params['limit'])?$this->params['limit']:10;
158
159	4	if ($range = Request::getHeader('Range')) {
160	1	list(, $offset, $last) = preg_split('/[-=]/', $range);
161		// for better compatibility
162	1	$limit = $last - $offset;
163	1	}
164	4	return $this->readSet($offset, $limit, $this->params);
165		}
166		}
167
168		/**
169		* Method POST
170		*
171		* @return array\|false
172		* @throws BadRequestException
173		* @throws NotImplementedException
174		*/
175	4	public function methodPost()
176		{
177	4	if (!empty($this->primary)) {
178		// POST + ID is incorrect behaviour
179	1	throw new NotImplementedException();
180		}
181
182		try {
183	3	$result = $this->createOne($this->data);
184	1	if (!$result) {
185		// system can't create record with this data
186		throw new BadRequestException();
187		}
188
189	1	if (is_array($result)) {
190	1	$result = join('-', array_values($result));
191	1	}
192
193	3	} catch (ValidatorException $e) {
194	2	Response::setStatusCode(400);
195	2	return ['errors' => $e->getErrors()];
196		}
197
198	1	Response::setStatusCode(201);
199	1	Response::setHeader(
200	1	'Location',
201	1	Router::getUrl(Request::getModule(), Request::getController()).'/'.$result
202	1	);
203	1	return false; // disable view
204		}
205
206		/**
207		* Method PUT
208		*
209		* @return array\|false
210		* @throws BadRequestException
211		*/
212	6	public function methodPut()
213		{
214	6	if (!sizeof($this->data)) {
215		// data not found
216	1	throw new BadRequestException();
217		}
218
219		try {
220	5	if (!empty($this->primary)) {
221		// update one item
222	4	$result = $this->updateOne($this->primary, $this->data);
223	2	} else {
224		// update collection
225	1	$result = $this->updateSet($this->data);
226		}
227		// if $result === 0 it's means a update is not apply
228		// or records not found
229	2	if (0 === $result) {
230	1	Response::setStatusCode(304);
231	1	}
232	5	} catch (ValidatorException $e) {
233	1	Response::setStatusCode(400);
234	1	return ['errors' => $e->getErrors()];
235		}
236	2	return false; // disable view
237		}
238
239		/**
240		* Method DELETE
241		*
242		* @return false
243		* @throws BadRequestException
244		*/
245	4	public function methodDelete()
246		{
247	4	if (!empty($this->primary)) {
248		// delete one
249		// @throws NotFoundException
250	2	$this->deleteOne($this->primary);
251	1	} else {
252		// delete collection
253		// @throws NotFoundException
254	2	if (!sizeof($this->data)) {
255		// data not exist
256	1	throw new BadRequestException();
257		}
258	1	$this->deleteSet($this->data);
259		}
260	1	Response::setStatusCode(204);
261	1	return false; // disable view
262		}
263
264		/**
265		* Method OPTIONS
266		*
267		* @return false
268		*/
269	2	public function methodOptions()
270		{
271	2	$allow = $this->getMethods(sizeof($this->primary));
272	2	Response::setHeader('Allow', join(',', $allow));
273	2	return false; // no body
274		}
275
276		/**
277		* Get allowed methods by CRUD
278		*
279		* @param bool $primary
280		* @return array
281		*/
282	2	protected function getMethods($primary = false)
283		{
284	2	$methods = $this->getCrud()->getMethods();
285
286	2	$allow = [Request::METHOD_HEAD, Request::METHOD_OPTIONS];
287
288	2	if ($primary) {
289	1	if (in_array('readOne', $methods)) {
290	1	$allow[] = Request::METHOD_GET;
291	1	}
292	1	if (in_array('updateOne', $methods)) {
293	1	$allow[] = Request::METHOD_PATCH;
294	1	$allow[] = Request::METHOD_PUT;
295	1	}
296	1	if (in_array('deleteOne', $methods)) {
297	1	$allow[] = Request::METHOD_DELETE;
298	1	}
299	1	} else {
300	1	if (in_array('readSet', $methods)) {
301	1	$allow[] = Request::METHOD_GET;
302	1	}
303	1	if (in_array('createOne', $methods)
304	1	\|\| in_array('createSet', $methods)) {
305	1	$allow[] = Request::METHOD_POST;
306	1	}
307	1	if (in_array('updateSet', $methods)) {
308		$allow[] = Request::METHOD_PATCH;
309		$allow[] = Request::METHOD_PUT;
310		}
311	1	if (in_array('deleteSet', $methods)) {
312		$allow[] = Request::METHOD_DELETE;
313		}
314		}
315	2	return $allow;
316		}
317		}
318

bluzphp / framework

Pull Request — master (#357)

Rest::__invoke() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like