RestControllerUtilitiesTrait.php

Go to the documentation of this file.

<?php
 
namespace Ubiquity\controllers\rest\traits;
 
use Ubiquity\controllers\rest\formatters\RequestFormatter;
use Ubiquity\controllers\rest\formatters\ResponseFormatter;
use Ubiquity\controllers\rest\RestServer;
use Ubiquity\orm\DAO;
use Ubiquity\utils\base\UString;
use Ubiquity\utils\http\URequest;
use Ubiquity\contents\validation\ValidatorsManager;
use Ubiquity\contents\validation\validators\ConstraintViolation;
use Ubiquity\orm\OrmUtils;
use Ubiquity\orm\parser\Reflexion;
use Ubiquity\controllers\rest\RestError;
 
class RestControllerUtilitiesTrait {
    protected $errors;
 
    abstract public function _setResponseCode($value);
 
    protected function getDatas() {
        return $this->_getRequestFormatter ()->getDatas ( $this->model );
    }
 
    protected function getRequestParam($param, $default) {
        return $_GET [$param] ?? $default;
    }
 
    protected function operate_($instance, $callback, $status, $exceptionMessage, $keyValues) {
        if (isset ( $instance )) {
            $result = $callback ( $instance );
            if ($result == true) {
                $formatter = $this->_getResponseFormatter ();
                echo $formatter->format ( [ "status" => $status,"data" => $formatter->cleanRestObject ( $instance ) ] );
            } elseif ($result === null) {
                $this->displayErrors ();
            } else {
                throw new \Exception ( $exceptionMessage );
            }
        } else {
            $this->_setResponseCode ( 404 );
            echo $this->_getResponseFormatter ()->format ( [ "message" => "No result found","keyValues" => $keyValues ] );
        }
    }
 
    protected function generatePagination(&$filter, $pageNumber, $pageSize) {
        $count = DAO::count ( $this->model, $filter );
        $pagesCount = \ceil ( $count / $pageSize );
        $pages = [ 'self' => $pageNumber,'first' => 1,'last' => $pagesCount,'pageSize' => $pageSize ];
        if ($pageNumber - 1 > 0) {
            $pages ['prev'] = $pageNumber - 1;
        }
        if ($pageNumber + 1 <= $pagesCount) {
            $pages ['next'] = $pageNumber + 1;
        }
        $offset = ($pageNumber - 1) * $pageSize;
        $filter .= ' limit ' . $offset . ',' . $pageSize;
        return $pages;
    }
 
    protected function updateOperation($instance, $datas, $updateMany = false) {
        return DAO::update ( $instance, $updateMany );
    }
 
    protected function addOperation($instance, $datas, $insertMany = false) {
        return DAO::insert ( $instance, $insertMany );
    }
 
    protected function _getResponseFormatter() {
        if (! isset ( $this->responseFormatter )) {
            $this->responseFormatter = $this->getResponseFormatter ();
        }
        return $this->responseFormatter;
    }
 
    protected function getResponseFormatter(): ResponseFormatter {
        return new ResponseFormatter ();
    }
 
    protected function _getRequestFormatter() {
        if (! isset ( $this->requestFormatter )) {
            $this->requestFormatter = $this->getRequestFormatter ();
        }
        return $this->requestFormatter;
    }
 
    protected function getRequestFormatter(): RequestFormatter {
        return new RequestFormatter ();
    }
 
    protected function _getRestServer() {
        if (! isset ( $this->server )) {
            $this->server = $this->getRestServer ();
        }
        return $this->server;
    }
 
    protected function getRestServer(): RestServer {
        return new RestServer ( $this->config );
    }
 
    protected function _setValuesToObject($instance, $values = [ ]) {
        if (URequest::isJSON ()) {
            if (\is_string ( $values )) {
                $values = \json_decode ( $values, true );
            }
        }
        $className = \get_class ( $instance );
        $fieldsInRelationForUpdate = OrmUtils::getFieldsInRelationsForUpdate_ ( $className );
        $manyToOneRelations = $fieldsInRelationForUpdate ["manyToOne"];
 
        $members = \array_keys ( $values );
        OrmUtils::setFieldToMemberNames ( $members, $fieldsInRelationForUpdate ["relations"] );
        URequest::setValuesToObject ( $instance, $values );
        if ($manyToOneRelations) {
            $this->updateManyToOne ( $manyToOneRelations, $members, $className, $instance, $values );
        }
    }
 
    protected function updateManyToOne($manyToOneRelations, $members, $className, $instance, $values) {
        foreach ( $manyToOneRelations as $member ) {
            if (\array_search ( $member, $members ) !== false) {
                $joinColumn = OrmUtils::getAnnotationInfoMember ( $className, "#joinColumn", $member );
                if ($joinColumn) {
                    $fkClass = $joinColumn ["className"];
                    $fkField = $joinColumn ["name"];
                    if (isset ( $values [$fkField] )) {
                        $fkObject = DAO::getById ( $fkClass, $values ["$fkField"] );
                        Reflexion::setMemberValue ( $instance, $member, $fkObject );
                    }
                }
            }
        }
    }
 
    protected function getInclude($include) {
        if (! UString::isBooleanStr ( $include )) {
            return \explode ( ',', $include );
        }
        return UString::isBooleanTrue ( $include );
    }
 
    protected function addError($code, $title, $detail = null, $source = null, $status = null) {
        $this->errors [] = new RestError( $code, $title, $detail, $source, $status );
    }
 
    protected function hasErrors() {
        return \is_array ( $this->errors ) && \count ( $this->errors ) > 0;
    }
 
    protected function displayErrors() {
        if ($this->hasErrors ()) {
            $status = 200;
            $errors = [ ];
            foreach ( $this->errors as $error ) {
                $errors [] = $error->asArray ();
                if ($error->getStatus () > $status) {
                    $status = $error->getStatus ();
                }
            }
            echo $this->_getResponseFormatter ()->format ( [ 'errors' => $errors ] );
            $this->_setResponseCode ( $status );
            return true;
        }
        return false;
    }
 
    protected function getAssociatedMemberValues_($ids, $getDatas, $member, $include = false, $useCache = false, $multiple = true) {
        $include = $this->getInclude ( $include );
        $useCache = UString::isBooleanTrue ( $useCache );
        $datas = $getDatas ( [ $this->model,$ids ], $member, $include, $useCache );
        if ($multiple) {
            echo $this->_getResponseFormatter ()->get ( $datas );
        } else {
            echo $this->_getResponseFormatter ()->getOne ( $datas );
        }
    }
 
    public function _validateInstance($instance, $members, $excludedValidators = [ ]) {
        if ($this->useValidation) {
            $isValid = true;
            $violations = ValidatorsManager::validate ( $instance, '', $excludedValidators );
            foreach ( $violations as $violation ) {
                if (\array_search ( $violation->getMember (), $members ) !== false) {
                    $this->addViolation ( $violation );
                    $isValid = false;
                }
            }
            return $isValid;
        }
        return true;
    }
 
    protected function addViolation(ConstraintViolation $violation) {
        $this->addError ( 406, 'Validation error', $violation->getMessage (), $violation->getMember (), $violation->getValidatorType () );
    }
 
    protected function getPrimaryKeysFromDatas($datas, $model) {
        $pks = OrmUtils::getKeyFields ( $model );
        $result = [ ];
        foreach ( $pks as $pk ) {
            if (isset ( $datas [$pk] )) {
                $result [] = $datas [$pk];
            } else {
                $this->addError ( 404, 'Primary key required', 'The primary key ' . $pk . ' is required!', $pk );
            }
        }
        return $result;
    }
 
    protected function getCondition($condition) {
        if (\is_array ( $condition )) {
            $conds = [ ];
            foreach ( $condition as $f => $v ) {
                $conds [] = $f . "='" . \urldecode ( $v ) . "'";
            }
            $condition = \implode ( ' AND ', $conds );
        } else {
            $condition = \urldecode ( $condition );
        }
        if (\strpos ( $condition, 'like' ) !== false) {
            $condition = \str_replace ( '*', '%', $condition );
        }
        return $condition;
    }
}