Proyectos de Subversion Moodle

<?php
defined('MOODLE_INTERNAL') || die();

use core_completion\progress;

global $CFG;
require_once $CFG->libdir  . '/externallib.php';
require_once $CFG->dirroot . '/course/classes/category.php';
require_once $CFG->dirroot . '/blocks/moodleblock.class.php';
require_once $CFG->dirroot . '/blocks/course_list/block_course_list.php';



class block_cursos_catalogo_ajax_external extends \external_api
{

    public static function enrolar_usuario_cursos_catalogo_parameters()
    {
        return new \external_function_parameters([
            'courseid' => new \external_value(PARAM_INT, 'ID del curso', VALUE_DEFAULT, 0),
        ]);
    }

    public static function enrolar_usuario_cursos_catalogo($courseid)
    {
        global $USER, $DB, $CFG;


        $userid = $USER->id;
        $course = get_course($courseid);
        $enrol = false;

        if (!$course) {
            return json_encode(['success' => false, 'data' => 'No existe el curso']);
        }


        $enrolmethod = 'self';

        $instance = $DB->get_record('enrol', ['courseid' => $course->id, 'enrol' => $enrolmethod, 'status' => 0]);
        if (!$instance) {
            return json_encode(['success' => false, 'data' => 'El curso no permite auto inscribirse']);
        }

        try {
            $user = $DB->get_record('user', ['id' => $userid]);
            $role = $DB->get_record('role', array('archetype' => 'student'));
            $context = context_course::instance($course->id);

            $context = context_course::instance($course->id);
            if (is_enrolled($context, $user)) {
                return json_encode(['success' => true]);
            } else {
                $enrol = enrol_get_plugin($enrolmethod);
                if ($enrol === null) {
                    return false;
                }
                $instances = enrol_get_instances($course->id, true);
                $manualinstance = null;
                foreach ($instances as $instance) {
                    if ($instance->name == $enrolmethod) {
                        $manualinstance = $instance;
                        break;
                    }
                }
                if ($manualinstance !== null) {
                    $instanceid = $enrol->add_default_instance($course);
                    if ($instanceid === null) {
                        $instanceid = $enrol->add_instance($course);
                    }
                    $instance = $DB->get_record('enrol', array('id' => $instanceid));
                }
                $enrol->enrol_user($instance, $user->id, $role->id);
            }

            return json_encode(['success' => true]);
        } catch (\Exception $e) {
            error_log($e->getTraceAsString());

            return json_encode(['success' => false, 'data' => $e->getMessage()]);
        }
    }


    public static function enrolar_usuario_cursos_catalogo_returns()
    {
        return new \external_value(PARAM_RAW, 'The updated JSON output');
    }



    public static function get_cursos_catalogo_parameters()
    {
        return new \external_function_parameters([
            'category_id' => new \external_value(PARAM_INT, 'Categoría de los Cursos', VALUE_DEFAULT, 0),
            'search_text' => new \external_value(PARAM_ALPHANUM, 'Palabra de busqueda', VALUE_DEFAULT, ' '),
        ]);
    }

    public static function get_cursos_catalogo($category_id, $search_text, $page = 1, $courses_per_page = 10)
    {

        global $USER, $DB, $CFG, $OUTPUT, $PAGE;

        $userid = $USER->id;
        $url_noimage =  $CFG->wwwroot . '/theme/' . $PAGE->theme->name . '/pix/coursenoimage.jpg';

        $is_admin = false;
        $admins = get_admins();
        foreach ($admins as $admin) {
            if ($USER->id == $admin->id) {
                $is_admin = true;
                break;
            }
        }

        $all_categories = [];
        $records = $DB->get_records('course_categories', ['visible' => 1], 'sortorder, name');
        foreach ($records as $record) {
            $all_categories[$record->id] = $record;
        }

        $categories_ids = [];
        $category_filter_active = false;
        if ($category_id) {
            $category_filter_active = true;

            $recordLevel0 = $DB->get_record('course_categories', ['id' => $category_id]);

            if ($recordLevel0) {
                array_push($categories_ids, $recordLevel0->id);

                $recordsLevel1 = $DB->get_records('course_categories', ['visible' => 1, 'parent' => $recordLevel0->id]);
                foreach ($recordsLevel1 as $recordLevel1) {
                    array_push($categories_ids, $recordLevel1->id);

                    $recordsLevel2 = $DB->get_records('course_categories', ['visible' => 1, 'parent' => $recordLevel1->id]);
                    foreach ($recordsLevel2 as $recordLevel2) {
                        array_push($categories_ids, $recordLevel2->id);

                        $recordsLevel3 = $DB->get_records('course_categories', ['visible' => 2, 'parent' => $recordLevel2->id]);
                        foreach ($recordsLevel3 as $recordLevel3) {
                            array_push($categories_ids, $recordLevel3->id);
                        }
                    }
                }
            }
        }

        $course_ids = [];
        $course_category_ids = [];
        $courseAvailableForAutoRol = [];

        if ($is_admin) {
            $mycourses = get_courses();
        } else {
            $mycourses = enrol_get_users_courses($USER->id);
        }

        foreach ($mycourses as $course) {
            if (!$course->visible) {
                continue;
            }

            if ($search_text) {
                if (stripos($course->fullname, $search_text) === false) {
                    continue;
                }
            }

            if ($category_filter_active) {
                if (!in_array($course->category, $categories_ids)) {
                    continue;
                }
            }

            array_push($course_ids, $course->id);
        }

        $courses_with_autoenrol = $DB->get_records('enrol', ['enrol' => 'self', 'status' => 0]);
        foreach ($courses_with_autoenrol as $course_with_autoenrol) {
            $course = get_course($course_with_autoenrol->courseid);
            if (!$course->visible) {
                continue;
            }

            if ($search_text) {
                if (stripos($course_with_autoenrol->fullname, $search_text) === false) {
                    continue;
                }
            }

            if ($category_filter_active) {
                if (!in_array($course->category, $categories_ids)) {
                    continue;
                }
            }

            array_push($course_ids, $course->id);
            array_push($courseAvailableForAutoRol, $course->id);
        }

        // Calculate pagination
        $total_courses = count($course_ids);
        $total_pages = ceil($total_courses / $courses_per_page);
        $offset = ($page - 1) * $courses_per_page;

        $course_ids_paginated = array_slice($course_ids, $offset, $courses_per_page);

        $courses = [];
        foreach ($course_ids_paginated as $course_id) {
            // Rest of your code remains the same
            // ...
        }

        usort($courses, function ($a, $b) {
            return $a['fullname'] <=> $b['fullname'];
        });

        $categories = [];
        foreach ($course_category_ids as $course_category_id) {
            $category = $all_categories[$course_category_id];
            if ($category) {
                array_push($categories, ['id' => $category->id, 'name' => $category->name]);
            }
        }

        $data = ['courses' => $courses];
        $cards = $OUTPUT->render_from_template('block_cursos_catalogo_ajax/cards', $data);

        $data = ['categories' => $categories];
        $badges = $OUTPUT->render_from_template('block_cursos_catalogo_ajax/badges', $data);

        return json_encode([
            'success' => true,
            'search_text' => $search_text,
            'category_id' => $category_id,
            'cards' => $cards,
            'badges' => $badges,
            'pagination' => [
                'current_page' => $page,
                'total_pages' => $total_pages
            ]
        ]);
    }


    public static function get_cursos_catalogo_returns()
    {
        return new \external_value(PARAM_RAW, 'The updated JSON output');
    }
}