Kitodo\Dlf\Common\Document\FullTextDocument

Complexity

Total Complexity

11

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	_getHasFullText()	0	4	1
B	getRawTextFromXml()	0	52	10

<?php

/**
 * (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\Common\Document;

use Kitodo\Dlf\Common\FulltextInterface;
use Kitodo\Dlf\Common\Helper;
use TYPO3\CMS\Core\Configuration\ExtensionConfiguration;
use TYPO3\CMS\Core\Utility\GeneralUtility;

/**
 * Document class for the 'dlf' extension
 *
 * @author Beatrycze Volk <beatrycze.volk@slub-dresden.de>
 * @package TYPO3
 * @subpackage dlf
 * @access public
 * @property-read bool $hasFullText Are there any full text files available?
 * @property array $rawTextArray array containing raw text
 * @abstract
 */
abstract class FullTextDocument extends Document
{
    /**
     * The extension key
     *
     * @var string
     * @access public
     */
    public static $extKey = 'dlf';

    /**
     * Are there any fulltext files available? This also includes IIIF text annotations
     * with motivation 'painting' if Kitodo.Presentation is configured to store text
     * annotations as fulltext.
     *
     * @var bool
     * @access protected
     */
    protected $hasFullText = false;

    /**
     * This holds the documents' raw text pages with their corresponding
     * structMap//div's ID (METS) or Range / Manifest / Sequence ID (IIIF) as array key
     *
     * @var array
     * @access protected
     */
    protected $rawTextArray = [];

    /**
     * This extracts the raw text for a physical structure node / IIIF Manifest / Canvas. Text might be
     * given as ALTO for METS or as annotations or ALTO for IIIF resources. If IIIF plain text annotations
     * with the motivation "painting" should be treated as full text representations, the extension has to be
     * configured accordingly.
     *
     * @access public
     *
     * @abstract
     *
     * @param string $id: The @ID attribute of the physical structure node (METS) or the @id property
     * of the Manifest / Range (IIIF)
     *
     * @return string The physical structure node's / IIIF resource's raw text
     */
    public abstract function getRawText($id);

    /**
     * Analyze the document if it contains any full text that needs to be indexed.
     *
     * @access protected
     *
     * @abstract
     */
    protected abstract function ensureHasFullTextIsSet();

    /**
     * This extracts the raw text for a physical structure node / IIIF Manifest / Canvas from an
     * XML full text representation (currently only ALTO). For IIIF manifests, ALTO documents have
     * to be given in the Canvas' / Manifest's "seeAlso" property.
     *
     * @param string $id: The @ID attribute of the physical structure node (METS) or the @id property
     * of the Manifest / Range (IIIF)
     *
     * @return string The physical structure node's / IIIF resource's raw text from XML
     */
    protected function getRawTextFromXml($id)
    {
        $rawText = '';
        // Load available text formats, ...
        $this->loadFormats();
        // ... physical structure ...
        $this->_getPhysicalStructure();
        // ... and extension configuration.
        $extConf = GeneralUtility::makeInstance(ExtensionConfiguration::class)->get(self::$extKey);
        $fileGrpsFulltext = GeneralUtility::trimExplode(',', $extConf['fileGrpFulltext']);
        if (!empty($this->physicalStructureInfo[$id])) {
            while ($fileGrpFulltext = array_shift($fileGrpsFulltext)) {
                if (!empty($this->physicalStructureInfo[$id]['files'][$fileGrpFulltext])) {
                    // Get full text file.
                    $file = GeneralUtility::getUrl($this->getFileLocation($this->physicalStructureInfo[$id]['files'][$fileGrpFulltext]));
                    if ($file !== false) {
                        $rawTextXml = Helper::getXmlFileAsString($file);

The method getXmlFileAsString() does not exist on Kitodo\Dlf\Common\Helper.

                        // Get the root element's name as text format.
                        $textFormat = strtoupper($rawTextXml->getName());
                    } else {
                        $this->logger->warning('Couldn\'t load fulltext file for structure node @ID "' . $id . '"');

The method warning() does not exist on TYPO3\CMS\Core\Log\LogManager.

                        return $rawText;
                    }
                    break;
                }
            }
        } else {
            $this->logger->warning('Invalid structure node @ID "' . $id . '"');
            return $rawText;
        }
        // Is this text format supported?
        if (
            !empty($rawTextXml)
            && !empty($this->formats[$textFormat])

The variable $textFormat does not seem to be defined for all execution paths leading up to this point.

        ) {
            if (!empty($this->formats[$textFormat]['class'])) {
                $class = $this->formats[$textFormat]['class'];
                // Get the raw text from class.
                if (
                    class_exists($class)
                    && ($obj = GeneralUtility::makeInstance($class)) instanceof FulltextInterface
                ) {
                    $rawText = $obj->getRawText($rawTextXml);
                    $this->rawTextArray[$id] = $rawText;
                } else {
                    $this->logger->warning('Invalid class/method "' . $class . '->getRawText()" for text format "' . $textFormat . '"');
                }
            }
        } else {
            $this->logger->warning('Unsupported text format "' . $textFormat . '" in physical node with @ID "' . $id . '"');
        }
        return $rawText;
    }

    /**
     * This returns $this->hasFullText via __get()
     *
     * @access protected
     *
     * @return bool Are there any full text files available?
     */
    protected function _getHasFullText()
    {
        $this->ensureHasFullTextIsSet();
        return $this->hasFullText;
    }
}