FormDataReader::uploadError() - 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
FormDataReader::uploadError() B

↳ Parent: FormDataReader
Complexity

Conditions	8
Paths	1
Size

Total Lines	22
Code Lines	11
Duplication

Lines	0
Ratio	0 %
Importance

Changes	2
Bugs	1	Features	0
Metric	Value
eloc	11
dl	0
loc	22
rs	8.4444
c	2
b	1
f	0
cc	8
nc	1
nop	0
<?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\Document;
use EWW\Dpf\Domain\Model\DocumentForm;
use EWW\Dpf\Domain\Model\File;
use EWW\Dpf\Domain\Model\MetadataObject;
use TYPO3\CMS\Core\Core\Environment;

class FormDataReader
{

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

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

    /**
     * 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;

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

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

    /**
     * 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;

    /**
     * formData
     *
     * @var array
     */
    protected $formData;

    /**
     * documentType
     *
     * @var
     */
    protected $documentType;

    /**
     * uploadPath
     *
     * @var
     */
    protected $uploadPath;

    /**
     * basePath
     *
     * @var
     */
    protected $uploadBaseUrl;

    public function __construct()
    {

        $uploadFileUrl = new \EWW\Dpf\Helper\UploadFileUrl;

        $this->uploadBaseUrl = $uploadFileUrl->getUploadUrl() . "/";

        $this->uploadPath = Environment::getPublicPath() . "/" . $uploadFileUrl->getDirectory() . "/";

    }

    /**
     *
     * @param array $formData
     */
    public function setFormData($formData)
    {
        $this->formData     = $formData;
        $this->documentType = $this->documentTypeRepository->findByUid($formData['type']);
    }

    protected function getFields()
    {

        $fields = array();

        if (is_array($this->formData['metadata'])) {
            foreach ($this->formData['metadata'] as $key => $value) {
                $formField = new \EWW\Dpf\Helper\FormField($key, $value);
                $fields[]  = $formField;
            }
        }

        return $fields;
    }

    protected function getDeletedFiles()
    {
        $deletedFiles = array();

        if (is_array($this->formData['deleteFile'])) {
            foreach ($this->formData['deleteFile'] as $key => $value) {

                $file = $this->fileRepository->findByUid($value);

                // Deleting the primary file is not allowed.
                // if (!$file->isPrimaryFile()) {
                //    $deletedFiles[] = $file;
                // }

                $deletedFiles[] = $file;
            }
        }

        return $deletedFiles;
    }

    public function uploadError()
    {
        // todo: To be updated or implemented elsewhere
        return false;

        if (
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
            $this->formData['primaryFile'] &&
            $this->formData['primaryFile']['error'] != UPLOAD_ERR_OK &&
            $this->formData['primaryFile']['error'] != UPLOAD_ERR_NO_FILE
        ) {
            return true;
        }

        if (is_array($this->formData['secondaryFiles'])) {
            foreach ($this->formData['secondaryFiles'] as $tmpFile) {
                if ($tmpFile['error'] != UPLOAD_ERR_OK && $tmpFile['error'] != UPLOAD_ERR_NO_FILE) {
                    return true;
                }
            }
        }

        return false;
    }

    protected function getUploadedFile($tmpFile, $primary = false, \EWW\Dpf\Domain\Model\File $file = null)
    {

        if (empty($file)) {
            $file = $this->objectManager->get(File::class);
        }

        $fileName = uniqid(time(), true);

        \TYPO3\CMS\Core\Utility\GeneralUtility::upload_copy_move($tmpFile['tmp_name'], $this->uploadPath . $fileName);

        $finfo       = finfo_open(FILEINFO_MIME_TYPE);
        $contentType = finfo_file($finfo, $this->uploadPath . $fileName);
        finfo_close($finfo);

        $file->setContentType($contentType);

        $file->setTitle($tmpFile['name']);
        $file->setLink($fileName);
        $file->setPrimaryFile($primary);
        $file->setFileIdentifier(uniqid(time(), true));

        if ($primary) {
            if ($file->getDatastreamIdentifier()) {
                $file->setStatus(\EWW\Dpf\Domain\Model\File::STATUS_CHANGED);
            } else {
                $file->setStatus(\EWW\Dpf\Domain\Model\File::STATUS_ADDED);
            }
        } else {
            $file->setStatus(\EWW\Dpf\Domain\Model\File::STATUS_ADDED);
        }

        return $file;
    }

    public function getDocumentForm()
    {
        $fields = $this->getFields();

        $documentForm = new \EWW\Dpf\Domain\Model\DocumentForm();
        $documentForm->setCsrfToken($this->formData['csrfToken']);
        $documentForm->setUid($this->documentType->getUid());
        $documentForm->setDisplayName($this->documentType->getDisplayName());
        $documentForm->setName($this->documentType->getName());
        $documentForm->setDocumentUid($this->formData['documentUid']);
        $documentForm->setFedoraPid($this->formData['fedoraPid']);
        $documentForm->setValid(!empty($this->formData['validDocument']));
        if ($this->formData['comment']) {
            $documentForm->setComment($this->formData['comment']);
        }

        $documentData = array();

        foreach ($fields as $field) {
            $pageUid    = $field->getPageUid();
            $groupUid   = $field->getGroupUid();
            $groupIndex = $field->getGroupIndex();
            $fieldUid   = $field->getFieldUid();
            $fieldIndex = $field->getFieldIndex();
            $value      = $field->getValue();

            $documentData[$pageUid][$groupUid][$groupIndex][$fieldUid][$fieldIndex] = $value;
        }

        foreach ($documentData as $pageUid => $page) {
            $metadataPage     = $this->metadataPageRepository->findByUid($pageUid);
            $documentFormPage = new \EWW\Dpf\Domain\Model\DocumentFormPage();
            $documentFormPage->setUid($metadataPage->getUid());
            $documentFormPage->setDisplayName($metadataPage->getDisplayName());
            $documentFormPage->setName($metadataPage->getName());

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

            foreach ($page as $groupUid => $groupItem) {
                foreach ($groupItem as $group) {
                    $metadataGroup     = $this->metadataGroupRepository->findByUid($groupUid);
                    $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->setMaxIteration($metadataGroup->getMaxIteration());

                    $fileLabel = "";
                    $fileDownload = "";
                    $fileArchive = "";

                    $fileIdentifier = '';
                    if (array_key_exists('fileIdentifier', $group)) {
                        $fileIdentifier = array_shift($group['fileIdentifier']);
                        unset($group['fileIdentifier']);
                    }

                    foreach ($group as $objectUid => $objectItem) {

                        foreach ($objectItem as $objectItem => $object) {

                            /** @var MetadataObject $metadataObject */
                            $metadataObject    = $this->metadataObjectRepository->findByUid($objectUid);

                            /** @var DocumentForm $documentFormField */
                            $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());
                                                setConsent($metadataObject->getConsent());
                            $documentFormField->setValidation($metadataObject->getValidation());
                                                setValidation($metadataObject->getValidation());
                            $documentFormField->setDataType($metadataObject->getDataType());
                                                setDataType($metadataObject->getDataType());
                            $documentFormField->setMaxIteration($metadataObject->getMaxIteration());
                            $documentFormField->setInputOptions($metadataObject->getInputOptionList());
                                                setInputOptions($metadataObject->getInputOptionList());
                            $documentFormField->setInputField($metadataObject->getInputField());
                                                setInputField($metadataObject->getInputField());
                            $documentFormField->setFillOutService($metadataObject->getFillOutService());
                                                setFillOutService($metadataObject->getFillOutService());
                            $documentFormField->setGndFieldUid($metadataObject->getGndFieldUid());
                                                setGndFieldUid($metadataObject->getGndFieldUid());
                            $documentFormField->setMaxInputLength($metadataObject->getMaxInputLength());
                                                setMaxInputLength($metadataObject->getMaxInputLength());
                            $documentFormField->setValue($object, $metadataObject->getDefaultValue());
                                                setValue($object, $metadataObject->getDefaultValue());

                            $documentFormGroup->addItem($documentFormField);

                            if ($metadataGroup->isFileGroup()) {

                                // Use the existing file entry
                                $file = null;
                                $document = $this->documentRepository->findByUid($this->formData['documentUid']);
                                if ($document) {
                                    if ($metadataGroup->isPrimaryFileGroup()) {
                                        $file = $document->getPrimaryFile();
                                    } else {
                                        $file = $document->getFileByFileIdentifier($fileIdentifier);
                                    }
                                }

                                if ($metadataObject->isUploadField() ) {
                                    if ($object && is_array($object) &&
                                        array_key_exists('error', $object) &&
                                        $object['error'] != UPLOAD_ERR_NO_FILE)
                                    {
                                        if (empty($file)) {
                                            $file = $this->objectManager->get(File::class);
                                            $file = $this->getUploadedFile(
                                                $object,
                                                $metadataGroup->isPrimaryFileGroup(),
                                                $file);
                                            $documentFormField->setFile($file);
                                                                setFile($file);
                                        } else {
                                            $file = $this->getUploadedFile(
                                                $object,
                                                $metadataGroup->isPrimaryFileGroup(),
                                                $file);
                                            $documentFormField->setFile($file);
                                        }

                                        $documentFormField->setValue($file->getUrl());
                                        $fileIdentifier = $file->getFileIdentifier();
                                        $documentForm->addFile($file);

                                    } elseif ($object && !is_array($object)) {
                                        $documentFormField->setFile($file);
                                        $fileIdentifier = $file->getFileIdentifier();
                                        $documentForm->addFile($file);
                                    }
                                } else {
                                    if ($metadataObject->isFileLabelField()) {
                                        $fileLabel = $object;
                                    }

                                    if ($metadataObject->isFileDownloadField()) {
                                        $fileDownload = !empty($object);
                                    }

                                    if ($metadataObject->isFileArchiveField()) {
                                        $fileArchive = !empty($object);
                                    }

                                }

                                if ($file) {
                                    $file->setLabel($fileLabel);
                                    $file->setDownload($fileDownload);
                                    $file->setArchive($fileArchive);
                                }
                            }
                        }
                    }

                    if (!$metadataGroup->isFileGroup() || $fileIdentifier) {
                        $documentFormPage->addItem($documentFormGroup);
                    }
                }
            }

            $documentForm->addItem($documentFormPage);
        }

        return $documentForm;
    }
}

kitodo / kitodo-publication

Push — master ( f02d33...dc5694 )

FormDataReader::uploadError() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
