Chamilo\CoreBundle\Search\Xapian\DocumentXapianIndexer

Complexity

Total Complexity

42

Size/Duplication

Total Lines	302
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

<?php
use Symfony\Component\HttpFoundation\RequestStack;
use Symfony\Component\Process\Process;
use Throwable;
use ZipArchive;

/**
 * Handles Xapian indexing for CDocument entities.
 */
final class DocumentXapianIndexer
{
    public function __construct(
        private readonly XapianIndexService $xapianIndexService,
        private readonly EntityManagerInterface $em,
        private readonly SettingsManager $settingsManager,
        private readonly DocumentRawTextExtractor $rawTextExtractor,
        private readonly RequestStack $requestStack,
    ) {}

    /**
     * Index a CDocument into Xapian.
     *
     * @return int|null Xapian document id or null when indexing is skipped
     */
    public function indexDocument(CDocument $document): ?int
    {
        $resourceNode = $document->getResourceNode();

        $enabled = (string) $this->settingsManager->getSetting('search.search_enabled', true);

        if ('true' !== $enabled) {
            error_log('[Xapian] indexDocument: search is disabled, skipping indexing');
            return null;
        }

        if (!$resourceNode instanceof ResourceNode) {
            error_log('[Xapian] indexDocument: missing ResourceNode, skipping');
            return null;
        }

        if ('folder' === $document->getFiletype()) {
            error_log('[Xapian] indexDocument: skipping folder document, resource_node_id='.$resourceNode->getId());
            return null;
        }

        [$courseId, $sessionId, $courseRootNodeId] = $this->resolveCourseSessionAndRootNode($resourceNode);

        $content = $this->rawTextExtractor->extract($document);

        $fields = [
            'title' => (string) $document->getTitle(),
            'description' => (string) ($document->getComment() ?? ''),
            'content' => $content,
            'filetype' => (string) $document->getFiletype(),
            'resource_node_id' => (string) $resourceNode->getId(),
            'course_id' => null !== $courseId ? (string) $courseId : '',
            'session_id' => null !== $sessionId ? (string) $sessionId : '',
            'course_root_node_id' => null !== $courseRootNodeId ? (string) $courseRootNodeId : '',
            'full_path' => $document->getFullPath(),
        ];

        $terms = ['Tdocument'];

        if (null !== $courseId) {
            $terms[] = 'C'.$courseId;
        }
        if (null !== $sessionId) {
            $terms[] = 'S'.$sessionId;
        }

        $this->applyPrefilterConfigToTerms($terms, $courseId, $sessionId, $document);

        $resourceNodeId = (int) $resourceNode->getId();
        $resourceNodeRef = $this->em->getReference(ResourceNode::class, $resourceNodeId);

        /** @var SearchEngineRef|null $existingRef */
        $existingRef = $this->em
            ->getRepository(SearchEngineRef::class)
            ->findOneBy(['resourceNode' => $resourceNodeRef]);

        $existingDocId = $existingRef?->getSearchDid();

        if (null !== $existingDocId) {
            try {
                $this->xapianIndexService->deleteDocument($existingDocId);
            } catch (Throwable $e) {
                error_log('[Xapian] indexDocument: failed to delete previous docId='.$existingDocId.' error='.$e->getMessage());
            }
        }

        // Get raw input from request (might be keyed by code OR by field_id)
        $rawInput = $this->extractSearchFieldValuesFromRequest();

        // Normalize into code => value (t/d/k/whatever)
        $inputByCode = $this->normalizeSearchFieldValuesToCode($rawInput);

        // Merge with stored values (stored wins only when request has nothing for that field)
        $storedByCode = $this->fetchStoredSearchFieldValuesByCode($resourceNodeId);

        // Request should override stored
        $searchFieldValuesByCode = array_replace($storedByCode, $inputByCode);

        // resolve language ISO for stemming (resource_file > resource_node)
        $languageIso = $this->resolveLanguageIsoForResourceNode($resourceNode);

        try {
            // Pass language ISO to the index service (it will map ISO -> Xapian language)
            $docId = $this->xapianIndexService->indexDocument(
                $fields,
                $terms,
                $languageIso,
                $searchFieldValuesByCode
            );
        } catch (Throwable $e) {
            error_log('[Xapian] indexDocument: Xapian indexing failed: '.$e->getMessage());
            return null;
        }

        if ($existingRef instanceof SearchEngineRef) {
            $existingRef->setSearchDid($docId);
        } else {
            $existingRef = new SearchEngineRef();
            $existingRef->setResourceNode($resourceNodeRef);
            $existingRef->setSearchDid($docId);
            $this->em->persist($existingRef);
        }

        // Persist dynamic search field values (create/update)
        $this->syncSearchEngineFieldValues($resourceNodeId, $document, $content);

        $this->em->flush();

        return $docId;
    }

    public function deleteForResourceNodeId(int $resourceNodeId): void
    {
        $enabled = (string) $this->settingsManager->getSetting('search.search_enabled', true);
        if ('true' !== $enabled) {
            error_log('[Xapian] deleteForResourceNodeId: search is disabled, skipping');
            return;
        }

        try {
            $this->em->getConnection()->executeStatement(
                'DELETE FROM search_engine_field_value WHERE resource_node_id = ?',
                [$resourceNodeId]
            );
        } catch (Throwable $e) {
            error_log('[Xapian] deleteForResourceNodeId: failed to delete field values: '.$e->getMessage());
        }

        $resourceNodeRef = $this->em->getReference(ResourceNode::class, $resourceNodeId);

        /** @var SearchEngineRef|null $ref */
        $ref = $this->em
            ->getRepository(SearchEngineRef::class)
            ->findOneBy(['resourceNode' => $resourceNodeRef]);

        if (!$ref instanceof SearchEngineRef) {
            error_log('[Xapian] deleteForResourceNodeId: no SearchEngineRef found, nothing to delete');
            return;
        }

        $docId = $ref->getSearchDid();
        if (null !== $docId) {
            try {
                $this->xapianIndexService->deleteDocument($docId);
            } catch (Throwable $e) {
                error_log('[Xapian] deleteForResourceNodeId: deleteDocument failed for did='.$docId.' error='.$e->getMessage());
            }
        }

        $this->em->remove($ref);
        $this->em->flush();
    }

    /**
     * Persist search_engine_field_value dynamically based on values sent by UI/API.
     *
     * Accepts:
     * - multipart: searchFieldValues[t]=..., searchFieldValues[d]=...
     * - multipart: searchFieldValues as JSON string {"t":"..."}
     * - legacy/alt: searchFieldValues as array keyed by field id (1,2,3)
     */
    private function syncSearchEngineFieldValues(int $resourceNodeId, CDocument $document, string $content): void
    {
        $conn = $this->em->getConnection();

        $maps = $this->fetchSearchEngineFields($conn);
        $byCode = $maps['byCode'];
        $byId = $maps['byId'];

        if (empty($byCode)) {
            error_log('[Xapian] syncSearchEngineFieldValues: no search_engine_field rows found, skipping');
            return;
        }

        // Raw values from request (could be keyed by code OR id)
        $rawValues = $this->extractSearchFieldValuesFromRequest();
        $hasExplicitInput = \is_array($rawValues) && \count($rawValues) > 0;

        // If we didn't receive anything, do NOT overwrite existing values on update.
        // This prevents accidental resets when the request does not carry searchFieldValues.
        try {
            $existingCount = (int) $conn->fetchOne(
                'SELECT COUNT(*) FROM search_engine_field_value WHERE resource_node_id = ?',
                [$resourceNodeId]
            );
        } catch (Throwable $e) {
            $existingCount = 0;
        }

        if (!$hasExplicitInput && $existingCount > 0) {
            error_log(
                '[Xapian] syncSearchEngineFieldValues: no input received, keeping existing values for resource_node_id='.$resourceNodeId
            );
            return;
        }

        // Normalize into field_id => value
        $valuesByFieldId = [];

        foreach ($rawValues as $key => $val) {
            // NOTE: keep explicit empty strings to allow "clear",
            // but skip when building inserts
            $value = (string) $val;

            $fieldId = null;

            if (is_numeric((string) $key)) {
                $id = (int) $key;
                if (isset($byId[$id])) {
                    $fieldId = $id;
                }
            } else {
                $code = strtolower(trim((string) $key));
                if (isset($byCode[$code])) {
                    $fieldId = (int) $byCode[$code]['id'];
                }
            }

            if (null === $fieldId) {
                continue;
            }

            $valuesByFieldId[$fieldId] = trim($value);
        }

        // Conservative fallback: only fill missing ones for known semantics (t/d/c)
        foreach ($byCode as $code => $meta) {
            $fid = (int) $meta['id'];
            if (isset($valuesByFieldId[$fid])) {
                continue;
            }

            $fallback = $this->guessFallbackValue(
                (string) $code,
                (string) ($meta['title'] ?? ''),
                $document,
                $content
            );

            if (null !== $fallback) {
                $fallback = trim($fallback);
                if ('' !== $fallback) {
                    $valuesByFieldId[$fid] = $fallback;
                }
            }
        }

        try {
            $conn->executeStatement(
                'DELETE FROM search_engine_field_value WHERE resource_node_id = ?',
                [$resourceNodeId]
            );

            foreach ($valuesByFieldId as $fid => $value) {
                $conn->insert('search_engine_field_value', [
                    'resource_node_id' => $resourceNodeId,
                    'field_id' => (int) $fid,
                    'value' => (string) $value,
                ]);
            }
        } catch (Throwable $e) {
            error_log('[Xapian] syncSearchEngineFieldValues: failed: '.$e->getMessage());
        }
    }

    /**
     * @return array{
     *   byCode: array<string, array{id:int,title:string}>,
     *   byId: array<int, array{code:string,title:string}>
     * }
     */
    private function fetchSearchEngineFields(Connection $conn): array
    {
        try {
            $rows = $conn->fetchAllAssociative('SELECT id, code, title FROM search_engine_field');
        } catch (Throwable $e) {
            error_log('[Xapian] fetchSearchEngineFields: query failed: '.$e->getMessage());
            return ['byCode' => [], 'byId' => []];
        }