Kitodo\Dlf\Validation\DocumentValidator

Complexity

Total Complexity

10

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	hasCorrectPhysicalStructure()	0	15	3
A	__construct()	0	6	1
A	hasAllMandatoryMetadataFields()	0	9	3
A	hasCorrectLogicalStructure()	0	15	3

<?php

declare(strict_types=1);

/*
 * (c) Kitodo. Key to digital objects e.V. <contact@kitodo.org>
 *
 * This file is part of the Kitodo and TYPO3 projects.
 *
 * @license GNU General Public License version 3 or later.
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 */

namespace Kitodo\Dlf\Validation;

use TYPO3\CMS\Core\Log\Logger;
use TYPO3\CMS\Core\Log\LogManager;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/**
 * Class for document validation. Currently used for validating metadata
 * fields but in the future should be extended also for other fields.
 *
 * @package TYPO3
 * @subpackage dlf
 *
 * @access public
 */
class DocumentValidator
{
     /**
     * @access protected
     * @var Logger This holds the logger
     */
    protected Logger $logger;

    /**
     * @access private
     * @var array
     */
    private array $metadata;

    /**
     * @access private
     * @var array
     */
    private array $requiredMetadataFields;

    /**
     * @access private
     * @var ?\SimpleXMLElement
     */
    private ?\SimpleXMLElement $xml;

    /**
     * Constructs DocumentValidator instance.
     *
     * @access public
     *
     * @param array $metadata
     * @param array $requiredMetadataFields
     *
     * @return void
     */
    public function __construct(array $metadata = [], array $requiredMetadataFields = [], ?\SimpleXMLElement $xml = null)
    {
        $this->logger = GeneralUtility::makeInstance(LogManager::class)->getLogger(static::class);
        $this->metadata = $metadata;
        $this->requiredMetadataFields = $requiredMetadataFields;
        $this->xml = $xml;
    }

    /**
     * Check if metadata array contains all mandatory fields before save.
     *
     * @access public
     *
     * @return bool
     */
    public function hasAllMandatoryMetadataFields(): bool
    {
        foreach ($this->requiredMetadataFields as $requiredMetadataField) {
            if (empty($this->metadata[$requiredMetadataField][0])) {
                $this->logger->error('Missing required metadata field "' . $requiredMetadataField . '".');
                return false;
            }
        }
        return true;
    }

    /**
     * Check if xml contains at least one logical structure with given type.
     *
     * @access public
     * 
     * @param string $type e.g. documentary, newspaper or object
     *
     * @return bool
     */
    public function hasCorrectLogicalStructure(string $type): bool
    {
        $expectedNodes = $this->xml->xpath('./mets:structMap[@TYPE="LOGICAL"]/mets:div[@TYPE="' . $type . '"]');

The method xpath() does not exist on null.

        if ($expectedNodes) {

The expression $expectedNodes of type array<mixed,SimpleXMLElement> is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return true;
        }

        $existingNodes = $this->xml->xpath('./mets:structMap[@TYPE="LOGICAL"]/mets:div');
        if ($existingNodes) {

The expression $existingNodes of type array<mixed,SimpleXMLElement> is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->logger->error('Document contains logical structure but @TYPE="' . $type . '" is missing.');
            return false;
        }

        $this->logger->error('Document does not contain logical structure.');
        return false;
    }

    /**
     * Check if xml contains at least one physical structure with type 'physSequence'.
     *
     * @access public
     *
     * @return bool
     */
    public function hasCorrectPhysicalStructure(): bool
    {
        $physSequenceNodes = $this->xml->xpath('./mets:structMap[@TYPE="PHYSICAL"]/mets:div[@TYPE="physSequence"]');
        if ($physSequenceNodes) {

The expression $physSequenceNodes of type array<mixed,SimpleXMLElement> is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            return true;
        }

        $physicalStructureNodes = $this->xml->xpath('./mets:structMap[@TYPE="PHYSICAL"]/mets:div');
        if ($physicalStructureNodes) {

The expression $physicalStructureNodes of type array<mixed,SimpleXMLElement> is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->logger->error('Document contains physical structure but @TYPE="physSequence" is missing.');
            return false;
        }

        $this->logger->error('Document does not contain physical structure.');
        return false;
    }
}