Sco\Admin\Form\Form

Complexity

Total Complexity

29

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

0%

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getElements()	0	4	1
A	getElement()	0	12	2
A	setElements()	0	6	1
A	addElement()	0	6	1
A	getModel()	0	4	1
A	setModel()	0	8	1
A	setElementModel()	0	10	1
A	validate()	0	11	1
A	getValidationRules()	0	4	1
A	getValidationMessages()	0	4	1
A	getValidationTitles()	0	4	1
A	getElementsValidationRules()	0	11	2
A	getElementsValidationMessages()	0	11	2
A	getElementsValidationTitles()	0	11	2
A	saveElements()	0	6	1
A	finishSaveElements()	0	6	1
A	finishSave()	0	4	1
A	save()	0	13	2
A	getValues()	0	8	1
A	toArray()	0	7	1
A	jsonSerialize()	0	4	1
A	toJson()	0	4	1
A	__toString()	0	4	1

<?php

namespace Sco\Admin\Form;

use Illuminate\Database\Eloquent\Model;
use InvalidArgumentException;
use Sco\Admin\Contracts\Form\Elements\ElementInterface;
use Sco\Admin\Contracts\Form\FormInterface;
use Sco\Admin\Contracts\Validatable;
use Validator;

class Form implements
    FormInterface,
    Validatable
{
    /**
     * @var \Sco\Admin\Form\ElementsCollection
     */
    protected $elements;

    /**
     * @var \Illuminate\Database\Eloquent\Model
     */
    protected $model;

    public function __construct(array $elements = [])
    {
        $this->setElements($elements);
    }

    /**
     * {@inheritdoc}
     */
    public function getElements()
    {
        return $this->elements;
    }

    /**
     * {@inheritdoc}
     */
    public function getElement($name)
    {
        $key = $this->getElements()->search(function (ElementInterface $item) use ($name
        ) {
            return $item->getName() == $name;
        });
        if ($key === false) {
            throw new InvalidArgumentException('Not found element');
        }

        return $this->getElements()->get($key);
    }

    /**
     * {@inheritdoc}
     */
    public function setElements(array $elements)
    {
        $this->elements = new ElementsCollection($elements);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function addElement(ElementInterface $element)
    {
        $this->elements->push($element);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getModel()
    {
        return $this->model;
    }

    /**
     * {@inheritdoc}
     */
    public function setModel(Model $model)
    {
        $this->model = $model;

        $this->setElementModel($model);

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function setElementModel(Model $model)
    {
        $this->elements->each(function (ElementInterface $element) use ($model) {
            //if ($element instanceof WithModel) {

55% of this comment could be valid code. Did you maybe forget this after debugging?

            $element->setModel($model);
            //}
        });

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function validate()
    {
        Validator::validate(
            request()->all(),
            $this->getValidationRules(),
            $this->getValidationMessages(),
            $this->getValidationTitles()
        );

        return $this;
    }

    public function getValidationRules()
    {
        return $this->getElementsValidationRules();
    }

    public function getValidationMessages()
    {
        return $this->getElementsValidationMessages();
    }

    public function getValidationTitles()
    {
        return $this->getElementsValidationTitles();
    }

    protected function getElementsValidationRules()
    {
        $rules = [];
        $this->elements->each(function (ElementInterface $element) use (&$rules) {
            if ($element instanceof Validatable) {
                $rules += $element->getValidationRules();
            }
        });

        return $rules;
    }

    protected function getElementsValidationMessages()
    {
        $messages = [];
        $this->elements->each(function (ElementInterface $element) use (&$messages) {
            if ($element instanceof Validatable) {
                $messages += $element->getValidationMessages();
            }
        });

        return $messages;
    }

    protected function getElementsValidationTitles()
    {
        $titles = [];
        $this->elements->each(function (ElementInterface $element) use (&$titles) {
            if ($element instanceof Validatable) {
                $titles += $element->getValidationTitles();
            }
        });

        return $titles;
    }

    protected function saveElements()
    {
        $this->getElements()->each(function (ElementInterface $element) {
            $element->save();
        });
    }

    protected function finishSaveElements()
    {
        $this->getElements()->each(function (ElementInterface $element) {
            $element->finishSave();
        });
    }

    protected function finishSave()
    {
        $this->finishSaveElements();
    }

    public function save()
    {
        $this->saveElements();

        $model = $this->getModel();
        $saved = $model->save();

        if ($saved) {
            $this->finishSave();
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function getValues()
    {
        return $this->elements->mapWithKeys(function (ElementInterface $element) {
            return [
                $element->getName() => $element->getValue(),
            ];
        });
    }

    public function toArray()
    {
        return [
            'elements' => $this->getElements(),
            'values'   => $this->getValues(),
        ];
    }

    public function jsonSerialize()
    {
        return $this->toArray();
    }

    public function toJson($options = 0)
    {
        return json_encode($this->jsonSerialize(), $options);
    }

    public function __toString()
    {
        return $this->toJson();
    }
}