JsonToDocumentMapper::getMetadataFromJson() - Code Metrics - Inspection of "Ap5 ap6 ap1 internal format" - kitodo/kitodo-publication - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#195)

unknown
created 2020-12-15 14:36 UTC
JsonToDocumentMapper::getMetadataFromJson() F

↳ Parent: JsonToDocumentMapper
Complexity

Conditions	17
Paths	492
Size

Total Lines	97
Code Lines	55
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
cc	17
eloc	55
c	1
b	0
f	0
nc	492
nop	2
dl	0
loc	97
rs	1.7555
How to fix Long Method Complexity

<?php
namespace EWW\Dpf\Services\Api;

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

use EWW\Dpf\Domain\Model\Document;
use EWW\Dpf\Services\ProcessNumber\ProcessNumberGenerator;
use JsonPath\JsonObject;
filter:
    dependency_paths: ["lib/*"]

class JsonToDocumentMapper
{
    /**
     * objectManager
     *
     * @var \TYPO3\CMS\Extbase\Object\ObjectManagerInterface
     * @inject
     */
    protected $objectManager;

    /**
     * documentTypeRepository
     *
     * @var \EWW\Dpf\Domain\Repository\DocumentTypeRepository
     * @inject
     */
    protected $documentTypeRepository = null;

    /**
     * documentRepository
     *
     * @var \EWW\Dpf\Domain\Repository\DocumentRepository
     * @inject
     */
    protected $documentRepository = null;

    /**
     * Replaces the data from the document with the data from the json
     * @param Document $document
     * @param $jsonData
     * @return Document
     */
    public function editDocument(Document $document, $jsonData) {

        $metaData = $this->getMetadataFromJson($jsonData, $document->getDocumentType());
        $xmlData = $document->getXmlData();

        $domDocument = new \DOMDocument();
        $domDocument->loadXML($xmlData);

        $xpath = \EWW\Dpf\Helper\XPath::create($domDocument);

        foreach ($metaData as $groupKey => $group) {
            $groupMapping = $group['mapping'];
            if ($group['values']) {
                foreach ($group['values'] as $fieldKey => $field) {
                    $nodes = $xpath->query($groupMapping .'/'. $field['mapping']);
                    $nodes->item(0)->nodeValue = $field['value'];
                }
            }
        }

        $xmlData = $domDocument->saveXML();
        $document->setXmlData($xmlData);

        return $document;
    }

    /**
     * Creates a document from the given json data
     *
     * @param string $jsonData
     * @return Document $document
     */
    public function getDocument($jsonData)
    {
        $jsonObject = new JsonObject($jsonData);
        $publicationType = $jsonObject->get('$.publicationType');

        if ($publicationType && is_array($publicationType)) {
            $publicationType = $publicationType[0];
        }

        $documentType = $this->documentTypeRepository->findOneByName($publicationType);
        $documentType = $this->documentTypeRepository->findOneByName($publicationType);
        if (!$documentType) {
            return null;
        }

        /** @var Document $document */
        $document = $this->objectManager->get(Document::class);

        $document->setDocumentType($documentType);

        $processNumberGenerator = $this->objectManager->get(ProcessNumberGenerator::class);
        $processNumber = $processNumberGenerator->getProcessNumber();
        $document->setProcessNumber($processNumber);

        $metaData = $this->getMetadataFromJson($jsonData);

        $exporter = new \EWW\Dpf\Services\ParserGenerator();

        $documentData['documentUid'] = 0;

        $documentData['metadata']    = $metaData;
        $documentData['files']       = array();

        $exporter->buildXmlFromForm($documentData);

        $internalXml = $exporter->getXMLData();
        $document->setXmlData($internalXml);

        $internalFormat = new \EWW\Dpf\Helper\InternalFormat($internalXml);

        $document->setTitle($internalFormat->getTitle());
        $document->setAuthors($internalFormat->getAuthors());
        $document->setDateIssued($internalFormat->getDateIssued());
        //$document->setEmbargoDate($formMetaData['embargo']);

        $internalFormat->setDocumentType($documentType->getName());
        $internalFormat->setDocumentType($documentType->/** @scrutinizer ignore-call */ getName());
        $internalFormat->setProcessNumber($document->getProcessNumber());

        $document->setXmlData($internalFormat->getXml());

        $document->setState(\EWW\Dpf\Domain\Workflow\DocumentWorkflow::STATE_REGISTERED_NONE);

        return $document;
    }


    public function getMetadataFromJson($jsonData, $documentType = null)
    {
        $jsonObject = new JsonObject($jsonData);

        if ($documentType) {
            $publicationType = $documentType;

        } else {
            $publicationType = $jsonObject->get('$.publicationType');
            if ($publicationType && is_array($publicationType)) {
                $publicationType = $publicationType[0];
            }

            /** @var \EWW\Dpf\Domain\Model\DocumentType $documentType */
            $documentType = $this->documentTypeRepository->findOneByName($publicationType);
        }

        $resultData = [];

        if (empty($documentType)) {
            // default type
            $documentType = $this->documentTypeRepository->findOneByName('article');
        }

        foreach ($documentType->getMetadataPage() as $metadataPage) {

            foreach ($metadataPage->getMetadataGroup() as $metadataGroup) {

                // Group mapping
                $jsonDataObject = new JsonObject($jsonData);
                $jsonGroupMapping = $metadataGroup->getJsonMapping();
                $groupItems = [];
                if ($jsonGroupMapping) {
                    $groupItems = $jsonDataObject->get($jsonGroupMapping);
                }

                foreach ($groupItems as $groupItem) {

                    $resultGroup = [
                        'attributes' => [],
                        'values' => []
                    ];
                    $resultGroup['mapping'] = $metadataGroup->getRelativeMapping();
                    $resultGroup['modsExtensionMapping'] = $metadataGroup->getRelativeModsExtensionMapping();
                    $resultGroup['modsExtensionReference'] = trim($metadataGroup->getModsExtensionReference(), " /");
                    $resultGroup['groupUid'] = $metadataGroup->getUid();

                    foreach ($metadataGroup->getMetadataObject() as $metadataObject) {

                        $json = json_encode($groupItem);

                        $jsonObject = new JsonObject($json);
                        $fieldItems = [];
                        $jsonFieldMapping = $metadataObject->getJsonMapping();

                        if ($jsonFieldMapping) {
                            $fieldItems = $jsonObject->get($jsonFieldMapping);
                        }

                        foreach ($fieldItems as $fieldItem) {
                            $resultField = [];

                            if (!is_array($fieldItem)) {
                                $value = $fieldItem;
                            } else {
                                $value = implode("; ", $fieldItem);
                            }

                            if ($metadataObject->getDataType() == \EWW\Dpf\Domain\Model\MetadataObject::INPUT_DATA_TYPE_DATE) {
                                $date = date_create_from_format('d.m.Y', trim($value));
                                if ($date) {
                                    $value = date_format($date, 'Y-m-d');
                                }
                            }

                            if ($value) {
                                $value = str_replace('"', "'", $value);
                                $fieldMapping = $metadataObject->getRelativeMapping();
                                $resultField['modsExtension'] = $metadataObject->getModsExtension();
                                $resultField['mapping'] = $fieldMapping;
                                $resultField['value']   = $value;

                                if (strpos($fieldMapping, "@") === 0) {
                                    $resultGroup['attributes'][] = $resultField;
                                } else {
                                    $resultGroup['values'][] = $resultField;
                                }
                            }
                        }
                    }

                    $resultData[] = $resultGroup;;
                }

            }
        }

        return $resultData;
    }

}

kitodo / kitodo-publication

Pull Request — master (#195)

JsonToDocumentMapper::getMetadataFromJson() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like
