RestBaseController.php

Go to the documentation of this file.

<?php
 
namespace Ubiquity\controllers\rest;
 
use Ubiquity\cache\CacheManager;
use Ubiquity\controllers\Controller;
use Ubiquity\controllers\rest\traits\RestControllerUtilitiesTrait;
use Ubiquity\controllers\Router;
use Ubiquity\controllers\Startup;
use Ubiquity\events\EventsManager;
use Ubiquity\events\RestEvents;
use Ubiquity\orm\DAO;
use Ubiquity\orm\OrmUtils;
use Ubiquity\utils\base\UString;
 
abstract class RestBaseController extends Controller ,  RestControllerUtilitiesTrait {
 
    protected $config;
    protected $model;
    protected $contentType;
    protected $restCache;
    protected $useValidation = true;
 
    protected $responseFormatter;
    protected $requestFormatter;
 
    protected $server;
 
    public function __construct() {
        if (!\headers_sent()) {
            @\set_exception_handler(array($this, '_errorHandler'));
            $this->config = Startup::getConfig();
            $this->server = $this->_getRestServer();
            $this->server->cors();
            $this->responseFormatter = $this->_getResponseFormatter();
            $this->requestFormatter = $this->_getRequestFormatter();
            $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(function ($datas = null) use ($action) {
                    return $this->checkPermissions($action, $datas);
                });
            }
        }
        return true;
    }
 
    protected function checkPermissions($action, $datas = null): bool {
        return true;
    }
 
    protected function requireAuth($action): bool {
        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);
    }
 
    public function connect() {
        $datas = null;
        $resp = $this->server->connect($datas);
        echo $this->_format($resp);
    }
 
    protected function refreshToken() {
        $resp = $this->server->refreshToken();
        echo $this->_format($resp);
    }
 
    public function initialize() {
    }
 
    public function finalize() {
        parent::finalize();
        $this->server->finalizeTokens();
    }
 
    public function _errorHandler($e) {
        $this->_setResponseCode(Router::getStatusCode());
        echo $this->_getResponseFormatter()->formatException($e);
    }
 
    public function _setResponseCode($value) {
        \http_response_code($value);
    }
 
    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);
        }
    }
 
    public function _getAll() {
        $filter = $this->getCondition($this->getRequestParam('filter', '1=1'));
        $pages = null;
        if (isset ($_GET ['page'])) {
            $pageNumber = $_GET ['page'] ['number'];
            $pageSize = $_GET ['page'] ['size'] ?? 1;
            $pages = $this->generatePagination($filter, $pageNumber, $pageSize);
        }
        $datas = DAO::getAll($this->model, $filter, $this->getInclude($this->getRequestParam('include', false)));
        EventsManager::trigger(RestEvents::BEFORE_GET_ALL, $datas, $this);
        echo $this->_getResponseFormatter()->get($datas, $pages);
    }
 
    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);
        EventsManager::trigger(RestEvents::BEFORE_GET_ONE, $data, $this);
        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);
    }
 
    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);
    }
 
    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);
    }
 
    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);
    }
 
    public function _update(...$keyValues) {
        $instance = DAO::getById($this->model, $keyValues, false);
        $this->operate_($instance, function ($instance) {
            $datas = $this->getDatas();
            $this->_setValuesToObject($instance, $datas);
            EventsManager::trigger(RestEvents::BEFORE_UPDATE, $instance, $datas, $this);
            if ($this->_validateInstance($instance, \array_keys($datas))) {
                return $this->updateOperation($instance, $datas, true);
            }
            return null;
        }, 'updated', 'Unable to update the instance', $keyValues);
    }
 
    public function _add() {
        $model = $this->model;
        $instance = new $model ();
        $this->operate_($instance, function ($instance) use ($model) {
            $datas = $this->getDatas();
            $this->_setValuesToObject($instance, $datas);
            EventsManager::trigger(RestEvents::BEFORE_INSERT, $instance, $datas, $this);
            $fields = \array_keys(OrmUtils::getSerializableFields($model));
            if ($this->_validateInstance($instance, $fields, ['id' => false])) {
                $this->_setResponseCode(201);
                return $this->addOperation($instance, $datas, true);
            }
            return null;
        }, 'inserted', 'Unable to insert the instance', []);
    }
 
    public function _getRelationShip($id, $member) {
        $relations = OrmUtils::getAnnotFieldsInRelations($this->model);
        if (isset ($relations [$member])) {
            $include = $this->getRequestParam('include', true);
            switch ($relations [$member] ['type']) {
                case 'manyToOne' :
                    $this->_getManyToOne($id, $member, $include);
                    break;
                case 'oneToMany' :
                    $this->_getOneToMany($id, $member, $include);
                    break;
                case 'manyToMany' :
                    $this->_getManyToMany($id, $member, $include);
                    break;
            }
        }
    }
 
    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 '?';
    }
 
    public static function _getTemplateFile() {
        return 'restController.tpl';
    }
}