RestBaseController::__construct() - Code Metrics - Inspection of "Update AdminCest.php" - phpMv/ubiquity - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( d7f029...202469 )

by Jean-Christophe
created 2020-08-29 01:27 UTC
RestBaseController::__construct() A

↳ Parent: RestBaseController
Complexity

Conditions	3
Paths	4
Size

Total Lines	15
Code Lines	12
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	12
CRAP Score	3.004
Importance

Changes
Metric	Value
eloc	12
c	0
b	0
f	0
dl	0
loc	15
ccs	12
cts	13
cp	0.9231
rs	9.8666
cc	3
nc	4
nop	0
crap	3.004
<?php
namespace Ubiquity\controllers\rest;

use Ubiquity\cache\CacheManager;
use Ubiquity\controllers\Controller;
use Ubiquity\controllers\Startup;
use Ubiquity\orm\DAO;
use Ubiquity\utils\base\UString;
use Ubiquity\controllers\Router;
use Ubiquity\orm\OrmUtils;
use Ubiquity\events\EventsManager;
use Ubiquity\events\RestEvents;

/**
 * Abstract base class for Rest controllers.
 * Ubiquity\controllers\rest$RestController
 * This class is part of Ubiquity
 *
 * @author jcheron <[email protected]>
 * @version 1.0.8
 *
 */
abstract class RestBaseController extends Controller {
	use RestControllerUtilitiesTrait;

	protected $config;

	protected $model;

	protected $contentType;

	protected $restCache;

	protected $useValidation = true;

	/**
	 *
	 * @var ResponseFormatter
	 */
	protected $responseFormatter;

	/**
	 *
	 * @var RestServer
	 */
	protected $server;

	public function __construct() {
		if (! \headers_sent()) {
			@\set_exception_handler(array(
			/** @scrutinizer ignore-unhandled */ @\set_exception_handler(array(
				$this,
				'_errorHandler'
			));
			$this->config = Startup::getConfig();
			$this->server = $this->_getRestServer();
			$this->server->cors();
			$this->responseFormatter = $this->_getResponseFormatter();
			$this->server->_setContentType($this->contentType);
			$this->restCache = CacheManager::getRestCacheController(\get_class($this));
		}
		if (! $this->isValid(Startup::getAction()))
			$this->onInvalidControl();
	}

	public function index() {
		$routesPath = Router::getRoutesPathByController(get_class($this));
		echo $this->_getResponseFormatter()->format([
			'links' => $routesPath
		]);
	}

	public function isValid($action) {
		if (isset($this->restCache['authorizations'])) {
			if (\array_search($action, $this->restCache['authorizations']) !== false) {
				return $this->server->isValid();
			}
		}
		return true;
	}

	/**
	 * Returns true if $action require an authentification with token
	 *
	 * @param string $action
	 * @return boolean
	 */
	protected function requireAuth($action) {
		if (isset($this->restCache["authorizations"])) {
			return array_search($action, $this->restCache["authorizations"]) !== false;
		}
		return false;
	}

	public function onInvalidControl() {
		throw new \Exception('HTTP/1.1 401 Unauthorized, you need an access token for this request', 401);
	}

	/**
	 * Realize the connection to the server
	 * To override in derived classes to define your own authentication
	 */
	public function connect() {
		$resp = $this->server->connect();
		echo $this->_format($resp);
	}

	public function initialize() {}

	public function finalize() {
		parent::finalize();
		$this->server->finalizeTokens();
	}

	public function _errorHandler($e) {
		$this->_setResponseCode(200);
		echo $this->_getResponseFormatter()->formatException($e);
	}

	public function _setResponseCode($value) {
		\http_response_code($value);
	}

	/**
	 * Returns a list of objects from the server.
	 *
	 * @param string $condition
	 *        	the sql Where part
	 * @param boolean|string $include
	 *        	if true, loads associate members with associations, if string, example : client.*,commands
	 * @param boolean $useCache
	 */
	public function _get($condition = '1=1', $include = false, $useCache = false) {
		try {
			$condition = $this->getCondition($condition);
			$include = $this->getInclude($include);
			$useCache = UString::isBooleanTrue($useCache);
			$datas = DAO::getAll($this->model, $condition, $include, null, $useCache);
			echo $this->_getResponseFormatter()->get($datas);
		} catch (\Exception $e) {
			$this->_setResponseCode(500);
			echo $this->_getResponseFormatter()->formatException($e);
		}
	}

	/**
	 * Get the first object corresponding to the $keyValues.
	 *
	 * @param string $keyValues
	 *        	primary key(s) value(s) or condition
	 * @param boolean|string $include
	 *        	if true, loads associate members with associations, if string, example : client.*,commands
	 * @param boolean $useCache
	 *        	if true then response is cached
	 */
	public function _getOne($keyValues, $include = false, $useCache = false) {
		$keyValues = $this->getCondition($keyValues);
		$include = $this->getInclude($include);
		$useCache = UString::isBooleanTrue($useCache);
		$data = DAO::getById($this->model, $keyValues, $include, $useCache);
		if (isset($data)) {
			$_SESSION["_restInstance"] = $data;
			echo $this->_getResponseFormatter()->getOne($data);
		} else {
			$this->_setResponseCode(404);
			echo $this->_getResponseFormatter()->format(RestError::notFound($keyValues, "RestController/getOne")->asArray());
		}
	}

	public function _format($arrayMessage) {
		return $this->_getResponseFormatter()->format($arrayMessage);
	}

	/**
	 *
	 * @param string $ids
	 * @param string $member
	 * @param string|boolean $include
	 *        	if true, loads associate members with associations, if string, example : client.*,commands
	 * @param boolean $useCache
	 */
	public function _getManyToOne($ids, $member, $include = false, $useCache = false) {
		$this->getAssociatedMemberValues_($ids, function ($instance, $member, $include, $useCache) {
			return DAO::getManyToOne($instance, $member, $include, $useCache);
		}, $member, $include, $useCache, false);
	}

	/**
	 *
	 * @param string $ids
	 * @param string $member
	 * @param string|boolean $include
	 *        	if true, loads associate members with associations, if string, example : client.*,commands
	 * @param boolean $useCache
	 * @throws \Exception
	 */
	public function _getOneToMany($ids, $member, $include = false, $useCache = false) {
		$this->getAssociatedMemberValues_($ids, function ($instance, $member, $include, $useCache) {
			return DAO::getOneToMany($instance, $member, $include, $useCache);
		}, $member, $include, $useCache, true);
	}

	/**
	 *
	 * @param string $ids
	 * @param string $member
	 * @param string|boolean $include
	 *        	if true, loads associate members with associations, if string, example : client.*,commands
	 * @param boolean $useCache
	 * @throws \Exception
	 */
	public function _getManyToMany($ids, $member, $include = false, $useCache = false) {
		$this->getAssociatedMemberValues_($ids, function ($instance, $member, $include, $useCache) {
			return DAO::getManyToMany($instance, $member, $include, null, $useCache);
		}, $member, $include, $useCache, true);
	}

	/**
	 * Update an instance of $model selected by the primary key $keyValues
	 * Require members values in $_POST array
	 *
	 * @param array $keyValues
	 */
	public function _update(...$keyValues) {
		$instance = DAO::getById($this->model, $keyValues, false);
		$this->operate_($instance, function ($instance) {
			$datas = $this->getDatas();
			EventsManager::trigger(RestEvents::BEFORE_UPDATE, $instance, $datas, $this);
			$this->_setValuesToObject($instance, $datas);
			if ($this->_validateInstance($instance, \array_keys($datas))) {
				return $this->updateOperation($instance, $datas, true);
			}
			return null;
		}, 'updated', 'Unable to update the instance', $keyValues);
	}

	/**
	 * Insert a new instance of $model
	 * Require members values in $_POST array
	 */
	public function _add() {
		$model = $this->model;
		$instance = new $model();
		$this->operate_($instance, function ($instance) use ($model) {
			$datas = $this->getDatas();
			EventsManager::trigger(RestEvents::BEFORE_INSERT, $instance, $datas, $this);
			$this->_setValuesToObject($instance, $datas);
			$fields = \array_keys(OrmUtils::getSerializableFields($model));
			if ($this->_validateInstance($instance, $fields, [
				'id' => false
			])) {
				return $this->AddOperation($instance, $datas, true);
			}
			return null;
		}, 'inserted', 'Unable to insert the instance', []);
	}

	/**
	 * Delete the instance of $model selected by the primary key $keyValues
	 *
	 * @param array $keyValues
	 */
	public function _delete(...$keyValues) {
		$instance = DAO::getById($this->model, $keyValues, false);
		$this->operate_($instance, function ($instance) {
			return DAO::remove($instance);
		}, 'deleted', 'Unable to delete the instance', $keyValues);
	}

	public static function _getApiVersion() {
		return '?';
	}

	/**
	 * Returns the template for creating this type of controller
	 *
	 * @return string
	 */
	public static function _getTemplateFile() {
		return 'restController.tpl';
	}
}

phpMv / ubiquity

Push — master ( d7f029...202469 )

RestBaseController::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like
