DocumentMapper::updateFiles() - Code Metrics - Inspection of "Configurable form file groups and upload fields" - kitodo/kitodo-publication - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( f02d33...dc5694 )

by Ralf
created 2021-06-21 12:44 UTC
DocumentMapper::updateFiles() B

↳ Parent: DocumentMapper
Complexity

Conditions	8
Paths	12
Size

Total Lines	35
Code Lines	19
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
eloc	19
c	0
b	0
f	0
dl	0
loc	35
rs	8.4444
cc	8
nc	12
nop	2
<?php
namespace EWW\Dpf\Helper;

/*
 * 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\MetadataGroup;
use EWW\Dpf\Domain\Model\DocumentForm;
use EWW\Dpf\Domain\Model\File;
use EWW\Dpf\Services\Identifier\Urn;
use EWW\Dpf\Domain\Model\Document;
use EWW\Dpf\Domain\Workflow\DocumentWorkflow;
use EWW\Dpf\Services\ProcessNumber\ProcessNumberGenerator;

class DocumentMapper
{

    /**
     * objectManager
     *
     * @var \TYPO3\CMS\Extbase\Object\ObjectManagerInterface
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $objectManager;

    /**
     *
     * @var \TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $configurationManager;

    /**
     * metadataGroupRepository
     *
     * @var \EWW\Dpf\Domain\Repository\MetadataGroupRepository
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $metadataGroupRepository = null;

    /**
     * metadataObjectRepository
     *
     * @var \EWW\Dpf\Domain\Repository\MetadataObjectRepository
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $metadataObjectRepository = null;

    /**
     * documentTypeRepository
     *
     * @var \EWW\Dpf\Domain\Repository\DocumentTypeRepository
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $documentTypeRepository = null;

    /**
     * documentRepository
     *
     * @var \EWW\Dpf\Domain\Repository\DocumentRepository
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $documentRepository = null;

    /**
     * fileRepository
     *
     * @var \EWW\Dpf\Domain\Repository\FileRepository
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $fileRepository = null;

    /**
     * depositLicenseRepository
     *
     * @var \EWW\Dpf\Domain\Repository\DepositLicenseRepository
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $depositLicenseRepository = null;

    /**
     * clientPid
     *
     * @var int
     */
    protected $clientPid = 0;

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

    /**
     * clientConfigurationManager
     *
     * @var \EWW\Dpf\Configuration\ClientConfigurationManager
     * @TYPO3\CMS\Extbase\Annotation\Inject
     */
    protected $clientConfigurationManager;

    /**
     * Get typoscript settings
     *
     * @return mixed
     */
    public function getSettings()
    {
        $frameworkConfiguration = $this->configurationManager->getConfiguration(
            \TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK
        );
        return $frameworkConfiguration['settings'];
    }

    /**
     * Gets the document form representation of the document data
     *
     * @param \EWW\Dpf\Domain\Model\Document $document
     * @param bool $generateEmptyFields
     * @return \EWW\Dpf\Domain\Model\DocumentForm
     */
    public function getDocumentForm(Document $document, $generateEmptyFields = true)
    public function getDocumentForm(Document $document, /** @scrutinizer ignore-unused */ $generateEmptyFields = true)
    {
        $documentForm = new \EWW\Dpf\Domain\Model\DocumentForm();
        $documentForm->generateCsrfToken();
        $documentForm->setUid($document->getDocumentType()->getUid());
        $documentForm->setDisplayName($document->getDocumentType()->getDisplayName());
        $documentForm->setName($document->getDocumentType()->getName());
        $documentForm->setDocumentUid($document->getUid());

        $documentForm->setPrimaryFileMandatory(
            (
                (
                    $this->getSettings()['deactivatePrimaryFileMandatoryCheck'] ||
                    $document->getDocumentType()->getVirtualType()
                )? false : true
            )
        );

        $documentForm->setProcessNumber($document->getProcessNumber());
        $documentForm->setTemporary($document->isTemporary());

        $fedoraPid = $document->getObjectIdentifier();

        if (empty($fedoraPid)) {
            $fedoraPid = $document->getReservedObjectIdentifier();
        }

        $documentForm->setFedoraPid($fedoraPid);

        $internalFormat = new \EWW\Dpf\Helper\InternalFormat($document->getXmlData(), $this->clientPid);

        $excludeGroupAttributes = array();

        foreach ($document->getDocumentType()->getMetadataPage() as $metadataPage) {
            $documentFormPage = new \EWW\Dpf\Domain\Model\DocumentFormPage();
            $documentFormPage->setUid($metadataPage->getUid());
            $documentFormPage->setDisplayName($metadataPage->getDisplayName());
            $documentFormPage->setName($metadataPage->getName());

            $documentFormPage->setAccessRestrictionRoles($metadataPage->getAccessRestrictionRoles());

            foreach ($metadataPage->getMetadataGroup() as $metadataGroup) {
                /** @var MetadataGroup $metadataGroup */

                $documentFormGroup = new \EWW\Dpf\Domain\Model\DocumentFormGroup();
                $documentFormGroup->setUid($metadataGroup->getUid());
                $documentFormGroup->setDisplayName($metadataGroup->getDisplayName());
                $documentFormGroup->setName($metadataGroup->getName());
                $documentFormGroup->setMandatory($metadataGroup->getMandatory());

                $documentFormGroup->setAccessRestrictionRoles($metadataGroup->getAccessRestrictionRoles());

                $documentFormGroup->setInfoText($metadataGroup->getInfoText());
                $documentFormGroup->setGroupType($metadataGroup->getGroupType());
                $documentFormGroup->setMaxIteration($metadataGroup->getMaxIteration());

                $documentFormGroup->setOptionalGroups($metadataGroup->getOptionalGroups());
                $documentFormGroup->setRequiredGroups($metadataGroup->getRequiredGroups());

                $xpath = $internalFormat->getXpath();

                // get fixed attributes from xpath configuration
                $fixedGroupAttributes = array();

                preg_match_all('/[A-Za-z0-9:@\.]+(\[@.*?\])*/', $metadataGroup->getAbsoluteMapping(), $groupMappingPathParts);
                $groupMappingPathParts = $groupMappingPathParts[0];

                $groupMappingPath = end($groupMappingPathParts);
                $groupMappingName = preg_replace('/\[@.+?\]/', '', $groupMappingPath);

                if (preg_match_all('/\[@.+?\]/', $groupMappingPath, $matches)) {
                    $fixedGroupAttributes = $matches[0];
                }

                // build mapping path, previous fixed attributes which are differ from
                // the own fixed attributes are excluded
                $queryGroupMapping = $metadataGroup->getAbsoluteMapping();
                if (strpos($queryGroupMapping, "@displayLabel") === false && is_array($excludeGroupAttributes[$groupMappingName])) {
                    foreach ($excludeGroupAttributes[$groupMappingName] as $excludeAttr => $excludeAttrValue) {
                        if (!in_array($excludeAttr, $fixedGroupAttributes)) {
                            $queryGroupMapping .= $excludeAttrValue;
                        }
                    }
                }

                // Read the group data.
                if ($metadataGroup->hasMappingForReading()) {
                    $groupData = $xpath->query($metadataGroup->getAbsoluteMappingForReading());
                } else {
                    $groupData = $xpath->query($queryGroupMapping);
                }

                // Fixed attributes from groups must be excluded in following xpath queries
                foreach ($fixedGroupAttributes as $excludeGroupAttribute) {
                    $excludeGroupAttributes[$groupMappingName][$excludeGroupAttribute] = "[not(" . trim($excludeGroupAttribute, "[] ") . ")]";
                }

                if ($groupData->length > 0) {
                    foreach ($groupData as $key => $data) {

                        $documentFormGroupItem = clone ($documentFormGroup);

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

                            $documentFormField = new \EWW\Dpf\Domain\Model\DocumentFormField();
                            $documentFormField->setUid($metadataObject->getUid());
                            $documentFormField->setDisplayName($metadataObject->getDisplayName());
                            $documentFormField->setName($metadataObject->getName());
                            $documentFormField->setMandatory($metadataObject->getMandatory());

                            $documentFormField->setAccessRestrictionRoles($metadataObject->getAccessRestrictionRoles());

                            $documentFormField->setConsent($metadataObject->getConsent());
                            $documentFormField->setValidation($metadataObject->getValidation());
                            $documentFormField->setDataType($metadataObject->getDataType());
                            $documentFormField->setMaxIteration($metadataObject->getMaxIteration());
                            $documentFormField->setInputField($metadataObject->getInputField());
                            $documentFormField->setInputOptions($metadataObject->getInputOptionList());
                            $documentFormField->setFillOutService($metadataObject->getFillOutService());
                            $documentFormField->setGndFieldUid($metadataObject->getGndFieldUid());
                            $documentFormField->setMaxInputLength($metadataObject->getMaxInputLength());
                            $documentFormField->setObjectType($metadataObject->getObjectType());

                            $depositLicense = $this->depositLicenseRepository->findByUid($metadataObject->getDepositLicense());
                            $documentFormField->setDepositLicense($depositLicense);

                            $documentFormField->setHelpText($metadataObject->getHelpText());

                            $objectMapping = "";


                            preg_match_all('/([A-Za-z0-9]+:[A-Za-z0-9]+(\[.*\])*|[A-Za-z0-9:@\.]+)/', $metadataObject->getRelativeMapping(), $objectMappingPath);
                            $objectMappingPath = $objectMappingPath[0];

                            foreach ($objectMappingPath as $key => $value) {


                                // ensure that e.g. <mods:detail> and <mods:detail type="volume">
                                // are not recognized as the same node
                                if ((strpos($value, "@") === false) && ($value != '.')) {
                                    $objectMappingPath[$key] .= "[not(@*)]";
                                }
                            }

                            $objectMapping = implode("/", $objectMappingPath);

                            if ($objectMapping == '[not(@*)]' || empty($objectMappingPath)) {
                                $objectMapping = '.';
                            }

                            if ($metadataObject->isModsExtension()) {

                                $referenceAttribute        = $metadataGroup->getModsExtensionReference();
                                $modsExtensionGroupMapping = $metadataGroup->getAbsoluteModsExtensionMapping();

                                $refID      = $data->getAttribute("ID");
                                // filter hashes from referenceAttribute value for backwards compatibility reasons
                                $objectData = $xpath->query($modsExtensionGroupMapping . "[translate(@" . $referenceAttribute . ",'#','')=" . '"' . $refID . '"]/' . $objectMapping);
                            } else {
                                $objectData = $xpath->query($objectMapping, $data);
                            }

                            $documentFormField->setValue("", $metadataObject->getDefaultValue());

                            if ($objectData->length > 0) {

                                foreach ($objectData as $key => $value) {

                                    $documentFormFieldItem = clone ($documentFormField);

                                    $objectValue = $value->nodeValue;

                                    if ($metadataObject->getDataType() == \EWW\Dpf\Domain\Model\MetadataObject::INPUT_DATA_TYPE_DATE) {
                                        $dateStr = explode('T', $objectValue);
                                        $date    = date_create_from_format('Y-m-d', trim($dateStr[0]));
                                        if ($date) {
                                            $objectValue = date_format($date, 'd.m.Y');
                                        }
                                    }

                                    $objectValue = str_replace('"', "'", $objectValue);

                                    $documentFormFieldItem->setValue($objectValue, $metadataObject->getDefaultValue());

                                    if ($metadataGroup->isFileGroup() && $metadataObject->isUploadField()) {

                                        $fileIdentifier = '';
                                        $fileIdXpath = $this->clientConfigurationManager->getFileIdXpath();
                                        $fileIdentifierNode = $xpath->query($fileIdXpath, $data);
                                        if ($fileIdentifierNode->length > 0) {
                                            $fileIdentifier = $fileIdentifierNode->item(0)->nodeValue;
                                        }

                                        if ($fileIdentifier) {
                                            $file = $document->getFileByFileIdentifier($fileIdentifier);
                                            if ($file) {
                                                $documentFormFieldItem->setFile($file);
                                                $documentForm->addFile($file);
                                            }
                                        }
                                    }

                                    $documentFormGroupItem->addItem($documentFormFieldItem);
                                }
                            } else {
                                $documentFormGroupItem->addItem($documentFormField);
                            }

                        }

                        $documentFormPage->addItem($documentFormGroupItem);
                    }
                } else {

                    $documentFormGroup->setEmptyGroup(true);

                    foreach ($metadataGroup->getMetadataObject() as $metadataObject) {
                        $documentFormField = new \EWW\Dpf\Domain\Model\DocumentFormField();
                        $documentFormField->setUid($metadataObject->getUid());
                        $documentFormField->setDisplayName($metadataObject->getDisplayName());
                        $documentFormField->setName($metadataObject->getName());
                        $documentFormField->setMandatory($metadataObject->getMandatory());

                        $documentFormField->setAccessRestrictionRoles($metadataObject->getAccessRestrictionRoles());

                        $documentFormField->setConsent($metadataObject->getConsent());
                        $documentFormField->setValidation($metadataObject->getValidation());
                        $documentFormField->setDataType($metadataObject->getDataType());
                        $documentFormField->setMaxIteration($metadataObject->getMaxIteration());
                        $documentFormField->setInputField($metadataObject->getInputField());
                        $documentFormField->setInputOptions($metadataObject->getInputOptionList());
                        $documentFormField->setFillOutService($metadataObject->getFillOutService());
                        $documentFormField->setGndFieldUid($metadataObject->getGndFieldUid());
                        $documentFormField->setMaxInputLength($metadataObject->getMaxInputLength());
                        $documentFormField->setValue("", $metadataObject->getDefaultValue());
                        $documentFormField->setObjectType($metadataObject->getObjectType());

                        $depositLicense = $this->depositLicenseRepository->findByUid($metadataObject->getDepositLicense());
                        $documentFormField->setDepositLicense($depositLicense);

                        $documentFormField->setHelpText($metadataObject->getHelpText());

                        $documentFormGroup->addItem($documentFormField);
                    }

                    $documentFormPage->addItem($documentFormGroup);
                }
            }

            $documentForm->addItem($documentFormPage);
        }

        return $documentForm;
    }

    public function getDocument($documentForm)
    {
        /** @var Document $document */

        if ($documentForm->getDocumentUid()) {
            if ($this->isCustomClientPid()) {
                $this->documentRepository->crossClient(true);
            }
            $document = $this->documentRepository->findByUid($documentForm->getDocumentUid());
            $tempInternalFormat = new \EWW\Dpf\Helper\InternalFormat($document->getXmlData(), $this->clientPid);
            $fobIdentifiers = $tempInternalFormat->getPersonFisIdentifiers();
        } else {
            $document = $this->objectManager->get(Document::class);
            $fobIdentifiers = [];
        }

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

        $documentType = $this->documentTypeRepository->findByUid($documentForm->getUid());

        $document->setDocumentType($documentType);

        $document->setReservedObjectIdentifier($documentForm->getFedoraPid());

        $document->setValid($documentForm->getValid());

        if ($documentForm->getComment()) {
            $document->setComment($documentForm->getComment());
        }

        $formMetaData = $this->getMetadata($documentForm);

        $exporter = new \EWW\Dpf\Services\ParserGenerator($this->clientPid);

        $documentData['documentUid'] = $documentForm->getDocumentUid();

        $documentData['metadata']    = $formMetaData['mods'];

        $exporter->buildXmlFromForm($documentData);

        $internalXml = $exporter->getXmlData();
        $internalFormat = new \EWW\Dpf\Helper\InternalFormat($internalXml, $this->clientPid);

        // set static xml
        $internalFormat->setDocumentType($documentType->getName());
        $internalFormat->setProcessNumber($processNumber);

        $document = $this->updateFiles($document, $documentForm->getFiles());
        $document->setXmlData($internalFormat->getXml());

        $document->setNewlyAssignedFobIdentifiers(array_diff($internalFormat->getPersonFisIdentifiers(), $fobIdentifiers));

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

        return $document;
    }

    /**
     * @param DocumentForm $documentForm
     * @return array
     * @throws \Exception
     */
    public function getMetadata(DocumentForm $documentForm)
    {
        foreach ($documentForm->getItems() as $page) {

            foreach ($page[0]->getItems() as $group) {

                foreach ($group as $groupItem) {

                    $item = array();

                    $uid           = $groupItem->getUid();
                    $metadataGroup = $this->metadataGroupRepository->findByUid($uid);

                    $item['mapping'] = $metadataGroup->getRelativeMapping();

                    $item['modsExtensionMapping'] = $metadataGroup->getRelativeModsExtensionMapping();

                    $item['modsExtensionReference'] = trim($metadataGroup->getModsExtensionReference(), " /");

                    $item['groupUid'] = $uid;

                    $item['groupType'] = $metadataGroup->getGroupType();

                    $fieldValueCount   = 0;
                    $defaultValueCount = 0;
                    $fieldCount        = 0;
                    foreach ($groupItem->getItems() as $field) {
                        foreach ($field as $fieldItem) {
                            $fieldUid       = $fieldItem->getUid();
                            $metadataObject = $this->metadataObjectRepository->findByUid($fieldUid);

                            $fieldMapping = $metadataObject->getRelativeMapping();

                            $formField = array();

                            $value = $fieldItem->getValue();

                            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 ($metadataObject->getEmbargo()) {
                                $form['embargo'] = new \DateTime($value);
                            }

                            $fieldCount++;
                            if (!empty($value)) {
                                $fieldValueCount++;
                                $defaultValue = $fieldItem->getHasDefaultValue();

                                if ($fieldItem->getHasDefaultValue()) {
                                    $defaultValueCount++;
                                }
                            }

                            $file = $fieldItem->getFile();
                            $value = str_replace('"', "'", $value);
                            if ($value || $file) {
                                $formField['modsExtension'] = $metadataObject->getModsExtension();

                                $formField['mapping'] = $fieldMapping;
                                $formField['value']   = $value;

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

                                $fileIdXpath = $this->clientConfigurationManager->getFileIdXpath();
                                if ($file) {
                                    $item['values'][] = [
                                        'mapping' => $fileIdXpath,
                                        'value'   => $file->getFileIdentifier()
                                    ];
                                }
                            }
                        }
                    }

                    if (!key_exists('attributes', $item)) {
                        $item['attributes'] = array();
                    }

                    if (!key_exists('values', $item)) {
                        $item['values'] = array();
                    }

                    if ($groupItem->getMandatory() || $defaultValueCount < $fieldValueCount || $defaultValueCount == $fieldCount) {
                        $form['mods'][] = $item;
                    }

                }

            }
        }

        return $form;


    }

    /**
     * @return int
     */
    public function getClientPid(): int
    {
        return $this->clientPid;
    }

    /**
     * @param int $clientPid
     */
    public function setClientPid(int $clientPid): void
    {
        $this->customClientPid = true;
        $this->clientPid = $clientPid;
    }

    /**
     * @return bool
     */
    public function isCustomClientPid(): bool
    {
        return $this->customClientPid;
    }

    /**
     * Adds and delete file model objects attached to the document.
     *
     * @param Document $document
     * @param array $files
     * @return Document
     * @throws \TYPO3\CMS\Extbase\Persistence\Exception\IllegalObjectTypeException
     * @throws \TYPO3\CMS\Extbase\Persistence\Exception\UnknownObjectException
     */
    protected function updateFiles(Document $document, $files)
    {
        $filesToBeDeleted = [];
        foreach ($document->getFile() as $docFile) {
            $filesToBeDeleted[$docFile->getFileIdentifier()] = $docFile;
        }
        // Add or update files
        /** @var File $file */
        if (is_array($files)) {

            foreach ($files as $file) {
                if ($file->getUid()) {
                    $this->fileRepository->update($file);
                } else {
                    $this->fileRepository->add($file);
                    $document->addFile($file);
                }

                if (array_key_exists($file->getFileIdentifier(), $filesToBeDeleted)) {
                    unset($filesToBeDeleted[$file->getFileIdentifier()]);
                }
            }
        }

        // Delete files
        /** @var File $deleteFile */
        foreach ($filesToBeDeleted as $fileToBeDeleted) {
            if (trim($fileToBeDeleted->getDatastreamIdentifier())) {
                $fileToBeDeleted->setStatus(File::STATUS_DELETED);
                $this->fileRepository->update($fileToBeDeleted);
            } else {
                $document->removeFile($fileToBeDeleted);
            }
        }

        return $document;
    }

}

kitodo / kitodo-publication

Push — master ( f02d33...dc5694 )

DocumentMapper::updateFiles() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
