Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - https://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 <https://www.gnu.org/licenses/>.

/**

 * Library of interface functions and constants.

 *

 * @package     mod_stickynotes

 * @copyright   2021 Olivier VALENTIN

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

 */

defined('MOODLE_INTERNAL') || die();

require_once(dirname(__FILE__) . '/../../config.php');

require_once("$CFG->libdir/formslib.php");

require_once("{$CFG->dirroot}/lib/navigationlib.php");

global $COURSE, $OUTPUT, $PAGE, $CFG;;

/**

 * Return if the plugin supports $feature.

 *

 * @param string $feature Constant representing the feature.

 * @return true | null True if the feature is supported, null otherwise.

 */

function stickynotes_supports($feature) {

    switch ($feature) {

        case FEATURE_MOD_INTRO:

            return true;

        case FEATURE_COMPLETION_TRACKS_VIEWS:

            return true;

        case FEATURE_COMPLETION_HAS_RULES:

            return true;

        case FEATURE_BACKUP_MOODLE2:

            return true;

        case FEATURE_SHOW_DESCRIPTION:

            return true;

        case FEATURE_MOD_PURPOSE:

            return MOD_PURPOSE_COLLABORATION;

        default:

            return null;

    }

}

/**

 * Saves a new instance of the mod_stickynotes into the database.

 *

 * Given an object containing all the necessary data, (defined by the form

 * in mod_form.php) this function will create a new instance and return the id

 * number of the instance.

 *

 * @param object $moduleinstance An object from the form.

 * @param mod_stickynotes_mod_form $mform The form.

 * @return int The id of the newly inserted record.

 */

function stickynotes_add_instance($moduleinstance, $mform = null) {

    global $DB;

    $moduleinstance->timecreated = time();

    $id = $DB->insert_record('stickynotes', $moduleinstance);

    $col = new stdClass();

    $col->stickyid = $id;

    $col->title = get_string('new_column_title', 'stickynotes');

    $defaultcolumn = $DB->insert_record('stickynotes_column', $col);

    return $id;

}

/**

 * Updates an instance of the mod_stickynotes in the database.

 *

 * Given an object containing all the necessary data (defined in mod_form.php),

 * this function will update an existing instance with new data.

 *

 * @param object $moduleinstance An object from the form in mod_form.php.

 * @param mod_stickynotes_mod_form $mform The form.

 * @return bool True if successful, false otherwise.

 */

function stickynotes_update_instance($moduleinstance, $mform = null) {

    global $DB;

    $moduleinstance->timemodified = time();

    $moduleinstance->id = $moduleinstance->instance;

    return $DB->update_record('stickynotes', $moduleinstance);

}

/**

 * Removes an instance of the mod_stickynotes from the database.

 *

 * @param int $id Id of the module instance.

 * @return bool True if successful, false on failure.

 */

function stickynotes_delete_instance($id) {

    global $DB;

    $exists = $DB->get_record('stickynotes', array('id' => $id));

    if (!$exists) {

        return false;

    }

    $DB->delete_records('stickynotes', array('id' => $id));

    $DB->delete_records('stickynotes_column', array('stickyid' => $id));

    $DB->delete_records('stickynotes_note', array('stickyid' => $id));

    $DB->delete_records('stickynotes_vote', array('stickyid' => $id));

    return true;

}

/**

 * Returns the lists of all browsable file areas within the given module context.

 *

 * The file area 'intro' for the activity introduction field is added automatically

 * by {@see file_browser::get_file_info_context_module()}.

 *

 * @package     mod_stickynotes

 * @category    files

 *

 * @param stdClass $course

 * @param stdClass $cm

 * @param stdClass $context

 * @return string[].

 */

function stickynotes_get_file_areas($course, $cm, $context) {

    return array();

}

/**

 * File browsing support for mod_stickynotes file areas.

 *

 * @package     mod_stickynotes

 * @category    files

 *

 * @param file_browser $browser

 * @param array $areas

 * @param stdClass $course

 * @param stdClass $cm

 * @param stdClass $context

 * @param string $filearea

 * @param int $itemid

 * @param string $filepath

 * @param string $filename

 * @return file_info Instance or null if not found.

 */

function stickynotes_get_file_info($browser, $areas, $course, $cm, $context, $filearea, $itemid, $filepath, $filename) {

    return null;

}

/**

 * Serves the files from the mod_stickynotes file areas.

 *

 * @package     mod_stickynotes

 * @category    files

 *

 * @param stdClass $course The course object.

 * @param stdClass $cm The course module object.

 * @param stdClass $context The mod_stickynotes's context.

 * @param string $filearea The name of the file area.

 * @param array $args Extra arguments (itemid, path).

 * @param bool $forcedownload Whether or not force download.

 * @param array $options Additional options affecting the file serving.

 */

function stickynotes_pluginfile($course, $cm, $context, $filearea, $args, $forcedownload, $options = array()) {

    global $DB, $CFG;

    if ($context->contextlevel != CONTEXT_MODULE) {

        send_file_not_found();

    }

    require_login($course, true, $cm);

    send_file_not_found();

}

/**

 * Extends the global navigation tree by adding mod_stickynotes nodes if there is a relevant content.

 *

 * This can be called by an AJAX request so do not rely on $PAGE as it might not be set up properly.

 *

 * @param navigation_node $stickynotesnode An object representing the navigation tree node.

 * @param stdClass $course

 * @param stdClass $module

 * @param cm_info $cm

 */

function stickynotes_extend_navigation($stickynotesnode, $course, $module, $cm) {

}

/**

 * Extend navigation.

 * @param object $settings

 * @param object $stickynotesnode

 */

function stickynotes_extend_settings_navigation($settings, $stickynotesnode) {

    global $PAGE;

    if (has_capability('mod/stickynotes:export', $PAGE->cm->context)) {

        $node = navigation_node::create(get_string('export', 'stickynotes'),

                new moodle_url('/mod/stickynotes/export_csv.php', array('id' => $PAGE->cm->id)),

                navigation_node::TYPE_SETTING,

                new pix_icon('i/export', ''));

        $stickynotesnode->add_node($node);

    }

}

/**

 * Generates form to create or update a note.

 */

class form_note extends moodleform {

     /**

      * Form definition for notes.

      *

      * @return void

      */

    public function definition() {

        global $CFG, $USER, $DB;

        $mform = $this->_form;

        $stickyid     = $this->_customdata['post'];

        if (isset($stickyid->create)) {

            $stickyid->color = 'color1';

        }

        $mform->addElement('text', 'message', get_string('message', 'stickynotes'), 'maxlength="100" size="48"');

        $mform->setType('message', PARAM_TEXT);

        $mform->addRule('message', get_string('maximumchars', '', 100), 'maxlength', 100, 'client');

        // If color choice is enabled.

        if ($stickyid->choose_color == 1) {

            // First, array the 6 colors defined for this activity.

            $configcolor = array (

                'color1',

                'color2',

                'color3',

                'color4',

                'color5',

                'color6'

            );

            // Second, retrieve colors settings for this instance.

            $retrievecolors = $DB->get_record('stickynotes', array('id' => $stickyid->stickyid), '*', MUST_EXIST);

            $colorarray = array();

            foreach ($configcolor as $color) {

                if ($retrievecolors->$color == 1) {

                    // If a color is used in instance, design a colored square and add meaning if define.

                    $thiscolor = "<div style=\"width:50px;background-color:".get_config('mod_stickynotes', $color)

                    ."\">&nbsp;</div>&nbsp;";

                    $thiscolor .= $DB->get_field('stickynotes', $color.'_meaning', array('id' => $stickyid->stickyid));

                    $thiscolor .= "\n";

                    // Create a radio button to choose color.

                    $colorarray[] = $mform->createElement('radio', 'color', '', $thiscolor, $color);

                }

            }

            $mform->setDefault('color', $stickyid->color);

            $mform->addGroup($colorarray, 'colorarr', get_string('choosecolorbuttons', 'stickynotes'), array('<br />'), false);

        } else {

            // Else, default color for note is always color 1.

            $mform->addElement('hidden', 'color');

            $mform->setType('color', PARAM_TEXT);

            $mform->setDefault('color',  'color1');

        }

        if (isset($stickyid->edit)) {

            // If editing note, display menu to change column.

            // Does the note stays at its place ?

            $mform->addElement('advcheckbox', 'nomove', get_string('nomove', 'stickynotes'));

            $mform->addHelpButton('nomove', 'nomove', 'stickynotes');

            $mform->setDefault('nomove',  '0');

            $req = $DB->get_records('stickynotes_column', array('stickyid' => $stickyid->stickyid), 'id', 'id,title');

            $options = [];

            foreach ($req as $new) {

                $options[$new->id] = $new->title;

            }

            $mform->disabledIf('stickycolid', 'nomove', '1');

            $mform->addElement('select', 'stickycolid', get_string('changecolumn', 'stickynotes'), $options);

            $mform->setType('stickycolid', PARAM_INT);

            $optionsorder = [];

            $mform->disabledIf('selectorder', 'nomove', '1');

            $mform->addElement('select', 'selectorder', get_string('selectorder', 'stickynotes'), $optionsorder);

            $mform->setType('selectorder', PARAM_INT);

            $mform->setDefault('selectorder', 0);

            $mform->addElement('hidden', 'ordernote');

            $mform->setType('ordernote', PARAM_INT);

            $mform->addElement('hidden', 'oldrank');

            $mform->setType('oldrank', PARAM_INT);

            $mform->setDefault('oldrank', $stickyid->oldrank);

            $mform->addElement('hidden', 'oldcolumn');

            $mform->setType('oldcolumn', PARAM_INT);

            $mform->setDefault('oldcolumn', $stickyid->oldcolumn);

        } else {

            // Else, hide column select and create ordernote select.

            $sql = 'SELECT ordernote, message FROM {stickynotes_note} WHERE stickycolid = ? ORDER BY ordernote';

            $paramsdb = array($stickyid->stickycolid);

            $dbresult = $DB->get_records_sql($sql, $paramsdb);

            $createorder[0] = get_string('lastplace', 'stickynotes');

            $createorder[1] = get_string('firstplace', 'stickynotes');

            foreach ($dbresult as $move) {

                $neworder = $move->ordernote + 1;

                $createorder[$neworder] = get_string('after', 'stickynotes')." '".$move->message."'";

            }

            $mform->addElement('select', 'ordernote', get_string('selectorder', 'stickynotes'), $createorder);

            $mform->setType('ordernote', PARAM_INT);

            $mform->setDefault('ordernote', 1000);

            $mform->addElement('hidden', 'stickycolid');

            $mform->setType('stickycolid', PARAM_INT);

        }

        $mform->addElement('hidden', 'id');

        $mform->setType('id', PARAM_INT);

        $mform->addElement('hidden', 'userid');

        $mform->setType('userid', PARAM_INT);

        $mform->addElement('hidden', 'oldrank');

        $mform->setType('oldrank', PARAM_INT);

        $mform->addElement('hidden', 'oldcolumn');

        $mform->setType('oldcolumn', PARAM_INT);

        // Are we creating a note?

        $mform->addElement('hidden', 'create');

        $mform->setType('create', PARAM_INT);

        // Are we editing a note?

        $mform->addElement('hidden', 'edit');

        $mform->setType('edit', PARAM_INT);

        // Instance id.

        $mform->addElement('hidden', 'stickyid');

        $mform->setType('stickyid', PARAM_INT);

        // Stickynote id.

        $mform->addElement('hidden', 'note');

        $mform->setType('note', PARAM_INT);

        $this->add_action_buttons(true, get_string('validate', 'stickynotes'));

    }

    /**

     * Form validation.

     *

     * @param array $data  data from the form.

     * @param array $files files uplaoded.

     *

     * @return array of errors.

     */

    public function validation($data, $files) {

        $errors = parent::validation($data, $files);

        if (empty($data['message'])) {

            $errors['message'] = get_string('erroremptymessage', 'stickynotes');

        }

        return $errors;

    }

}

/**

 * Generates form to create or update column.

 */

class form_column extends moodleform {

    /**

     * Form definition for columns.

     *

     * @return void

     */

    public function definition() {

        global $CFG, $USER;

        $mform = $this->_form;

        $mform->addElement('text', 'title', get_string('title', 'stickynotes'), 'size="48"');

        $mform->setType('title', PARAM_TEXT);

        $mform->addRule('title', get_string('maximumchars', '', 20), 'maxlength', 20, 'client');

        $mform->addElement('hidden', 'id');

        $mform->setType('id', PARAM_INT);

        $mform->addElement('hidden', 'userid');

        $mform->setType('userid', PARAM_INT);

        // Are we creating a column?

        $mform->addElement('hidden', 'create');

        $mform->setType('create', PARAM_INT);

        // Are we editing a column?

        $mform->addElement('hidden', 'edit');

        $mform->setType('edit', PARAM_INT);

        // Instance id.

        $mform->addElement('hidden', 'stickyid');

        $mform->setType('stickyid', PARAM_INT);

        // Column id.

        $mform->addElement('hidden', 'col');

        $mform->setType('col', PARAM_INT);

        $this->add_action_buttons(true, get_string('validate', 'stickynotes'));

    }

    /**

     * Form validation.

     *

     * @param array $data  data from the form.

     * @param array $files files uplaoded.

     *

     * @return array of errors.

     */

    public function validation($data, $files) {

        $errors = parent::validation($data, $files);

        if (empty($data['title'])) {

            $errors['title'] = get_string('erroremptytitle', 'stickynotes');

        }

        return $errors;

    }

}

 /**

  * Creates a new note.

  * @param stdClass $data  Datas from the form.

  *

  * @return bool True if successful, false otherwise.

  */

function insert_stickynote($data, $moduleinstance, $course, $cm) {

    global $DB, $USER;

    $id = required_param('id', PARAM_INT);

    $data = (object)$data;

    $data->timecreated = time();

     // Check ordernote.

    if ($data->ordernote == 0) {

        // If ordernote is zero, user creates note at the end of the column.

        // Calculate order : order of last note + 1.

        $sql = 'SELECT ordernote FROM {stickynotes_note} WHERE stickycolid = ? ORDER BY ordernote DESC LIMIT 1';

        $paramsdb = array($data->stickycolid);

        $dbresult = $DB->get_field_sql($sql, $paramsdb);

        $data->ordernote = $dbresult + 1;

    } else {

        // User creates a note at a specific place.

        // First, all notes following are moved of one place BEFORE creating new note.

        $sql = 'SELECT id, ordernote FROM {stickynotes_note} WHERE stickycolid = ? AND ordernote >= ? ORDER BY ordernote';

        $paramsdb = array($data->stickycolid, $data->ordernote);

        $dbresult = $DB->get_records_sql($sql, $paramsdb);

        foreach ($dbresult as $note) {

            $updatenotes = (object)$note;

            $updatenotes->ordernote = $note->ordernote + 1;

            $resnotes = $DB->update_record('stickynotes_note', $updatenotes);

        }

    }

    // Finally, create the new note.

    $res = $DB->insert_record('stickynotes_note', $data);

    // Activates completion checking.

    $completion = new \completion_info($course);

    if ($completion->is_enabled($cm) && $moduleinstance->completionstickynotes) {

        $completion->update_state($cm);

    }

    return $res;

}

 /**

  * Updates a note

  * @param object $data  Datas from the form

  *

  * @return $post The id of the activity.

  */

function update_stickynote($data) {

    global $DB, $USER;

    $data = (object)$data;

    $data->timemodified = time();

    // First, retrieve all notes following the moved note BEFORE updating !

    $sql = 'SELECT id, ordernote FROM {stickynotes_note} WHERE stickycolid = ? AND ordernote >= ? AND id != ? ORDER BY ordernote';

    $paramsdb = array($data->stickycolid, $data->ordernote, $data->note);

    $dbresult = $DB->get_records_sql($sql, $paramsdb);

    // Now we can update the note at its new place.

    $res = $DB->update_record('stickynotes_note', $data);

    // Finally, all notes following are moved of one place.

    foreach ($dbresult as $note) {

        $updatenotes = (object)$note;

        $updatenotes->ordernote = $note->ordernote + 1;

        $resnotes = $DB->update_record('stickynotes_note', $updatenotes);

    }

    $post = new StdClass;

    $post->id = $data->instance;

    return $post;

}

 /**

  * Creates a new column.

  * @param object $data  Datas from the form

  * @return bool True if successful, false otherwise.

  */

function insert_column($data) {

    global $DB, $USER;

    $id = required_param('id', PARAM_INT);

    $data = (object)$data;

    // Count numbers of column for this activity.

    $options = array('stickyid' => $data->stickyid);

    $count = $DB->count_records('stickynotes_column', $options);

    $last = $count + 1;

    $data->column_order    = $last;

    $DB->insert_record('stickynotes_column', $data);

    return true;

}

 /**

  * Updates a column.

  * @param object $data  Datas from the form

  * @return post The id of the activity.

  */

function update_column($data) {

    global $DB, $USER;

    $data = (object)$data;

    $data->id = $data->col;

    $res = $DB->update_record('stickynotes_column', $data);

    return true;

}

 /**

  * Deletes a column.

  * @param int $col  Column id

  * @param int $modulecontext  Activity id

  * @return bool True if successful, false otherwise.

  */

function delete_column($col, $modulecontext) {

    global $DB;

    if (!$DB->delete_records('stickynotes_column', array('id' => $col))) {

        $result = false;

    }

}

 /**

  * Deletes a note.

  * @param int $note  Note id

  * @param int $modulecontext  Activity id

  * @return bool True if successful, false otherwise.

  */

function delete_stickynote($note, $modulecontext, $moduleinstance, $course, $cm,$user) {

    global $DB;

    if (!$DB->delete_records('stickynotes_note', array('id' => $note))) {

        $result = false;

    }

    // Activates completion checking.

    $completion = new \completion_info($course);

    if ($completion->is_enabled($cm) == COMPLETION_TRACKING_AUTOMATIC && $moduleinstance->completionstickynotes) {

        $completion->update_state($cm, COMPLETION_INCOMPLETE, $user);

    }

}

 /**

  * Count number of notes created by a given user in activity.

  * @param int $userid  user id.

  * @param int $modulecontext activity id.

  * @return int Number of notes created by user.

  */

function stickynote_count_notes($userid, $modulecontext) {

    global $DB;

    $count = $DB->count_records('stickynotes_note', array ('userid' => $userid, 'stickyid' => $modulecontext));

    return $count;

}

 /**

  * Count number of votes created for a given note.

  * @param int $note  sticky note id.

  * @return int Number of votes of user in given activity.

  */

function stickynote_count_votes($note) {

    global $DB;

    $count = $DB->count_records('stickynotes_vote', array ('stickynoteid' => $note));

     return $count;

}

 /**

  * Search column title.

  * @param int $col  Column id.

  * @return array

  */

function get_column_title($col) {

    global $DB;

    $record = $DB->get_record('stickynotes_column', array('id' => $col));

    if (!$record) {

        return;

    } else {

        $column['title'] = $record->title;

    }

    return $column;

}

 /**

  * Defines icon to display for a note for a "Like" vote type.

  *

  * This function is related to the "Like" vote.

  * Checks if user has alreadey voted or not, and if he hasn't voted,

  * defines if he has reached or not the max votes limit.

  *

  * @param int $userid user id.

  * @param int $note sticky note id

  * @param int $limit activity setting (vote limit is enabled if 1)

  * @param int $max activity setting (max number of votes per user)

  * @param int $instance activity ID

  * @return int myvote  return if user has voted or not.

  * @return int limitedvote  return if user has reached limit.

  * @return int action  return action to trigger if user clicks on heart.

  */

function stickynote_get_vote_like($userid, $note, $limit, $max, $instance) {

    global $DB, $USER;

    $post = $DB->get_record('stickynotes_vote', array('userid' => $userid, 'stickynoteid' => $note));

    // If User has already voted for this note, display full icon to unvote.

    if ($post) {

        $params['myvote'] = 1;

        $params['limitedvote'] = 0;

        // Action : delete vote.

        $params['action'] = 'del';

    } else {

        // If no votes detected.

        if ($limit == 1) {

            // If vote has max limit, count votes for this user.

            $check = $DB->count_records('stickynotes_vote', array ('userid' => $userid, 'stickyid' => $instance));

            if ($check >= $max) {

                // If user has reached max votes, icon is grey.

                $params['myvote'] = 0;

                $params['limitedvote'] = 1;

                $params['action'] = 'n';

            } else {

                // If limit is note reached, user can vote for this note.

                $params['myvote'] = 0;

                $params['limitedvote'] = 0;

                $params['action'] = 'add';

            }

        } else {

            // Else, user can vote.

            $params['myvote'] = 0;

            $params['limitedvote'] = 0;

            $params['action'] = 'add';

        }

    }

    return $params;

}

/**

 * Defines action to trigger for a "Like" vote type.

 *

 * This function is related to "Like" vote.

 * Triggers action if user is voting or retiring his vote.

 *

 * @param int $userid user id.

 * @param int $note sticky note id

 * @param int $action definess if user adds or delete vote

 * @param int $instance  activity id

 * @return bool True if successful, false otherwise.

 */

function stickynote_do_vote_like($userid, $note, $action, $instance) {

    global $DB, $USER;

    $data = new StdClass;

    if ($action == "add") {

        $data->userid = $userid;

        $data->vote = 1;

        $data->stickynoteid = $note;

        $data->stickyid = $instance;

        $data->timecreated = time();

        if (!$DB->insert_record('stickynotes_vote', $data)) {

            $result = false;

        }

    } else if ($action == "del") {

        $data->userid = $userid;

        $data->stickynoteid = $note;

        if (!$DB->delete_records('stickynotes_vote', array('userid' => $data->userid, 'stickynoteid' => $data->stickynoteid))) {

            $result = false;

        }

    }

    return true;

}

/**

 * Implementation of the function for printing the form elements that control

 * whether the course reset functionality affects the Sticky Notes activity.

 *

 * @param $mform the course reset form that is being built.

 */

function stickynotes_reset_course_form_definition($mform) {

    $mform->addElement('header', 'stickynotesheader', get_string('modulenameplural', 'stickynotes'));

    $mform->addElement('advcheckbox', 'reset_stickynotes_all',

            get_string('resetstickynotesall', 'stickynotes'));

    $mform->addElement('advcheckbox', 'reset_stickynotes_notes',

            get_string('resetstickynotesnotes', 'stickynotes'));

    $mform->disabledIf('reset_stickynotes_notes', 'reset_stickynotes_all', 'checked');

    $mform->addElement('advcheckbox', 'reset_stickynotes_votes',

            get_string('resetstickynotesvotes', 'stickynotes'));

    $mform->disabledIf('reset_stickynotes_votes', 'reset_stickynotes_all', 'checked');

    $mform->disabledIf('reset_stickynotes_votes', 'reset_stickynotes_notes', 'checked');

}

/**

 * Course reset form defaults.

 * @return array the defaults.

 */

function stickynotes_reset_course_form_defaults($course) {

    return array('reset_stickynotes_all' => 1,

                 'reset_stickynotes_notes' => 1,

                 'reset_stickynotes_votes' => 1);

}

/**

 * Actual implementation of the reset course functionality, delete all contents,

 * or only notes, or only votes.

 *

 * If delete all is selected, a start column will be created.

 *

 * @param object $data the data submitted from the reset course.

 * @return array status array

 */

function stickynotes_reset_userdata($data) {

    global $CFG, $DB;

    $componentstr = get_string('modulenameplural', 'stickynotes');

    $status = array();

    $sql = "SELECT sn.id FROM {stickynotes} sn WHERE sn.course=".$data->courseid."";

    // Remove all contents - columns, notes and votes.

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

        // Delete all columns, notes and votes queries.

        $res_columns = $DB->delete_records_select('stickynotes_column', "stickyid IN ($sql)");

        $res_notes = $DB->delete_records_select('stickynotes_note', "stickyid IN ($sql)");

        $res_votes = $DB->delete_records_select('stickynotes_vote', "stickyid IN ($sql)");

        // Now columns are deleted, create a new default column for each activity.

        $res_activities = $DB->get_records_sql($sql);

        foreach ($res_activities as $recreate_column) {

            $new = new stdClass();

            $new->stickyid = $recreate_column->id;

            $new->title = get_string('new_column_title', 'stickynotes');

            insert_column($new);

        }

        $status[] = array('component'=>$componentstr, 'item'=>get_string('removeallresponse', 'stickynotes'), 'error'=>false);

    }

    // Remove notes and votes. Columns stay.

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

        $res_notes = $DB->delete_records_select('stickynotes_note', "stickyid IN ($sql)");

        $res_votes = $DB->delete_records_select('stickynotes_vote', "stickyid IN ($sql)");

        $status[] = array('component'=>$componentstr, 'item'=>get_string('removenotesandvotesresponse', 'stickynotes'), 'error'=>false);

    }

    // Remove votes only

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

        $res_votes = $DB->delete_records_select('stickynotes_vote', "stickyid IN ($sql)");

        $status[] = array('component'=>$componentstr, 'item'=>get_string('removevotesresponse', 'stickynotes'), 'error'=>false);

    }

    return $status;

}

/**

 * Add a get_coursemodule_info function in case any stickynotes type wants to add 'extra' information

 * for the course (see resource).

 *

 * Given a course_module object, this function returns any "extra" information that may be needed

 * when printing this activity in a course listing.  See get_array_of_activities() in course/lib.php.

 *

 * @param stdClass $coursemodule The coursemodule object (record).

 * @return cached_cm_info An object on information that the courses

 *                        will know about (most noticeably, an icon).

 */

function stickynotes_get_coursemodule_info($coursemodule) {

    global $DB;

    $dbparams = ['id' => $coursemodule->instance];

    $fields = 'id, name, intro, introformat, completionstickynotes';

    if (!$stickynotes = $DB->get_record('stickynotes', $dbparams, $fields)) {

        return false;

    }

    $result = new cached_cm_info();

    $result->name = $stickynotes->name;

    if ($coursemodule->showdescription) {

        // Convert intro to html. Do not filter cached version, filters run at display time.

        $result->content = format_module_intro('stickynotes', $stickynotes, $coursemodule->id, false);

    }

    // Populate the custom completion rules as key => value pairs, but only if the completion mode is 'automatic'.

    if ($coursemodule->completion == COMPLETION_TRACKING_AUTOMATIC) {

        $result->customdata['customcompletionrules']['completionstickynotes'] = $stickynotes->completionstickynotes;

    }

    return $result;

}

/**

 * Obtains the automatic completion state for this stickynotes on any conditions

 * in stickynotes settings

 *

 * @param object $course Course

 * @param object $cm Course-module

 * @param int $userid User ID

 * @param bool $type Type of comparison (or/and; can be used as return value if no conditions)

 * @return bool True if completed, false if not. (If no conditions, then return

 *   value depends on comparison type)

 */

function stickynotes_get_completion_state($course, $cm, $userid, $type) {

    global $DB;

    $stickynotesid = $cm->instance;

    if (!$stickynotes = $DB->get_record('stickynotes', ['id' => $stickynotesid])) {

        throw new \moodle_exception('Unable to find stickynotes activity with id ' . $stickynotesid);

    }

    $params = ['userid' => $userid, 'stickyid' => $stickynotesid];

    $sql = "SELECT COUNT(*)

                FROM {stickynotes_note} sn

                JOIN {stickynotes_column} sc ON sn.stickycolid = sc.id

                WHERE sn.userid = :userid

                AND sc.stickyid = :stickyid";

    if ($stickynotes->completionstickynotes) {

        $stickynotes = $DB->get_field_sql($sql, $params);

        if ($stickynotes) {

            return ($stickynotes >= $stickynotes->completionstickynotes) ? COMPLETION_COMPLETE : COMPLETION_INCOMPLETE;

        } else {

            return COMPLETION_INCOMPLETE;

        }

    }

    return $type;

}

/**

 * Callback which returns human-readable strings describing the active completion custom rules for the stickynotes module instance.

 *

 * @param cm_info|stdClass $cm object with fields ->completion and ->customdata['customcompletionrules']

 * @return array $descriptions the array of descriptions for the custom rules.

 */

function mod_stickynotes_get_completion_active_rule_descriptions($cm) {

    // Values will be present in cm_info, and we assume these are up to date.

    if (empty($cm->customdata['customcompletionrules'])

        || $cm->completion != COMPLETION_TRACKING_AUTOMATIC) {

        return [];

    }

    $descriptions = [];

    foreach ($cm->customdata['customcompletionrules'] as $key => $val) {

        switch ($key) {

            case 'completionstickynotes':

                if (!empty($val)) {

                    $descriptions[] = get_string('completionstickynotesdesc', 'mod_stickynotes', $val);

                }

                break;

            default:

                break;

        }

    }

    return $descriptions;

}

 /**

  * Updates locks parameters.

  * @param object $data  Datas from the form

  * @return post The id of the activity.

  */

  function update_lock($instance, $lock, $lockvalue) {

    global $DB;

    $data = (object)$data;

    $data->id = $instance;

    $data->$lock = $lockvalue;

    $res = $DB->update_record('stickynotes', $data);

    return true;

}

 /**

  * Decides if text color is black or white depending on

  * the note background color.

  * Author : Elmer Wilson

  * @param object $data  Hexadecimal background color.

  * @return post Text color (black or white) in hex.

  */

function getcontrastcolor($hexcolor)

{

        // hexColor RGB

        $R1 = hexdec(substr($hexcolor, 1, 2));

        $G1 = hexdec(substr($hexcolor, 3, 2));

        $B1 = hexdec(substr($hexcolor, 5, 2));

        // Black RGB

        $blackColor = "#000000";

        $R2BlackColor = hexdec(substr($blackColor, 1, 2));

        $G2BlackColor = hexdec(substr($blackColor, 3, 2));

        $B2BlackColor = hexdec(substr($blackColor, 5, 2));

         // Calc contrast ratio

         $L1 = 0.2126 * pow($R1 / 255, 2.2) +

               0.7152 * pow($G1 / 255, 2.2) +

               0.0722 * pow($B1 / 255, 2.2);

        $L2 = 0.2126 * pow($R2BlackColor / 255, 2.2) +

              0.7152 * pow($G2BlackColor / 255, 2.2) +

              0.0722 * pow($B2BlackColor / 255, 2.2);

        $contrastRatio = 0;

        if ($L1 > $L2) {

            $contrastRatio = (int)(($L1 + 0.05) / ($L2 + 0.05));

        } else {

            $contrastRatio = (int)(($L2 + 0.05) / ($L1 + 0.05));

        }

        // If contrast is more than 5, return black color

        if ($contrastRatio > 5) {

            return '#000000';

        } else {

            // if not, return white color.

            return '#FFFFFF';

        }

}