Rest::download() - Code Metrics - Inspection of "export + download features" - zemit-cms/core - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Push — master ( 656c0f...c8313f )

by Julien
created 2023-03-14 15:39 UTC
Rest::download() C

↳ Parent: Rest
Complexity

Conditions	13
Paths	134
Size

Total Lines	88
Code Lines	53
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	0
CRAP Score	182
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	53
c	1
b	0
f	0
dl	0
loc	88
ccs	0
cts	52
cp	0
rs	6.3333
cc	13
nc	134
nop	4
crap	182
How to fix Long Method Complexity

<?php
/**
 * This file is part of the Zemit Framework.
 *
 * (c) Zemit Team <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE.txt
 * file that was distributed with this source code.
 */

namespace Zemit\Mvc\Controller;

use League\Csv\CharsetConverter;
use Phalcon\Events\Manager;
use Phalcon\Http\Response;
use Phalcon\Http\ResponseInterface;
use Phalcon\Mvc\Dispatcher;
use Phalcon\Mvc\Model\Resultset;
use League\Csv\Writer;
use Phalcon\Version;
use Zemit\Db\Profiler;
use Zemit\Di\Injectable;
use Zemit\Utils;
use Zemit\Utils\Slug;

/**
 * Class Rest
 *
 * @author Julien Turbide <[email protected]>
 * @copyright Zemit Team <[email protected]>
 *
 * @since 1.0
 * @version 1.0
 *
 *
 * @property Profiler $profiler
 * @package Zemit\Mvc\Controller
 */
class Rest extends \Zemit\Mvc\Controller
{
    use Model;

    
    /**
     * Rest Bootstrap
     */
    public function indexAction($id = null)
    {
        $this->restForwarding($id);
    }
    
    /**
     * Rest bootstrap forwarding
     *
     * @return ResponseInterface
     */
    protected function restForwarding($id = null)
    {
        $id ??= $this->getParam('id');
        
        if ($this->request->isPost() || $this->request->isPut() || $this->request->isPatch()) {
            $this->dispatcher->forward(['action' => 'save']);
        }
        else if ($this->request->isDelete()) {
            $this->dispatcher->forward(['action' => 'delete']);
        }
        else if ($this->request->isGet()) {
            if (is_null($id)) {
                $this->dispatcher->forward(['action' => 'getList']);
            }
            else {
                $this->dispatcher->forward(['action' => 'get']);
            }
        }
    }
    
    /**
     * Retrieving a single record
     * Alias of method getAction()
     *
     * @param null $id

     * @deprecated Should use getAction() method instead
     * @return bool|ResponseInterface
     */
    public function getSingleAction($id = null)
    {
        return $this->getAction($id);
    }
    
    /**
     * Retrieving a single record
     *
     * @param null $id

     *
     * @return bool|ResponseInterface
     */
    public function getAction($id = null)
    {
        $modelName = $this->getModelClassName();
        $single = $this->getSingle($id, $modelName, null);
        
        $ret = [];
        $ret['single'] = $single ? $this->expose($single) : false;
        $ret['model'] = $modelName;
        $ret['source'] = $single ? $single->getSource() : false;
        $ret['source'] = $single ? $single->/** @scrutinizer ignore-call */ getSource() : false;
        $this->view->setVars($ret);
                     setVars($ret);
        
        if (!$single) {
            $this->response->setStatusCode(404, 'Not Found');
            return false;
        }
        
        return $this->setRestResponse((bool)$single);
        return $this->setRestResponse(/** @scrutinizer ignore-type */ (bool)$single);
    }
    
    /**
     * Retrieving a record list
     * Alias of method getListAction()
     *
     * @deprecated Should use getListAction() method instead
     * @return ResponseInterface
     * @throws \Exception
     */
    public function getAllAction()
    {
        return $this->getListAction();
    }
    
    /**
     * Retrieving a record list
     *
     * @return ResponseInterface
     * @throws \Exception
     */
    public function getListAction()
    {
        $model = $this->getModelClassName();
        
        /** @var Resultset $with */
        $find = $this->getFind();
        $with = $model::with($this->getListWith() ?: [], $find ?: []);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        $list = $this->listExpose($with);

//        $list = is_array($list) ? array_values(array_filter($list)) : $list; // @todo do we really need to do this?
        $this->view->list = $list;
        $this->view->listCount = count($list);
        $this->view->totalCount = $model::find($this->getFindCount($find));
        $this->view->totalCount = is_int($this->view->totalCount) ? $this->view->totalCount : count($this->view->totalCount); // @todo fix count to work with rollup when joins
        $this->view->limit = $find['limit'] ?? false;
        $this->view->offset = $find['offset'] ?? false;
        $this->view->find = ($this->config->app->debug || $this->config->debug->enable) ? $find : false;

        
        return $this->setRestResponse();
    }
    
    /**
     * Exporting a record list into a CSV stream
     *
     * @return ResponseInterface|null
     * @throws \Exception
     */
    public function exportAction()
    {
        $model = $this->getModelClassName();
        
        $find = $this->getFind();
        $with = $model::with($this->getExportWith() ?: [], $find ?: []);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        $list = $this->exportExpose($with);
        
        $this->flatternArrayForCsv($list);
        $this->formatColumnText($list);
        
        return $this->download($list);
    }
    
    /**
     * Download a JSON / CSV / XLSX
     * @param $list
     * @param $fileName
     * @param $contentType
     * @param $params
     * @return ResponseInterface|void
     * @throws \League\Csv\CannotInsertRecord
     * @throws \League\Csv\InvalidArgument
     * @throws \Zemit\Exception
     */
    public function download($list = [], $fileName = null, $contentType = null, $params = null) {
        $params ??= $this->getParams();
        $contentType ??= $this->getContentType();
        $fileName ??= ucfirst(Slug::generate(basename(str_replace('\\', '/', $this->getModelClassName())))) . ' List (' . date('Y-m-d') . ')';
        
        if ($contentType === 'json') {
//            $this->response->setJsonContent($list);
            $this->response->setContent(json_encode($list, JSON_PRETTY_PRINT, 2048));
            $this->response->setContentType('application/json');
            $this->response->setHeader('Content-disposition', 'attachment; filename="' . addslashes($fileName) . '.json"');
            return $this->response->send();
        }
    
        // CSV
        if ($contentType === 'csv') {
        
            // Get CSV custom request parameters
            $mode = $params['mode'] ?? null;
            $delimiter = $params['delimiter'] ?? null;
            $newline = $params['newline'] ?? null;
            $escape = $params['escape'] ?? null;
            $outputBOM = $params['outputBOM'] ?? null;
            $skipIncludeBOM = $params['skipIncludeBOM'] ?? null;

//            $csv = Writer::createFromFileObject(new \SplTempFileObject());
            $csv = Writer::createFromStream(fopen('php://memory', 'r+'));
        
            // CSV - MS Excel on MacOS
            if ($mode === 'mac') {
                $csv->setOutputBOM(Writer::BOM_UTF16_LE); // utf-16
                $csv->setDelimiter("\t"); // tabs separated
                $csv->setNewline("\r\n"); // new lines
                CharsetConverter::addTo($csv, 'UTF-8', 'UTF-16');
            }
        
            // CSV - MS Excel on Windows
            else {
                $csv->setOutputBOM(Writer::BOM_UTF8); // utf-8
                $csv->setDelimiter(','); // comma separated
                $csv->setNewline("\n"); // new line windows
                CharsetConverter::addTo($csv, 'UTF-8', 'UTF-8');
            }
        
            // Apply forced params from request
            if (isset($outputBOM)) {
                $csv->setOutputBOM($outputBOM);
            }
            if (isset($delimiter)) {
                $csv->setDelimiter($delimiter);
            }
            if (isset($newline)) {
                $csv->setNewline($newline);
            }
            if (isset($escape)) {
                $csv->setEscape($escape);
            }
            if ($skipIncludeBOM) {
                $csv->skipInputBOM();
            }
            else {
                $csv->includeInputBOM();
            }
        
            // CSV
            if (isset($list[0])) {
                $csv->insertOne(array_keys($list[0]));
                $csv->insertAll($list);
            }
            $csv->output($fileName . '.csv');
            die;

        }
    
        // XLSX
        if ($contentType === 'xlsx') {
            $xlsxArray = [];
            if (isset($list[0])) {
                $xlsxArray [] = array_keys($list[0]);
            }
            foreach ($list as $array) {
                $xlsxArray [] = array_values($array);
            }
            $xlsx = \SimpleXLSXGen::fromArray($xlsxArray);
filter:
    dependency_paths: ["lib/*"]
            $xlsx->downloadAs($fileName . '.xlsx');
            die;

        }
        
        // Something went wrong
        throw new \Exception('Failed to export `' . $this->getModelClassName() . '` using content-type `' . $contentType . '`', 400);
    }
    
    /**
     * Expose a single model
     */
    public function expose(\Zemit\Mvc\Model $item, $expose = null)
    {
        $expose ??= $this->getExpose();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        return $item->expose($expose);
    }
    
    /**
     * Expose a list of model
     */
    public function listExpose(iterable $items, $listExpose = null): array
    {
        $listExpose ??= $this->getListExpose();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        $ret = [];
        
        /** @var \Zemit\Mvc\Model $item */
        foreach ($items as $item) {
            $ret [] = $this->expose($item, $listExpose);
        }
        
        return $ret;
    }
    
    /**
     * Expose a list of model
     */
    public function exportExpose(iterable $items, $exportExpose = null): array
    {
        $exportExpose ??= $this->getExportExpose();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        return $this->listExpose($items, $exportExpose);
    }
    
    /**
     * @param array|null $array
     *
     * @return array|null
     */
    public function flatternArrayForCsv(?array &$list = null)
    {
        
        foreach ($list as $listKey => $listValue) {
            foreach ($listValue as $column => $value) {
                if (is_array($value) || is_object($value)) {
                    $value = $this->concatListFieldElementForCsv($value, ' ');
                    $list[$listKey][$column] = $this->arrayFlatten($value, $column);
                    $list[$listKey][$column] = $this->arrayFlatten(/** @scrutinizer ignore-type */ $value, $column);
                    if (is_array($list[$listKey][$column])) {
                        foreach ($list[$listKey][$column] as $childKey => $childValue) {
                            $list[$listKey][$childKey] = $childValue;
                            unset ($list[$listKey][$column]);

                        }
                    }
                }
            }
        }
    }
    
    /**
     * @param array|object $list
     * @param string|null $seperator
     *
     * @return array|object
     */
    public function concatListFieldElementForCsv($list, $seperator = ' ')
    {
        foreach ($list as $valueKey => $element) {
            if (is_array($element) || is_object($element)) {
                $lastKey = array_key_last($list);
                $lastKey = array_key_last(/** @scrutinizer ignore-type */ $list);
                if ($valueKey === $lastKey) {
                    continue;
                }
                foreach ($element as $elKey => $elValue) {
                    $list[$lastKey][$elKey] .= $seperator . $elValue;
                    if ($lastKey != $valueKey) {
                        unset($list[$valueKey]);
                    }
                }
            }
        }
        
        return $list;
    }
    
    /**
     * @param array|null $array
     * @param string|null $alias
     *
     * @return array|null
     */
    function arrayFlatten(?array $array, ?string $alias = null)

    {
        $return = [];
        foreach ($array as $key => $value) {
            if (is_array($value)) {
                $return = array_merge($return, $this->arrayFlatten($value, $alias));
            }
            else {
                $return[$alias . '.' . $key] = $value;
            }
        }
        return $return;
    }
    
    /**
     * @param array|null $listValue
     *
     * @return array|null
     */
    public function mergeColumns(?array $listValue)
    {
        $columnToMergeList = $this->getExportMergeColum();
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
        if (!$columnToMergeList || empty($columnToMergeList)) {

            return $listValue;
        }
        
        $columnList = [];
        foreach ($columnToMergeList as $columnToMerge) {
            foreach ($columnToMerge['columns'] as $column) {
                if (isset($listValue[$column])) {
                    $columnList[$columnToMerge['name']][] = $listValue[$column];
                    unset($listValue[$column]);
                }
            }
            $listValue[$columnToMerge['name']] = implode(' ', $columnList[$columnToMerge['name']] ?? []);
        }
        
        return $listValue;
    }
    
    /**
     * @param array|null $list
     *
     * @return array|null
     */
    public function formatColumnText(?array &$list)
    {
        foreach ($list as $listKey => $listValue) {
            
            $mergeColumArray = $this->mergeColumns($listValue);
            if (!empty($mergeColumArray)) {
                $list[$listKey] = $mergeColumArray;
            }
            
            $formatArray = $this->getExportFormatFieldText($listValue);
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
$object = $a->getObject();
            if ($formatArray) {
                $columNameList = array_keys($formatArray);
                $columNameList = array_keys(/** @scrutinizer ignore-type */ $formatArray);
                foreach ($formatArray as $formatKey => $formatValue) {

                    if (isset($formatValue['text'])) {
                        $list[$listKey][$formatKey] = $formatValue['text'];
                    }
                    
                    if (isset($formatValue['rename'])) {
                        
                        $list[$listKey][$formatValue['rename']] = $formatValue['text'] ?? ($list[$listKey][$formatKey] ?? null);
                        if ($formatValue['rename'] !== $formatKey) {
                            foreach ($columNameList as $columnKey => $columnValue) {
                                
                                if ($formatKey === $columnValue) {
                                    $columNameList[$columnKey] = $formatValue['rename'];
                                }
                            }
                            
                            unset($list[$listKey][$formatKey]);
                        }
                    }
                }
                
                if (isset($formatArray['reorderColumns']) && $formatArray['reorderColumns']) {
                    $list[$listKey] = $this->arrayCustomOrder($list[$listKey], $columNameList);
                }
            }
        }
        
        return $list;
    }
    
    /**
     * @param array $arrayToOrder
     * @param array $orderList
     *
     * @return array
     */
    function arrayCustomOrder($arrayToOrder, $orderList)

    {
        $ordered = [];
        foreach ($orderList as $key) {
            if (array_key_exists($key, $arrayToOrder)) {
                $ordered[$key] = $arrayToOrder[$key];
            }
        }
        return $ordered;
    }
    
    /**
     * Count a record list
     * @TODO add total count / deleted count / active count
     *
     * @return ResponseInterface
     */
    public function countAction()
    {
        $model = $this->getModelClassName();
        
        /** @var \Zemit\Mvc\Model $entity */
        $entity = new $model();
        
        $this->view->totalCount = $model::count($this->getFindCount($this->getFind()));
        $this->view->totalCount = is_int($this->view->totalCount) ? $this->view->totalCount : count($this->view->totalCount);
        $this->view->model = get_class($entity);
        $this->view->source = $entity->getSource();
        
        return $this->setRestResponse();
    }
    
    /**
     * Prepare a new model for the frontend
     *
     * @return ResponseInterface
     */
    public function newAction()
    {
        $model = $this->getModelClassName();
        
        /** @var \Zemit\Mvc\Model $entity */
        $entity = new $model();
        $entity->assign($this->getParams(), $this->getWhiteList(), $this->getColumnMap());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        
        $this->view->model = get_class($entity);
        $this->view->source = $entity->getSource();
        $this->view->single = $this->expose($entity);
        
        return $this->setRestResponse();
    }
    
    /**
     * Prepare a new model for the frontend
     *
     * @return ResponseInterface
     */
    public function validateAction($id = null)
    {
        $model = $this->getModelClassName();
        
        /** @var \Zemit\Mvc\Model $entity */
        $entity = $this->getSingle($id);
        $new = !$entity;

        
        if ($new) {

            $entity = new $model();
        }
        
        $entity->assign($this->getParams(), $this->getWhiteList(), $this->getColumnMap());
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        
        /**
         * Event to run
         * @see https://docs.phalcon.io/4.0/en/db-models-events
         */
        $events = [
            'beforeCreate' => null,
            'beforeUpdate' => null,
            'beforeSave' => null,
            'beforeValidationOnCreate' => null,
            'beforeValidationOnUpdate' => null,
            'beforeValidation' => null,
            'prepareSave' => null,
            'validation' => null,
            'afterValidationOnCreate' => null,
            'afterValidationOnUpdate' => null,
            'afterValidation' => null,
        ];
        
        // run events, as it would normally
        foreach ($events as $event => $state) {
            $this->skipped = false;

            
            // skip depending wether it's a create or update
            if (strpos($event, $new ? 'Update' : 'Create') !== false) {
                continue;
            }
            
            // fire the event, allowing to fail or skip
            $events[$event] = $entity->fireEventCancel($event);
            if ($events[$event] === false) {
                // event failed
                break;
            }
            
            // event was skipped, just for consistencies purpose
            if ($this->skipped) {
                continue;
            }
        }
        
        $this->view->model = get_class($entity);
        $this->view->source = $entity->getSource();
        $this->view->single = $this->expose($entity);
        $this->view->messages = $entity->getMessages();
        $this->view->events = $events;
        $this->view->validated = empty($this->view->messages);
        
        return $this->setRestResponse($this->view->validated);
        return $this->setRestResponse(/** @scrutinizer ignore-type */ $this->view->validated);
    }
    
    /**
     * Saving a record (create & update)
     *
     * @param null|int $id
     *
     * @return ResponseInterface
     */
    public function saveAction($id = null)
    {
        $ret = $this->save($id);
        $this->view->setVars($ret);
        
        return $this->setRestResponse($ret['saved']);
    }
    
    /**
     * Deleting a record
     *
     * @param null|int $id
     *
     * @return bool|ResponseInterface
     */
    public function deleteAction($id = null)
    {
        $entity = $this->getSingle($id);
        
        $ret = [];
        $ret['deleted'] = $entity && $entity->delete();
        $ret['single'] = $entity ? $this->expose($entity) : false;
        $ret['messages'] = $entity ? $entity->getMessages() : false;
        $this->view->setVars($ret);
        
        if (!$entity) {
            $this->response->setStatusCode(404, 'Not Found');
            return false;
        }
        
        return $this->setRestResponse($ret['deleted']);
        return $this->setRestResponse(/** @scrutinizer ignore-type */ $ret['deleted']);
    }
    
    /**
     * Restoring record
     *
     * @param null $id

     *
     * @return bool|ResponseInterface
     */
    public function restoreAction($id = null)
    {
        $entity = $this->getSingle($id);
    
        $ret = [];
        $ret['restored'] = $entity && $entity->restore();
        $ret['restored'] = $entity && $entity->/** @scrutinizer ignore-call */ restore();
        $ret['single'] = $entity ? $this->expose($entity) : false;
        $ret['messages'] = $entity ? $entity->getMessages() : false;
        $this->view->setVars($ret);
        
        if (!$entity) {
            $this->response->setStatusCode(404, 'Not Found');
            return false;
        }
        
        return $this->setRestResponse($ret['restored']);
        return $this->setRestResponse(/** @scrutinizer ignore-type */ $ret['restored']);
    }
    
    /**
     * Re-ordering a position
     *
     * @param null $id

     * @param null $position

     *
     * @return bool|ResponseInterface
     */
    public function reorderAction($id = null, $position = null)
    {
        $entity = $this->getSingle($id);
        $position = $this->getParam('position', 'int', $position);
        
        $ret = [];
        $ret['reordered'] = $entity ? $entity->reorder($position) : false;
        $ret['reordered'] = $entity ? $entity->/** @scrutinizer ignore-call */ reorder($position) : false;
        $ret['single'] = $entity ? $this->expose($entity) : false;
        $ret['messages'] = $entity ? $entity->getMessages() : false;
        $this->view->setVars($ret);
        
        if (!$entity) {
            $this->response->setStatusCode(404, 'Not Found');
            return false;
        }
        
        return $this->setRestResponse($ret['reordered']);
        return $this->setRestResponse(/** @scrutinizer ignore-type */ $ret['reordered']);
    }
    
    /**
     * Sending an error as an http response
     *
     * @param null $error

     * @param null $response

     *
     * @return ResponseInterface
     */
    public function setRestErrorResponse($code = 400, $status = 'Bad Request', $response = null)
    {
        return $this->setRestResponse($response, $code, $status);
    }
    
    /**
     * Sending rest response as an http response
     *
     * @param array|null $response
     * @param null $status

     * @param null $code

     * @param int $jsonOptions
     * @param int $depth
     *
     * @return ResponseInterface
     */
    public function setRestResponse($response = null, $code = null, $status = null, $jsonOptions = 0, $depth = 512)
    {
        $debug = $this->config->app->debug ?? false;
        
        // keep forced status code or set our own
        $responseStatusCode = $this->response->getStatusCode();
        $reasonPhrase = $this->response->getReasonPhrase();
        $status ??= $reasonPhrase ?: 'OK';
        $code ??= (int)$responseStatusCode ?: 200;
        $view = $this->view->getParamsToView();
        $hash = hash('sha512', json_encode($view));
        
        /**
         * Debug section
         * - Versions
         * - Request
         * - Identity
         * - Profiler
         * - Dispatcher
         * - Router
         */
        $request = $debug ? $this->request->toArray() : null;
        $request = $debug ? $this->request->/** @scrutinizer ignore-call */ toArray() : null;
        $identity = $debug ? $this->identity->getIdentity() : null;
        $profiler = $debug && $this->profiler ? $this->profiler->toArray() : null;
        $dispatcher = $debug ? $this->dispatcher->toArray() : null;
        $router = $debug ? $this->router->toArray() : null;
        
        $api = $debug ? [
            'php' => phpversion(),
            'phalcon' => Version::get(),
            'zemit' => $this->config->core->version,

            'core' => $this->config->core->name,

            'app' => $this->config->app->version,
            'name' => $this->config->app->name,
        ] : [];
        $api['version'] = '0.1';
        
        $this->response->setStatusCode($code, $code . ' ' . $status);
        
        // @todo handle this correctly
        // @todo private vs public cache type
        $cache = $this->getCache();
        if (!empty($cache['lifetime'])) {
            if ($this->response->getStatusCode() === 200) {
                $this->response->setCache($cache['lifetime']);
                $this->response->setEtag($hash);
            }
        }
        else {
            $this->response->setCache(0);
            $this->response->setHeader('Cache-Control', 'no-cache, max-age=0');
        }
        
        return $this->response->setJsonContent(array_merge([
            'api' => $api,
            'timestamp' => date('c'),
            'hash' => $hash,
            'status' => $status,
            'code' => $code,
            'response' => $response,
            'view' => $view,
        ], $debug ? [
            'identity' => $identity,
            'profiler' => $profiler,
            'request' => $request,
            'dispatcher' => $dispatcher,
            'router' => $router,
            'memory' => Utils::getMemoryUsage(),
        ] : []), $jsonOptions, $depth);
        return $this->response->/** @scrutinizer ignore-call */ setJsonContent(array_merge([
    }
    
    public function beforeExecuteRoute(Dispatcher $dispatcher)
    public function beforeExecuteRoute(/** @scrutinizer ignore-unused */ Dispatcher $dispatcher)
    {
        // @todo use eventsManager from service provider instead
        $this->eventsManager->enablePriorities(true);
        // @todo see if we can implement receiving an array of responses globally: V2
        // $this->eventsManager->collectResponses(true);
        
        // retrieve events based on the config roles and features
        $permissions = $this->config->get('permissions')->toArray() ?? [];
        $featureList = $permissions['features'] ?? [];
        $roleList = $permissions['roles'] ?? [];
        
        foreach ($roleList as $role => $rolePermission) {
            
            if (isset($rolePermission['features'])) {
                foreach ($rolePermission['features'] as $feature) {
                    $rolePermission = array_merge_recursive($rolePermission, $featureList[$feature] ?? []);
                    // @todo remove duplicates
                }
            }
            
            $behaviorsContext = $rolePermission['behaviors'] ?? [];
            foreach ($behaviorsContext as $className => $behaviors) {
                if (is_int($className) || get_class($this) === $className) {
                    $this->attachBehaviors($behaviors, 'rest');
                }
                if ($this->getModelClassName() === $className) {
                    $this->attachBehaviors($behaviors, 'model');
                }
            }
        }
    }
    
    public function attachBehaviors($behaviors, $eventType = 'rest')
    {
        if (!is_array($behaviors)) {
            $behaviors = [$behaviors];
        }
        foreach ($behaviors as $behavior) {
            $event = new $behavior();
            if ($event instanceof Injectable) {
                $event->setDI($this->getDI());
            }
            $this->eventsManager->attach($event->eventType ?? $eventType, $event, $event->priority ?? Manager::DEFAULT_PRIORITY);
                                  attach($event->eventType ?? $eventType, $event, $event->priority ?? Manager::DEFAULT_PRIORITY);
        }
    }
    
    /**
     * Handle rest response automagically
     *
     * @param Dispatcher $dispatcher
     */
    public function afterExecuteRoute(Dispatcher $dispatcher)
    {
        $response = $dispatcher->getReturnedValue();
        
        // Avoid breaking default phalcon behaviour
        if ($response instanceof Response) {
            return;
        }
        
        // Merge response into view variables
        if (is_array($response)) {
            $this->view->setVars($response, true);
        }
        
        // Return our Rest normalized response
        $dispatcher->setReturnedValue($this->setRestResponse(is_array($response) ? null : $response));
    }
}

zemit-cms / core

Push — master ( 656c0f...c8313f )

Rest::download() C

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
