db_utils.php

<?php
// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

namespace assignsubmission_dta;

use assignsubmission_dta\dta_backend_utils;
use assignsubmission_dta\dta_view_submission_utils;
use assignsubmission_dta\models\dta_result;
use assignsubmission_dta\models\dta_result_summary;
use assignsubmission_dta\models\dta_recommendation;

/**
 * Class dta_db_utils
 *
 * Persistence layer utility class for storing and retrieving
 * DTA plugin data (results, summaries, recommendations).
 *
 * @package    assignsubmission_dta
 * @copyright  2023 Gero Lueckemeyer
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class dta_db_utils {

    /**
     * Summary database table name.
     */
    private const ASSIGNSUBMISSION_DTA_TABLE_SUMMARY = 'assignsubmission_dta_summary';

    /**
     * Result database table name.
     */
    private const ASSIGNSUBMISSION_DTA_TABLE_RESULT = 'assignsubmission_dta_result';

    /**
     * Recommendations database table name.
     */
    private const ASSIGNSUBMISSION_DTA_TABLE_RECOMMENDATIONS = 'assignsubmission_dta_recommendations';

    /**
     * Returns an array of recommendations from the database.
     *
     * @param int $assignmentid The assignment ID.
     * @param int $submissionid The submission ID.
     * @return array An array of recommendation records.
     */
    public static function assignsubmission_dta_get_recommendations_from_database(
        int $assignmentid,
        int $submissionid
    ): array {
        global $DB, $USER;
        $userid = $USER->id;

        // Step 1: Retrieve all recommendations.
        $records = $DB->get_records(
            self::ASSIGNSUBMISSION_DTA_TABLE_RECOMMENDATIONS,
            [
                'assignment_id' => $assignmentid,
                'submission_id' => $submissionid,
            ]
        );

        // Step 2: Retrieve module ID for 'assign'.
        $module = $DB->get_record('modules', ['name' => 'assign'], 'id');
        if (!$module) {
            // Handle error case if the module is not found.
            return $records;
        }
        $moduleid = $module->id;

        // Step 3: Check each record.
        foreach ($records as $key => $record) {
            // Get the name of the exercise from the record.
            $exercisename = $record->exercise_name;

            // Find the assignment with this name.
            $assign = $DB->get_record('assign', ['name' => $exercisename], 'id');
            if ($assign) {
                // Get the course module ID for this assignment.
                $cm = $DB->get_record(
                    'course_modules',
                    [
                        'module'   => $moduleid,
                        'instance' => $assign->id,
                    ],
                    'id'
                );

                if ($cm) {
                    // Check the completion status for this course module and user.
                    $completion = $DB->get_record(
                        'course_modules_completion',
                        [
                            'coursemoduleid' => $cm->id,
                            'userid' => $userid,
                        ],
                        'completionstate'
                    );

                    // If the completion state is 1, remove the record from $records.
                    if ($completion && (int)$completion->completionstate === 1) {
                        unset($records[$key]);
                    }
                }
            }
        }

        // Return the filtered records.
        return $records;
    }

    /**
     * Gets a summary with all corresponding result entries.
     *
     * @param int $assignmentid Assignment ID to search for.
     * @param int $submissionid Submission ID to search for.
     * @return dta_result_summary Summary representing the submission.
     */
    public static function assignsubmission_dta_get_result_summary_from_database(
        int $assignmentid,
        int $submissionid
    ): dta_result_summary {
        global $DB;

        // Fetch data from database.
        $summaryrecord = $DB->get_record(
            self::ASSIGNSUBMISSION_DTA_TABLE_SUMMARY,
            [
                'assignment_id' => $assignmentid,
                'submission_id' => $submissionid,
            ]
        );

        $resultsarray = $DB->get_records(
            self::ASSIGNSUBMISSION_DTA_TABLE_RESULT,
            [
                'assignment_id' => $assignmentid,
                'submission_id' => $submissionid,
            ]
        );

        // Create a summary instance.
        $summary = new dta_result_summary();
        $summary->timestamp = $summaryrecord->timestamp;
        $summary->globalstacktrace = $summaryrecord->global_stacktrace;
        $summary->successfultestcompetencies = $summaryrecord->successful_competencies;
        $summary->overalltestcompetencies = $summaryrecord->tested_competencies;
        $summary->results = [];

        // Create result instances and add to array of summary instance.
        foreach ($resultsarray as $rr) {
            $result = new dta_result();
            $result->packagename = $rr->package_name;
            $result->classname = $rr->class_name;
            $result->name = $rr->name;
            $result->state = $rr->state;
            $result->failuretype = $rr->failure_type;
            $result->failurereason = $rr->failure_reason;
            $result->stacktrace = $rr->stacktrace;
            $result->columnnumber = $rr->column_number;
            $result->linenumber = $rr->line_number;
            $result->position = $rr->position;

            $summary->results[] = $result;
        }

        return $summary;
    }

    /**
     * Stores an array of recommendations in the database.
     *
     * @param int $assignmentid The assignment ID.
     * @param int $submissionid The submission ID.
     * @param array $recommendations An array of dta_recommendation objects.
     */
    public static function assignsubmission_dta_store_recommendations_to_database(
        int $assignmentid,
        int $submissionid,
        array $recommendations
    ): void {
        global $DB;

        // Debug output (you can remove or adapt this if unneeded).
        debugging('Recommendations array: ' . json_encode($recommendations));

        // If recommendations already exist, delete old values beforehand.
        $existingrecords = $DB->get_records(
            'assignsubmission_dta_recommendations',
            [
                'assignment_id' => $assignmentid,
                'submission_id' => $submissionid,
            ]
        );

        if ($existingrecords) {
            $DB->delete_records(
                'assignsubmission_dta_recommendations',
                [
                    'assignment_id' => $assignmentid,
                    'submission_id' => $submissionid,
                ]
            );
        }

        // Create new recommendation entries.
        foreach ($recommendations as $recommendation) {
            // Check if $recommendation is an instance of dta_recommendation.
            if ($recommendation instanceof dta_recommendation) {
                // Add assignment and submission IDs to the recommendation object.
                $recommendation->assignment_id = $assignmentid;
                $recommendation->submission_id = $submissionid;

                debugging('Inserting new recommendation record: ' . json_encode($recommendation));

                // Insert the recommendation into the database.
                $DB->insert_record('assignsubmission_dta_recommendations', $recommendation);
            } else {
                // Handle the case where $recommendation is not a dta_recommendation instance.
                debugging('Invalid recommendation object encountered.');
            }
        }
    }

    /**
     * Saves the given result summary and single results to the database
     * under the specified assignment and submission ID.
     *
     * @param int $assignmentid Assignment this submission is linked to.
     * @param int $submissionid Submission ID for these results.
     * @param dta_result_summary $summary Summary instance to persist.
     */
    public static function assignsubmission_dta_store_result_summary_to_database(
        int $assignmentid,
        int $submissionid,
        dta_result_summary $summary
    ): void {
        global $DB;

        // Prepare new database entries.
        $summaryrecord = new dta_result_summary();
        $summaryrecord->assignment_id = $assignmentid;
        $summaryrecord->submission_id = $submissionid;
        $summaryrecord->timestamp = $summary->timestamp;
        $summaryrecord->global_stacktrace = $summary->globalstacktrace;
        $summaryrecord->successful_competencies = $summary->successfultestcompetencies;
        $summaryrecord->tested_competencies = $summary->overalltestcompetencies;

        // Prepare results to persist.
        $resultrecords = [];
        foreach ($summary->results as $r) {
            $record = new dta_result();
            $record->assignment_id = $assignmentid;
            $record->submission_id = $submissionid;
            $record->package_name = $r->packagename;
            $record->class_name = $r->classname;
            $record->name = $r->name;
            $record->state = $r->state;
            $record->failure_type = $r->failuretype;
            $record->failure_reason = $r->failurereason;
            $record->stacktrace = $r->stacktrace;
            $record->column_number = $r->columnnumber;
            $record->line_number = $r->linenumber;
            $record->position = $r->position;
            $resultrecords[] = $record;
        }

        // If results already exist, delete old values beforehand.
        $submission = $DB->get_record(
            self::ASSIGNSUBMISSION_DTA_TABLE_SUMMARY,
            [
                'assignment_id' => $assignmentid,
                'submission_id' => $submissionid,
            ]
        );

        if ($submission) {
            $DB->delete_records(
                self::ASSIGNSUBMISSION_DTA_TABLE_RESULT,
                [
                    'assignment_id' => $assignmentid,
                    'submission_id' => $submissionid,
                ]
            );

            $DB->delete_records(
                self::ASSIGNSUBMISSION_DTA_TABLE_SUMMARY,
                [
                    'assignment_id' => $assignmentid,
                    'submission_id' => $submissionid,
                ]
            );
        }

        // Create summary and single result entries.
        $DB->insert_record(self::ASSIGNSUBMISSION_DTA_TABLE_SUMMARY, $summaryrecord);
        foreach ($resultrecords as $rr) {
            $DB->insert_record(self::ASSIGNSUBMISSION_DTA_TABLE_RESULT, $rr);
        }
    }

    /**
     * Cleans up database if plugin is uninstalled.
     */
    public static function assignsubmission_dta_uninstall_plugin_cleaup(): void {
        global $DB;

        $DB->delete_records(self::ASSIGNSUBMISSION_DTA_TABLE_RESULT, null);
        $DB->delete_records(self::ASSIGNSUBMISSION_DTA_TABLE_SUMMARY, null);
        $DB->delete_records(self::ASSIGNSUBMISSION_DTA_TABLE_RECOMMENDATIONS, null);
    }
}