Riesenia\Pohoda

Complexity

Total Complexity

27

Size/Duplication

Total Lines	244
Duplicated Lines	0 %

Test Coverage

Coverage

97.3%

Importance

Changes	7
Bugs	0	Features	1

11 Methods

Rating	Name	Duplication	Size	Complexity
A	next()	0	12	5
A	__construct()	0	14	3
A	addItem()	0	11	2
A	setApplicationName()	0	3	1
A	getTransformerListing()	0	3	1
A	__call()	0	17	4
A	detectXmlFileHeader()	0	3	1
A	load()	0	23	4
A	close()	0	5	1
A	create()	0	8	1
A	open()	0	33	4

<?php

declare(strict_types=1);

namespace kalanis;

use Psr\Container\ContainerInterface;
use kalanis\Pohoda\AbstractAgenda;
use kalanis\Pohoda\Common\OneDirectionalVariablesTrait;

/**
 * Factory for Pohoda objects.
 *
 * @method Pohoda\AddressBook   createAddressBook(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Bank          createBank(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\CashSlip      createCashSlip(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Category      createCategory(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Contract      createContract(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\IntDoc        createIntDoc(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\IntParam      createIntParam(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Invoice       createInvoice(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\IssueSlip     createIssueSlip(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\ListRequest   createListRequest(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\ListResponse  createListResponse(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Offer         createOffer(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Order         createOrder(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\PrintRequest  createPrintRequest(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Receipt       createReceipt(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Stock         createStock(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\StockTransfer createStockTransfer(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Storage       createStorage(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Supplier      createSupplier(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\UserList      createUserList(Pohoda\Common\Dtos\AbstractDto $data)
 * @method Pohoda\Voucher       createVoucher(Pohoda\Common\Dtos\AbstractDto $data)
 * @method \bool loadAddressBook(string $filename)
 * @method \bool loadBank(string $filename)
 * @method \bool loadCashSlip(string $filename)
 * @method \bool loadCategory(string $filename)
 * @method \bool loadContract(string $filename)
 * @method \bool loadIntDoc(string $filename)
 * @method \bool loadIntParam(string $filename)
 * @method \bool loadInvoice(string $filename)
 * @method \bool loadIssueSlip(string $filename)
 * @method \bool loadListRequest(string $filename)
 * @method \bool loadListResponse(string $filename)
 * @method \bool loadOffer(string $filename)
 * @method \bool loadOrder(string $filename)
 * @method \bool loadPrintRequest(string $filename)
 * @method \bool loadReceipt(string $filename)
 * @method \bool loadStock(string $filename)
 * @method \bool loadStockTransfer(string $filename)
 * @method \bool loadStorage(string $filename)
 * @method \bool loadSupplier(string $filename)
 * @method \bool loadUserList(string $filename)
 * @method \bool loadVoucher(string $filename)
 *
 * @link https://www.stormware.cz/pohoda/xml/seznamschemat/   schemas
 */
class Pohoda
{
    use OneDirectionalVariablesTrait;

    protected string $application = 'Pohoda connector';

    protected bool $isInMemory;

    protected \XMLWriter $xmlWriter;

    protected \XMLReader $xmlReader;

    protected Pohoda\DI\DependenciesFactory $dependenciesFactory;

    protected string $elementName;

    protected bool $importRecursive = false;

    protected readonly Pohoda\Common\CompanyRegistrationNumberInterface $companyRegistrationNumber;

    public function __construct(
        string|Pohoda\Common\CompanyRegistrationNumberInterface $companyRegistrationNumber,
        ?Pohoda\DI\DependenciesFactory $dependenciesFactory = null,
        ?Pohoda\ValueTransformer\SanitizeEncoding $sanitizeEncoding = new Pohoda\ValueTransformer\SanitizeEncoding(new Pohoda\ValueTransformer\Listing()),
        ?Pohoda\Common\NamespacesPaths $namespacesPaths = new Pohoda\Common\NamespacesPaths(),
        ?Pohoda\Common\OptionsResolver\Normalizers\NormalizerFactory $normalizerFactory = new Pohoda\Common\OptionsResolver\Normalizers\NormalizerFactory(),
        ?ContainerInterface $container = null,
    ) {
        $this->companyRegistrationNumber = is_object($companyRegistrationNumber)

The property companyRegistrationNumber is declared read-only in kalanis\Pohoda.

            ? $companyRegistrationNumber
            : Pohoda\Common\CompanyRegistrationNumber::init($companyRegistrationNumber);
        $this->dependenciesFactory = is_object($dependenciesFactory)
            ? $dependenciesFactory
            : new Pohoda\DI\DependenciesFactory($namespacesPaths, $sanitizeEncoding, $normalizerFactory, $container);
    }

    /**
     * Set the name of the application.
     *
     * @param string $name
     *
     * @return void
     */
    public function setApplicationName(string $name): void
    {
        $this->application = $name;
    }

    /**
     * Get class listing transformers for content serialization
     *
     * @return Pohoda\ValueTransformer\Listing
     */
    public function getTransformerListing(): Pohoda\ValueTransformer\Listing
    {
        return $this->dependenciesFactory->getSanitizeEncoding()->getListing();
    }

    /**
     * Create and return instance of requested agenda.
     *
     * @param string              $name
     * @param Pohoda\Common\Dtos\AbstractDto $data
     *
     * @return AbstractAgenda
     */
    public function create(string $name, Pohoda\Common\Dtos\AbstractDto $data = new Pohoda\Common\Dtos\EmptyDto()): AbstractAgenda
    {
        return $this->dependenciesFactory
            ->getAgendaFactory()
            ->getAgenda($name)
            ->setDirectionalVariable($this->useOneDirectionalVariables)
            ->setResolveOptions(true)
            ->setData($data);
    }

    /**
     * Open new XML file for writing.
     *
     * @param string|null $filename path to output file or null for memory
     * @param string      $id
     * @param string      $note
     *
     * @return bool
     */
    public function open(?string $filename, string $id, string $note = ''): bool
    {
        $this->xmlWriter = new \XMLWriter();

        if (is_null($filename)) {
            $this->isInMemory = true;
            $this->xmlWriter->openMemory();
        } else {
            $this->isInMemory = false;

            if (!$this->xmlWriter->openUri($filename)) {
                // @codeCoverageIgnoreStart
                // I cannot test this, because it needs source file somewhere online
                return false;
            }
            // @codeCoverageIgnoreEnd
        }

        $this->xmlWriter->startDocument('1.0', $this->dependenciesFactory->getSanitizeEncoding()->getEncoding());
        $this->xmlWriter->startElementNs('dat', 'dataPack', null);

        $this->xmlWriter->writeAttribute('id', $id);
        $this->xmlWriter->writeAttribute('ico', $this->companyRegistrationNumber->getCompanyNumber());
        $this->xmlWriter->writeAttribute('application', $this->application);
        $this->xmlWriter->writeAttribute('version', '2.0');
        $this->xmlWriter->writeAttribute('note', $note);

        foreach ($this->dependenciesFactory->getNamespacePaths()->allNamespaces() as $k => $v) {
            // put all known namespaces into base element attributes
            $this->xmlWriter->writeAttributeNs('xmlns', $k, null, $v);
        }

        return true;
    }

    /**
     * Add item.
     *
     * @param string $id
     * @param AbstractAgenda $agenda
     *
     * @return void
     */
    public function addItem(string $id, AbstractAgenda $agenda): void
    {
        $this->xmlWriter->startElementNs('dat', 'dataPackItem', null);

        $this->xmlWriter->writeAttribute('id', $id);
        $this->xmlWriter->writeAttribute('version', '2.0');
        $this->xmlWriter->writeRaw((string) $agenda->getXML()->asXML());
        $this->xmlWriter->endElement();

        if (!$this->isInMemory) {
            $this->xmlWriter->flush();
        }
    }

    /**
     * End and close XML file.
     *
     * @return int|string written bytes for file or XML string for memory
     */
    public function close(): int|string
    {
        $this->xmlWriter->endElement();

        return $this->xmlWriter->flush();
    }

    /**
     * Load XML file.
     *
     * @param string $name
     * @param string $filename filename or current xml content
     *
     * @return bool
     */
    public function load(string $name, string $filename): bool
    {
        $this->xmlReader = new \XMLReader();

        if ($this->detectXmlFileHeader($filename)) {
            if (!@$this->xmlReader->XML($filename)) {
                // @codeCoverageIgnoreStart
                // cannot create string which will be parsed as XML and crash itself afterward
                return false;
            }
            // @codeCoverageIgnoreEnd
        } else {
            if (!@$this->xmlReader->open($filename)) {
                return false;
            }
        }

        $class = $this->dependenciesFactory->getAgendaFactory()->getAgenda($name);
        $class->setResolveOptions(false);
        $this->elementName = $class->getImportRoot() ?? throw new \DomainException('Not allowed entity: ' . $name);

Are you sure the usage of $class->getImportRoot() targeting kalanis\Pohoda\AbstractAgenda::getImportRoot() seems to always return null.

        $this->importRecursive = $class->canImportRecursive();

        return true;
    }

    /**
     * Detect if passed file is in fact XML and not just path
     * A bit simple, but it is enough for now
     *
     * @param string $string
     *
     * @return bool
     */
    protected function detectXmlFileHeader(string $string): bool
    {
        return str_contains(substr($string, 0, 64), '<?xml');
    }

    /**
     * Get next item in loaded file.
     *
     * @return \SimpleXMLElement|null
     */
    public function next(): ?\SimpleXMLElement
    {
        while (\XMLReader::ELEMENT != $this->xmlReader->nodeType || $this->xmlReader->name !== $this->elementName) {
            if (!$this->xmlReader->read()) {
                return null;
            }
        }

        $xml = new \SimpleXMLElement($this->xmlReader->readOuterXml());
        $this->importRecursive ? $this->xmlReader->next() : $this->xmlReader->read();

        return $xml;
    }

    /**
     * Handle dynamic method calls.
     *
     * @param string  $method
     * @param mixed[] $arguments
     *
     * @return mixed
     */
    public function __call(string $method, array $arguments)
    {
        // create<Agenda> method
        if (\preg_match('/create([A-Z][a-zA-Z0-9]*)/', $method, $matches)) {
            return \call_user_func([$this, 'create'], $matches[1], $arguments[0] ?? []);
        }

        // load<Agenda> method
        if (\preg_match('/load([A-Z][a-zA-Z0-9]*)/', $method, $matches)) {
            if (!isset($arguments[0])) {
                throw new \DomainException('Filename not set.');
            }

            return \call_user_func([$this, 'load'], $matches[1], $arguments[0]);
        }

        throw new \BadMethodCallException('Unknown method: ' . $method);
    }
}