Romm\Formz\Form\FormObject\FormObject

Complexity

Total Complexity

28

Size/Duplication

Total Lines	233
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes

0

23 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getName()	0	4	1
A	getClassName()	0	4	1
A	getForm()	0	4	1
A	hasForm()	0	4	1
A	getDefinition()	0	4	1
A	getDefinitionValidationResult()	0	4	1
A	setForm()	0	10	2
A	formWasSubmitted()	0	4	2
A	formWasValidated()	0	4	2
A	getFormResult()	0	4	1
A	getRequestData()	0	4	1
A	getFormMetadata()	0	4	1
A	getFormHash()	0	4	1
A	getObjectHash()	0	4	1
A	getPersistenceManager()	0	4	1
A	hasSteps()	0	4	1
A	getCurrentStep()	0	4	1
A	fetchCurrentStep()	0	6	1
A	getCurrentSubstepDefinition()	0	5	1
A	registerFormInstance()	0	6	2
A	getProxy()	0	8	2
A	createProxy()	0	4	1

<?php
/*
 * 2017 Romain CANON <romain.hydrocanon@gmail.com>
 *
 * This file is part of the TYPO3 FormZ project.
 * It is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, either
 * version 3 of the License, or any later version.
 *
 * For the full copyright and license information, see:
 * http://www.gnu.org/licenses/gpl-3.0.html
 */

namespace Romm\Formz\Form\FormObject;

use Romm\Formz\Core\Core;
use Romm\Formz\Domain\Model\FormMetadata;
use Romm\Formz\Error\FormResult;
use Romm\Formz\Exceptions\DuplicateEntryException;
use Romm\Formz\Exceptions\PropertyNotAccessibleException;
use Romm\Formz\Form\Definition\FormDefinition;
use Romm\Formz\Form\Definition\Step\Step\Step;
use Romm\Formz\Form\Definition\Step\Step\Substep\Substep;
use Romm\Formz\Form\Definition\Step\Step\Substep\SubstepDefinition;
use Romm\Formz\Form\FormInterface;
use Romm\Formz\Form\FormObject\Service\FormObjectRequestData;
use Romm\Formz\Persistence\PersistenceManager;
use TYPO3\CMS\Extbase\Error\Result;
use TYPO3\CMS\Extbase\Mvc\Web\Request;

/**
 * This is the object representation of a form. In here we can manage which
 * properties the form does have, its configuration, and more.
 */
class FormObject
{
    /**
     * @var string
     */
    protected $name;

    /**
     * @var FormObjectStatic
     */
    protected $static;

    /**
     * @var FormObjectProxy
     */
    protected $proxy;

    /**
     * @var PersistenceManager
     */
    protected $persistenceManager;

    /**
     * You should never create a new instance of this class directly, use the
     * `FormObjectFactory->getInstanceFromClassName()` function instead.
     *
     * @param string           $name
     * @param FormObjectStatic $static
     */
    public function __construct($name, FormObjectStatic $static)
    {
        $this->name = $name;
        $this->static = $static;

        $this->persistenceManager = Core::instantiate(PersistenceManager::class, $this);
    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @return string
     */
    public function getClassName()
    {
        return $this->static->getClassName();
    }

    /**
     * @return FormDefinition
     */
    public function getDefinition()
    {
        return $this->static->getDefinition();
    }

    /**
     * @return Result
     */
    public function getDefinitionValidationResult()
    {
        return $this->static->getDefinitionValidationResult();
    }

    /**
     * @return FormInterface
     */
    public function getForm()
    {
        return $this->getProxy()->getForm();
    }

    /**
     * @return bool
     */
    public function hasForm()
    {
        return $this->proxy !== null;
    }

    /**
     * @param FormInterface $form
     * @throws DuplicateEntryException
     */
    public function setForm(FormInterface $form)
    {
        if ($this->proxy) {
            throw DuplicateEntryException::formInstanceAlreadyAdded($this);
        }

        $this->registerFormInstance($form);

        $this->proxy = $this->createProxy($form);
    }

    /**
     * @return bool
     */
    public function formWasSubmitted()
    {
        return $this->hasForm() && $this->getProxy()->formWasSubmitted();
    }

    /**
     * @return bool
     */
    public function formWasValidated()
    {
        return $this->hasForm() && $this->getProxy()->formWasValidated();
    }

    /**
     * @return FormResult
     */
    public function getFormResult()
    {
        return $this->getProxy()->getFormResult();
    }

    /**
     * @return FormObjectRequestData
     */
    public function getRequestData()
    {
        return $this->getProxy()->getRequestData();
    }
    /**
     * @return FormMetadata
     */
    public function getFormMetadata()
    {
        return $this->getProxy()->getFormMetadata();
    }

    /**
     * @return string
     */
    public function getFormHash()
    {
        return $this->getProxy()->getFormHash();
    }

    /**
     * @return string
     */
    public function getObjectHash()
    {
        return $this->static->getObjectHash();
    }

    /**
     * @return PersistenceManager
     */
    public function getPersistenceManager()
    {
        return $this->persistenceManager;
    }

    /**
     * @return bool
     */
    public function hasSteps()
    {
        return $this->getDefinition()->hasSteps();
    }

    /**
     * @return Step|null
     */
    public function getCurrentStep()
    {
        return $this->getProxy()->getCurrentStep();
    }

    /**
     * @param Request $request
     * @return $this
     */
    public function fetchCurrentStep(Request $request)
    {
        $this->getProxy()->fetchCurrentStep($request);

        return $this;
    }

    /**
     * @return SubstepDefinition
     */
    public function getCurrentSubstepDefinition()
    {
        return $this->getProxy()->getCurrentSubstepDefinition();

    }

    /**
     * @param FormInterface $form
     */
    protected function registerFormInstance(FormInterface $form)
    {
        if (false === FormObjectFactory::get()->formInstanceWasRegistered($form)) {
            FormObjectFactory::get()->registerFormInstance($form, $this->getName());
        }
    }

    /**
     * @return FormObjectProxy
     * @throws PropertyNotAccessibleException
     */
    protected function getProxy()
    {
        if (null === $this->proxy) {
            throw PropertyNotAccessibleException::formInstanceNotSet();
        }

        return $this->proxy;
    }

    /**
     * Wrapper for unit tests.
     *
     * @param FormInterface $form
     * @return FormObjectProxy
     */
    protected function createProxy(FormInterface $form)
    {
        return FormObjectFactory::get()->getProxy($form);
    }
}