Proyectos de Subversion Moodle

<?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 tool_courserating;

use core\output\inplace_editable;

use tool_courserating\event\flag_created;

use tool_courserating\event\flag_deleted;

use tool_courserating\event\rating_created;

use tool_courserating\event\rating_deleted;

use tool_courserating\event\rating_updated;

use tool_courserating\external\summary_exporter;

use tool_courserating\local\models\flag;

use tool_courserating\local\models\rating;

use tool_courserating\local\models\summary;

/**

 * Methods to add/remove ratings

 *

 * @package     tool_courserating

 * @copyright   2022 Marina Glancy <marina.glancy@gmail.com>

 * @license     https://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class api {

    /**

     * Add or update user rating

     *

     * @param int $courseid

     * @param \stdClass $data

     * @param int $userid - only for phpunit and behat tests

     * @return rating

     */

    public static function set_rating(int $courseid, \stdClass $data, int $userid = 0): rating {

        global $USER;

        // TODO $userid can only be used in phpunit and behat.

        $userid = $userid ?: $USER->id;

        // TODO validate rating is within limits, trim/crop review.

        $rating = $data->rating;

        $ratingold = rating::get_record(['userid' => $userid, 'courseid' => $courseid]);

        if ($ratingold) {

            $oldrecord = $ratingold->to_record();

            $r = $ratingold;

            $review = self::prepare_review($r, $data);

            $r->set('rating', $rating);

            $r->set('review', $review);

            $r->save();

            $summary = summary::update_rating($courseid, $r, $oldrecord);

        } else {

            $r = new rating(0, (object)[

                'userid' => $userid,

                'courseid' => $courseid,

                'rating' => $rating,

            ]);

            $r->set('review', self::prepare_review(null, $data));

            $r->save();

            $review = self::prepare_review($r, $data);

            if ($review !== $r->get('review')) {

                $r->set('review', $review);

                $r->save();

            }

            $summary = summary::add_rating($courseid, $r);

        }

        self::update_course_rating_in_custom_field($summary);

        if ($ratingold) {

            rating_updated::create_from_rating($r, $oldrecord)->trigger();

        } else {

            rating_created::create_from_rating($r)->trigger();

        }

        return $r;

    }

    /**

     * Delete rating and review made by somebody else

     *

     * @param int $ratingid

     * @param string|null $reason

     * @return rating|null

     */

    public static function delete_rating(int $ratingid, string $reason = ''): ?rating {

        global $DB;

        if (!$rating = rating::get_record(['id' => $ratingid])) {

            return null;

        }

        $flagcount = $DB->count_records(flag::TABLE, ['ratingid' => $ratingid]);

        $record = $rating->to_record();

        $rating->delete();

        if ($context = \context_course::instance($record->courseid, IGNORE_MISSING)) {

            // Sometimes it might be called after course is deleted.

            get_file_storage()->delete_area_files($context->id, 'tool_courserating', 'review', $record->id);

        }

        if ($flagcount) {

            $DB->delete_records(flag::TABLE, ['ratingid' => $record->id]);

        }

        $summary = summary::delete_rating($record);

        self::update_course_rating_in_custom_field($summary);

        rating_deleted::create_from_rating($record, $flagcount, $reason)->trigger();

        return $rating;

    }

    /**

     * Update content of the course custom field that displays the rating

     *

     * @param summary|null $summary

     * @return void

     */

    protected static function update_course_rating_in_custom_field(?summary $summary) {

        global $PAGE;

        if (!$summary || !helper::get_course_rating_field()) {

            return;

        }

        $courseid = $summary->get('courseid');

        if ($summary->get('ratingmode') == constants::RATEBY_NOONE) {

            $ratingstr = '';

        } else {

            /** @var \tool_courserating\output\renderer $output */

            $output = $PAGE->get_renderer('tool_courserating');

            $data = (new summary_exporter(0, $summary))->export($output);

            $ratingstr = $output->render_from_template('tool_courserating/summary_for_cfield', $data);

        }

        if ($data = helper::get_course_rating_data_in_cfield($courseid)) {

            $data->instance_form_save((object)[

                'id' => $courseid,

                $data->get_form_element_name() => ['text' => $ratingstr, 'format' => FORMAT_HTML],

            ]);

        }

    }

    /**

     * Prepare review for storing (store files, convert to html)

     *

     * @param rating|null $rating

     * @param \stdClass $data

     * @return string

     */

    protected static function prepare_review(?rating $rating, \stdClass $data): string {

        $usehtml = helper::get_setting(constants::SETTING_USEHTML);

        if ($rating && $usehtml && !rating::review_is_empty($data->review_editor['text'] ?? '')) {

            $context = \context_course::instance($rating->get('courseid'));

            $data = file_postupdate_standard_editor($data, 'review', helper::review_editor_options($context), $context,

                'tool_courserating', 'review', $rating->get('id'));

            if ($data->reviewformat != FORMAT_HTML) {

                // We always store reviews as HTML, we don't even store the reviewformat field.

                // Do not apply filters now, they will be applied during display.

                return format_text($data->review, $data->reviewformat, ['filter' => false, 'context' => $context]);

            }

            return $data->review;

        } else if (!$usehtml && !rating::review_is_empty($data->review ?? '')) {

            return $data->review;

        } else {

            return '';

        }

    }

    /**

     * Prepare review to be displayed in a form (copy files to draft area)

     *

     * @param int $courseid

     * @return array|array[]

     */

    public static function prepare_rating_for_form(int $courseid): array {

        global $USER;

        $rv = [

            'review_editor' => ['text' => '', 'format' => FORMAT_HTML],

            'review' => '',

        ];

        if ($rating = rating::get_record(['userid' => $USER->id, 'courseid' => $courseid])) {

            $data = $rating->to_record();

            $rv['rating'] = $data->rating;

            if (helper::get_setting(constants::SETTING_USEHTML)) {

                $data->reviewformat = FORMAT_HTML;

                $context = \context_course::instance($courseid);

                $data = file_prepare_standard_editor($data, 'review', helper::review_editor_options($context), $context,

                    'tool_courserating', 'review', $data->id);

                $rv['review_editor'] = $data->review_editor;

            } else {

                $rv['review'] = clean_param($data->review, PARAM_TEXT);

            }

            return $rv;

        }

        return $rv;

    }

    /**

     * Flag somebody else's review

     *

     * @param int $ratingid

     * @return flag|null

     */

    public static function flag_review(int $ratingid): ?flag {

        global $USER;

        $flag = flag::get_records(['ratingid' => $ratingid, 'userid' => $USER->id]);

        if ($flag) {

            return null;

        }

        $rating = new rating($ratingid);

        $flag = new flag(0, (object)['userid' => $USER->id, 'ratingid' => $ratingid]);

        $flag->save();

        flag_created::create_from_flag($flag, $rating)->trigger();

        return $flag;

    }

    /**

     * Revoke a flag on somebody else's review

     *

     * @param int $ratingid

     * @return flag|null

     */

    public static function revoke_review_flag(int $ratingid): ?flag {

        global $USER;

        $flags = flag::get_records(['ratingid' => $ratingid, 'userid' => $USER->id]);

        $flag = reset($flags);

        if (!$flag) {

            return null;

        }

        $rating = new rating($ratingid);

        $oldrecord = $flag->to_record();

        $flag->delete();

        flag_deleted::create_from_flag($oldrecord, $rating)->trigger();

        return $flag;

    }

    /**

     * Get the flag

     *

     * @param int $ratingid

     * @param bool|null $hasflag

     * @return inplace_editable

     */

    public static function get_flag_inplace_editable(int $ratingid, ?bool $hasflag = null): inplace_editable {

        global $USER;

        if (!permission::can_flag_rating($ratingid)) {

            return new inplace_editable('tool_courserating', 'flag', $ratingid, false, '', 0, '');

        }

        if ($hasflag === null) {

            $hasflag = flag::count_records(['ratingid' => $ratingid, 'userid' => $USER->id]) > 0;

        }

        $displayvalue = $hasflag ? get_string('revokeratingflag', 'tool_courserating') :

            get_string('flagrating', 'tool_courserating');

        $edithint = $displayvalue;

        $r = new inplace_editable('tool_courserating', 'flag', $ratingid, true, $displayvalue,

            $hasflag ? 1 : 0, $edithint);

        $r->set_type_toggle([0, 1]);

        return $r;

    }

    /**

     * Re-index all courses, update ratings in the summary table and custom fields

     *

     * @param int $courseid

     * @return void

     */

    public static function reindex(int $courseid = 0) {

        global $DB, $SITE;

        $percourse = helper::get_setting(constants::SETTING_PERCOURSE);

        $ratingfield = helper::get_course_rating_field();

        $ratingmodefield = helper::get_course_rating_mode_field();

        if (!$ratingfield) {

            return;

        }

        $fields = 'c.id as courseid, d.value as cfield, s.cntall as summarycntall, s.ratingmode as summaryratingmode,

               (select count(1) from {tool_courserating_rating} r where r.courseid=c.id) as actualcntall ';

        $join = 'from {course} c

            left join {tool_courserating_summary} s on s.courseid = c.id

            left join {customfield_field} f on f.shortname = :field1

            left join {customfield_data} d on d.fieldid = f.id and d.instanceid = c.id ';

        $params = [

            'field1' => $ratingfield->get('shortname'),

            'siteid' => $SITE->id ?? SITEID,

        ];

        if ($percourse && $ratingmodefield) {

            // Each course may override whether course ratings are enabled.

            $fields .= ', dr.intvalue as rateby';

            $join .= ' left join {customfield_field} fr on fr.shortname = :field2

            left join {customfield_data} dr on dr.fieldid = fr.id and dr.instanceid = c.id';

            $params['field2'] = $ratingmodefield->get('shortname');

        }

        $sql = "SELECT $fields $join WHERE c.id <> :siteid ";

        if ($courseid) {

            $sql .= " AND c.id = :courseid ";

            $params['courseid'] = $courseid;

        } else {

            $sql .= " ORDER BY c.id DESC";

        }

        $records = $DB->get_records_sql($sql, $params);

        foreach ($records as $record) {

            $record->actualratingmode = helper::get_setting(constants::SETTING_RATINGMODE);

            if ($percourse && $record->rateby && array_key_exists($record->rateby, constants::rated_courses_options())) {

                $record->actualratingmode = $record->rateby;

            }

            self::reindex_course($record);

        }

    }

    /**

     * Re-index individual course

     *

     * @param \stdClass $data contains fields: courseid, cfield, summarycntall, actualcntall

     *     where cfield is the actual value stored in the "course rating" custom course field,

     *     summarycntall - the field tool_courserating_summary.cntall that corresponds to this course,

     *     summaryratingmode - the field tool_courserating_summary.ratingmode that corresponds to this course,

     *     actualcntall - the actual count of ratings for this course (count(*) from tool_courserating_rating)

     *     actualratingmode - what actually must be the rating mode of this course

     */

    protected static function reindex_course(\stdClass $data) {

        $mustbeempty = $data->actualratingmode == constants::RATEBY_NOONE

            || (!$data->actualcntall && !helper::get_setting(constants::SETTING_DISPLAYEMPTY));

        if ($data->summaryratingmode != $data->actualratingmode) {

            // Rating mode for this course has changed.

            $summary = summary::get_for_course($data->courseid);

            $summary->set('ratingmode', $data->actualratingmode);

            if ($data->actualratingmode == constants::RATEBY_NOONE) {

                $summary->reset_all_counters();

            }

            $summary->save();

        }

        if ($mustbeempty) {

            // Course rating should not be displayed at all.

            if (!empty($data->cfield)) {

                $summary = $summary ?? summary::get_for_course($data->courseid);

                self::update_course_rating_in_custom_field($summary);

            }

        } else {

            // Update summary and cfield with the data.

            $summary = $summary ?? summary::get_for_course($data->courseid);

            $summary->recalculate();

            self::update_course_rating_in_custom_field($summary);

        }

    }

    /**

     * Completely delete all data related to a course (i.e. when course is deleted)

     *

     * @param int $courseid

     * @return void

     */

    public static function delete_all_data_for_course(int $courseid) {

        global $DB;

        $DB->execute('DELETE from {'.flag::TABLE.'} WHERE ratingid IN (SELECT id FROM {'.

            rating::TABLE.'} WHERE courseid = ?)', [$courseid]);

        $DB->delete_records(rating::TABLE, ['courseid' => $courseid]);

        $DB->delete_records(summary::TABLE, ['courseid' => $courseid]);

    }

}