Certificate::generate()

Complexity

Conditions	33
Paths	> 20000

Size

Total Lines	199
Code Lines	132

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

<?php
    public function generate($params = [], $sendNotification = false)
    {
        // Safe defaults
        $params = is_array($params) ? $params : [];
        $params['hide_print_button'] = isset($params['hide_print_button'])
            ? (bool) $params['hide_print_button']
            : false;

        // Repository (required).
        try {
            $certRepo = Container::getGradeBookCertificateRepository();
        } catch (\Throwable $e) {
            error_log('[CERT::generate] FATAL: cannot get GradeBookCertificateRepository: '.$e->getMessage());
            return false;
        }
        if (!$certRepo) {

$certRepo is of type Chamilo\CoreBundle\Repository\GradebookCertificateRepository, thus it always evaluated to true.

            error_log('[CERT::generate] FATAL: GradeBookCertificateRepository is NULL');
            return false;
        }

        $categoryId = 0;
        $category   = null;
        $isCertificateAvailableInCategory = false;

        // If the certificate is linked to a Gradebook category, check availability
        if (isset($this->certificate_data['cat_id'])) {
            $categoryId = (int) $this->certificate_data['cat_id'];

            // Category::load() returns an array
            $myCategory = Category::load($categoryId);

            try {
                $repo = Container::getGradeBookCategoryRepository();
                /** @var GradebookCategory|null $category */
                $category = $repo ? $repo->find($categoryId) : null;

$repo is of type Chamilo\CoreBundle\Repository\GradeBookCategoryRepository, thus it always evaluated to true.

            } catch (\Throwable $e) {
                error_log('[CERT::generate] category repo fetch failed: '.$e->getMessage());
                $category = null;
            }

            if (!empty($categoryId) && !empty($myCategory) && isset($myCategory[0])) {
                $isCertificateAvailableInCategory = $myCategory[0]->is_certificate_available($this->user_id);
            }
        }

        // Path A: course/session-bound certificate (category context)
        if ($isCertificateAvailableInCategory && null !== $category) {
            // Course/session info
            $course     = $category->getCourse();
            $courseInfo = api_get_course_info($course->getCode());
            $courseId   = $courseInfo['real_id'];
            $sessionId  = $category->getSession() ? (int) $category->getSession()->getId() : 0;

            try {
                $skill = new SkillModel();
                $skill->addSkillToUser(
                    $this->user_id,
                    $category,
                    $courseId,
                    $sessionId
                );
            } catch (\Throwable $e) {
                error_log('[CERT::generate] addSkillToUser failed: '.$e->getMessage());
            }

            $categoryHasDefaultTemplate = false;
            $documentIdForLog = null;
            try {
                $doc = $category->getDocument();
                if ($doc !== null) {
                    $categoryHasDefaultTemplate = true;
                    try {
                        $documentIdForLog = method_exists($doc, 'getId') ? $doc->getId() : null;
                    } catch (\Throwable $ignored) {
                        $documentIdForLog = null;
                    }
                }
            } catch (\Throwable $e) {
                error_log('[CERT::generate] getDocument() failed (no default template): '.$e->getMessage());
                $categoryHasDefaultTemplate = false;
            }

            $gb = GradebookUtils::get_user_certificate_content(
                $this->user_id,
                $course->getId(),
                $sessionId,
                false,
                $params['hide_print_button']
            );

            $score = 100.0;
            if (is_array($gb) && isset($gb['score'])) {
                $score = (float)$gb['score'];
            }

            $html   = '';
            $source = '';

            if ($categoryHasDefaultTemplate) {
                if (is_array($gb) && !empty($gb['content'])) {
                    $html   = (string)$gb['content'];
                    $source = 'DEFAULT_TEMPLATE';
                } elseif (is_string($gb) && $gb !== '') {
                    $html   = $gb;
                    $source = 'DEFAULT_TEMPLATE';
                }
            } else {
                error_log(sprintf(
                    '[CERT::generate] course DEFAULT template NOT found. cat=%d user=%d -> fallback to CUSTOM',
                    (int)$categoryId,
                    (int)$this->user_id
                ));
            }

            if ($html === '') {
                $html   = $this->generateCustomCertificate('');
                $source = 'CUSTOM_TEMPLATE_FALLBACK';
            }

            if ($html === '') {
                error_log(sprintf(
                    '[CERT::generate] Empty HTML on category path. cat=%d user=%d',
                    (int)$categoryId,
                    (int)$this->user_id
                ));
                return false;
            }

            try {
                // Persist as Resource and register legacy info (no PersonalFile)
                $entity = $certRepo->upsertCertificateResource($categoryId, $this->user_id, $score, $html);
                $certRepo->registerUserInfoAboutCertificate($categoryId, $this->user_id, $score);

                // Ensure PDF flow has the HTML in memory
                $this->certificate_data['file_content']     = $html;
                $this->certificate_data['path_certificate'] = '';

                // Send notification if required (we have course context here)
                if ($sendNotification) {
                    $subject = get_lang('Certificate notification');
                    $message = nl2br(get_lang('((user_first_name)),'));
                    $htmlUrl = '';
                    try {
                        $htmlUrl = $certRepo->getResourceFileUrl($entity);
                    } catch (\Throwable $e) {
                        error_log('[CERT::generate] getResourceFileUrl failed for notification: '.$e->getMessage());
                    }

                    self::sendNotification(
                        $subject,
                        $message,
                        api_get_user_info($this->user_id),
                        $courseInfo,
                        [
                            'score_certificate' => $score,
                            'html_url'          => $htmlUrl,
                        ]
                    );
                }

                return true;
            } catch (\Throwable $e) {
                error_log(sprintf(
                    '[CERT::generate] Upsert FAILED (course). cat=%d user=%d err=%s',
                    (int)$categoryId,
                    (int)$this->user_id,
                    $e->getMessage()
                ));
                return false;
            }
        }

        // Path B: general (portal-wide) certificate
        try {
            $html  = $this->generateCustomCertificate('');
            $score = 100.0;

            if ($html === '') {
                error_log(sprintf(
                    '[CERT::generate] Empty HTML on general path. user=%d',
                    (int)$this->user_id
                ));
                return false;
            }

            $entity = $certRepo->upsertCertificateResource(0, $this->user_id, $score, $html);
            $certRepo->registerUserInfoAboutCertificate(0, $this->user_id, $score);

            $this->certificate_data['file_content']     = $html;
            $this->certificate_data['path_certificate'] = ''; // resource

            return true;
        } catch (\Throwable $e) {
            error_log(sprintf(
                '[CERT::generate] Upsert FAILED (general). user=%d err=%s',
                (int)$this->user_id,
                $e->getMessage()
            ));
            return false;
        }