Romm\Formz\Persistence\PersistenceManager

Complexity

Total Complexity

17

Size/Duplication

Total Lines	135
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	save()	0	22	3
A	fetchFirst()	0	18	4
A	refreshFormIdentifier()	0	10	3
A	initializePersistence()	0	10	3
A	getSortedPersistence()	0	17	3

<?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\Persistence;

use Romm\Formz\Exceptions\InvalidEntryException;
use Romm\Formz\Form\FormInterface;
use Romm\Formz\Form\FormObject;
use Romm\Formz\Form\Service\DataObject\FormIdentifierObject;

/**
 * Manages persistence for a given form object.
 */
class PersistenceManager
{
    /**
     * @var FormObject
     */
    protected $formObject;

    /**
     * @var bool
     */
    protected $initializationDone = false;

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

    /**
     * Loops on the registered persistence services and saves the given form
     * instance in each one.
     *
     * @param FormIdentifierObject $identifierObject
     * @param FormInterface        $form
     */
    public function save(FormIdentifierObject $identifierObject, FormInterface $form)
    {
        $this->initializePersistence();

        $identifierObjectBackup = clone $identifierObject;

        foreach ($this->getSortedPersistence() as $persistence) {
            $persistence->save($identifierObject, $form);
        }

        /*
         * Checking if the identifier hash did change during the saving process.
         * This can happen for instance when the form has been inserted in
         * database and has a new uid.
         *
         * If this does happen, we need to remove the old form identifier
         * instances from persistence services, and replace them by the new one.
         */
        if ($identifierObjectBackup->getIdentifierHash() !== $identifierObject->getIdentifierHash()) {
            $this->refreshFormIdentifier($identifierObjectBackup, $identifierObject, $form);
        }
    }

    /**
     * Loops on the registered persistence services, and tries to fetch the
     * form. If a form is found, it is returned and the loop breaks. If not form
     * is found, `null` is returned.
     *
     * @param FormIdentifierObject $identifierObject
     * @return FormInterface|null
     * @throws InvalidEntryException
     */
    public function fetchFirst(FormIdentifierObject $identifierObject)
    {
        $this->initializePersistence();

        foreach ($this->getSortedPersistence() as $persistence) {
            if ($persistence->has($identifierObject)) {
                $form = $persistence->fetch($identifierObject);

                if (false === $form instanceof FormInterface) {
                    throw InvalidEntryException::persistenceInvalidEntryFetched($persistence, $form);
                }

                return $form;
            }
        }

        return null;
    }

    /**
     * Will remove the old identifier objects on every persistence service that
     * has it, and replace it with the new identifier object.
     *
     * @param FormIdentifierObject $oldIdentifierObject
     * @param FormIdentifierObject $newIdentifierObject
     * @param FormInterface        $form
     */
    protected function refreshFormIdentifier(FormIdentifierObject $oldIdentifierObject, FormIdentifierObject $newIdentifierObject, FormInterface $form)
    {
        foreach ($this->getSortedPersistence() as $persistence) {
            $persistence->delete($oldIdentifierObject);

            if (false === $persistence->has($newIdentifierObject)) {
                $persistence->save($newIdentifierObject, $form);
            }
        }
    }

    /**
     * Loops on persistence services and initializes them.
     */
    protected function initializePersistence()
    {
        if (false === $this->initializationDone) {
            $this->initializationDone = true;

            foreach ($this->formObject->getConfiguration()->getPersistence() as $persistence) {
                $persistence->initialize();
            }
        }
    }

    /**
     * Sorts the persistence services, based on their priority property: the
     * ones with the highest priority will come first.
     *
     * @return PersistenceInterface[]
     */
    protected function getSortedPersistence()
    {
        $items = $this->formObject->getConfiguration()->getPersistence();

        usort($items, function (PersistenceInterface $a, PersistenceInterface $b) {
            $priorityA = (int)$a->getPriority();
            $priorityB = (int)$b->getPriority();

            if ($priorityA === $priorityB) {
                return 0;
            }

            return $priorityA < $priorityB ? 1 : -1;
        });

        return $items;
    }
}