Merge branch 'main' into dependabot/npm_and_yarn/Build/lodash-4.17.23

Author: sebastian-meyer

Classes/Common/Indexer.php

@@ -80,6 +80,13 @@ class Indexer
      */
     protected static array $processedDocs = [];
 
+    /**
+     * @access protected
+     * @static
+     * @var array List of already extracted structure nodes for structure path
+     */
+    protected static array $extractedStructurePathNodes = [];
+
     /**
      * @access protected
      * @static
@@ -371,6 +378,10 @@ protected static function processLogical(Document $document, array $logicalUnit)
                 $solrDoc->setField('toplevel', $logicalUnit['id'] == $doc->getToplevelId());
                 $solrDoc->setField('title', $metadata['title'][0]);
                 $solrDoc->setField('volume', $metadata['volume'][0] ?? '');
+                // extract structure path
+                self::$extractedStructurePathNodes[$logicalUnit['id']] = self::extractStructurePathNodes($doc->tableOfContents, $logicalUnit['id']);
+                $processedStructurePath = self::buildStructurePathData(self::$extractedStructurePathNodes[$logicalUnit['id']], $document->getCurrentDocument()->getToplevelId());
+                $solrDoc->setField('structure_path', json_encode($processedStructurePath, JSON_UNESCAPED_UNICODE));
                 // verify date formatting
                 if (strtotime($metadata['date'][0])) {
                     $solrDoc->setField('date', self::getFormattedDate($metadata['date'][0]));
@@ -465,7 +476,21 @@ protected static function processPhysical(Document $document, int $page, array $
             $solrDoc->setField('type', $physicalUnit['type']);
             $solrDoc->setField('collection', $doc->metadataArray[$doc->getToplevelId()]['collection']);
             $solrDoc->setField('location', $document->getLocation());
-
+            // pick only the deepest structure paths
+            $associatedPaths = [];
+            foreach ($doc->smLinks['p2l'][$physicalUnit['id']] as $logicalId) {
+                $path = self::$extractedStructurePathNodes[$logicalId] ?? [];
+                if (!empty($path)) {
+                    $associatedPaths[$logicalId] = $path;
+                }
+            }
+            $deepestPaths = self::filterDeepestStructurePaths($associatedPaths);
+            $processedStructurePath = [];
+            foreach ($deepestPaths as $path) {
+                $segments = self::buildStructurePathData($path, $document->getCurrentDocument()->getToplevelId());
+                $processedStructurePath[] = json_encode($segments, JSON_UNESCAPED_UNICODE);
+            }
+            $solrDoc->setField('structure_path', $processedStructurePath);
             $solrDoc->setField('fulltext', $fullText);
             if (is_array($doc->metadataArray[$doc->getToplevelId()])) {
                 self::addFaceting($doc, $solrDoc, $physicalUnit);
@@ -728,6 +753,147 @@ private static function removeAppendsFromAuthor(array|string $authors): array|st
         return $authors;
     }
 
+    /**
+     * Extract nodes alongside the structure map in direct line to the target id and return them as flattened array.
+     *
+     * @access private
+     *
+     * @static
+     *
+     * @param array $nodes Tree or Sub-Tree, where the target id should be extracted from if present
+     * @param string $targetId The ID of the logical structure element to be found
+     * @param array $path An intermediate array that keeps track of the current branch that is being looked up
+     *
+     * @return array
+     */
+    private static function extractStructurePathNodes(array $nodes, string $targetId, array $path = []): array
+    {
+        foreach ($nodes as $node) {
+            // remember where we came from
+            $currentPath = array_merge($path, [$node]);
+            if ($node['id'] == $targetId) {
+                return $currentPath;
+            }
+            if (!empty($node['children'])) {
+                $result = self::extractStructurePathNodes($node['children'], $targetId, $currentPath);
+                if ($result) {
+                    return $result;
+                }
+            }
+        }
+        return [];
+    }
+
+    /**
+     * Filters those structure path nodes that are the descending into the structure tree the most and removes any that resemble a "prefix" of another.
+     *
+     * @access private
+     *
+     * @static
+     *
+     * @param array $paths The array containing all structure path nodes associated with a physical page
+     *
+     * @return array
+     */
+    private static function filterDeepestStructurePaths(array $paths): array
+    {
+        if (count($paths) <= 1) {
+            return $paths;
+        }
+
+        $deepestPath = [];
+        foreach ($paths as $currentLogicalId => $currentPath) {
+            $currentIds = array_column($currentPath, 'id');
+            $isPrefix = false;
+
+            foreach ($paths as $comparisonLogicalId => $comparisonPath) {
+                if ($currentLogicalId === $comparisonLogicalId) {
+                    continue;
+                }
+                $comparisonIds = array_column($comparisonPath, 'id');
+                // check if structure path is part/prefix of another structure path
+                if (
+                    count($currentIds) < count($comparisonIds)
+                    && array_slice($comparisonIds, 0, count($currentIds)) === $currentIds
+                ) {
+                    $isPrefix = true;
+                    break;
+                }
+            }
+
+            if (!$isPrefix) {
+                $deepestPath[$currentLogicalId] = $currentPath;
+            }
+        }
+        return $deepestPath;
+    }
+
+    /**
+     * Create the actual array with the required data for the structure path that will be JSON encoded and indexed.
+     *
+     * @access private
+     *
+     * @static
+     *
+     * @param array $path The structure path nodes that shall be processed
+     * @param string $cutoffId The logical id at which ancestors and itself will not be part of the structure path data
+     *
+     * @return array
+     */
+    private static function buildStructurePathData(array $path, string $cutoffId): array
+    {
+        $cutoffIndex = array_search($cutoffId, array_column($path, 'id'));
+        if ($cutoffIndex !== false) {
+            $path = array_slice($path, $cutoffIndex + 1);
+        }
+
+        $segments = [];
+        foreach ($path as $node) {
+            $segments[] = self::buildStructurePathSegments($node);
+        }
+        return $segments;
+    }
+
+    /**
+     * Gets the label or type of a structure path node with corresponding tag
+     *
+     * @access private
+     *
+     * @static
+     *
+     * @param array $node The current node that should be processed
+     *
+     * @return array
+     */
+    private static function buildStructurePathSegments(array $node): array
+    {
+        if (!empty($node['label'])) {
+            return [
+                'label' => $node['label'],
+            ];
+        }
+        if (!empty($node['orderlabel'])) {
+            return [
+                'label' => $node['orderlabel'],
+            ];
+        }
+        if (!empty($node['volume'])) {
+            $value = !empty($node['year'])
+                ? $node['volume'] . ' ' . $node['year']
+                : $node['volume'];
+
+            return [
+                'label' => $value,
+            ];
+        }
+        if (!empty($node['type'])) {
+            return [
+                'type' => $node['type'],
+            ];
+        }
+        return ['label' => ''];
+    }
+
     /**
      * Handle exception.
      *

Classes/Common/Solr/SearchResult/ResultDocument.php

@@ -73,6 +73,12 @@ class ResultDocument
      */
     private ?string $type;
 
+    /**
+     * @access private
+     * @var array The JSON encoded structure path(s)
+     */
+    private array $structurePath = [];
+
     /**
      * @access private
      * @var Page[] All pages in which search phrase was found
@@ -117,6 +123,7 @@ public function __construct(Document $record, array $highlighting, array $fields
         $this->title = $record[$fields['title']];
         $this->toplevel = $record[$fields['toplevel']] ?? false;
         $this->type = $record[$fields['type']];
+        $this->structurePath = $record[$fields['structure_path']] ?? [];
 
         if (!empty($highlighting[$this->id])) {
             $highlightingForRecord = $highlighting[$this->id][$fields['fulltext']];
@@ -225,6 +232,18 @@ public function getType(): ?string
         return $this->type;
     }
 
+    /**
+     * Get the structure path(s)
+     *
+     * @access public
+     *
+     * @return array
+     */
+    public function getStructurePath(): array
+    {
+        return $this->structurePath;
+    }
+
     /**
      * Get all result's pages which contain search phrase.
      *

Classes/Common/Solr/Solr.php

@@ -256,6 +256,7 @@ public static function getFields(): array
             self::$fields['type'] = $solrFields['type'];
             self::$fields['title'] = $solrFields['title'];
             self::$fields['volume'] = $solrFields['volume'];
+            self::$fields['structure_path'] = $solrFields['structurePath'];
             self::$fields['date'] = $solrFields['date'] ?? null;
             self::$fields['thumbnail'] = $solrFields['thumbnail'];
             self::$fields['default'] = $solrFields['default'];

Classes/Common/Solr/SolrSearch.php

@@ -487,7 +487,7 @@ public function prepare()
         $params['listMetadataRecords'] = [];
 
         // Restrict the fields to the required ones.
-        $params['fields'] = 'uid,id,page,title,thumbnail,partof,toplevel,type';
+        $params['fields'] = 'uid,id,page,title,thumbnail,partof,toplevel,type,structure_path';
 
         if ($this->listedMetadata) {
             foreach ($this->listedMetadata as $metadata) {
@@ -560,6 +560,31 @@ public function submit(int $start, int $rows, bool $processResults = true): void
                             $searchResult['page'] = $doc['page'];
                             $searchResult['thumbnail'] = $doc['thumbnail'];
                             $searchResult['structure'] = $doc['type'];
+                            // create string(s) from structure path(s)
+                            $encodedStructurePaths = $doc['structure_path'] ?? [];
+                            if (!is_array($encodedStructurePaths)) {
+                                $encodedStructurePaths = [$encodedStructurePaths];
+                            }
+                            $structurePathStrings = [];
+                            foreach ($encodedStructurePaths as $jsonString) {
+                                if (!is_string($jsonString) || $jsonString === '') {
+                                    continue;
+                                }
+                                $segments = json_decode($jsonString, true);
+                                if ($segments === null && json_last_error() !== JSON_ERROR_NONE) {
+                                    continue;
+                                }
+                                $structurePathLabels = [];
+                                foreach ($segments as $currentSegment) {
+                                    if (isset($currentSegment['type'])) {
+                                        $structurePathLabels[] = Helper::translate($currentSegment['type'], 'tx_dlf_structures', $this->settings['storagePid']);
+                                    } elseif (!empty($currentSegment['label'])) {
+                                        $structurePathLabels[] = $currentSegment['label'];
+                                    }
+                                }
+                                $structurePathStrings[] = implode(' → ', $structurePathLabels);
+                            }
+                            $searchResult['structure_path'] = $structurePathStrings;
                             $searchResult['title'] = $doc['title'];
                             foreach ($params['listMetadataRecords'] as $indexName => $solrField) {
                                 if (isset($doc['metadata'][$indexName])) {
@@ -901,6 +926,7 @@ private function getDocument(Document $record, array $highlighting, array $field
             'title' => $resultDocument->getTitle(),
             'toplevel' => $resultDocument->getToplevel(),
             'type' => $resultDocument->getType(),
+            'structure_path' => $resultDocument->getStructurePath(),
             'uid' => !empty($resultDocument->getUid()) ? $resultDocument->getUid() : $parameters['uid'],
             'highlight' => $resultDocument->getHighlightsIds(),
         ];

Configuration/ApacheSolr/configsets/dlf/conf/schema.xml

@@ -144,6 +144,8 @@ limitations under the License.
         <!-- Next two fields are mandatory for identifying documents. -->
         <field name="title" type="standard" indexed="true" stored="true" multiValued="false" default="" />
         <field name="volume" type="standard" indexed="true" stored="true" multiValued="false" default="" />
+        <!-- Convenience field to provide context about the path within the logical structure map -->
+        <field name="structure_path" type="string" indexed="false" stored="true" multiValued="true" default="" />
         <!-- The keydate of a resource e.g a newspaper was issued or a letter was written -->
 	    <field name="date" type="daterange" indexed="true" stored="true" multiValued="false" />
         <!-- URL of thumbnail image for the document. -->

Configuration/FlexForms/ListView.xml

@@ -65,6 +65,14 @@
                             <default>0</default>
                         </config>
                     </settings.getTitle>
+                    <settings.getStructurePath>
+                        <exclude>1</exclude>
+                        <label>LLL:EXT:dlf/Resources/Private/Language/locallang_be.xlf:flexform.getStructurePath</label>
+                        <config>
+                            <type>check</type>
+                            <default>0</default>
+                        </config>
+                    </settings.getStructurePath>
                     <settings.basketButton>
                         <onChange>reload</onChange>
                         <exclude>1</exclude>

Documentation/Administrator/Index.rst

@@ -226,6 +226,26 @@ d. Reindex all documents. This can be done by the kitodo:reindex CLI command wit
 Furthermore version 5.1 supports the use of Solr Managed Schemas to update the schemas automatically during the update of the extension.
 To use this feature you have to change the schemaFactory within solrconfig.xml from "ClassicIndexSchemaFactory" to "ManagedIndexSchemaFactory".
 
+Version 5.1 & Version 6.0 -> 7.0
+==================
+
+Version 7.0 introduces a new Solr field :code:`structure_path`, that provides context in the ListView about where search results appear in the structure tree. Indexing requires 
+the field to be present in your running Solr instance, thus making the update of the schema.xml mandatory.
+
+Steps to Update your Solr schema.xml
+---------------
+a. Copy the updated schema.xml to your Solr configsets in $SOLR_HOME/configsets/dlf/
+b. Restart Solr.
+c. Reindex all documents in order to profit from the new field. This can be done by the kitodo:reindex CLI command with the '-a' (all) flag. See: :ref:`reindex_collections`.
+
+Plugin ListView
+---------------
+
+The ListView plugin has now a new setting 'Show breadcrumb/path to result location within the structure map', which is deactivated by default. When activated the 
+search results will display a string similar to a breadcrumb, that shows the label or type of the parents structures up to but excluding the toplevel structure. The 
+structure path will always be generated during indexing, the plugin settings toggles wether it will be displayed or not. Documents that not have been reindexed yet 
+will not display a structure path.
+
 *******
 Logging
 *******

Documentation/Plugins/Index.rst

@@ -443,6 +443,13 @@ List View
    :Default:
        0
 
+ - :Property:
+        getStructurePath
+   :Data Type:
+        :ref:`t3tsref:data-type-boolean`
+   :Default:
+       0
+
  - :Property:
        basketButton
    :Data Type:

Resources/Private/Language/de.locallang_be.xlf

@@ -17,6 +17,10 @@
                 <source><![CDATA[Show only documents from the selected collection(s)]]></source>
                 <target><![CDATA[Nur Dokumente der ausgewählten Kollektion(en) berücksichtigen]]></target>
             </trans-unit>
+            <trans-unit id="flexform.getStructurePath" approved="yes">
+                <source><![CDATA[Show breadcrumb/path to result location within the structure map]]></source>
+                <target><![CDATA[Breadcrumb/Pfad des Treffers innerhalb des Strukturbaums anzeigen]]></target>
+            </trans-unit>
             <trans-unit id="flexform.getTitle" approved="yes">
                 <source><![CDATA[Show title of parent document if document has no title itself]]></source>
                 <target><![CDATA[Bei Bedarf Titel des übergeordneten Dokuments anzeigen]]></target>

Resources/Private/Language/de.locallang_labels.xlf

@@ -821,6 +821,10 @@
                 <target>Solr-Schema-Feld "volume" : Volume field is mandatory for identifying documents (Standard ist "volume")</target>
                 <source>Solr Schema Field "volume" : Volume field is mandatory for identifying documents (default is "volume")</source>
             </trans-unit>
+            <trans-unit id="config.solr.fields.structurePath">
+                <target>Solr-Schema-Feld "structure_path" : Field providing context about the location of a resource in the structure map (Standard ist "structure_path")</target>
+                <source>Solr Schema Field "structure_path" : Field providing context about the location of a resource in the structure map (default is "structure_path")</source>
+            </trans-unit>
             <trans-unit id="config.solr.fields.date">
                 <target>Solr Schema Field "date" : The date a resource was issued or created. Used for datesearch (Standard ist "date")</target>
                 <source>Solr Schema Field "date" : The date a resource was issued or created. Used for datesearch (default is "date")</source>