Ubiquity\controllers\rest\RestController

Complexity

Total Complexity

36

Size/Duplication

Total Lines	254
Duplicated Lines	19.29 %

Coupling/Cohesion

Components	2
Dependencies	8

Importance

Changes

0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	2
A	isValid()	0	8	3
A	onInvalidControl()	0	3	1
A	connect()	0	3	1
A	initialize()	0	10	3
A	finalize()	0	4	1
A	_errorHandler()	0	7	2
A	_setResponseCode()	0	3	1
A	connectDb()	0	6	2
A	_setValuesToObject()	0	3	1
A	index()	0	5	1
A	get()	0	14	2
A	getOne()	0	15	2
A	_format()	0	3	1
A	getOneToMany()	10	10	2
A	getManyToMany()	10	10	2
A	update()	15	15	3
A	add()	0	16	3
A	delete()	14	14	3

<?php

namespace Ubiquity\controllers\rest;

use Ubiquity\controllers\Controller;
use Ubiquity\orm\DAO;
use Ubiquity\controllers\Startup;
use Ubiquity\utils\StrUtils;
use Ubiquity\cache\CacheManager;
use Ubiquity\utils\RequestUtils;

/**
 * @author jc
 * Abstract base class for Rest controllers
 *
 */
abstract class RestController extends Controller {
	protected $config;
	protected $model;
	protected $contentType;
	protected $restCache;
	/**
	 * @var ResponseFormatter
	 */
	protected $responseFormatter;

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

	public function __construct(){
		if(!\headers_sent()){
			@\set_exception_handler(array ($this,'_errorHandler' ));
			$this->config=Startup::getConfig();
			$this->server=new RestServer($this->config);
			$this->server->cors();
			$this->responseFormatter=new ResponseFormatter();
			$this->contentType="application/json";
			$this->server->_setContentType($this->contentType);
			$this->restCache=CacheManager::getRestCacheController(\get_class($this));
		}
		parent::__construct();
	}

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

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

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

	public function initialize(){
		$thisClass=\get_class($this);
		if(!isset($this->model))
			$this->model=CacheManager::getRestResource($thisClass);
		if(!isset($this->model)){
			$modelsNS=$this->config["mvcNS"]["models"];
			$this->model=$modelsNS."\\".$this->responseFormatter->getModel($thisClass);
		}
		$this->connectDb($this->config);
	}

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



	public function _errorHandler($e){
		$code=500;
		if($e->getCode()!==0)
			$code=$e->getCode();
		$this->_setResponseCode($code);
		echo $this->responseFormatter->formatException($e);
	}

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

	protected function connectDb($config){
		$db=$config["database"];
		if($db["dbName"]!==""){
			DAO::connect($db["type"],$db["dbName"],@$db["serverName"],@$db["port"],@$db["user"],@$db["password"],@$db["cache"]);
		}
	}

	/**
	 * Updates $instance with $values
	 * To eventually be redefined in derived classes
	 * @param object $instance the instance to update
	 * @param array|null $values
	 */
	protected function _setValuesToObject($instance,$values=null){
		RequestUtils::setValuesToObject($instance,$values);
	}

	/**
	 * Returns all objects for the resource $model
	 * @route("methods"=>["get"],"cache"=>true,"duration"=>1000)
	 */
	public function index() {
			$datas=DAO::getAll($this->model);
			$datas=\array_map(function($o){return $o->_rest;}, $datas);
			echo $this->responseFormatter->get($datas);
	}

	/**
	 * Returns a list of objects from the server
	 * @param string $condition the sql Where part
	 * @param boolean $loadManyToOne
	 * @param boolean $loadOneToMany
	 * @param boolean $useCache
	 */
	public function get($condition="1=1",$loadManyToOne=false,$loadOneToMany=false,$useCache=false){
		try{
			$condition=\urldecode($condition);
			$loadManyToOne=StrUtils::isBooleanTrue($loadManyToOne);
			$loadOneToMany=StrUtils::isBooleanTrue($loadOneToMany);
			$useCache=StrUtils::isBooleanTrue($useCache);
			$datas=DAO::getAll($this->model,$condition,$loadManyToOne,$loadOneToMany,$useCache);
			$datas=\array_map(function($o){return $o->_rest;}, $datas);
			echo $this->responseFormatter->get($datas);
		}catch (\Exception $e){
			$this->_setResponseCode(500);
			echo $this->responseFormatter->formatException($e);
		}
	}

	/**
	 * Get the first object corresponding to the $keyValues
	 * @param string $keyValues primary key(s) value(s) or condition
	 * @param boolean $loadManyToOne if true then manyToOne members are loaded.
	 * @param boolean $loadOneToMany if true then oneToMany members are loaded.
	 * @param boolean $useCache if true then response is cached
	 */
	public function getOne($keyValues,$loadManyToOne=false,$loadOneToMany=false,$useCache=false){
		$keyValues=\urldecode($keyValues);
		$loadManyToOne=StrUtils::isBooleanTrue($loadManyToOne);
		$loadOneToMany=StrUtils::isBooleanTrue($loadOneToMany);
		$useCache=StrUtils::isBooleanTrue($useCache);
		$data=DAO::getOne($this->model, $keyValues,$loadManyToOne,$loadOneToMany,$useCache);
		if(isset($data)){
			$_SESSION["_restInstance"]=$data;
			echo $this->responseFormatter->getOne($data->_rest);
		}
		else{
			$this->_setResponseCode(404);
			echo $this->responseFormatter->format(["message"=>"No result found","keyValues"=>$keyValues]);
		}
	}

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

	/**
	 * @param string $member
	 * @param boolean $useCache
	 * @throws \Exception
	 */
	public function getOneToMany($member,$useCache=false){

This method seems to be duplicated in your project.

		if(isset($_SESSION["_restInstance"])){
			$useCache=StrUtils::isBooleanTrue($useCache);
			$datas=DAO::getOneToMany($_SESSION["_restInstance"], $member,null,$useCache);
			$datas=\array_map(function($o){return $o->_rest;}, $datas);
			echo $this->responseFormatter->get($datas);
		}else{
			throw new \Exception("You have to call getOne before calling getOneToMany.");
		}
	}

	/**
	 * @param string $member
	 * @param boolean $useCache
	 * @throws \Exception
	 */
	public function getManyToMany($member,$useCache=false){

This method seems to be duplicated in your project.

		if(isset($_SESSION["_restInstance"])){
			$useCache=StrUtils::isBooleanTrue($useCache);
			$datas=DAO::getManyToMany($_SESSION["_restInstance"], $member,null,$useCache);
			$datas=\array_map(function($o){return $o->_rest;}, $datas);
			echo $this->responseFormatter->get($datas);
		}else{
			throw new \Exception("You have to call getOne before calling getManyToMany.");
		}
	}

	/**
	 * Update an instance of $model selected by the primary key $keyValues
	 * Require members values in $_POST array
	 * @param array $keyValues
	 * @authorization
	 */
	public function update(...$keyValues){

This method seems to be duplicated in your project.

		$instance=DAO::getOne($this->model, $keyValues);
		if(isset($instance)){
			$this->_setValuesToObject($instance,RequestUtils::getInput());
			$result=DAO::update($instance);
			if($result){
				echo $this->responseFormatter->format(["status"=>"updated","data"=>$instance->_rest]);
			}else{
				throw new \Exception("Unable to update the instance");
			}
		}else{
			$this->_setResponseCode(404);
			echo $this->responseFormatter->format(["message"=>"No result found","keyValues"=>$keyValues]);
		}
	}

	/**
	 * Insert a new instance of $model
	 * Require members values in $_POST array
	 * @authorization
	 */
	public function add(){
		$model=$this->model;
		$instance=new $model();
		if(isset($instance)){
			$this->_setValuesToObject($instance,RequestUtils::getInput());
			$result=DAO::insert($instance);
			if($result){
				echo $this->responseFormatter->format(["status"=>"inserted","data"=>$instance->_rest]);
			}else{
				throw new \Exception("Unable to insert the instance");
			}
		}else{
			$this->_setResponseCode(500);
			echo $this->responseFormatter->format(["message"=>"Unable to create ".$model." instance"]);
		}
	}

	/**
	 * Delete the instance of $model selected by the primary key $keyValues
	 * Requires an authorization with access token
	 * @param array $keyValues
	 * @route("methods"=>["delete"])
	 * @authorization
	 */
	public function delete(...$keyValues){

This method seems to be duplicated in your project.

		$instance=DAO::getOne($this->model, $keyValues);
		if(isset($instance)){
			$result=DAO::remove($instance);
			if($result){
				echo $this->responseFormatter->format(["status"=>"deleted","data"=>$instance->_rest]);
			}else{
				throw new \Exception("Unable to delete the instance");
			}
		}else{
			$this->_setResponseCode(404);
			echo $this->responseFormatter->format(["message"=>"No result found","keyValues"=>$keyValues]);
		}
	}
}