gitlab_medici/app/model/facade/TransliterationFacade.php @ master

<?php


namespace App\Model\Facade;


use App\AdminModule\Components\TransliterationNewForm;
use App\Enum\EFlashMessage;
use App\Model\Repository\BookRepository;
use App\Model\Repository\LineRepository;
use App\Model\Repository\LitReferenceRepository;
use App\Model\Repository\ObjectTypeRepository;
use App\Model\Repository\SurfaceRepository;
use App\Model\Repository\SurfaceTypeRepository;
use App\Model\Repository\TransliterationRepository;
use Nette\Application\UI\Form;
use Nette\Database\Context;
use Nette\Database\Table\ActiveRow;
use Nette\Utils\ArrayHash;
use Tracy\Debugger;

class TransliterationFacade
{
    /**
     * @var SurfaceRepository
     */
    private $surfaceRepository;
    /**
     * @var LineRepository
     */
    private $lineRepository;
    /**
     * @var ObjectTypeRepository
     */
    private $objectTypeRepository;
    /**
     * @var SurfaceTypeRepository
     */
    private $surfaceTypeRepository;
    /**
     * @var Context
     */
    private $context;
    /**
     * @var TransliterationRepository
     */
    private $transliterationRepository;
    /**
     * @var LitReferenceRepository
     */
    private $litReferenceRepository;
    /**
     * @var BookFacade
     */
    private $bookFacade;

    public function __construct(SurfaceRepository $surfaceRepository,
                                LineRepository $lineRepository,
                                ObjectTypeRepository $objectTypeRepository,
                                SurfaceTypeRepository $surfaceTypeRepository,
                                TransliterationRepository $transliterationRepository,
                                LitReferenceRepository $litReferenceRepository,
                                Context $context,
                                BookFacade $bookFacade
    )
    {
        $this->surfaceRepository = $surfaceRepository;
        $this->lineRepository = $lineRepository;
        $this->objectTypeRepository = $objectTypeRepository;
        $this->surfaceTypeRepository = $surfaceTypeRepository;
        $this->context = $context;
        $this->transliterationRepository = $transliterationRepository;
        $this->litReferenceRepository = $litReferenceRepository;
        $this->bookFacade = $bookFacade;
    }

    /**
     * Vložení nové transliterace do databáze
     *
     * @param \App\Utils\Form $form
     * @return bool|void
     */
    public function saveNewTransliteration(\App\Utils\Form $form)
    {
        $data = $form->getValues();
        $transliteration = $this->saveTransliterationInfo($form);

        if ($data['bookContainer']['book'] == TransliterationNewForm::BOOK_EXISTING)
        {
            $bookId = $data['bookContainer'][BookRepository::COLUMN_ID];
        } else
        {
            $book = $this->bookFacade->saveBook($form);
            $bookId = $book[BookRepository::COLUMN_ID];
        }

        $transliteration->update([TransliterationRepository::COLUMN_BOOK_ID => $bookId]);

        if ($transliteration == null)
        {
            return FALSE;
        }

        $result = $this->saveTransliterationData($transliteration[TransliterationRepository::COLUMN_ID], $form);
        return $result;
    }

    /**
     * Uložení informací o transliteraci do databáze
     *
     * @param Form $form
     * @param int|null $id
     * @return ActiveRow|null
     */
    public function saveTransliterationInfo(Form $form, int $id = null)
    {
        $formValues = $form->getValues();
        $formValues = isset($formValues['infoContainer']) ? $formValues['infoContainer'] : $formValues;

        $references = $formValues['references'];
        unset($formValues['references']);

        $newTransliteration = $this->transliterationRepository->save($formValues, $id);

        if ($id != null)
        {
            $this->deleteRemovedReferences($references, $id);
        } else
        {
            $id = $newTransliteration[TransliterationRepository::COLUMN_ID];
        }

        foreach ($references as $item)
        {
            $item[LitReferenceRepository::COLUMN_TRANSLITERATION_ID] = $id;
            $this->litReferenceRepository->save($item, (int)$item[LitReferenceRepository::COLUMN_ID]);
        }

        return $newTransliteration;
    }

    /**
     * Zkontroluje jestli není nějaká refence prázdná
     *
     * @param $references array referencí
     * @return bool
     */
    public function isAnyReferenceEmpty($references)
    {
        foreach ($references as $r)
        {
            if (empty($r[LitReferenceRepository::COLUMN_SERIES]) && empty($r[LitReferenceRepository::COLUMN_NUMBER])
                && empty($r[LitReferenceRepository::COLUMN_PLATE]))
            {
                return true;
            }
        }
        return false;
    }

    /**
     * Odstraní odebrané reference transliterace
     *
     * @param $newReferences array nových transliterací
     */
    public function deleteRemovedReferences($newReferences, $id)
    {
        $references = $this->litReferenceRepository->findByTransliterationId($id);

        foreach ($references as $ref)
        {
            if ($this->isRemovedReference($ref, $newReferences))
            {
                $this->litReferenceRepository->delete($ref[LitReferenceRepository::COLUMN_ID]);
            }
        }

    }

    /**
     * Zkontroluje jestli je refence v poli referencí
     *
     * @param $reference ActiveRow reference ke kontrole
     * @param $newReferences array pole referencí
     * @return bool
     */
    public function isRemovedReference($reference, $newReferences)
    {
        foreach ($newReferences as $ref)
        {
            if ($ref[LitReferenceRepository::COLUMN_ID] == $reference[LitReferenceRepository::COLUMN_ID])
            {
                return false;
            }
        }
        return true;
    }

    /**
     * Uloží data transliterace
     *
     * @param int|null $id : ID transliterace
     * @param Form $form
     * @return int $id : Vrací ID transliterace
     */
    public function saveTransliterationData(int $id, Form $form): int
    {
        $formValues = $form->getValues();
        $formValues = isset($formValues['dataContainer']) ? $formValues['dataContainer'] : $formValues;

        $this->removeDeletedLines($id, $formValues);

        // Škaredý zanoření hodnot z formuláře v kontainerech :(
        foreach ($formValues as $objectTypeId => $surfaceContainers)
        {
            foreach ($surfaceContainers as $surfaceTypeId => $inputs)
            {
                foreach ($inputs as $key => $values)
                {
                    try
                    {
                        $lineId = (int)$values->{LineRepository::COLUMN_ID};

                        // Editace již existující řádky
                        if (!empty($lineId))
                        {
                            $this->lineRepository->fetchById($lineId)->update($values);

                        } else
                        {
                            unset($values->{LineRepository::COLUMN_ID});

                            $surface = $this->surfaceRepository->fetchSurface($id, $objectTypeId, $surfaceTypeId);

                            if ($surface === FALSE)
                            {
                                $surface = $this->surfaceRepository->insert(
                                    [
                                        SurfaceRepository::COLUMN_SURFACE_TYPE_ID => $surfaceTypeId,
                                        SurfaceRepository::COLUMN_OBJECT_TYPE_ID => $objectTypeId,
                                        SurfaceRepository::COLUMN_TRANSLITERATION_ID => $id
                                    ]
                                );
                            }

                            $surfaceId = $this->context->getInsertId(SurfaceRepository::TABLE_NAME);

                            $values->{LineRepository::COLUMN_SURFACE_ID} = !empty($surfaceId) ? $surfaceId : $surface->{SurfaceRepository::COLUMN_ID};

                            $this->lineRepository->insert($values);
                        }
                    } catch (\Exception $exception)
                    {
                        \Tracy\Debugger::log('Nepodařilo se uložit data transliterace. Chyba: ' . $exception->getMessage(), 'transliteration-facade');
                        return 0;
                    }
                }
            }
        }

        return $id;
    }

    /**
     * Vrací data transliterace pro formulář
     *
     * @param int $id : ID transliterace
     * @return array : pole výchozích hodnot pro formulář
     */
    public function getTransliterationData(int $id): array
    {
        $surfaces = $this->surfaceRepository->findByTransliterationId($id)->fetchAll();

        $defaults = array();

        /** @var ActiveRow $surface */
        foreach ($surfaces as $surface)
        {
            // Načtení všech řádek
            $lineRows = $surface->related(LineRepository::TABLE_NAME, SurfaceRepository::COLUMN_ID)->fetchAll();
            if ($lineRows === FALSE || empty($lineRows))
            {
                continue;
            }

            $objectId = $surface->{SurfaceRepository::COLUMN_OBJECT_TYPE_ID};
            $surfaceId = $surface->{SurfaceRepository::COLUMN_SURFACE_TYPE_ID};

            $defaults[$objectId][$surfaceId] = $lineRows;
        }

        return $defaults;
    }

    /**
     * Odstraní smazané řádky z DB
     *
     * @param int $id : ID transliterace
     * @param ArrayHash $formValues : hodnoty z formuláře
     * @return int : počet smazaných řádek
     */
    public function removeDeletedLines(int $id, ArrayHash $formValues)
    {
        $deletedIds = $this->getDeletedLineIds($id, $formValues);

        return $this->lineRepository->deleteLines($deletedIds);
    }

    /**
     * Vrací ID smazaných řádek transliterace
     *
     * @param int $id : ID transliterace
     * @param ArrayHash $formValues : hodnoty z formuláře
     * @return array
     */
    private function getDeletedLineIds(int $id, ArrayHash $formValues)
    {
        $deletedIds = [];
        $oldLines = $this->getTransliterationData($id);

        // Tohle je fakt nádhera :(
        foreach ($oldLines as $objectTypeId => $surfaceContainers)
        {
            foreach ($surfaceContainers as $surfaceTypeId => $activeRows)
            {
                foreach ($activeRows as $activeRow)
                {
                    if (isset($formValues[$objectTypeId][$surfaceTypeId]))
                    {
                        $oldLineFound = FALSE;
                        foreach ($formValues[$objectTypeId][$surfaceTypeId] as $array)
                        {
                            if ($array[LineRepository::COLUMN_ID] == $activeRow->{LineRepository::COLUMN_ID})
                            {
                                $oldLineFound = TRUE;
                                break;
                            }
                        }

                        if (!$oldLineFound)
                        {
                            $deletedIds[] = $activeRow->{LineRepository::COLUMN_ID};
                        }
                    }
                }
            }
        }

        return $deletedIds;
    }
}