LpXapianIndexer::indexLp() - Code Metrics - Inspection of "Search: enable Xapian indexing for course resource..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#7144)

unknown

created 2025-12-12 19:05 UTC

LpXapianIndexer::indexLp() F

↳ Parent: LpXapianIndexer

Complexity

Conditions	13
Paths	578

Size

Total Lines	88
Code Lines	55

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	13
eloc	55
c	1
b	0
f	0
nc	578
nop	1
dl	0
loc	88
rs	3.036

How to fix Long Method Complexity

<?php

declare(strict_types=1);

/* For licensing terms, see /license.txt */

namespace Chamilo\CoreBundle\Search\Xapian;

use Chamilo\CoreBundle\Entity\ResourceLink;
use Chamilo\CoreBundle\Entity\ResourceNode;
use Chamilo\CoreBundle\Entity\SearchEngineRef;
use Chamilo\CoreBundle\Settings\SettingsManager;
use Chamilo\CourseBundle\Entity\CLp;
use Doctrine\ORM\EntityManagerInterface;

/**
 * Handles Xapian indexing for learning paths (CLp).
 */
final class LpXapianIndexer
{
    public function __construct(
        private readonly XapianIndexService $xapianIndexService,
        private readonly EntityManagerInterface $em,
        private readonly SettingsManager $settingsManager,
    ) {
    }

    /**
     * Index or reindex a learning path.
     *
     * @return int|null Xapian document id or null when indexing is skipped
     */
    public function indexLp(CLp $lp): ?int
    {
        // Global feature toggle (same style as QuestionXapianIndexer)
        $enabled = (string) $this->settingsManager->getSetting('search.search_enabled', true);
        if ($enabled !== 'true') {
            return null;
        }

        $resourceNode = $lp->getResourceNode();
        if (!$resourceNode instanceof ResourceNode) {
            // Learning path without a resource node cannot be indexed
            return null;
        }

        // Resolve course and session from resource links
        [$courseId, $sessionId] = $this->resolveCourseAndSession($resourceNode);

        $title       = (string) $lp->getTitle();
        $description = (string) ($lp->getDescription() ?? '');
        $content     = \trim($title.' '.$description);

        // Keep field names consistent across indexers
        $fields = [
            'kind'             => 'learnpath',
            'tool'             => 'learnpath',
            'title'            => $title,
            'description'      => $description,
            'content'          => $content,
            'filetype'         => 'learnpath',
            'resource_node_id' => (string) $resourceNode->getId(),
            'lp_id'            => $lp->getIid() !== null ? (string) $lp->getIid() : '',
            'course_id'        => $courseId !== null ? (string) $courseId : '',
            'session_id'       => $sessionId !== null ? (string) $sessionId : '',
            'full_path'        => (string) $lp->getPath(),
            'xapian_data'      => json_encode([
                'type'       => 'learnpath',
                'lp_id'      => $lp->getIid(),
                'course_id'  => $courseId,
                'session_id' => $sessionId,
            ]),
        ];

        // Terms for filtering
        $terms = ['Tlearnpath', 'Tlp'];
        if ($courseId !== null) {
            $terms[] = 'C'.$courseId;
        }
        if ($sessionId !== null) {
            $terms[] = 'S'.$sessionId;
        }
        if ($lp->getIid() !== null) {
            $terms[] = 'L'.$lp->getIid();
        }

        // Reuse SearchEngineRef per resource node (same pattern as questions)
        /** @var SearchEngineRef|null $existingRef */
        $existingRef = $this->em
            ->getRepository(SearchEngineRef::class)
            ->findOneBy(['resourceNodeId' => $resourceNode->getId()]);

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

        if ($existingDocId !== null) {
            try {
                $this->xapianIndexService->deleteDocument($existingDocId);
            } catch (\Throwable) {
                // Best-effort delete: ignore errors
            }
        }

        try {
            $docId = $this->xapianIndexService->indexDocument($fields, $terms);
        } catch (\Throwable) {
            return null;
        }

        if ($existingRef instanceof SearchEngineRef) {
            $existingRef->setSearchDid($docId);
        } else {
            $existingRef = new SearchEngineRef();
            $existingRef->setResourceNodeId((int) $resourceNode->getId());
            $existingRef->setSearchDid($docId);
            $this->em->persist($existingRef);
        }

        $this->em->flush();

        return $docId;
    }

    /**
     * Delete learning path index (called on entity removal).
     */
    public function deleteLpIndex(CLp $lp): void
    {
        $resourceNode = $lp->getResourceNode();
        if (!$resourceNode instanceof ResourceNode) {
            return;
        }

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

        if (!$ref) {
            return;
        }

        try {
            $this->xapianIndexService->deleteDocument($ref->getSearchDid());
        } catch (\Throwable) {
            // Best-effort delete
        }

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

    /**
     * Resolve course and session ids from resource links.
     *
     * @return array{0:int|null,1:int|null}
     */
    private function resolveCourseAndSession(ResourceNode $resourceNode): array
    {
        $courseId  = null;
        $sessionId = null;

        foreach ($resourceNode->getResourceLinks() as $link) {
            if (!$link instanceof ResourceLink) {
                continue;
            }

            if ($courseId === null && $link->getCourse()) {
                $courseId = $link->getCourse()->getId();
            }

            if ($sessionId === null && $link->getSession()) {
                $sessionId = $link->getSession()->getId();
            }

            if ($courseId !== null && $sessionId !== null) {
                break;
            }
        }

        return [$courseId, $sessionId];
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/* For licensing terms, see /license.txt */
6
7			namespace Chamilo\CoreBundle\Search\Xapian;
8
9			use Chamilo\CoreBundle\Entity\ResourceLink;
10			use Chamilo\CoreBundle\Entity\ResourceNode;
11			use Chamilo\CoreBundle\Entity\SearchEngineRef;
12			use Chamilo\CoreBundle\Settings\SettingsManager;
13			use Chamilo\CourseBundle\Entity\CLp;
14			use Doctrine\ORM\EntityManagerInterface;
15
16			/**
17			* Handles Xapian indexing for learning paths (CLp).
18			*/
19			final class LpXapianIndexer
20			{
21			public function __construct(
22			private readonly XapianIndexService $xapianIndexService,
23			private readonly EntityManagerInterface $em,
24			private readonly SettingsManager $settingsManager,
25			) {
26			}
27
28			/**
29			* Index or reindex a learning path.
30			*
31			* @return int\|null Xapian document id or null when indexing is skipped
32			*/
33			public function indexLp(CLp $lp): ?int
34			{
35			// Global feature toggle (same style as QuestionXapianIndexer)
36			$enabled = (string) $this->settingsManager->getSetting('search.search_enabled', true);
37			if ($enabled !== 'true') {
38			return null;
39			}
40
41			$resourceNode = $lp->getResourceNode();
42			if (!$resourceNode instanceof ResourceNode) {
43			// Learning path without a resource node cannot be indexed
44			return null;
45			}
46
47			// Resolve course and session from resource links
48			[$courseId, $sessionId] = $this->resolveCourseAndSession($resourceNode);
49
50			$title = (string) $lp->getTitle();
51			$description = (string) ($lp->getDescription() ?? '');
52			$content = \trim($title.' '.$description);
53
54			// Keep field names consistent across indexers
55			$fields = [
56			'kind' => 'learnpath',
57			'tool' => 'learnpath',
58			'title' => $title,
59			'description' => $description,
60			'content' => $content,
61			'filetype' => 'learnpath',
62			'resource_node_id' => (string) $resourceNode->getId(),
63			'lp_id' => $lp->getIid() !== null ? (string) $lp->getIid() : '',
64			'course_id' => $courseId !== null ? (string) $courseId : '',
65			'session_id' => $sessionId !== null ? (string) $sessionId : '',
66			'full_path' => (string) $lp->getPath(),
67			'xapian_data' => json_encode([
68			'type' => 'learnpath',
69			'lp_id' => $lp->getIid(),
70			'course_id' => $courseId,
71			'session_id' => $sessionId,
72			]),
73			];
74
75			// Terms for filtering
76			$terms = ['Tlearnpath', 'Tlp'];
77			if ($courseId !== null) {
78			$terms[] = 'C'.$courseId;
79			}
80			if ($sessionId !== null) {
81			$terms[] = 'S'.$sessionId;
82			}
83			if ($lp->getIid() !== null) {
84			$terms[] = 'L'.$lp->getIid();
85			}
86
87			// Reuse SearchEngineRef per resource node (same pattern as questions)
88			/** @var SearchEngineRef\|null $existingRef */
89			$existingRef = $this->em
90			->getRepository(SearchEngineRef::class)
91			->findOneBy(['resourceNodeId' => $resourceNode->getId()]);
92
93			$existingDocId = $existingRef?->getSearchDid();
94
95			if ($existingDocId !== null) {
96			try {
97			$this->xapianIndexService->deleteDocument($existingDocId);
98			} catch (\Throwable) {
99			// Best-effort delete: ignore errors
100			}
101			}
102
103			try {
104			$docId = $this->xapianIndexService->indexDocument($fields, $terms);
105			} catch (\Throwable) {
106			return null;
107			}
108
109			if ($existingRef instanceof SearchEngineRef) {
110			$existingRef->setSearchDid($docId);
111			} else {
112			$existingRef = new SearchEngineRef();
113			$existingRef->setResourceNodeId((int) $resourceNode->getId());
114			$existingRef->setSearchDid($docId);
115			$this->em->persist($existingRef);
116			}
117
118			$this->em->flush();
119
120			return $docId;
121			}
122
123			/**
124			* Delete learning path index (called on entity removal).
125			*/
126			public function deleteLpIndex(CLp $lp): void
127			{
128			$resourceNode = $lp->getResourceNode();
129			if (!$resourceNode instanceof ResourceNode) {
130			return;
131			}
132
133			/** @var SearchEngineRef\|null $ref */
134			$ref = $this->em
135			->getRepository(SearchEngineRef::class)
136			->findOneBy(['resourceNodeId' => $resourceNode->getId()]);
137
138			if (!$ref) {
139			return;
140			}
141
142			try {
143			$this->xapianIndexService->deleteDocument($ref->getSearchDid());
144			} catch (\Throwable) {
145			// Best-effort delete
146			}
147
148			$this->em->remove($ref);
149			$this->em->flush();
150			}
151
152			/**
153			* Resolve course and session ids from resource links.
154			*
155			* @return array{0:int\|null,1:int\|null}
156			*/
157			private function resolveCourseAndSession(ResourceNode $resourceNode): array
158			{
159			$courseId = null;
160			$sessionId = null;
161
162			foreach ($resourceNode->getResourceLinks() as $link) {
163			if (!$link instanceof ResourceLink) {
164			continue;
165			}
166
167			if ($courseId === null && $link->getCourse()) {
168			$courseId = $link->getCourse()->getId();
169			}
170
171			if ($sessionId === null && $link->getSession()) {
172			$sessionId = $link->getSession()->getId();
173			}
174
175			if ($courseId !== null && $sessionId !== null) {
176			break;
177			}
178			}
179
180			return [$courseId, $sessionId];
181			}
182			}
183

chamilo / chamilo-lms

Pull Request — master (#7144)

LpXapianIndexer::indexLp() F

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like