Romm\Formz\Form\Service\DataObject\FormIdentifierObject

Complexity

Total Complexity

20

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
C	analyzeIdentifierHash()	0	33	7
A	getIdentifierHash()	0	10	2
A	getClassName()	0	4	1
A	getIdentifier()	0	4	1
A	hasIdentifier()	0	4	1
A	getUniqueHash()	0	4	1
B	getFormIdentifierData()	0	22	6

<?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\Service\DataObject;

use Romm\Formz\Form\FormObject;
use Romm\Formz\Form\IdentifiableFormInterface;
use Romm\Formz\Service\HashService;
use TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface;

/**
 * This class is used to handle a form identifiers, that can be passed from one
 * request to another via a hashed string parameter.
 *
 * It allows retrieving the form hash, as well as an identifier if the form was
 * saved in a database (for instance a uid).
 */
class FormIdentifierObject
{
    /**
     * This is the full hash used to retrieve this form identifier data. It can
     * be passed to another request.
     *
     * @var string
     */
    protected $identifierHash;

    /**
     * Contains the class name of the form.
     *
     * @var string
     */
    protected $className;

    /**
     * This is the form identifier, in most cases it will be the uid of the form
     * if it is an instance of `DomainObjectInterface`.
     *
     * @var string
     */
    protected $identifier;

    /**
     * @var string
     */
    protected $uniqueHash;

    /**
     * @var FormObject
     */
    protected $formObject;

    /**
     * @param FormObject $formObject
     */
    public function __construct(FormObject $formObject)
    {
        $this->formObject = $formObject;
    }

    /**
     * Will decrypt and parse the given hash. The data should be an array
     * containing the following information:
     *
     * - `c` - the class name of the form (required)
     * - `h` - the unique hash of the form (required)
     * - `i` - the identifier of the form
     *
     * @param string $hash
     * @throws WrongFormIdentifierObjectDataException
     * @internal
     */
    public function analyzeIdentifierHash($hash)
    {
        $decodedHash = base64_decode($hash);
        $data = HashService::get()->decrypt($decodedHash);

        if (false === $data) {
            throw WrongFormIdentifierObjectDataException::wrongHash($hash);
        }

        if (false === is_array($data)) {
            throw WrongFormIdentifierObjectDataException::wrongType($data);
        }

        if (false === isset($data['c'])) {
            throw WrongFormIdentifierObjectDataException::classNameNotFound();
        }

        if (false === isset($data['h'])) {
            throw WrongFormIdentifierObjectDataException::uniqueHashNotFound();
        }

        if ($data['c'] !== $this->formObject->getClassName()) {
            throw WrongFormIdentifierObjectDataException::wrongClassName($data['c'], $this->formObject->getClassName());
        }

        $this->identifierHash = $hash;
        $this->className = $data['c'];
        $this->uniqueHash = $data['h'];
        $this->identifier = (isset($data['i']))
            ? $data['i']
            : null;

    }

    /**
     * @return string
     */
    public function getIdentifierHash()
    {
        if (null === $this->identifierHash) {
            $data = $this->getFormIdentifierData();
            $data = HashService::get()->encrypt($data);
            $this->identifierHash = base64_encode($data);
        }

        return $this->identifierHash;
    }

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

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

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

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

    /**
     * @return array
     */
    protected function getFormIdentifierData()
    {
        $data = ['c' => $this->formObject->getClassName()];

        if ($this->formObject->hasForm()) {
            $form = $this->formObject->getForm();

            if ($form instanceof IdentifiableFormInterface) {
                $data['i'] = $form->getFormIdentifier();
            } elseif ($form instanceof DomainObjectInterface
                && null !== $form->getUid()
            ) {
                $data['i'] = $form->getUid();
            }
        }

        if (false === isset($data['i'])) {
            $data['h'] = uniqid();
        }

        return $data;
    }
}