DocumentRepository::fetchMetadataFromSolr() - Code Metrics - Inspection of "Merge pull request #847 from dvoracek-slub/pr-fix-..." - Erikmitk/kitodo-presentation - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 1e45e0...9c8682 )

unknown
created 2022-08-04 19:23 UTC
DocumentRepository::fetchMetadataFromSolr() B

↳ Parent: Project
Complexity

Conditions	10
Paths	6
Size

Total Lines	38
Code Lines	20
Duplication

Lines	0
Ratio	0 %
Importance

Changes	5
Bugs	0	Features	0
Metric	Value
cc	10
eloc	20
c	5
b	0
f	0
nc	6
nop	2
dl	0
loc	38
rs	7.6666
How to fix Complexity

<?php

/**
 * (c) Kitodo. Key to digital objects e.V. <[email protected]>
 *
 * 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\Domain\Repository;

use Kitodo\Dlf\Common\Doc;
use Kitodo\Dlf\Common\Helper;
use Kitodo\Dlf\Common\Solr;
use Kitodo\Dlf\Common\SolrSearch;
use Kitodo\Dlf\Domain\Model\Document;
use TYPO3\CMS\Core\Database\ConnectionPool;
use TYPO3\CMS\Core\Database\Connection;
use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Utility\MathUtility;
use TYPO3\CMS\Extbase\Persistence\QueryInterface;

class DocumentRepository extends \TYPO3\CMS\Extbase\Persistence\Repository
{
    /**
     * The controller settings passed to the repository for some special actions.
     *
     * @var array
     * @access protected
     */
    protected $settings;

    /**
     * Find one document by given parameters
     *
     * GET parameters may be:
     *
     * - 'id': the uid of the document
     * - 'location': the URL of the location of the XML file
     * - 'recordId': the record_id of the document
     *
     * Currently used by EXT:slub_digitalcollections
     *
     * @param array $parameters
     *
     * @return \Kitodo\Dlf\Domain\Model\Document|null
     */
    public function findOneByParameters($parameters)
    {
        $doc = null;
        $document = null;

        if (isset($parameters['id']) && MathUtility::canBeInterpretedAsInteger($parameters['id'])) {

            $document = $this->findOneByIdAndSettings($parameters['id']);

        } else if (isset($parameters['recordId'])) {

            $document = $this->findOneByRecordId($parameters['recordId']);
            $document = $this->findOneByRecordId($parameters['recordId']);

        } else if (isset($parameters['location']) && GeneralUtility::isValidUrl($parameters['location'])) {

            $doc = Doc::getInstance($parameters['location'], [], true);

            if ($doc->recordId) {
                $document = $this->findOneByRecordId($doc->recordId);
            }

            if ($document === null) {
                // create new (dummy) Document object
                $document = GeneralUtility::makeInstance(Document::class);
                $document->setLocation($parameters['location']);
            }

        }

        if ($document !== null && $doc === null) {
            $doc = Doc::getInstance($document->getLocation(), [], true);
            $doc = Doc::getInstance($document->/** @scrutinizer ignore-call */ getLocation(), [], true);
        }

        if ($doc !== null) {
            $document->setDoc($doc);
                       setDoc($doc);
        }

        return $document;

    }

    /**
     * Find the oldest document
     *
     * @return \Kitodo\Dlf\Domain\Model\Document|null
     */
    public function findOldestDocument()
    {
        $query = $this->createQuery();

        $query->setOrderings(['tstamp' => QueryInterface::ORDER_ASCENDING]);
        $query->setLimit(1);

        return $query->execute()->getFirst();
    }

    /**
     * @param int $partOf
     * @param  \Kitodo\Dlf\Domain\Model\Structure $structure
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function getChildrenOfYearAnchor($partOf, $structure)
    {
        $query = $this->createQuery();

        $query->matching($query->equals('structure', $structure));
        $query->matching($query->equals('partof', $partOf));

        $query->setOrderings([
            'mets_orderlabel' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_ASCENDING
        ]);

        return $query->execute();
    }

    /**
     * Finds all documents for the given settings
     *
     * @param int $uid
     * @param array $settings
     *
     * @return \Kitodo\Dlf\Domain\Model\Document|null
     */
    public function findOneByIdAndSettings($uid, $settings = [])
    public function findOneByIdAndSettings($uid, /** @scrutinizer ignore-unused */ $settings = [])
    {
        $settings = ['documentSets' => $uid];

        return $this->findDocumentsBySettings($settings)->getFirst();
    }

    /**
     * Finds all documents for the given settings
     *
     * @param array $settings
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findDocumentsBySettings($settings = [])
    {
        $query = $this->createQuery();

        $constraints = [];

        if ($settings['documentSets']) {
            $constraints[] = $query->in('uid', GeneralUtility::intExplode(',', $settings['documentSets']));
        }

        if (isset($settings['excludeOther']) && (int) $settings['excludeOther'] === 0) {
            $query->getQuerySettings()->setRespectStoragePage(false);
        }

        if (count($constraints)) {
            $query->matching(
                $query->logicalAnd($constraints)
            );
        }

        return $query->execute();
    }

    /**
     * Finds all documents for the given collections
     *
     * @param array $collections
     * @param int $limit
     *
     * @return array|\TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function findAllByCollectionsLimited($collections, $limit = 50)
    {
        $query = $this->createQuery();

        // order by start_date -> start_time...
        $query->setOrderings(
            ['tstamp' => QueryInterface::ORDER_DESCENDING]
        );

        $constraints = [];
        if ($collections) {

            $constraints[] = $query->in('collections.uid', $collections);
        }

        if (count($constraints)) {
            $query->matching(
                $query->logicalAnd($constraints)
            );
        }

        if ($limit > 0) {
            $query->setLimit((int) $limit);
        }

        return $query->execute();
    }

    /**
     * Count the titles and volumes for statistics
     *
     * Volumes are documents that are both
     *  a) "leaf" elements i.e. partof != 0
     *  b) "root" elements that are not referenced by other documents ("root" elements that have no descendants)

     * @param array $settings
     *
     * @return array
     */
    public function getStatisticsForSelectedCollection($settings)
    {
        if ($settings['collections']) {
            // Include only selected collections.
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_dlf_documents');

            $countTitles = $queryBuilder
                ->count('tx_dlf_documents.uid')
                ->from('tx_dlf_documents')
                ->innerJoin(
                    'tx_dlf_documents',
                    'tx_dlf_relations',
                    'tx_dlf_relations_joins',
                    $queryBuilder->expr()->eq(
                        'tx_dlf_relations_joins.uid_local',
                        'tx_dlf_documents.uid'
                    )
                )
                ->innerJoin(
                    'tx_dlf_relations_joins',
                    'tx_dlf_collections',
                    'tx_dlf_collections_join',
                    $queryBuilder->expr()->eq(
                        'tx_dlf_relations_joins.uid_foreign',
                        'tx_dlf_collections_join.uid'
                    )
                )
                ->where(
                    $queryBuilder->expr()->eq('tx_dlf_documents.pid', intval($settings['storagePid'])),
                    $queryBuilder->expr()->eq('tx_dlf_collections_join.pid', intval($settings['storagePid'])),
                    $queryBuilder->expr()->eq('tx_dlf_documents.partof', 0),
                    $queryBuilder->expr()->in('tx_dlf_collections_join.uid', $queryBuilder->createNamedParameter(GeneralUtility::intExplode(',', $settings['collections']), Connection::PARAM_INT_ARRAY)),
                    $queryBuilder->expr()->eq('tx_dlf_relations_joins.ident', $queryBuilder->createNamedParameter('docs_colls'))
                )
                ->execute()
                ->fetchColumn(0);

                $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                    ->getQueryBuilderForTable('tx_dlf_documents');
                $subQueryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                    ->getQueryBuilderForTable('tx_dlf_documents');

                $subQuery = $subQueryBuilder
                    ->select('tx_dlf_documents.partof')
                    ->from('tx_dlf_documents')
                    ->where(
                        $subQueryBuilder->expr()->neq('tx_dlf_documents.partof', 0)
                    )
                    ->groupBy('tx_dlf_documents.partof')
                    ->getSQL();

                $countVolumes = $queryBuilder
                    ->count('tx_dlf_documents.uid')
                    ->from('tx_dlf_documents')
                    ->innerJoin(
                        'tx_dlf_documents',
                        'tx_dlf_relations',
                        'tx_dlf_relations_joins',
                        $queryBuilder->expr()->eq(
                            'tx_dlf_relations_joins.uid_local',
                            'tx_dlf_documents.uid'
                        )
                    )
                    ->innerJoin(
                        'tx_dlf_relations_joins',
                        'tx_dlf_collections',
                        'tx_dlf_collections_join',
                        $queryBuilder->expr()->eq(
                            'tx_dlf_relations_joins.uid_foreign',
                            'tx_dlf_collections_join.uid'
                        )
                    )
                    ->where(
                        $queryBuilder->expr()->eq('tx_dlf_documents.pid', intval($settings['storagePid'])),
                        $queryBuilder->expr()->eq('tx_dlf_collections_join.pid', intval($settings['storagePid'])),
                        $queryBuilder->expr()->notIn('tx_dlf_documents.uid', $subQuery),
                        $queryBuilder->expr()->in('tx_dlf_collections_join.uid', $queryBuilder->createNamedParameter(GeneralUtility::intExplode(',', $settings['collections']), Connection::PARAM_INT_ARRAY)),
                        $queryBuilder->expr()->eq('tx_dlf_relations_joins.ident', $queryBuilder->createNamedParameter('docs_colls'))
                    )
                    ->execute()
                    ->fetchColumn(0);
        } else {
            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable('tx_dlf_documents');

            // Include all collections.
            $countTitles = $queryBuilder
                ->count('tx_dlf_documents.uid')
                ->from('tx_dlf_documents')
                ->where(
                    $queryBuilder->expr()->eq('tx_dlf_documents.pid', intval($settings['storagePid'])),
                    $queryBuilder->expr()->eq('tx_dlf_documents.partof', 0),
                    Helper::whereExpression('tx_dlf_documents')
                )
                ->execute()
                ->fetchColumn(0);

            $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable('tx_dlf_documents');
            $subQueryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
                ->getQueryBuilderForTable('tx_dlf_documents');

            $subQuery = $subQueryBuilder
                ->select('tx_dlf_documents.partof')
                ->from('tx_dlf_documents')
                ->where(
                    $subQueryBuilder->expr()->neq('tx_dlf_documents.partof', 0)
                )
                ->groupBy('tx_dlf_documents.partof')
                ->getSQL();

            $countVolumes = $queryBuilder
                ->count('tx_dlf_documents.uid')
                ->from('tx_dlf_documents')
                ->where(
                    $queryBuilder->expr()->eq('tx_dlf_documents.pid', intval($settings['storagePid'])),
                    $queryBuilder->expr()->notIn('tx_dlf_documents.uid', $subQuery)
                )
                ->execute()
                ->fetchColumn(0);
        }

        return ['titles' => $countTitles, 'volumes' => $countVolumes];
    }

    /**
     * Build table of contents
     *
     * @param int $uid
     * @param int $pid
     * @param array $settings
     *
     * @return \TYPO3\CMS\Extbase\Persistence\QueryResultInterface
     */
    public function getTableOfContentsFromDb($uid, $pid, $settings)
    {
        // Build table of contents from database.
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getQueryBuilderForTable('tx_dlf_documents');

        $excludeOtherWhere = '';
        if ($settings['excludeOther']) {
            $excludeOtherWhere = 'tx_dlf_documents.pid=' . intval($settings['storagePid']);
        }
        // Check if there are any metadata to suggest.
        $result = $queryBuilder
            ->select(
                'tx_dlf_documents.uid AS uid',
                'tx_dlf_documents.title AS title',
                'tx_dlf_documents.volume AS volume',
                'tx_dlf_documents.mets_label AS mets_label',
                'tx_dlf_documents.mets_orderlabel AS mets_orderlabel',
                'tx_dlf_structures_join.index_name AS type'
            )
            ->innerJoin(
                'tx_dlf_documents',
                'tx_dlf_structures',
                'tx_dlf_structures_join',
                $queryBuilder->expr()->eq(
                    'tx_dlf_structures_join.uid',
                    'tx_dlf_documents.structure'
                )
            )
            ->from('tx_dlf_documents')
            ->where(
                $queryBuilder->expr()->eq('tx_dlf_documents.partof', intval($uid)),
                $queryBuilder->expr()->eq('tx_dlf_structures_join.pid', intval($pid)),
                $excludeOtherWhere
            )
            ->addOrderBy('tx_dlf_documents.volume_sorting')
            ->addOrderBy('tx_dlf_documents.mets_orderlabel')
            ->execute();
        return $result;
    }

    /**
     * Find one document by given settings and identifier
     *
     * @param array $settings
     * @param array $parameters
     *
     * @return array The found document object
     */
    public function getOaiRecord($settings, $parameters)
    {
        $where = '';

        if (!$settings['show_userdefined']) {
            $where .= 'AND tx_dlf_collections.fe_cruser_id=0 ';
        }

        $connection = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable('tx_dlf_documents');

        $sql = 'SELECT `tx_dlf_documents`.*, GROUP_CONCAT(DISTINCT `tx_dlf_collections`.`oai_name` ORDER BY `tx_dlf_collections`.`oai_name` SEPARATOR " ") AS `collections` ' .
            'FROM `tx_dlf_documents` ' .
            'INNER JOIN `tx_dlf_relations` ON `tx_dlf_relations`.`uid_local` = `tx_dlf_documents`.`uid` ' .
            'INNER JOIN `tx_dlf_collections` ON `tx_dlf_collections`.`uid` = `tx_dlf_relations`.`uid_foreign` ' .
            'WHERE `tx_dlf_documents`.`record_id` = ? ' .
            'AND `tx_dlf_relations`.`ident`="docs_colls" ' .
            $where;

        $values = [
            $parameters['identifier']
        ];

        $types = [
            Connection::PARAM_STR
        ];

        // Create a prepared statement for the passed SQL query, bind the given params with their binding types and execute the query
        $statement = $connection->executeQuery($sql, $values, $types);

        return $statement->fetch();
    }

    /**
     * Finds all documents for the given settings
     *
     * @param array $settings
     * @param array $documentsToProcess
     *
     * @return array The found document objects
     */
    public function getOaiDocumentList($settings, $documentsToProcess)
    public function getOaiDocumentList(/** @scrutinizer ignore-unused */ $settings, $documentsToProcess)
    {
        $connection = GeneralUtility::makeInstance(ConnectionPool::class)
            ->getConnectionForTable('tx_dlf_documents');

        $sql = 'SELECT `tx_dlf_documents`.*, GROUP_CONCAT(DISTINCT `tx_dlf_collections`.`oai_name` ORDER BY `tx_dlf_collections`.`oai_name` SEPARATOR " ") AS `collections` ' .
            'FROM `tx_dlf_documents` ' .
            'INNER JOIN `tx_dlf_relations` ON `tx_dlf_relations`.`uid_local` = `tx_dlf_documents`.`uid` ' .
            'INNER JOIN `tx_dlf_collections` ON `tx_dlf_collections`.`uid` = `tx_dlf_relations`.`uid_foreign` ' .
            'WHERE `tx_dlf_documents`.`uid` IN ( ? ) ' .
            'AND `tx_dlf_relations`.`ident`="docs_colls" ' .
            'AND ' . Helper::whereExpression('tx_dlf_collections') . ' ' .
            'GROUP BY `tx_dlf_documents`.`uid` ';

        $values = [
            $documentsToProcess,
        ];

        $types = [
            Connection::PARAM_INT_ARRAY,
        ];

        // Create a prepared statement for the passed SQL query, bind the given params with their binding types and execute the query
        $documents = $connection->executeQuery($sql, $values, $types);

        return $documents;
    }

    /**
     * Finds all documents with given uids
     *
     * @param array $uids
     * @param array $checkPartof Whether or not to also match $uids against partof.
     *
     * @return array
     */
    public function findAllByUids($uids, $checkPartof = false)
    {
        // get all documents from db we are talking about
        $connectionPool = GeneralUtility::makeInstance(ConnectionPool::class);
        $queryBuilder = $connectionPool->getQueryBuilderForTable('tx_dlf_documents');
        // Fetch document info for UIDs in $documentSet from DB
        $exprDocumentMatchesUid = $queryBuilder->expr()->in('tx_dlf_documents.uid', $uids);
        if ($checkPartof) {
            $exprDocumentMatchesUid = $queryBuilder->expr()->orX(
                $exprDocumentMatchesUid,
                $queryBuilder->expr()->in('tx_dlf_documents.partof', $uids)
            );
        }
        $kitodoDocuments = $queryBuilder
            ->select(
                'tx_dlf_documents.uid AS uid',
                'tx_dlf_documents.title AS title',
                'tx_dlf_documents.structure AS structure',
                'tx_dlf_documents.thumbnail AS thumbnail',
                'tx_dlf_documents.volume_sorting AS volumeSorting',
                'tx_dlf_documents.mets_orderlabel AS metsOrderlabel',
                'tx_dlf_documents.partof AS partOf'
            )
            ->from('tx_dlf_documents')
            ->where(
                $queryBuilder->expr()->in('tx_dlf_documents.pid', $this->settings['storagePid']),
                $exprDocumentMatchesUid
            )
            ->addOrderBy('tx_dlf_documents.volume_sorting', 'asc')
            ->addOrderBy('tx_dlf_documents.mets_orderlabel', 'asc')
            ->execute();

        $allDocuments = [];
        $documentStructures = Helper::getDocumentStructures($this->settings['storagePid']);
        // Process documents in a usable array structure
        while ($resArray = $kitodoDocuments->fetch()) {
            $resArray['structure'] = $documentStructures[$resArray['structure']];
            $allDocuments[$resArray['uid']] = $resArray;
        }

        return $allDocuments;
    }

    /**
     *
     *
     * @param array $uids
     *
     * @return array
     */
    public function findChildrenOfEach(array $uids)
    {
        $allDocuments = $this->findAllByUids($uids, true);
        $allDocuments = $this->findAllByUids($uids, /** @scrutinizer ignore-type */ true);

        $result = [];
        foreach ($allDocuments as $doc) {
            if ($doc['partOf']) {
                $result[$doc['partOf']][] = $doc;
            }
        }
        return $result;
    }

    /**
     * Find all documents with given collection from Solr
     *
     * @param \TYPO3\CMS\Extbase\Persistence\Generic\QueryResult|\Kitodo\Dlf\Domain\Model\Collection $collection
     * @param array $settings
     * @param array $searchParams
     * @param \TYPO3\CMS\Extbase\Persistence\Generic\QueryResult $listedMetadata
     * @return array
     */
    public function findSolrByCollection($collection, $settings, $searchParams, $listedMetadata = null)
    {
        // set settings global inside this repository
        // (may be necessary when SolrSearch calls back)
        $this->settings = $settings;

        $search = new SolrSearch($this, $collection, $settings, $searchParams, $listedMetadata);
        $search->prepare();
        return $search;

    }
}

Erikmitk / kitodo-presentation

Push — master ( 1e45e0...9c8682 )

DocumentRepository::fetchMetadataFromSolr() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like
