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/>.

/**

 * mod_glossary data generator.

 *

 * @package    mod_glossary

 * @category   test

 * @copyright  2013 Marina Glancy

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

 */

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

/**

 * mod_glossary data generator class.

 *

 * @package    mod_glossary

 * @category   test

 * @copyright  2013 Marina Glancy

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

 */

class mod_glossary_generator extends testing_module_generator {

    /**

     * @var int keep track of how many entries have been created.

     */

    protected $entrycount = 0;

    /**

     * @var int keep track of how many entries have been created.

     */

    protected $categorycount = 0;

    /**

     * To be called from data reset code only,

     * do not use in tests.

     * @return void

     */

    public function reset() {

        $this->entrycount = 0;

        $this->categorycount = 0;

        parent::reset();

    }

    public function create_instance($record = null, ?array $options = null) {

        global $CFG;

        // Add default values for glossary.

        $record = (array)$record + array(

            'globalglossary' => 0,

            'mainglossary' => 0,

            'defaultapproval' => $CFG->glossary_defaultapproval,

            'allowduplicatedentries' => $CFG->glossary_dupentries,

            'allowcomments' => $CFG->glossary_allowcomments,

            'usedynalink' => $CFG->glossary_linkbydefault,

            'displayformat' => 'dictionary',

            'approvaldisplayformat' => 'default',

            'entbypage' => !empty($CFG->glossary_entbypage) ? $CFG->glossary_entbypage : 10,

            'showalphabet' => 1,

            'showall' => 1,

            'showspecial' => 1,

            'allowprintview' => 1,

            'rsstype' => 0,

            'rssarticles' => 0,

            'grade' => 100,

            'assessed' => 0,

        );

        return parent::create_instance($record, (array)$options);

    }

    public function create_category($glossary, $record = array(), $entries = array()) {

        global $CFG, $DB;

        $this->categorycount++;

        $record = (array)$record + array(

            'name' => 'Glossary category '.$this->categorycount,

            'usedynalink' => $CFG->glossary_linkbydefault,

        );

        $record['glossaryid'] = $glossary->id;

        $id = $DB->insert_record('glossary_categories', $record);

        if ($entries) {

            foreach ($entries as $entry) {

                $ce = new stdClass();

                $ce->categoryid = $id;

                $ce->entryid = $entry->id;

                $DB->insert_record('glossary_entries_categories', $ce);

            }

        }

        return $DB->get_record('glossary_categories', array('id' => $id), '*', MUST_EXIST);

    }

    public function create_content($glossary, $record = array(), $aliases = array()) {

        global $DB;

        $entry = $this->create_entry((array)$record + ['glossaryid' => $glossary->id]);

        if ($aliases) {

            foreach ($aliases as $alias) {

                $ar = new stdClass();

                $ar->entryid = $entry->id;

                $ar->alias = $alias;

                $DB->insert_record('glossary_alias', $ar);

            }

        }

        if (array_key_exists('tags', $record)) {

            $tags = is_array($record['tags']) ? $record['tags'] : preg_split('/,/', $record['tags']);

            core_tag_tag::set_item_tags('mod_glossary', 'glossary_entries', $entry->id,

                context_module::instance($glossary->cmid), $tags);

        }

        return $entry;

    }

    /**

     * Create an entry.

     *

     * @param array $data Data to create the entry record.

     *        In addition to columns in the entry table, the following attributes are supported:

     *         - glossaryid (required): Id of the glossary where the entry will be created.

     *         - categoryids: Array of ids for the categories this entry belongs to.

     *

     * @return stdClass Entry record.

     */

    public function create_entry(array $data): stdClass {

        global $DB, $USER, $CFG;

        // Prepare glossary.

        $coursemodule = get_coursemodule_from_instance('glossary', $data['glossaryid']);

        $glossary = $DB->get_record('glossary', ['id' => $data['glossaryid']], '*', MUST_EXIST);

        $glossary->cmid = $coursemodule->id;

        unset($data['glossaryid']);

        // Prepare category ids.

        $categoryids = $data['categoryids'] ?? [];

        unset($data['categoryids']);

        // Create entry.

        $this->entrycount++;

        $now = time();

        $record = $data + [

            'glossaryid' => $glossary->id,

            'timecreated' => $now,

            'timemodified' => $now,

            'userid' => $USER->id,

            'concept' => 'Glossary entry '.$this->entrycount,

            'definition' => 'Definition of glossary entry '.$this->entrycount,

            'definitionformat' => FORMAT_MOODLE,

            'definitiontrust' => 0,

            'usedynalink' => $CFG->glossary_linkentries,

            'casesensitive' => $CFG->glossary_casesensitive,

            'fullmatch' => $CFG->glossary_fullmatch

        ];

        if (!isset($record['teacherentry']) || !isset($record['approved'])) {

            $context = context_module::instance($glossary->cmid);

            if (!isset($record['teacherentry'])) {

                $record['teacherentry'] = has_capability('mod/glossary:manageentries', $context, $record['userid']);

            }

            if (!isset($record['approved'])) {

                $defaultapproval = $glossary->defaultapproval;

                $record['approved'] = ($defaultapproval || has_capability('mod/glossary:approve', $context));

            }

        }

        $id = $DB->insert_record('glossary_entries', $record);

        foreach ($categoryids as $categoryid) {

            $DB->insert_record('glossary_entries_categories', ['entryid' => $id, 'categoryid' => $categoryid]);

        }

        $entries =  $DB->get_record('glossary_entries', ['id' => $id], '*', MUST_EXIST);

        if (isset($record['tags'])) {

            $cm = get_coursemodule_from_instance('glossary', $glossary->id);

            $tags = is_array($record['tags']) ? $record['tags'] : explode(',', $record['tags']);

            core_tag_tag::set_item_tags('mod_glossary', 'glossary_entries', $id,

                context_module::instance($cm->id), $tags);

        }

        return $entries;

    }

}