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 mod_data\local\importer;

use context_module;
use core_php_time_limit;
use core_tag_tag;
use core_user;
use csv_import_reader;
use moodle_exception;
use stdClass;

/**
 * CSV entries_importer class for importing data and - if needed - files as well from a zip archive.
 *
 * @package    mod_data
 * @copyright  2023 ISB Bayern
 * @author     Philipp Memmel
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class csv_entries_importer extends entries_importer {

    /** @var array Log entries for successfully added records. */
    private array $addedrecordsmessages = [];

    /**
     * Declares the entries_importer to use a csv file as data file.
     *
     * @see entries_importer::get_import_data_file_extension()
     */
    public function get_import_data_file_extension(): string {
        return 'csv';
    }

    /**
     * Import records for a data instance from csv data.
     *
     * @param stdClass $cm Course module of the data instance.
     * @param stdClass $data The data instance.
     * @param string $encoding The encoding of csv data.
     * @param string $fielddelimiter The delimiter of the csv data.
     *
     * @throws moodle_exception
     */
    public function import_csv(stdClass $cm, stdClass $data, string $encoding, string $fielddelimiter): void {
        global $CFG, $DB;
        // Large files are likely to take their time and memory. Let PHP know
        // that we'll take longer, and that the process should be recycled soon
        // to free up memory.
        core_php_time_limit::raise();
        raise_memory_limit(MEMORY_HUGE);

        $iid = csv_import_reader::get_new_iid('moddata');
        $cir = new csv_import_reader($iid, 'moddata');

        $context = context_module::instance($cm->id);

        $readcount = $cir->load_csv_content($this->get_data_file_content(), $encoding, $fielddelimiter);
        if (empty($readcount)) {
            throw new \moodle_exception('csvfailed', 'data', "{$CFG->wwwroot}/mod/data/edit.php?d={$data->id}");
        } else {
            if (!$fieldnames = $cir->get_columns()) {
                throw new \moodle_exception('cannotreadtmpfile', 'error');
            }

            // Check the fieldnames are valid.
            $rawfields = $DB->get_records('data_fields', ['dataid' => $data->id], '', 'name, id, type');
            $fields = [];
            $errorfield = '';
            $usernamestring = get_string('username');
            $safetoskipfields = [get_string('user'), get_string('email'),
                get_string('timeadded', 'data'), get_string('timemodified', 'data'),
                get_string('approved', 'data'), get_string('tags', 'data')];
            $userfieldid = null;
            foreach ($fieldnames as $id => $name) {
                if (!isset($rawfields[$name])) {
                    if ($name == $usernamestring) {
                        $userfieldid = $id;
                    } else if (!in_array($name, $safetoskipfields)) {
                        $errorfield .= "'$name' ";
                    }
                } else {
                    // If this is the second time, a field with this name comes up, it must be a field not provided by the user...
                    // like the username.
                    if (isset($fields[$name])) {
                        if ($name == $usernamestring) {
                            $userfieldid = $id;
                        }
                        unset($fieldnames[$id]); // To ensure the user provided content fields remain in the array once flipped.
                    } else {
                        $field = $rawfields[$name];
                        $field->type = clean_param($field->type, PARAM_ALPHA);
                        $filepath = "$CFG->dirroot/mod/data/field/$field->type/field.class.php";
                        if (!file_exists($filepath)) {
                            $errorfield .= "'$name' ";
                            continue;
                        }
                        require_once($filepath);
                        $classname = 'data_field_' . $field->type;
                        $fields[$name] = new $classname($field, $data, $cm);
                    }
                }
            }

            if (!empty($errorfield)) {
                throw new \moodle_exception('fieldnotmatched', 'data',
                    "{$CFG->wwwroot}/mod/data/edit.php?d={$data->id}", $errorfield);
            }

            $fieldnames = array_flip($fieldnames);

            $cir->init();
            while ($record = $cir->next()) {
                $authorid = null;
                if ($userfieldid) {
                    if (!($author = core_user::get_user_by_username($record[$userfieldid], 'id'))) {
                        $authorid = null;
                    } else {
                        $authorid = $author->id;
                    }
                }

                // Determine presence of "approved" field within the record to import.
                $approved = true;
                if (array_key_exists(get_string('approved', 'data'), $fieldnames)) {
                    $approvedindex = $fieldnames[get_string('approved', 'data')];
                    $approved = !empty($record[$approvedindex]);
                }

                if ($recordid = data_add_record($data, 0, $authorid, $approved)) { // Add instance to data_record.
                    foreach ($fields as $field) {
                        $fieldid = $fieldnames[$field->field->name];
                        if (isset($record[$fieldid])) {
                            $value = $record[$fieldid];
                        } else {
                            $value = '';
                        }

                        if (method_exists($field, 'update_content_import')) {
                            $field->update_content_import($recordid, $value, 'field_' . $field->field->id);
                        } else {
                            $content = new stdClass();
                            $content->fieldid = $field->field->id;
                            $content->content = $value;
                            $content->recordid = $recordid;
                            if ($field->file_import_supported() && $this->importfiletype === 'zip') {
                                $filecontent = $this->get_file_content_from_zip($content->content);
                                if (!$filecontent) {
                                    // No corresponding file in zip archive, so no record for this field being added at all.
                                    continue;
                                }
                                $contentid = $DB->insert_record('data_content', $content);
                                $field->import_file_value($contentid, $filecontent, $content->content);
                            } else {
                                $DB->insert_record('data_content', $content);
                            }
                        }
                    }

                    if (core_tag_tag::is_enabled('mod_data', 'data_records') &&
                        isset($fieldnames[get_string('tags', 'data')])) {
                        $columnindex = $fieldnames[get_string('tags', 'data')];
                        $rawtags = $record[$columnindex];
                        $tags = explode(',', $rawtags);
                        foreach ($tags as $tag) {
                            $tag = trim($tag);
                            if (empty($tag)) {
                                continue;
                            }
                            core_tag_tag::add_item_tag('mod_data', 'data_records', $recordid, $context, $tag);
                        }
                    }

                    $this->addedrecordsmessages[] = get_string('added', 'moodle',
                            count($this->addedrecordsmessages) + 1)
                        . ". " . get_string('entry', 'data')
                        . " (ID $recordid)\n";
                }
            }
            $cir->close();
            $cir->cleanup(true);
        }
    }

    /**
     * Getter for the array of messages for added records.
     *
     * For each successfully added record the array contains a log message.
     *
     * @return array Array of message strings: For each added record one message string
     */
    public function get_added_records_messages(): array {
        return $this->addedrecordsmessages;
    }
}