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;

use action_menu;
use action_menu_link_secondary;
use core\output\checkbox_toggleall;
use data_field_base;
use html_writer;
use mod_data\manager;
use moodle_url;
use pix_icon;
use stdClass;
use user_picture;
use core_user;
use portfolio_add_button;
use data_portfolio_caller;
use comment;
use core_tag_tag;

/**
 * Class template for database activity
 *
 * @package    mod_data
 * @copyright  2022 Ferran Recio <ferran@moodle.com>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */
class template {

    /** @var manager the current instance manager. */
    private $manager;

    /** @var stdClass the current instance record. */
    private $instance;

    /** @var string the template. */
    private $templatecontent;

    /** @var string the template name. */
    private $templatename;

    /** @var moodle_url the base url. */
    private $baseurl;

    /** @var string the current search if any. */
    private $search;

    /** @var bool if ratings must be added. */
    private $ratings;

    /** @var bool if comments must be added if not present in the template. */
    private $forcecomments;

    /** @var bool if show more option must be added. */
    private $showmore;

    /** @var bool if the current user can manage entries. */
    private $canmanageentries = null;

    /** @var array if icons HTML. */
    private $icons = [];

    /** @var array All template tags (calculated in load_template_tags). */
    protected $tags = [];

    /** @var array The mod_data fields. */
    protected $fields = [];

    /** @var array All fields that are not present in the template content. */
    protected $otherfields = [];

    /**
     * Class contructor.
     *
     * See the add_options method for the available display options.
     *
     * @param manager $manager the current instance manager
     * @param string $templatecontent the template string to use
     * @param array $options an array of extra diplay options
     * @param array $fields alternative array of fields (for preview presets)
     */
    public function __construct(manager $manager, string $templatecontent, array $options = [], array $fields = null) {
        $this->manager = $manager;
        $this->instance = $manager->get_instance();
        $this->templatecontent = $templatecontent;

        $context = $manager->get_context();
        $this->canmanageentries = has_capability('mod/data:manageentries', $context);
        $this->icons = $this->get_icons();
        $this->fields = $fields ?? $manager->get_fields();
        $this->add_options($options);
        $this->load_template_tags($templatecontent);
    }

    /**
     * Create a template class with the default template content.
     *
     * @param manager $manager the current instance manager.
     * @param string $templatename the template name.
     * @param bool $form whether the fields should be displayed as form instead of data.
     * @return self The template with the default content (to be displayed when no template is defined).
     */
    public static function create_default_template(
            manager $manager,
            string $templatename,
            bool $form = false
    ): self {
        $renderer = $manager->get_renderer();
        $content = '';
        switch ($templatename) {
            case 'addtemplate':
            case 'asearchtemplate':
            case 'listtemplate':
            case 'rsstemplate':
            case 'singletemplate':
                $template = new \mod_data\output\defaulttemplate($manager->get_fields(), $templatename, $form);
                $content = $renderer->render_defaulttemplate($template);
        }

        // Some templates have extra options.
        $options = self::get_default_display_options($templatename);

        return new self($manager, $content, $options);
    }

    /**
     * Get default options for templates.
     *
     * For instance, the list template supports the show more button.
     *
     * @param string $templatename the template name.
     * @return array an array of extra diplay options.
     */
    public static function get_default_display_options(string $templatename): array {
        $options = [];

        if ($templatename === 'singletemplate') {
            $options['comments'] = true;
            $options['ratings'] = true;
        }
        if ($templatename === 'listtemplate') {
            // The "Show more" button should be only displayed in the listtemplate.
            $options['showmore'] = true;
        }

        return $options;
    }

    /**
     * Return the raw template content.
     *
     * @return string the template content before parsing
     */
    public function get_template_content(): string {
        return $this->templatecontent;
    }

    /**
     * Add extra display options.
     *
     * The extra options are:
     *  - page: the current pagination page
     *  - search: the current search text
     *  - baseurl: an alternative entry url (moodle_url)
     *  - comments: if comments must be added if not present
     *  - ratings: if ratings must be added
     *
     * @param array $options the array of options.
     */
    public function add_options(array $options = []) {
        $cm = $this->manager->get_coursemodule();
        $baseurl = $options['baseurl'] ?? new moodle_url('/mod/data/view.php', ['id' => $cm->id]);
        if (isset($options['page'])) {
            $baseurl->params([
                'page' => $options['page'],
            ]);
        }
        $this->baseurl = $baseurl;

        // Save options.
        $this->search = $options['search'] ?? null;
        $this->ratings = $options['ratings'] ?? false;
        $this->forcecomments = $options['comments'] ?? false;
        $this->showmore = $options['showmore'] ?? false;
        $this->templatename = $options['templatename'] ?? 'singletemplate';
    }

    /**
     * Scan the template tags.
     *
     * This method detects which tags are used in this template and store them
     * in the $this->tags attribute. This attribute will be used to determine
     * which replacements needs to be calculated.
     *
     * @param string $templatecontent the current template
     */
    protected function load_template_tags(string $templatecontent) {
        // Detect action tags.
        $pattern = '/##(?P<tags>\w+?)##/';
        $matches = [];
        preg_match_all($pattern, $templatecontent, $matches);
        if (!isset($matches['tags']) || empty($matches['tags'])) {
            return;
        }
        $this->tags = $matches['tags'];
        // Check if some tag require some extra template scan.
        foreach ($this->tags as $tagname) {
            $methodname = "preprocess_tag_{$tagname}";
            if (method_exists($this, $methodname)) {
                $this->$methodname($templatecontent);
            }
        }
    }

    /**
     * Check if a tag is present in the template.
     *
     * @param bool $tagname the tag to check (without ##)
     * @return bool if the tag is present
     */
    public function has_tag(string $tagname): bool {
        return in_array($tagname, $this->tags);
    }

    /**
     * Return the current template name.
     *
     * @return string the template name
     */
    public function get_template_name(): string {
        return $this->templatename;
    }

    /**
     * Generate the list of action icons.
     *
     * @return pix_icon[] icon name => pix_icon
     */
    protected function get_icons() {
        $attrs = ['class' => 'iconsmall dataicon'];
        return [
            'edit' => new pix_icon('t/editinline', get_string('edit'), '', $attrs),
            'delete' => new pix_icon('t/delete', get_string('delete'), '', $attrs),
            'more' => new pix_icon('t/preview', get_string('more', 'data'), '', $attrs),
            'approve' => new pix_icon('t/approve', get_string('approve', 'data'), '', $attrs),
            'disapprove' => new pix_icon('t/block', get_string('disapprove', 'data'), '', $attrs),
        ];
    }

    /**
     * Return the parsed entry using a template.
     *
     * This method apply a template replacing all necessary tags.
     *
     * @param array $entries of entres to parse
     * @return string the entries outputs using the template
     */
    public function parse_entries(array $entries): string {
        if (empty($entries)) {
            return '';
        }
        $result = '';
        foreach ($entries as $entry) {
            $result .= $this->parse_entry($entry);
        }
        return $result;
    }

    /**
     * Parse a single entry.
     *
     * @param stdClass $entry the entry to parse
     * @return string the parsed entry
     */
    private function parse_entry(stdClass $entry): string {
        if (empty($this->templatecontent)) {
            return '';
        }
        $context = $this->manager->get_context();
        $canmanageentry = data_user_can_manage_entry($entry, $this->instance, $context);

        // Load all replacements for the entry.
        $fields = $this->get_fields_replacements($entry);
        $tags = $this->get_tags_replacements($entry, $canmanageentry);
        $replacements = array_merge($fields, $tags);

        $patterns = array_keys($replacements);
        $replacement = array_values($replacements);
        $result = str_ireplace($patterns, $replacement, $this->templatecontent);

        return $this->post_parse($result, $entry);
    }

    /**
     * Get all field replacements.
     *
     * @param stdClass $entry the entry object
     * @return array of pattern => replacement
     */
    private function get_fields_replacements(stdClass $entry): array {
        $result = [];
        foreach ($this->fields as $field) {
            // Field value.
            $pattern = '[[' . $field->field->name . ']]';
            $result[$pattern] = highlight(
                $this->search,
                $field->display_browse_field($entry->id, $this->templatename)
            );
            // Other dynamic field information.
            $pattern = '[[' . $field->field->name . '#id]]';
            $result[$pattern] = $field->field->id;
            $pattern = '[[' . $field->field->name . '#name]]';
            $result[$pattern] = $field->field->name;
            $pattern = '[[' . $field->field->name . '#description]]';
            $result[$pattern] = $field->field->description;
        }
        return $result;
    }

    /**
     * Get all standard tags replacements.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return array of pattern => replacement
     */
    private function get_tags_replacements(stdClass $entry, bool $canmanageentry): array {
        $result = [];
        foreach ($this->tags as $tagname) {
            $methodname = "get_tag_{$tagname}_replacement";
            if (method_exists($this, $methodname)) {
                $pattern = "##$tagname##";
                $replacement = $this->$methodname($entry, $canmanageentry);
                $result[$pattern] = $replacement;
            }
        }
        return $result;
    }

    /**
     * Add any extra information to the parsed entry.
     *
     * @param string $result the parsed template with the entry data
     * @param stdClass $entry the entry object
     * @return string the final parsed template
     */
    private function post_parse(string $result, stdClass $entry): string {
        if ($this->ratings) {
            $result .= data_print_ratings($this->instance, $entry, false);
        }
        if ($this->forcecomments && strpos($this->templatecontent, '##comments##') === false) {
            $result .= $this->get_tag_comments_replacement($entry, false);
        }
        return $result;
    }

    /**
     * Returns the ##edit## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_edit_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;
        if (!$canmanageentry) {
            return '';
        }
        $backurl = new moodle_url($this->baseurl, [
            'rid' => $entry->id,
            'mode' => 'single',
        ]);
        $url = new moodle_url('/mod/data/edit.php', $this->baseurl->params());
        $url->params([
            'rid' => $entry->id,
            'sesskey' => sesskey(),
            'backto' => urlencode($backurl->out(false))
        ]);
        return html_writer::tag(
            'span',
            $OUTPUT->action_icon($url, $this->icons['edit']),
            ['class' => 'edit']
        );
    }

    /**
     * Returns the ##delete## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_delete_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;
        if (!$canmanageentry) {
            return '';
        }
        $url = new moodle_url($this->baseurl, [
            'delete' => $entry->id,
            'sesskey' => sesskey(),
            'mode' => 'single',
        ]);

        return html_writer::tag(
            'span',
            $OUTPUT->action_icon($url, $this->icons['delete']),
            ['class' => 'delete']
        );
    }

    /**
     * Returns the ##more## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_more_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;

        if (!$this->showmore) {
            return '';
        }

        $url = new moodle_url($this->baseurl, [
            'rid' => $entry->id,
            'filter' => 1,
        ]);
        return html_writer::tag(
            'span',
            $OUTPUT->action_icon($url, $this->icons['more']),
            ['class' => 'more']
        );
    }

    /**
     * Returns the ##moreurl## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_moreurl_replacement(stdClass $entry, bool $canmanageentry): string {
        $url = new moodle_url($this->baseurl, [
            'rid' => $entry->id,
            'filter' => 1,
        ]);
        return $url->out(false);
    }

    /**
     * Returns the ##delcheck## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_delcheck_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;
        if (!$this->canmanageentries) {
            return '';
        }
        $checkbox = new checkbox_toggleall('listview-entries', false, [
            'id' => "entry_{$entry->id}",
            'name' => 'delcheck[]',
            'classes' => 'recordcheckbox',
            'value' => $entry->id,
        ]);
        return $OUTPUT->render($checkbox);
    }

    /**
     * Returns the ##user## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_user_replacement(stdClass $entry, bool $canmanageentry): string {
        $cm = $this->manager->get_coursemodule();
        $url = new moodle_url('/user/view.php', [
            'id' => $entry->userid,
            'course' => $cm->course,
        ]);
        return html_writer::tag(
            'a',
            fullname($entry),
            ['href' => $url->out(false)]
        );
    }

    /**
     * Returns the ##userpicture## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_userpicture_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;
        $cm = $this->manager->get_coursemodule();
        $user = user_picture::unalias($entry, null, 'userid');
        // If the record didn't come with user data, retrieve the user from database.
        if (!isset($user->picture)) {
            $user = core_user::get_user($entry->userid);
        }
        return $OUTPUT->user_picture($user, ['courseid' => $cm->course, 'size' => 64]);
    }

    /**
     * Returns the ##export## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_export_replacement(stdClass $entry, bool $canmanageentry): string {
        global $CFG;
        if (empty($CFG->enableportfolios)) {
            return '';
        }
        // Check the user can export the entry.
        $cm = $this->manager->get_coursemodule();
        $context = $this->manager->get_context();
        $canexportall = has_capability('mod/data:exportentry', $context);
        $canexportown = has_capability('mod/data:exportownentry', $context);
        if (!$canexportall && !(data_isowner($entry->id) && $canexportown)) {
            return '';
        }
        // Add the portfolio export button.
        require_once($CFG->libdir . '/portfoliolib.php');
        $button = new portfolio_add_button();
        $button->set_callback_options(
            'data_portfolio_caller',
            ['id' => $cm->id, 'recordid' => $entry->id],
            'mod_data'
        );
        list($formats, $files) = data_portfolio_caller::formats($this->fields, $entry);
        $button->set_formats($formats);
        $result = $button->to_html(PORTFOLIO_ADD_ICON_LINK);
        if (is_null($result)) {
            $result = '';
        }
        return $result;
    }

    /**
     * Returns the ##timeadded## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_timeadded_replacement(stdClass $entry, bool $canmanageentry): string {
        return html_writer::tag(
            'span',
            userdate($entry->timecreated, get_string('strftimedatemonthabbr', 'langconfig')),
            ['title' => userdate($entry->timecreated)]
        );
    }

    /**
     * Returns the ##timemodified## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_timemodified_replacement(stdClass $entry, bool $canmanageentry): string {
        return html_writer::tag(
            'span',
            userdate($entry->timemodified, get_string('strftimedatemonthabbr', 'langconfig')),
            ['title' => userdate($entry->timemodified)]
        );
    }

    /**
     * Returns the ##approve## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_approve_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;
        $context = $this->manager->get_context();
        if (!has_capability('mod/data:approve', $context) || !$this->instance->approval || $entry->approved) {
            return '';
        }
        $url = new moodle_url($this->baseurl, [
            'approve' => $entry->id,
            'sesskey' => sesskey(),
        ]);
        return html_writer::tag(
            'span',
            $OUTPUT->action_icon($url, $this->icons['approve']),
            ['class' => 'approve']
        );
    }

    /**
     * Returns the ##disapprove## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_disapprove_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;
        $context = $this->manager->get_context();
        if (!has_capability('mod/data:approve', $context) || !$this->instance->approval || !$entry->approved) {
            return '';
        }
        $url = new moodle_url($this->baseurl, [
            'disapprove' => $entry->id,
            'sesskey' => sesskey(),
        ]);
        return html_writer::tag(
            'span',
            $OUTPUT->action_icon($url, $this->icons['disapprove']),
            ['class' => 'disapprove']
        );
    }

    /**
     * Returns the ##approvalstatus## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_approvalstatus_replacement(stdClass $entry, bool $canmanageentry): string {
        if (!$this->instance->approval) {
            return '';
        }
        return ($entry->approved) ? '' : html_writer::div(get_string('notapproved', 'data'), 'mod-data-approval-status-badge');
    }

    /**
     * Returns the ##approvalstatusclass## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_approvalstatusclass_replacement(stdClass $entry, bool $canmanageentry): string {
        if (!$this->instance->approval) {
            return '';
        }
        return ($entry->approved) ? 'approved' : 'notapproved';
    }

    /**
     * Returns the ##comments## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_comments_replacement(stdClass $entry, bool $canmanageentry): string {
        global $CFG;
        if (empty($CFG->usecomments) || empty($this->instance->comments)) {
            return '';
        }
        $context = $this->manager->get_context();
        require_once($CFG->dirroot  . '/comment/lib.php');
        list($context, $course, $cm) = get_context_info_array($context->id);
        $cmdata = (object)[
            'context' => $context,
            'course' => $course,
            'cm' => $cm,
            'area' => 'database_entry',
            'itemid' => $entry->id,
            'showcount' => true,
            'component' => 'mod_data',
        ];
        $comment = new comment($cmdata);
        return $comment->output(true);
    }

    /**
     * Returns the ##tags## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_tags_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;
        if (!core_tag_tag::is_enabled('mod_data', 'data_records')) {
            return '';
        }
        return $OUTPUT->tag_list(
            core_tag_tag::get_item_tags('mod_data', 'data_records', $entry->id),
            '',
            'data-tags'
        );
    }

    /**
     * Returns the ##id## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_id_replacement(stdClass $entry, bool $canmanageentry): string {
        return (string) $entry->id;
    }

    /**
     * Prepare otherfield tag scanning the present template fields.
     *
     * @param string $templatecontent the template content
     */
    protected function preprocess_tag_otherfields(string $templatecontent) {
        $otherfields = [];
        $fields = $this->manager->get_fields();
        foreach ($fields as $field) {
            if (strpos($templatecontent, "[[" . $field->field->name . "]]") === false) {
                $otherfields[] = $field;
            }
        }
        $this->otherfields = $otherfields;
    }

    /**
     * Returns the ##otherfields## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_otherfields_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT;
        $fields = [];
        foreach ($this->otherfields as $field) {
            $fieldvalue = highlight(
                $this->search,
                $field->display_browse_field($entry->id, $this->templatename)
            );
            $fieldinfo = [
                'fieldname' => $field->field->name,
                'fieldcontent' => $fieldvalue,
            ];
            $fields[] = $fieldinfo;
        }
        return $OUTPUT->render_from_template('mod_data/fields_otherfields', ['fields' => $fields]);
    }

    /**
     * Returns the ##actionsmenu## tag replacement for an entry.
     *
     * @param stdClass $entry the entry object
     * @param bool $canmanageentry if the current user can manage this entry
     * @return string the tag replacement
     */
    protected function get_tag_actionsmenu_replacement(stdClass $entry, bool $canmanageentry): string {
        global $OUTPUT, $CFG;

        $actionmenu = new action_menu();
        $actionmenu->set_kebab_trigger();
        $actionmenu->set_action_label(get_string('actions'));
        $actionmenu->set_additional_classes('entry-actionsmenu');

        // Show more.
        if ($this->showmore) {
            $showmoreurl = new moodle_url($this->baseurl, [
                'rid' => $entry->id,
                'filter' => 1,
            ]);
            $actionmenu->add(new action_menu_link_secondary(
                $showmoreurl,
                null,
                get_string('showmore', 'mod_data')
            ));
        }

        if ($canmanageentry) {
            // Edit entry.
            $backurl = new moodle_url($this->baseurl, [
                'rid' => $entry->id,
                'mode' => 'single',
            ]);
            $editurl = new moodle_url('/mod/data/edit.php', $this->baseurl->params());
            $editurl->params([
                'rid' => $entry->id,
                'sesskey' => sesskey(),
                'backto' => urlencode($backurl->out(false))
            ]);

            $actionmenu->add(new action_menu_link_secondary(
                $editurl,
                null,
                get_string('edit')
            ));

            // Delete entry.
            $deleteurl = new moodle_url($this->baseurl, [
                'delete' => $entry->id,
                'sesskey' => sesskey(),
                'mode' => 'single',
            ]);

            $actionmenu->add(new action_menu_link_secondary(
                $deleteurl,
                null,
                get_string('delete')
            ));
        }

        // Approve/disapprove entry.
        $context = $this->manager->get_context();
        if (has_capability('mod/data:approve', $context) && $this->instance->approval) {
            if ($entry->approved) {
                $disapproveurl = new moodle_url($this->baseurl, [
                    'disapprove' => $entry->id,
                    'sesskey' => sesskey(),
                ]);
                $actionmenu->add(new action_menu_link_secondary(
                    $disapproveurl,
                    null,
                    get_string('disapprove', 'mod_data')
                ));
            } else {
                $approveurl = new moodle_url($this->baseurl, [
                    'approve' => $entry->id,
                    'sesskey' => sesskey(),
                ]);
                $actionmenu->add(new action_menu_link_secondary(
                    $approveurl,
                    null,
                    get_string('approve', 'mod_data')
                ));
            }
        }

        // Export entry to portfolio.
        if (!empty($CFG->enableportfolios)) {
            // Check the user can export the entry.
            $cm = $this->manager->get_coursemodule();
            $canexportall = has_capability('mod/data:exportentry', $context);
            $canexportown = has_capability('mod/data:exportownentry', $context);
            if ($canexportall || (data_isowner($entry->id) && $canexportown)) {
                // Add the portfolio export button.
                require_once($CFG->libdir . '/portfoliolib.php');
                $button = new portfolio_add_button();
                $button->set_callback_options(
                    'data_portfolio_caller',
                    ['id' => $cm->id, 'recordid' => $entry->id],
                    'mod_data'
                );
                $fields = $this->manager->get_fields();
                list($formats, $files) = data_portfolio_caller::formats($fields, $entry);
                $button->set_formats($formats);
                $exporturl = $button->to_html(PORTFOLIO_ADD_MOODLE_URL);
                if (!is_null($exporturl)) {
                    $actionmenu->add(new action_menu_link_secondary(
                        $exporturl,
                        null,
                        get_string('addtoportfolio', 'portfolio')
                    ));
                }
            }
        }

        return $OUTPUT->render($actionmenu);
    }

    /**
     * Parse the template as if it was for add entry.
     *
     * This method is similar to the parse_entry but it uses the display_add_field method
     * instead of the display_browse_field.
     *
     * @param stdClass|null $processeddata the previous process data information.
     * @param int|null $entryid the possible entry id
     * @param stdClass|null $entrydata the entry data from a previous form or from a real entry
     * @return string the add entry HTML content
     */
    public function parse_add_entry(
        ?stdClass $processeddata = null,
        ?int $entryid = null,
        ?stdClass $entrydata = null
    ): string {
        global $OUTPUT;

        $manager = $this->manager;
        $renderer = $manager->get_renderer();
        $templatecontent = $this->templatecontent;

        if (!$processeddata) {
            $processeddata = (object)[
                'generalnotifications' => [],
                'fieldnotifications' => [],
            ];
        }

        $result = '';

        foreach ($processeddata->generalnotifications as $notification) {
            $result .= $renderer->notification($notification);
        }

        $possiblefields = $manager->get_fields();
        $patterns = [];
        $replacements = [];

        // Then we generate strings to replace.
        $otherfields = [];
        foreach ($possiblefields as $field) {
            $fieldinput = $this->get_field_input($processeddata, $field, $entryid, $entrydata);
            if (strpos($templatecontent, "[[" . $field->field->name . "]]") !== false) {
                // Replace the field tag.
                $patterns[] = "[[" . $field->field->name . "]]";
                $replacements[] = $fieldinput;
            } else {
                // Is in another fields.
                $otherfields[] = [
                    'fieldname' => $field->field->name,
                    'fieldcontent' => $fieldinput,
                ];
            }

            // Replace the field id tag.
            $patterns[] = "[[" . $field->field->name . "#id]]";
            $replacements[] = 'field_' . $field->field->id;
            $patterns[] = '[[' . $field->field->name . '#name]]';
            $replacements[] = $field->field->name;
            $patterns[] = '[[' . $field->field->name . '#description]]';
            $replacements[] = $field->field->description;
        }

        $patterns[] = "##otherfields##";
        if (!empty($otherfields)) {
            $replacements[] = $OUTPUT->render_from_template(
                'mod_data/fields_otherfields',
                ['fields' => $otherfields]
            );
        } else {
            $replacements[] = '';
        }

        if (core_tag_tag::is_enabled('mod_data', 'data_records')) {
            $patterns[] = "##tags##";
            $replacements[] = data_generate_tag_form($entryid);
        }

        $result .= str_ireplace($patterns, $replacements, $templatecontent);
        return $result;
    }

    /**
     * Return the input form html from a specific field.
     *
     * @param stdClass $processeddata the previous process data information.
     * @param data_field_base $field the field object
     * @param int|null $entryid the possible entry id
     * @param stdClass|null $entrydata the entry data from a previous form or from a real entry
     * @return string the add entry HTML content
     */
    private function get_field_input(
        stdClass $processeddata,
        data_field_base $field,
        ?int $entryid = null,
        ?stdClass $entrydata = null
    ): string {
        $renderer = $this->manager->get_renderer();
        $errors = '';
        $fieldnotifications = $processeddata->fieldnotifications[$field->field->name] ?? [];
        if (!empty($fieldnotifications)) {
            foreach ($fieldnotifications as $notification) {
                $errors .= $renderer->notification($notification);
            }
        }
        $fielddisplay = '';
        if ($field->type === 'unknown') {
            if ($this->canmanageentries) { // Display notification for users that can manage entries.
                $errors .= $renderer->notification(get_string(
                    'missingfieldtype',
                    'data',
                    (object)['name' => s($field->field->name)]
                ));
            }
        } else {
            $fielddisplay = $field->display_add_field($entryid, $entrydata);
        }
        return $errors . $fielddisplay;
    }
}