controller.php

<?php
 
namespace Bitrix\Vote\Base;
 
use Bitrix\Main\ArgumentException;
use Bitrix\Main\ArgumentOutOfRangeException;
use \Bitrix\Main\ErrorCollection;
use \Bitrix\Main\Error;
use \Bitrix\Main\Application;
use \Bitrix\Main\Context;
use Bitrix\Main\InvalidOperationException;
use Bitrix\Main\NotSupportedException;
use Bitrix\Main\SystemException;
use \Bitrix\Main\Localization\Loc;
use \Bitrix\Main\Web\Json;
use Bitrix\Tasks\AccessDeniedException;
 
Loc::loadMessages(__FILE__);
 
abstract class Controller
{
    const EVENT_ON_BEFORE_ACTION = 'onBeforeAction';
 
    const ERROR_REQUIRED_PARAMETER = 'VOTE_CONTROLLER_22001';
    const ERROR_UNKNOWN_ACTION     = 'VOTE_CONTROLLER_22002';
 
    const STATUS_SUCCESS      = 'success';
    const STATUS_DENIED       = 'denied';
    const STATUS_ERROR        = 'error';
    const STATUS_NEED_AUTH    = 'need_auth';
 
    protected $action;
    protected $actionDescription;
    protected $realActionName;
    protected $errorCollection;
    protected $request;
 
    private $collectDebugInfo = 1;
 
    public function __construct()
    {
        try
        {
            $this->errorCollection = new ErrorCollection;
            $this->request = Context::getCurrent()->getRequest();
 
            $this->init();
        }
        catch(\Exception $e)
        {
            $this->errorCollection->add(array(new Error($e->getMessage())));
        }
 
        if (!$this->errorCollection->isEmpty())
        {
            $this->sendJsonErrorResponse();
        }
    }
 
    protected function init()
    {}
 
    protected function end()
    {
        $this->logDebugInfo();
 
        \CMain::finalActions();
        die;
    }
 
    public function exec()
    {
        try
        {
            $this->collectDebugInfo();
            $this->resolveAction();
            $this->checkAction();
            if ($this->prepareParams() && $this->errorCollection->isEmpty() && $this->processBeforeAction($this->getAction()) === true)
            {
                $this->runAction();
            }
            $this->logDebugInfo();
        }
        catch(\Exception $e)
        {
            $this->errorCollection->add(array(new Error($e->getMessage())));
        }
 
        if (!$this->errorCollection->isEmpty())
        {
            $this->sendJsonErrorResponse();
        }
    }
 
    protected function collectDebugInfo()
    {
        if($this->collectDebugInfo)
        {
            Diag::getInstance()->collectDebugInfo(get_called_class());
        }
    }
 
    protected function logDebugInfo()
    {
        if($this->collectDebugInfo)
        {
            Diag::getInstance()->logDebugInfo(get_called_class(), get_called_class() . ':' . $this->getAction());
        }
    }
 
    protected function getUser()
    {
        global $USER;
 
        return $USER;
    }
 
    protected function sendJsonResponse($response, $params = null)
    {
        if(!defined('PUBLIC_AJAX_MODE'))
        {
            define('PUBLIC_AJAX_MODE', true);
        }
 
        global $APPLICATION;
        $APPLICATION->restartBuffer();
 
        if(!empty($params['http_status']) && $params['http_status'] == 403)
        {
            header('HTTP/1.0 403 Forbidden', true, 403);
        }
        if(!empty($params['http_status']) && $params['http_status'] == 500)
        {
            header('HTTP/1.0 500 Internal Server Error', true, 500);
        }
        if(!empty($params['http_status']) && $params['http_status'] == 510)
        {
            header('HTTP/1.0 510 Not Extended', true, 510);
        }
 
        header('Content-Type:application/json; charset=UTF-8');
        echo Json::encode($response);
 
        $this->end();
    }
 
    protected function sendJsonErrorResponse()
    {
        $errors = array();
        foreach($this->getErrors() as $error)
        {
            $errors[] = array(
                'message' => $error->getMessage(),
                'code' => $error->getCode(),
            );
        }
        unset($error);
        $this->sendJsonResponse(array(
            'status' => self::STATUS_ERROR,
            'errors' => $errors,
        ));
    }
 
    protected function sendJsonAccessDeniedResponse($message = '')
    {
        $this->sendJsonResponse(array(
            'status' => self::STATUS_DENIED,
            'message' => $message,
        ));
    }
 
    protected function sendJsonSuccessResponse(array $response = array())
    {
        $response['status'] = self::STATUS_SUCCESS;
        $this->sendJsonResponse($response);
    }
 
    protected function sendResponse($response)
    {
        $this->logDebugInfo();
 
        global $APPLICATION;
        $APPLICATION->restartBuffer();
 
        echo $response;
 
        $this->end();
    }
 
    public function getErrors()
    {
        return $this->errorCollection->toArray();
    }
 
 
    public function getErrorByCode($code)
    {
        return $this->errorCollection->getErrorByCode($code);
    }
 
    protected function resolveAction()
    {
        $listOfActions = array_change_key_case($this->listActions(), CASE_LOWER);
        $action = mb_strtolower($this->action);
 
        if(!isset($listOfActions[$action]))
            throw new NotSupportedException(Loc::getMessage(
                'VOTE_CONTROLLER_ERROR_UNKNOWN_ACTION',
                array('#ACTION#' => $this->sanitizeActionName($action))
            ));
 
        $this->realActionName = $action;
        $description = $this->normalizeActionDescription($action, $listOfActions[$this->realActionName]);
 
        $this->setAction($description['name'], $description);
 
        return $this;
    }
 
    private function sanitizeActionName($actionName)
    {
        if(!preg_match('/^[a-zA-Z0-9]+$/i', $actionName))
        {
            return 'unknown';
        }
 
        return $actionName;
    }
 
    protected function normalizeActionDescription($action, $description)
    {
        $description = array_merge(
            array(
                'method' => array('GET'),
                'name' => (is_string($description) && $description <> '' ? $description : $action),
                'need_auth' => true,
                'check_sessid' => true,
                'redirect_on_auth' => true
            ),
            (is_array($description) ? $description : array())
        );
        $description["method"] = array_intersect(is_array($description["method"]) ? $description["method"] : array($description["method"]), array("GET", "POST"));
        return $description;
    }
 
    protected function checkAction()
    {
        $description = $this->getActionDescription();
 
        if ($description["need_auth"] && (!$this->getUser() || !$this->getUser()->getId()))
        {
            if ($description["redirect_on_auth"])
            {
                LocalRedirect(SITE_DIR . 'auth/?backurl=' . urlencode(Application::getInstance()->getContext()->getRequest()->getRequestUri()));
            }
            else
            {
                throw new AccessDeniedException();
            }
        }
 
        if (!in_array($this->request->getRequestMethod(), $description['method']))
            throw new ArgumentException("Request method is not supported by ".$this->getAction()." operation.");
 
        if ($description['check_sessid'] && !check_bitrix_sessid())
            throw new ArgumentException("Bad sessid.");
 
        return true;
    }
 
    protected function listActions()
    {
        return array();
    }
 
    public function getAction()
    {
        return $this->action;
    }
 
    public function getActionDescription()
    {
        return $this->actionDescription;
    }
 
    public function setAction($action, array $description)
    {
        $this->action = $action;
        $this->actionDescription = $description;
        return $this;
    }
 
    public function setActionName($action)
    {
        $this->action = $action;
        return $this;
    }
 
    protected function prepareParams()
    {
        return true;
    }
 
    protected function processBeforeAction($actionName)
    {
        return true;
    }
 
    protected function runAction()
    {
        if (! method_exists($this, 'processAction' . $this->getAction()))
            throw new InvalidOperationException('processAction' . $this->getAction());
        return call_user_func(array($this, 'processAction' . $this->getAction()));
    }
 
 
    protected function getApplication()
    {
        global $APPLICATION;
        return $APPLICATION;
    }
 
    protected function checkRequiredInputParams(array $inputParams, array $required)
    {
        foreach ($required as $item)
        {
            if(!isset($inputParams[$item]) || (!$inputParams[$item] && !(is_string($inputParams[$item]) && mb_strlen($inputParams[$item]))))
            {
                $this->errorCollection->add(array(new Error(Loc::getMessage('VOTE_CONTROLLER_ERROR_REQUIRED_PARAMETER', array('#PARAM#' => $item)), self::ERROR_REQUIRED_PARAMETER)));
                return false;
            }
        }
 
        return true;
    }
 
    protected function checkRequiredPostParams(array $required)
    {
        $params = array();
        foreach($required as $item)
        {
            $params[$item] = $this->request->getPost($item);
        }
        unset($item);
 
        return $this->checkRequiredInputParams($params, $required);
    }
 
    protected function checkRequiredGetParams(array $required)
    {
        $params = array();
        foreach($required as $item)
        {
            $params[$item] = $this->request->getQuery($item);
        }
        unset($item);
 
        return $this->checkRequiredInputParams($params, $required);
    }
 
    protected function checkRequiredFilesParams(array $required)
    {
        $params = array();
        foreach($required as $item)
        {
            $params[$item] = $this->request->getFile($item);
        }
        unset($item);
 
        return $this->checkRequiredInputParams($params, $required);
    }
 
    protected function isAjaxRequest()
    {
        return $this->request->isAjaxRequest();
    }
}