gitlab_medici/app/model/facade/TransportFacade.php @ 175d726f

<?php


namespace App\Model\Facade;

use App\Model\Repository\BookRepository;
use App\Model\Repository\LineRepository;
use App\Model\Repository\SurfaceRepository;
use App\Model\Repository\TransliterationRepository;
use Nette\Database\Context;
use Nette\Database\Table\ActiveRow;

/**
 * Class TransportFacade sloužící pro import/export práce s db
 * @package App\Model\Facade
 */
class TransportFacade
{
    /** @var BookRepository */
    private $bookRepository;

    /** @var TransliterationRepository */
    private $transliterationRepository;

    /** @var SurfaceRepository */
    private $surfaceRepository;

    /** @var LineRepository */
    private $lineRepository;

    /** @var Context */
    private $context;


    public function __construct(BookRepository $bookRepository,
                                TransliterationRepository $transliterationRepository,
                                SurfaceRepository $surfaceRepository,
                                LineRepository $lineRepository,
                                Context $context
    )
    {
        $this->bookRepository = $bookRepository;
        $this->transliterationRepository = $transliterationRepository;
        $this->surfaceRepository = $surfaceRepository;
        $this->lineRepository = $lineRepository;
        $this->context = $context;
    }

    /**
     * Uloží data transliterace z importu
     *
     * @param $data
     * @return bool
     */
    public function saveImportedData($data)
    {
        // Škaredý zanoření hodnot z dat v importu :( Tohle bude pro db náročný
        foreach ($data as $book => $chapters)
        {
            try
            {
                $bookId = $this->getBookIdByName($book);
                if (!$bookId)
                {
                    $bookId = $this->bookRepository->insert([BookRepository::COLUMN_BOOK_ABREV => $book])->getPrimary();
                }
            }
            catch (\Exception $exception)
            {
                \Tracy\Debugger::log('Nepodařila se uložit nová kniha. Chyba: ' . $exception->getMessage(), 'transport-facade');
                return FALSE;
            }
            foreach ($chapters as $chapter => $surfaces)
            {
                try
                {
                    $transliterationId = $this->getTransliterationIdCurrentBookChapter($bookId, trim(explode(" ", $chapter)[0]));
                    if (!$transliterationId)
                    {
                        $chapterReg = explode(" ", $chapter);
                        if (isset($chapterReg[1]))
                        {
                            $chapterReg[1] = str_replace(array('(', ')'), '', $chapterReg[1]);
                            $this->transliterationRepository->insert([
                                TransliterationRepository::COLUMN_BOOK_ID => $bookId,
                                TransliterationRepository::COLUMN_CHAPTER => $chapterReg[0],
                                TransliterationRepository::COLUMN_REG_NO => $chapterReg[1]
                            ]);
                            $transliterationId = $this->context->getInsertId(TransliterationRepository::COLUMN_ID);
                        } else
                        {
                            $this->transliterationRepository->insert([
                                TransliterationRepository::COLUMN_BOOK_ID => $bookId,
                                TransliterationRepository::COLUMN_CHAPTER => $chapterReg[0]
                            ]);
                            $transliterationId = $this->context->getInsertId(TransliterationRepository::COLUMN_ID);
                        }
                    }
                }
                catch (\Exception $exception)
                {
                    \Tracy\Debugger::log('Nepodařila se uložit nová transliterace. Chyba: ' . $exception->getMessage(), 'transport-facade');
                    return FALSE;
                }
                foreach ($surfaces as $surface => $values)
                {
                    try
                    {
                        $surfaceId = $this->getSurfaceIdByCurrentTransSurfType($transliterationId, $surface);
                        if (!$surfaceId)
                        {
                            $surfaceId = $this->surfaceRepository->insert([
                                SurfaceRepository::COLUMN_TRANSLITERATION_ID => $transliterationId,
                                SurfaceRepository::COLUMN_SURFACE_TYPE_ID => $surface,
                                SurfaceRepository::COLUMN_OBJECT_TYPE_ID => 1
                            ])->getPrimary();
                        }
                    }
                    catch (\Exception $exception)
                    {
                        \Tracy\Debugger::log('Nepodařil se uložit nový surface. Chyba: ' . $exception->getMessage(), 'transport-facade');
                        return FALSE;
                    }

                    foreach ($values as $line)
                    {
                        try
                        {
                            $lineId = $this->getLineIdByCurrentSurfLineNum($surfaceId, (explode(' ', $line)[0]));
                            if (!$lineId)
                            {
                                $this->lineRepository->insert([
                                    LineRepository::COLUMN_SURFACE_ID => $surfaceId,
                                    LineRepository::COLUMN_LINE_NUMBER => (explode(' ', $line)[0]),
                                    LineRepository::COLUMN_TRANSLITERATION => substr(strchr($line, " "), 1),
                                ])->{LineRepository::COLUMN_ID};
                            } else
                            {
                                $this->lineRepository->fetchById($lineId)->update([
                                    LineRepository::COLUMN_TRANSLITERATION => substr(strchr($line, " "), 1)
                                ]);
                            }
                        }
                        catch (\Exception $exception)
                        {
                            \Tracy\Debugger::log('Nepodařil se uložit nová řádka (line) transliterace. Chyba: ' . $exception->getMessage(), 'transport-facade');
                            return FALSE;
                        }
                    }
                }
            }
        }
        return TRUE;
    }

    /**
     * Vrací id knihy podle jména zkratky
     * @param $bookName
     * @return bool|mixed|ActiveRow
     */
    public function getBookIdByName(string $bookName)
    {
        $book = $this->bookRepository->getBookByBookAbbrev($bookName)->fetch();
        if (!empty($book))
        {
            return $book->getPrimary();
        } else
        {
            return false;
        }
    }

    private function getTransliterationIdCurrentBookChapter(int $bookId, string $chapterName)
    {
        $transliteration = $this->transliterationRepository->getTransliterationByChapterNameAndBookId($bookId, $chapterName)->fetch();
        if (!empty($transliteration))
        {
            return $transliteration->getPrimary();
        } else
        {
            return false;
        }
    }

    private function getSurfaceIdByCurrentTransSurfType(int $transliterationId, int $surfaceId)
    {
        $surface = $this->surfaceRepository->getSurfaceByTransliterationIdAndSurfaceTypeId($transliterationId, $surfaceId)->fetch();

        if (!empty($surface))
        {
            return $surface->getPrimary();
        } else
        {
            return false;
        }
    }

    private function getLineIdByCurrentSurfLineNum(int $surfaceId, $lineNum)
    {
        $line = $this->lineRepository->getLineBySurfaceIdAndLineNumber($surfaceId, $lineNum)->fetch();
        if (!empty($line))
        {
            return $line->{LineRepository::COLUMN_ID};
        } else
        {
            return false;
        }
    }
}