Formularium\Model

Complexity

Total Complexity

40

Size/Duplication

Total Lines	260
Duplicated Lines	0 %

Test Coverage

Coverage

53.85%

Importance

Changes	7
Bugs	3	Features	1

15 Methods

Rating	Name	Duplication	Size	Complexity
A	fromStruct()	0	5	1
A	getName()	0	3	1
A	__construct()	0	3	1
A	getFields()	0	3	1
A	fromJSON()	0	9	2
A	getData()	0	3	1
A	fromJSONFile()	0	7	2
A	viewable()	0	3	1
A	getRandom()	0	7	2
A	serialize()	0	17	1
A	toJSON()	0	7	2
A	parseStruct()	0	11	4
D	validate()	0	67	18
A	editable()	0	3	1
A	getDefault()	0	7	2

<?php declare(strict_types=1);

namespace Formularium;

use Formularium\Exception\Exception;

/**
 * Model class, representing a whole object.
 */
class Model
{
    /**
     * @var string
     */
    protected $name;

    /**
     * @var Field[]
     */
    protected $fields;


    /**
     * Model data being processed.
     * @var array
     */
    protected $_data;

    /**
     *
     * @param string $name
     * @throws Exception
     */
    protected function __construct(string $name = '')
    {
        $this->name = $name;
    }

    /**
     * Loads model from JSON file.
     *
     * @param array $struct
     * @return Model
     */
    public static function fromStruct(array $struct): Model
    {
        $m = new self('');
        $m->parseStruct($struct);
        return $m;
    }

    /**
     * Loads model from JSON file.
     *
     * @param string $name The JSON filename.
     * @return Model
     */
    public static function fromJSONFile(string $name): Model
    {
        $json = file_get_contents($name); // TODO: path
        if ($json === false) {
            throw new Exception('File not found');
        }
        return static::fromJSON($json);
    }

    /**
     * Loads model from JSON string
     *
     * @param string $json The JSON string.
     * @return Model
     */
    public static function fromJSON(string $json): Model
    {
        $data = \json_decode($json, true);
        if ($data === null) {
            throw new Exception('Invalid JSON format');
        }
        $m = new self('');
        $m->parseStruct($data);
        return $m;
    }

    public function getName(): string
    {
        return $this->name;
    }

    public function getFields(): array
    {
        return $this->fields;
    }

    public function getData(): array
    {
        return $this->_data;
    }

    /**
     * Validates a set of data against this model.
     *
     * @param array $data A field name => data array.
     * @return array
     */
    public function validate(array $data): array
    {
        $this->_data = $data;
        $validate = [];
        $errors = [];
        foreach ($data as $name => $d) {
            // expected?
            if (!array_key_exists($name, $this->fields)) {
                $errors[$name] = "Field $name does not exist in this model";
                continue;
            }

            $field = $this->fields[$name];

            // must be filled?
            if ($field->getValidators()[Datatype::FILLED] ?? false) {
                if (empty($d)) {
                    $errors[$name] = "Field $name is empty";
                    continue;
                }
            }

            if ($field->getValidators()[Datatype::REQUIRED_WITH] ?? false) {
                $expectedFields = $field->getValidators()[Datatype::REQUIRED_WITH];
                $found = false;
                foreach ($expectedFields as $ef) {
                    if (array_key_exists($data, $ef)) {
                        $found = true;
                    }
                }
                if (!$found) {
                    $errors[$name] = "Field $name is required when at least one of fields " . join(',', $expectedFields . ' are present');

$expectedFields . ' are present' of type string is incompatible with the type array expected by parameter $pieces of join().

                    continue;
                }
            }

            if ($field->getValidators()[Datatype::REQUIRED_WITH_ALL] ?? false) {
                $expectedFields = $field->getValidators()[Datatype::REQUIRED_WITH_ALL];
                $found = true;
                foreach ($expectedFields as $ef) {
                    if (!array_key_exists($data, $ef)) {
                        $found = false;
                        break;
                    }
                }
                if (!$found) {
                    $errors[$name] = "Field $name is required when at all fields " . join(',', $expectedFields . ' are present');
                    continue;
                }
            }

            try {
                $validate[$name] = $field->getDatatype()->validate($d, $field, $this);
            } catch (Exception $e) {
                $errors[$name] = $e->getMessage();
            }
        }
        foreach ($this->fields as $name => $field) {
            if (($field->getValidators()[Datatype::REQUIRED] ?? false)
                && !array_key_exists($name, $validate)
                && !array_key_exists($name, $errors)
            ) {
                $errors[$name] = "Field $name is missing";
            }
        }
        $this->_data = [];
        return ['validated' => $validate, 'errors' => $errors];
    }

    /**
     * Serializes this model to JSON.
     *
     * @return array
     */
    public function serialize(): array
    {
        $fields = array_map(
            function ($f) {
                return [
                    'datatype' => $f->getDatatype()->getName(),
                    'validators' => $f->getValidators(),
                    'extensions' => $f->getExtensions()
                ];
            },
            $this->fields
        );
        $model = [
            'name' => $this->name,
            'fields' => $fields
        ];
        return $model;
    }

    public function toJSON(): string
    {
        $t = json_encode($this->serialize());
        if (!$t) {
            throw new Exception('Cannot serialize');
        }
        return $t;
    }

    /**
     * Renders a readonly view of the model with given data.
     *
     * @param array $modelData
     * @return string
     */
    public function viewable(array $modelData): string
    {
        return FrameworkComposer::viewable($this, $modelData);
    }

    /**
     * Renders a form view of the model with given data.
     *
     * @param array $modelData
     * @return string
     */
    public function editable(array $modelData = []): string
    {
        return FrameworkComposer::editable($this, $modelData);
    }

    public function getRandom(): array
    {
        $data = [];
        foreach ($this->fields as $f) {
            $data[$f->getName()] = $f->getDatatype()->getRandom();
        }
        return $data;
    }

    /**
     * Returns an array with the default values of each field
     *
     * @return array Field name => value
     */
    public function getDefault(): array
    {
        $data = [];
        foreach ($this->fields as $f) {
            $data[$f->getName()] = $f->getDatatype()->getDefault();
        }
        return $data;
    }

    /**
     * Parses struct
     *
     * @param array $data
     * @throws Exception
     * @return void
     */
    protected function parseStruct(array $data)
    {
        if (!array_key_exists('name', $data)) {
            throw new Exception('Missing name in model');
        }
        if (!array_key_exists('fields', $data)) {
            throw new Exception('Missing fields in model');
        }
        $this->name = $data['name'];
        foreach ($data['fields'] as $fieldName => $fieldData) {
            $this->fields[$fieldName] = Field::getFromData($fieldName, $fieldData);
        }
    }
}