Chamilo\CourseBundle\Component\CourseCopy\CourseRecycler

Complexity

Total Complexity

63

Size/Duplication

Total Lines	373
Duplicated Lines	0 %

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	courseRef()	0	4	1
A	hardDeleteMany()	0	21	4
A	autoCleanIfSupported()	0	5	2
A	cleanupScormDirsForAllLp()	0	2	1
A	fetchResourcesForCourse()	0	29	6
A	deleteAllOfTypeForCourse()	0	5	2
B	recycleGeneric()	0	37	10
B	preUnlinkBeforeDelete()	0	20	7
A	clearLpCategoriesForCourse()	0	15	6
A	unplugCertificateDocsForCourse()	0	33	4
A	deleteSelectedOfTypeForCourse()	0	8	3
A	ids()	0	6	3
B	clearLpCategoriesForIds()	0	15	7
A	recycle()	0	43	2
A	cleanupScormDirsForLpIds()	0	2	1
A	recycleLpCategories()	0	18	3

<?php

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

declare(strict_types=1);

namespace Chamilo\CourseBundle\Component\CourseCopy;

use Chamilo\CoreBundle\Entity\AbstractResource;
use Chamilo\CoreBundle\Entity\Course as CoreCourse;
use Chamilo\CoreBundle\Entity\GradebookCategory;
use Chamilo\CourseBundle\Entity\CAnnouncement;
use Chamilo\CourseBundle\Entity\CAttendance;
use Chamilo\CourseBundle\Entity\CCalendarEvent;
use Chamilo\CourseBundle\Entity\CCourseDescription;
use Chamilo\CourseBundle\Entity\CDocument;
use Chamilo\CourseBundle\Entity\CForum;
use Chamilo\CourseBundle\Entity\CForumCategory;
use Chamilo\CourseBundle\Entity\CGlossary;
use Chamilo\CourseBundle\Entity\CLink;
use Chamilo\CourseBundle\Entity\CLinkCategory;
use Chamilo\CourseBundle\Entity\CLp;
use Chamilo\CourseBundle\Entity\CLpCategory;
use Chamilo\CourseBundle\Entity\CQuiz;
use Chamilo\CourseBundle\Entity\CQuizCategory;
use Chamilo\CourseBundle\Entity\CStudentPublication;
use Chamilo\CourseBundle\Entity\CSurvey;
use Chamilo\CourseBundle\Entity\CThematic;
use Chamilo\CourseBundle\Entity\CWiki;
use Doctrine\ORM\EntityManagerInterface;

final class CourseRecycler
{
    public function __construct(
        private readonly EntityManagerInterface $em,
        private readonly string $courseCode,
        private readonly int $courseId
    ) {}

    /**
     * $type: 'full_backup' | 'select_items' ; $selected: [type => [id => true]].
     */
    public function recycle(string $type, array $selected): void
    {
        $isFull = ('full_backup' === $type);

        // If your EM doesn't have wrapInTransaction(), replace by $this->em->transactional(fn() => { ... })
        $this->em->wrapInTransaction(function () use ($isFull, $selected): void {
            $this->unplugCertificateDocsForCourse();

            // Links & categories
            $this->recycleGeneric($isFull, CLink::class, $selected['link'] ?? []);
            $this->recycleGeneric($isFull, CLinkCategory::class, $selected['link_category'] ?? [], autoClean: true);

            // Calendar & announcements
            $this->recycleGeneric($isFull, CCalendarEvent::class, $selected['event'] ?? []);
            $this->recycleGeneric($isFull, CAnnouncement::class, $selected['announcement'] ?? []);

            // Documents
            $this->recycleGeneric($isFull, CDocument::class, $selected['document'] ?? [], deleteFiles: true);

            // Forums & forum categories
            $this->recycleGeneric($isFull, CForum::class, $selected['forum'] ?? [], cascadeHeavy: true);
            $this->recycleGeneric($isFull, CForumCategory::class, $selected['forum_category'] ?? [], autoClean: true);

            // Quizzes & categories
            $this->recycleGeneric($isFull, CQuiz::class, $selected['quiz'] ?? [], cascadeHeavy: true);
            $this->recycleGeneric($isFull, CQuizCategory::class, $selected['test_category'] ?? []);

            // Surveys
            $this->recycleGeneric($isFull, CSurvey::class, $selected['survey'] ?? [], cascadeHeavy: true);

            // Learning paths & categories
            $this->recycleGeneric($isFull, CLp::class, $selected['learnpath'] ?? [], cascadeHeavy: true, scormCleanup: true);
            $this->recycleLpCategories($isFull, $selected['learnpath_category'] ?? []);

            // Other resources
            $this->recycleGeneric($isFull, CCourseDescription::class, $selected['course_description'] ?? []);
            $this->recycleGeneric($isFull, CWiki::class, $selected['wiki'] ?? [], cascadeHeavy: true);
            $this->recycleGeneric($isFull, CGlossary::class, $selected['glossary'] ?? []);
            $this->recycleGeneric($isFull, CThematic::class, $selected['thematic'] ?? [], cascadeHeavy: true);
            $this->recycleGeneric($isFull, CAttendance::class, $selected['attendance'] ?? [], cascadeHeavy: true);
            $this->recycleGeneric($isFull, CStudentPublication::class, $selected['work'] ?? [], cascadeHeavy: true);

            if ($isFull) {
                // If you keep cleaning course picture:
                // CourseManager::deleteCoursePicture($this->courseCode);
            }
        });
    }

    /**
     * Generic recycler for any AbstractResource-based entity.
     * - If $isFull => deletes *all resources of that type* for the course.
     * - If partial => deletes only the provided $ids.
     * Options:
     *  - deleteFiles: physical files are already handled by hardDelete (if repo supports it).
     *  - cascadeHeavy: for heavy-relations types (forums, LPs). hardDelete should traverse.
     *  - autoClean: e.g. remove empty categories after deleting links/forums.
     *  - scormCleanup: if LP SCORM → hook storage service if needed.
     */
    private function recycleGeneric(
        bool $isFull,
        string $entityClass,
        array $idsMap,
        bool $deleteFiles = false,
        bool $cascadeHeavy = false,
        bool $autoClean = false,
        bool $scormCleanup = false
    ): void {
        if ($isFull) {
            $this->deleteAllOfTypeForCourse($entityClass);
            if ($autoClean) {
                $this->autoCleanIfSupported($entityClass);
            }
            if ($scormCleanup && CLp::class === $entityClass) {
                $this->cleanupScormDirsForAllLp();
            }

            return;
        }

        $ids = $this->ids($idsMap);
        if (!$ids) {

The expression $ids of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            if ($autoClean) {
                $this->autoCleanIfSupported($entityClass);
            }

            return;
        }

        $this->deleteSelectedOfTypeForCourse($entityClass, $ids);

        if ($autoClean) {
            $this->autoCleanIfSupported($entityClass);
        }
        if ($scormCleanup && CLp::class === $entityClass) {
            $this->cleanupScormDirsForLpIds($ids);
        }
    }

    /**
     * LP categories: detach LPs and then delete selected/all categories.
     */
    private function recycleLpCategories(bool $isFull, array $idsMap): void
    {
        if ($isFull) {
            // Detach all categories from LPs in course
            $this->clearLpCategoriesForCourse();
            $this->deleteAllOfTypeForCourse(CLpCategory::class);

            return;
        }

        $ids = $this->ids($idsMap);
        if (!$ids) {

The expression $ids of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return;
        }

        // Detach LPs from these categories
        $this->clearLpCategoriesForIds($ids);
        $this->deleteSelectedOfTypeForCourse(CLpCategory::class, $ids);
    }

    /**
     * Normalizes IDs from [id => true] maps into int/string scalars.
     */
    private function ids(array $map): array
    {
        return array_values(array_filter(array_map(
            static fn ($k) => is_numeric($k) ? (int) $k : (string) $k,
            array_keys($map)
        ), static fn ($v) => '' !== $v && null !== $v));
    }

    /**
     * Lightweight Course reference for query builders.
     */
    private function courseRef(): CoreCourse
    {
        /** @var CoreCourse $ref */
        return $this->em->getReference(CoreCourse::class, $this->courseId);
    }

    /**
     * Fetches resources by entity class within course, optionally filtering by resource iid.
     * If the repository doesn't extend ResourceRepository, falls back to a generic QB.
     *
     * @return array<int, AbstractResource>
     */
    private function fetchResourcesForCourse(string $entityClass, ?array $ids = null): array
    {
        $repo = $this->em->getRepository($entityClass);

        // Path A: repository exposes ResourceRepository API
        if (method_exists($repo, 'getResourcesByCourseIgnoreVisibility')) {
            $qb = $repo->getResourcesByCourseIgnoreVisibility($this->courseRef());
            if ($ids && \count($ids) > 0) {
                $qb->andWhere('resource.iid IN (:ids)')->setParameter('ids', $ids);
            }

            return $qb->getQuery()->getResult();
        }

        // Path B: generic fallback (join to ResourceNode/ResourceLinks and filter by course)
        $qb = $this->em->createQueryBuilder()
            ->select('resource')
            ->from($entityClass, 'resource')
            ->innerJoin('resource.resourceNode', 'node')
            ->innerJoin('node.resourceLinks', 'links')
            ->andWhere('links.course = :course')
            ->setParameter('course', $this->courseRef())
        ;

        if ($ids && \count($ids) > 0) {
            $qb->andWhere('resource.iid IN (:ids)')->setParameter('ids', $ids);
        }

        return $qb->getQuery()->getResult();
    }

    /**
     * Force-unlink associations that can trigger cascade-persist on delete.
     * We always null GradebookCategory->document before removing the category.
     */
    private function preUnlinkBeforeDelete(array $entities): void
    {
        $changed = false;

        foreach ($entities as $e) {
            if ($e instanceof GradebookCategory
                && method_exists($e, 'getDocument')
                && method_exists($e, 'setDocument')
            ) {
                if (null !== $e->getDocument()) {
                    // Prevent "new entity found through relationship" on flush
                    $e->setDocument(null);
                    $this->em->persist($e);
                    $changed = true;
                }
            }
        }

        if ($changed) {
            $this->em->flush();
        }
    }

    /**
     * Hard-deletes a list of resources. If repository doesn't provide hardDelete(),
     * falls back to EM->remove() and a final flush (expect proper cascade mappings).
     */
    private function hardDeleteMany(string $entityClass, array $resources): void
    {
        $repo = $this->em->getRepository($entityClass);

        // Unlink problematic associations up front (prevents cascade-persist on flush)
        $this->preUnlinkBeforeDelete($resources);

        $usedFallback = false;
        foreach ($resources as $res) {
            if (method_exists($repo, 'hardDelete')) {
                // Repo handles full hard delete (nodes/links/files)
                $repo->hardDelete($res);
            } else {
                // Fallback: standard remove (expect proper cascades elsewhere)
                $this->em->remove($res);
                $usedFallback = true;
            }
        }

        if ($usedFallback) {
            $this->em->flush();
        }
    }

    /**
     * Deletes all resources of a type in the course.
     */
    private function deleteAllOfTypeForCourse(string $entityClass): void
    {
        $resources = $this->fetchResourcesForCourse($entityClass, null);
        if ($resources) {

The expression $resources of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->hardDeleteMany($entityClass, $resources);
        }
    }

    /**
     * Deletes selected resources (by iid) of a type in the course.
     */
    private function deleteSelectedOfTypeForCourse(string $entityClass, array $ids): void
    {
        if (!$ids) {

The expression $ids of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            return;
        }
        $resources = $this->fetchResourcesForCourse($entityClass, $ids);
        if ($resources) {

The expression $resources of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $this->hardDeleteMany($entityClass, $resources);
        }
    }

    /**
     * Optional post-clean for empty categories if repository supports it.
     */
    private function autoCleanIfSupported(string $entityClass): void
    {
        $repo = $this->em->getRepository($entityClass);
        if (method_exists($repo, 'deleteEmptyByCourse')) {
            $repo->deleteEmptyByCourse($this->courseId);
        }
    }

    /**
     * Detach categories from ALL LPs in course (repo-level bulk method preferred if available).
     */
    private function clearLpCategoriesForCourse(): void
    {
        $lps = $this->fetchResourcesForCourse(CLp::class, null);
        $changed = false;
        foreach ($lps as $lp) {
            if (method_exists($lp, 'getCategory') && method_exists($lp, 'setCategory')) {
                if ($lp->getCategory()) {
                    $lp->setCategory(null);
                    $this->em->persist($lp);
                    $changed = true;
                }
            }
        }
        if ($changed) {
            $this->em->flush();
        }
    }

    /**
     * Detach categories only for LPs that are linked to given category ids.
     */
    private function clearLpCategoriesForIds(array $catIds): void
    {
        $lps = $this->fetchResourcesForCourse(CLp::class, null);
        $changed = false;
        foreach ($lps as $lp) {
            $cat = method_exists($lp, 'getCategory') ? $lp->getCategory() : null;
            $catId = $cat?->getId();
            if (null !== $catId && \in_array($catId, $catIds, true) && method_exists($lp, 'setCategory')) {
                $lp->setCategory(null);
                $this->em->persist($lp);
                $changed = true;
            }
        }
        if ($changed) {
            $this->em->flush();
        }
    }

    private function unplugCertificateDocsForCourse(): void
    {
        // Detach any certificate-type document from gradebook categories of this course
        // Reason: avoid "A new entity was found through the relationship ... #document" on flush.
        $qb = $this->em->createQueryBuilder()
            ->select('c', 'd')
            ->from(GradebookCategory::class, 'c')
            ->innerJoin('c.course', 'course')
            ->leftJoin('c.document', 'd')
            ->where('course.id = :cid')
            ->andWhere('d IS NOT NULL')
            ->andWhere('d.filetype = :ft')
            ->setParameter('cid', $this->courseId)
            ->setParameter('ft', 'certificate')
        ;

        /** @var GradebookCategory[] $cats */
        $cats = $qb->getQuery()->getResult();

        $changed = false;
        foreach ($cats as $cat) {
            $doc = $cat->getDocument();
            if ($doc instanceof CDocument) {
                // Prevent transient Document from being cascaded/persisted during delete
                $cat->setDocument(null);
                $this->em->persist($cat);
                $changed = true;
            }
        }

        if ($changed) {
            // Materialize unlink before any deletion happens
            $this->em->flush();
        }
    }

    /**
     * SCORM directory cleanup for ALL LPs (hook your storage service here if needed).
     */
    private function cleanupScormDirsForAllLp(): void
    {
        // If you have a storage/scorm service, invoke it here.
        // By default, nothing: hardDelete already deletes files linked to ResourceNode.
    }

    /**
     * SCORM directory cleanup for selected LPs.
     */
    private function cleanupScormDirsForLpIds(array $lpIds): void
    {
        // Same as above, but limited to provided LP ids.
    }
}