HexMakina\kadro\Controllers\ORM

Complexity

Total Complexity

73

Size/Duplication

Total Lines	367
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

32 Methods

Rating	Name	Duplication	Size	Complexity
A	after_destroy()	0	3	1
A	route_model()	0	13	2
A	dashboard()	0	3	1
A	field_name_to_label()	0	4	1
A	save()	0	9	2
A	modelClassName()	0	8	2
A	after_save()	0	3	1
A	before_destroy()	0	8	3
A	route_list()	0	3	1
A	route_new()	0	3	1
A	routeFactory()	0	11	5
A	destroy_confirm()	0	10	2
A	persist_model()	0	12	3
A	edit()	0	2	1
A	prepare()	0	18	4
A	destroy()	0	12	3
A	export()	0	14	3
A	addErrors()	0	7	3
A	modelType()	0	8	2
A	collection_to_csv()	0	19	3
A	formModel()	0	9	3
A	copy()	0	6	1
A	listing()	0	14	4
A	before_edit()	0	5	3
B	viewport_listing()	0	28	7
A	before_save()	0	3	1
A	loadModel()	0	3	1
A	template_base()	0	3	1
A	model_type_to_label()	0	4	1
A	conclude()	0	8	2
A	modelPrefix()	0	9	2
A	sanitize_post_data()	0	9	3

<?php

namespace HexMakina\kadro\Controllers;

use HexMakina\BlackBox\ORM\ModelInterface;
use HexMakina\BlackBox\Controllers\ORMInterface;
use HexMakina\LeMarchand\LeMarchand;

abstract class ORM extends Kadro implements ORMInterface
{
    protected $model_class_name = null;
    protected $model_type = null;

    protected $load_model = null;
    protected $form_model = null;


    public function addErrors($errors)
    {
        foreach ($errors as $err) {
            if (is_array($err)) {
                $this->addError(array_unshift($err), array_unshift($err));
            } else {
                $this->addError($err);
            }
        }
    }

    public function loadModel(): ?ModelInterface
    {
        return $this->load_model;
    }

    public function formModel(ModelInterface $setter = null): ModelInterface
    {
        if (!is_null($setter)) {
            $this->form_model = $setter;
        } elseif (is_null($this->form_model)) {
            $reflection = new \ReflectionClass($this->modelClassName());
            $this->form_model = $reflection->newInstanceWithoutConstructor(); //That's it!
        }
        return $this->form_model;
    }

    // shortcut to model_type
    public function modelType(): string
    {
      // have to go through the model to garantee model_type existence via interface
        if (is_null($this->model_type)) {
            $this->model_type = get_class($this->formModel())::model_type();
        }

        return $this->model_type;
    }

    public function modelPrefix($suffix = null): string
    {
        $ret = $this->modelType();

        if (!is_null($suffix)) {
            $ret .= '_' . $suffix;
        }

        return $ret;
    }

    public function prepare()
    {
        parent::prepare();

        $this->model_type = $this->modelClassName()::model_type();

        $pk_values = [];

        if ($this->router()->submits()) {
            $this->formModel()->import($this->sanitize_post_data($this->router()->submitted()));
            $pk_values = $this->modelClassName()::table()->primaryKeysMatch($this->router()->submitted());

            $this->load_model = $this->modelClassName()::exists($pk_values);
        } elseif ($this->router()->requests()) {
            $pk_values = $this->modelClassName()::table()->primaryKeysMatch($this->router()->params());

            if (!is_null($this->load_model = $this->modelClassName()::exists($pk_values))) {
                $this->formModel(clone $this->load_model);
            }
        }
        // TODO restore model history
        // if (!is_null($this->load_model) && is_subclass_of($this->load_model, '\HexMakina\Tracer\TraceableInterface') && $this->load_model->traceable()) {
        //   // $traces = $this->tracer()->traces_by_model($this->load_model);
        //     $traces = $this->load_model->traces();
        //     //$this->tracer()->history_by_model($this->load_model);
        //     $this->viewport('load_model_history', $traces ?? []);
        // }
    }

    // ----------- META -----------

    // CoC class name by
    // 1. replacing namespace Controllers by Models
    // 2. removing the  from classname
    // overwrite this behavior by setting the model_class_name at controller construction
    public function modelClassName(): string
    {
        if (is_null($this->model_class_name)) {
            preg_match(LeMarchand::RX_MVC, get_called_class(), $m);
            $this->model_class_name = $this->get('Models\\'.$m[2].'::class');
        }

        return $this->model_class_name;
    }

    public function model_type_to_label($model = null)
    {
        $model = $model ?? $this->load_model ?? $this->formModel();
        return $this->l(sprintf('MODEL_%s_INSTANCE', get_class($model)::model_type()));
    }
    public function field_name_to_label($model, $field_name)
    {
        $model = $model ?? $this->load_model ?? $this->formModel();
        return $this->l(sprintf('MODEL_%s_FIELD_%s', (get_class($model))::model_type(), $field_name));
    }

    public function dashboard()
    {
        $this->listing(); //default dashboard is a listing
    }

    public function listing($model = null, $filters = [], $options = [])
    {
        $class_name = is_null($model) ? $this->modelClassName() : get_class($model);

        if (!isset($filters['date_start'])) {
            $filters['date_start'] = $this->get('HexMakina\BlackBox\StateAgentInterface')->filters('date_start');
        }
        if (!isset($filters['date_stop'])) {
            $filters['date_stop'] = $this->get('HexMakina\BlackBox\StateAgentInterface')->filters('date_stop');
        }

        $listing = $this->modelClassName()::filter($filters);

        $this->viewport_listing($class_name, $listing, $this->find_template($this->get('\Smarty'), __FUNCTION__));
    }

    public function viewport_listing($class_name, $listing, $listing_template)
    {
        $listing_fields = [];
        if (empty($listing)) {
            $hidden_columns = ['created_by', 'created_on', 'password'];
            foreach ($class_name::table()->columns() as $column) {
                if (!$column->isAutoIncremented() && !in_array($column->name(), $hidden_columns)) {
                    $listing_fields[$column->name()] = $this->l(sprintf('MODEL_%s_FIELD_%s', $class_name::model_type(), $column->name()));
                }
            }
        } else {
            $current = current($listing);
            if (is_object($current)) {
                $current = get_object_vars($current);
            }

            foreach (array_keys($current) as $field) {
                $listing_fields[$field] = $this->l(sprintf('MODEL_%s_FIELD_%s', $class_name::model_type(), $field));
            }
        }

        $this->viewport('listing', $listing);
        $this->viewport('listing_title', $this->l(sprintf('MODEL_%s_INSTANCES', $class_name::model_type())));
        $this->viewport('listing_fields', $listing_fields);
        $this->viewport('listing_template', $listing_template);

        $this->viewport('route_new', $this->router()->hyp($class_name::model_type() . '_new'));
        $this->viewport('route_export', $this->router()->hyp($class_name::model_type() . '_export'));
    }

    public function copy()
    {
        $this->formModel($this->load_model->copy());

        $this->routeBack($this->load_model);
        $this->edit();
    }

    public function edit()
    {
    }

    public function save()
    {
        $model = $this->persist_model($this->formModel());

        if (empty($this->errors())) {
            $this->routeBack($model);
        } else {
            $this->edit();
            return 'edit';
        }
    }

    public function persist_model($model): ?ModelInterface
    {
        $this->errors = $model->save($this->operator()->operatorId()); // returns [errors]
        if (empty($this->errors())) {
            $this->logger()->notice($this->l('CRUDITES_INSTANCE_ALTERED', [$this->l('MODEL_' . get_class($model)::model_type() . '_INSTANCE')]));
            return $model;
        }
        foreach ($this->errors() as $field => $error_msg) {
            $this->logger()->warning($this->l($error_msg, [$field]));
        }

        return null;
    }

    public function before_edit()
    {
        if (!is_null($this->router()->params('id')) && is_null($this->load_model)) {
            $this->logger()->warning($this->l('CRUDITES_ERR_INSTANCE_NOT_FOUND', [$this->l('MODEL_' . $this->modelClassName()::model_type() . '_INSTANCE')]));
            $this->router()->hop($this->modelClassName()::model_type());
        }
    }

    public function before_save()
    {
        return [];
    }

  // default: hop to altered object
    public function after_save()
    {
        $this->router()->hop($this->routeBack());
    }

    public function destroy_confirm()
    {
        if (is_null($this->load_model)) {
            $this->logger()->warning($this->l('CRUDITES_ERR_INSTANCE_NOT_FOUND', [$this->l('MODEL_' . $this->model_type . '_INSTANCE')]));
            $this->router()->hop($this->model_type);
        }

        $this->before_destroy();

        return 'destroy';
    }

    public function before_destroy() // default: checks for load_model and immortality, hops back to object on failure
    {
        if (is_null($this->load_model)) {
            $this->logger()->warning($this->l('CRUDITES_ERR_INSTANCE_NOT_FOUND', [$this->l('MODEL_' . $this->model_type . '_INSTANCE')]));
            $this->router()->hop($this->model_type);
        } elseif ($this->load_model->immortal()) {
            $this->logger()->warning($this->l('CRUDITES_ERR_INSTANCE_IS_IMMORTAL', [$this->l('MODEL_' . $this->model_type . '_INSTANCE')]));
            $this->router()->hop($this->route_model($this->load_model));
        }
    }

    public function destroy()
    {
        if (!$this->router()->submits()) {
            throw new \Exception('KADRO_ROUTER_MUST_SUBMIT');
        }

        if ($this->load_model->destroy($this->operator()->operatorId()) === false) {
            $this->logger()->info($this->l('CRUDITES_ERR_INSTANCE_IS_UNDELETABLE', ['' . $this->load_model]));
            $this->routeBack($this->load_model);
        } else {
            $this->logger()->notice($this->l('CRUDITES_INSTANCE_DESTROYED', [$this->l('MODEL_' . $this->model_type . '_INSTANCE')]));
            $this->routeBack($this->model_type);
        }
    }

    public function after_destroy()
    {
        $this->router()->hop($this->routeBack());
    }

    public function conclude()
    {
        $this->viewport('errors', $this->errors());
        $this->viewport('form_model_type', $this->model_type);
        $this->viewport('form_model', $this->formModel());

        if (isset($this->load_model)) {
            $this->viewport('load_model', $this->load_model);
        }
    }

    public function collection_to_csv($collection, $filename)
    {
      // TODO use Format/File/CSV class to generate file
        $file_path = $this->get('settings.export.directory') . $filename . '.csv';
        $fp = fopen($file_path, 'w');

        $header = false;

        foreach ($collection as $line) {
            $line = get_object_vars($line);
            if ($header === false) {
                fputcsv($fp, array_keys($line));
                $header = true;
            }
            fputcsv($fp, $line);
        }
        fclose($fp);

        return $file_path;
    }

    public function export()
    {
        $format = $this->router()->params('format');
        switch ($format) {
            case null:
                $filename = $this->model_type;
                $collection = $this->modelClassName()::listing();
                $file_path = $this->collection_to_csv($collection, $filename);
                $this->router()->sendFile($file_path);
                break;

            case 'xlsx':
                $report_controller = $this->get('HexMakina\koral\Controllers\ReportController');
                return $report_controller->collection($this->modelClassName());
        }
    }

    public function route_new(ModelInterface $model): string
    {
        return $this->router()->hyp(get_class($model)::model_type() . '_new');
    }

    public function route_list(ModelInterface $model): string
    {
        return $this->router()->hyp(get_class($model)::model_type());
    }

    public function route_model(ModelInterface $model): string
    {
        $route_params = [];

        $route_name = get_class($model)::model_type() . '_';
        if ($model->isNew()) {
            $route_name .= 'new';
        } else {
            $route_name .= 'default';
            $route_params = ['id' => $model->getId()];
        }
        $res = $this->router()->hyp($route_name, $route_params);
        return $res;
    }

    public function routeFactory($route = null, $route_params = []): string
    {
        if (is_null($route) && $this->router()->submits()) {
            $route = $this->formModel();
        }

        if (!is_null($route) && is_subclass_of($route, '\HexMakina\BlackBox\ORM\ModelInterface')) {
            $route = $this->route_model($route);
        }

        return parent::routeFactory($route, $route_params);
    }

    private function sanitize_post_data($post_data = [])
    {
        foreach ($this->modelClassName()::table()->columns() as $col) {
            if ($col->type()->isBoolean()) {
                $post_data[$col->name()] = !empty($post_data[$col->name()]);
            }
        }

        return $post_data;
    }

    // overriding displaycontroller
    protected function template_base()
    {
        return $this->modelClassName()::model_type();
    }
}