Annunci

            // The mimetype does not include image.
            return false;
        }
 
        // If it looks like an image, and it smells like an image, perhaps it's an image!
        return true;
    }
 
    /**
     * Returns image information relating to the specified path or URL.
     *
     * @param string $path The full path of the image file.
     * @return array|bool array that containing width, height, and mimetype or false if cannot get the image info.
     */
    protected function get_imageinfo_from_path($path) {
        $imagemimetype = file_storage::mimetype_from_file($path);
        $issvgimage = file_is_svg_image_from_mimetype($imagemimetype);
 
        if (!$issvgimage) {
            $imageinfo = getimagesize($path);
            if (!is_array($imageinfo)) {
                return false; // Nothing to process, the file was not recognised as image by GD.
            }
            $image = [
                    'width' => $imageinfo[0],
                    'height' => $imageinfo[1],
                    'mimetype' => image_type_to_mime_type($imageinfo[2]),
            ];
        } else {
            // Since SVG file is actually an XML file, GD cannot handle.
            $svgcontent = @simplexml_load_file($path);
            if (!$svgcontent) {
                // Cannot parse the file.
                return false;
            }
            $svgattrs = $svgcontent->attributes();
 
            if (!empty($svgattrs->viewBox)) {
                // We have viewBox.
                $viewboxval = explode(' ', $svgattrs->viewBox);

     * Information is determined from the file content
     *
     * @param stored_file $file The file to inspect
     * @return mixed array with width, height and mimetype; false if not an image
     */
    public function get_imageinfo(stored_file $file) {
        if (!$this->is_image_from_storedfile($file)) {
            return false;
        }
 
        $hash = $file->get_contenthash();
        $cache = cache::make('core', 'file_imageinfo');
        $info = $cache->get($hash);
        if ($info !== false) {
            return $info;
        }
 
        // Whilst get_imageinfo_from_path can use remote paths, it must download the entire file first.
        // It is more efficient to use a local file when possible.
        $info = $this->get_imageinfo_from_path($this->get_local_path_from_storedfile($file, true));
        $cache->set($hash, $info);
        return $info;
    }
 
    /**
     * Attempt to determine whether the specified file is likely to be an
     * image.
     * Since this relies upon the mimetype stored in the files table, there
     * may be times when this information is not 100% accurate.
     *
     * @param stored_file $file The file to check
     * @return bool
     */
    public function is_image_from_storedfile(stored_file $file) {
        if (!$file->get_filesize()) {
            // An empty file cannot be an image.
            return false;
        }
 
        $mimetype = $file->get_mimetype();

                // This file is not stored locally - attempt to retrieve it from the repository.
                // This may happen if the repository deliberately does not fetch files, or if there is a failure with the sync.
                $fileinfo = $this->repository->get_file($this->get_reference());
                if (isset($fileinfo['path'])) {
                    return $filearch->add_file_from_pathname($archivepath, $fileinfo['path']);
                }
            }
        }
 
        return $this->filesystem->add_storedfile_to_archive($this, $filearch, $archivepath);
    }
 
    /**
     * Returns information about image,
     * information is determined from the file content
     *
     * @return mixed array with width, height and mimetype; false if not an image
     */
    public function get_imageinfo() {
        return $this->filesystem->get_imageinfo($this);
    }
 
    /**
     * Verifies the file is a valid web image - gif, png and jpeg only.
     *
     * It should be ok to serve this image from server without any other security workarounds.
     *
     * @return bool true if file ok
     */
    public function is_valid_image() {
        $mimetype = $this->get_mimetype();
        if (!file_mimetype_in_typegroup($mimetype, 'web_image')) {
            return false;
        }
        if (!$info = $this->get_imageinfo()) {
            return false;
        }
        if ($info['mimetype'] !== $mimetype) {
            return false;
        }

     *
     * @return mixed array with width, height and mimetype; false if not an image
     */
    public function get_imageinfo() {
        return $this->filesystem->get_imageinfo($this);
    }
 
    /**
     * Verifies the file is a valid web image - gif, png and jpeg only.
     *
     * It should be ok to serve this image from server without any other security workarounds.
     *
     * @return bool true if file ok
     */
    public function is_valid_image() {
        $mimetype = $this->get_mimetype();
        if (!file_mimetype_in_typegroup($mimetype, 'web_image')) {
            return false;
        }
        if (!$info = $this->get_imageinfo()) {
            return false;
        }
        if ($info['mimetype'] !== $mimetype) {
            return false;
        }
        // ok, GD likes this image
        return true;
    }
 
    /**
     * Returns parent directory, creates missing parents if needed.
     *
     * @return stored_file
     */
    public function get_parent_directory() {
        if ($this->file_record->filepath === '/' and $this->file_record->filename === '.') {
            //root dir does not have parent
            return null;
        }
 

class stored_file_exporter extends \core\external\exporter {
 
    /** @var int Length of the shortened filename */
    protected const FILENAMESHORT_LENGTH = 25;
 
    /** @var stored_file */
    protected $file;
 
    public function __construct(stored_file $file, $related = array()) {
        $this->file = $file;
 
        $data = new stdClass();
        $data->contextid = $file->get_contextid();
        $data->component = $file->get_component();
        $data->filearea = $file->get_filearea();
        $data->itemid = $file->get_itemid();
        $data->filepath = $file->get_filepath();
        $data->filename = $file->get_filename();
        $data->isdir = $file->is_directory();
        $data->isimage = $file->is_valid_image();
        $data->timemodified = $file->get_timemodified();
        $data->timecreated = $file->get_timecreated();
        $data->filesize = $file->get_filesize();
        $data->author = $file->get_author();
        $data->license = $file->get_license();
 
        if ($related['context']->id != $data->contextid) {
            throw new coding_exception('Unexpected context ID received.');
        }
 
        parent::__construct($data, $related);
    }
 
    protected static function define_related() {
        return array('context' => 'context');
    }
 
    protected static function define_properties() {
        return array(
            'contextid' => array(

 
        $urlfactory = $this->related['urlfactory'];
        $enableplagiarism = $CFG->enableplagiarism;
        $forum = $this->related['forum'];
        $context = $this->related['context'];
 
        if ($enableplagiarism) {
            require_once($CFG->libdir . '/plagiarismlib.php' );
        }
 
        return array_map(function($attachment) use (
            $output,
            $enableplagiarism,
            $canexport,
            $context,
            $forum,
            $post,
            $urlfactory
        ) {
            $exporter = new stored_file_exporter($attachment, ['context' => $context]);
            $exportedattachment = $exporter->export($output);
            $exporturl = $canexport ? $urlfactory->get_export_attachment_url_from_post_and_attachment($post, $attachment) : null;
 
            if ($enableplagiarism) {
                $plagiarismhtml = plagiarism_get_links([
                    'userid' => $post->get_author_id(),
                    'file' => $attachment,
                    'cmid' => $forum->get_course_module_record()->id,
                    'course' => $forum->get_course_id(),
                    'forum' => $forum->get_id()
                ]);
            } else {
                $plagiarismhtml = null;
            }
 
            $exportedattachment->urls = [
                'export' => $exporturl ? $exporturl->out(false) : null
            ];
            $exportedattachment->html = [
                'plagiarism' => $plagiarismhtml

     *
     * @param stored_file[] $attachments The list of attachments for the post
     * @param post_entity $post The post being exported
     * @param renderer_base $output Renderer base
     * @param bool $canexport If the user can export the post (relates to portfolios not exporters like this class)
     * @return array
     */
    private function export_attachments(array $attachments, post_entity $post, renderer_base $output, bool $canexport): array {
        global $CFG;
 
        $urlfactory = $this->related['urlfactory'];
        $enableplagiarism = $CFG->enableplagiarism;
        $forum = $this->related['forum'];
        $context = $this->related['context'];
 
        if ($enableplagiarism) {
            require_once($CFG->libdir . '/plagiarismlib.php' );
        }
 
        return array_map(function($attachment) use (
            $output,
            $enableplagiarism,
            $canexport,
            $context,
            $forum,
            $post,
            $urlfactory
        ) {
            $exporter = new stored_file_exporter($attachment, ['context' => $context]);
            $exportedattachment = $exporter->export($output);
            $exporturl = $canexport ? $urlfactory->get_export_attachment_url_from_post_and_attachment($post, $attachment) : null;
 
            if ($enableplagiarism) {
                $plagiarismhtml = plagiarism_get_links([
                    'userid' => $post->get_author_id(),
                    'file' => $attachment,
                    'cmid' => $forum->get_course_module_record()->id,
                    'course' => $forum->get_course_id(),
                    'forum' => $forum->get_id()
                ]);

                'reply' => $canreply,
                'export' => $canexport,
                'controlreadstatus' => $cancontrolreadstatus,
                'canreplyprivately' => $canreplyprivately,
                'selfenrol' => $canselfenrol
            ],
            'urls' => [
                'view' => $viewurl ? $viewurl->out(false) : null,
                'viewisolated' => $viewisolatedurl ? $viewisolatedurl->out(false) : null,
                'viewparent' => $viewparenturl ? $viewparenturl->out(false) : null,
                'edit' => $editurl ? $editurl->out(false) : null,
                'delete' => $deleteurl ? $deleteurl->out(false) : null,
                'split' => $spliturl ? $spliturl->out(false) : null,
                'reply' => $replyurl ? $replyurl->out(false) : null,
                'export' => $exporturl && $exporturl ? $exporturl->out(false) : null,
                'markasread' => $markasreadurl ? $markasreadurl->out(false) : null,
                'markasunread' => $markasunreadurl ? $markasunreadurl->out(false) : null,
                'discuss' => $discussurl ? $discussurl->out(false) : null,
            ],
            'attachments' => ($exportattachments) ? $this->export_attachments($attachments, $post, $output, $canexport) : [],
            'messageinlinefiles' => ($exportinlineattachments) ? $this->export_inline_attachments($inlineattachments,
                $post, $output) : [],
            'tags' => ($loadcontent && $hastags) ? $this->export_tags($tags) : [],
            'html' => $includehtml ? [
                'rating' => ($loadcontent && $hasrating) ? $output->render($rating) : null,
                'taglist' => ($loadcontent && $hastags) ? $output->tag_list($tags) : null,
                'authorsubheading' => ($loadcontent) ? $this->get_author_subheading_html($exportedauthor, $timecreated) : null
            ] : null
        ];
    }
 
    /**
     * Returns a list of objects that are related.
     *
     * @return array
     */
    protected static function define_related() {
        return [
            'capabilitymanager' => 'mod_forum\local\managers\capability',
            'readreceiptcollection' => 'mod_forum\local\entities\post_read_receipt_collection?',

                    throw new coding_exception($missingdataerr . $key . ' => ' . $classname);
                }
            }
        }
    }
 
    /**
     * Function to export the renderer data in a format that is suitable for a
     * mustache template. This means raw records are generated as in to_record,
     * but all strings are correctly passed through \core_external\util::format_text (or \core_external\util::format_string).
     *
     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
     * @return stdClass
     */
    final public function export(renderer_base $output) {
        $data = new stdClass();
        $properties = self::read_properties_definition();
        $values = (array) $this->data;
 
        $othervalues = $this->get_other_values($output);
        if (array_intersect_key($values, $othervalues)) {
            // Attempt to replace a standard property.
            throw new coding_exception('Cannot override a standard property value.');
        }
        $values += $othervalues;
        $record = (object) $values;
 
        foreach ($properties as $property => $definition) {
            if (isset($data->$property)) {
                // This happens when we have already defined the format properties.
                continue;
            } else if (!property_exists($record, $property) && array_key_exists('default', $definition)) {
                // We have a default value for this property.
                $record->$property = $definition['default'];
            } else if (!property_exists($record, $property) && !empty($definition['optional'])) {
                // Fine, this property can be omitted.
                continue;
            } else if (!property_exists($record, $property)) {
                // Whoops, we got something that wasn't defined.
                throw new coding_exception('Unexpected property ' . $property);

            ) {
                $authorid = $post->get_author_id();
                $postid = $post->get_id();
                $author = isset($authorsbyid[$authorid]) ? $authorsbyid[$authorid] : [];
                $authorcontextid = isset($authorcontextids[$authorid]) ? $authorcontextids[$authorid] : null;
                $attachments = isset($attachmentsbypostid[$postid]) ? $attachmentsbypostid[$postid] : [];
                $inlineattachments = isset($inlineattachmentsbypostid[$postid]) ? $inlineattachmentsbypostid[$postid] : [];
                $authorgroups = isset($groupsbyauthorid[$authorid]) ? $groupsbyauthorid[$authorid] : [];
                $tags = isset($tagsbypostid[$postid]) ? $tagsbypostid[$postid] : [];
                $rating = isset($ratingbypostid[$postid]) ? $ratingbypostid[$postid] : null;
                $exporter = new post_exporter($post, array_merge($related, [
                    'author' => $author,
                    'authorcontextid' => $authorcontextid,
                    'attachments' => $attachments,
                    'messageinlinefiles' => $inlineattachments,
                    'authorgroups' => $authorgroups,
                    'tags' => $tags,
                    'rating' => $rating
                ]));
                return $exporter->export($output);
            },
            $this->posts
        );
 
        return [
            'posts' => $exportedposts
        ];
    }
 
    /**
     * Returns a list of objects that are related.
     *
     * @return array
     */
    protected static function define_related() {
        return [
            'capabilitymanager' => 'mod_forum\local\managers\capability',
            'urlfactory' => 'mod_forum\local\factories\url',
            'forum' => 'mod_forum\local\entities\forum',
            'discussion' => 'mod_forum\local\entities\discussion',

            ]
        ];
    }
 
    /**
     * Get the additional values to inject while exporting.
     *
     * @param renderer_base $output The renderer.
     * @return array Keys are the property names, values are their values.
     */
    protected function get_other_values(renderer_base $output) {
        $related = $this->related;
        $authorsbyid = $this->authorsbyid;
        $authorcontextids = $this->authorcontextids;
        $attachmentsbypostid = $this->attachmentsbypostid;
        $inlineattachmentsbypostid = $this->inlineattachmentsbypostid;
        $groupsbyauthorid = $this->groupsbyauthorid;
        $tagsbypostid = $this->tagsbypostid;
        $ratingbypostid = $this->ratingbypostid;
        $exportedposts = array_map(
            function($post) use (
                $related,
                $authorsbyid,
                $authorcontextids,
                $attachmentsbypostid,
                $groupsbyauthorid,
                $tagsbypostid,
                $ratingbypostid,
                $output,
                $inlineattachmentsbypostid
            ) {
                $authorid = $post->get_author_id();
                $postid = $post->get_id();
                $author = isset($authorsbyid[$authorid]) ? $authorsbyid[$authorid] : [];
                $authorcontextid = isset($authorcontextids[$authorid]) ? $authorcontextids[$authorid] : null;
                $attachments = isset($attachmentsbypostid[$postid]) ? $attachmentsbypostid[$postid] : [];
                $inlineattachments = isset($inlineattachmentsbypostid[$postid]) ? $inlineattachmentsbypostid[$postid] : [];
                $authorgroups = isset($groupsbyauthorid[$authorid]) ? $groupsbyauthorid[$authorid] : [];
                $tags = isset($tagsbypostid[$postid]) ? $tagsbypostid[$postid] : [];
                $rating = isset($ratingbypostid[$postid]) ? $ratingbypostid[$postid] : null;

                    throw new coding_exception($missingdataerr . $key . ' => ' . $classname);
                }
            }
        }
    }
 
    /**
     * Function to export the renderer data in a format that is suitable for a
     * mustache template. This means raw records are generated as in to_record,
     * but all strings are correctly passed through \core_external\util::format_text (or \core_external\util::format_string).
     *
     * @param renderer_base $output Used to do a final render of any components that need to be rendered for export.
     * @return stdClass
     */
    final public function export(renderer_base $output) {
        $data = new stdClass();
        $properties = self::read_properties_definition();
        $values = (array) $this->data;
 
        $othervalues = $this->get_other_values($output);
        if (array_intersect_key($values, $othervalues)) {
            // Attempt to replace a standard property.
            throw new coding_exception('Cannot override a standard property value.');
        }
        $values += $othervalues;
        $record = (object) $values;
 
        foreach ($properties as $property => $definition) {
            if (isset($data->$property)) {
                // This happens when we have already defined the format properties.
                continue;
            } else if (!property_exists($record, $property) && array_key_exists('default', $definition)) {
                // We have a default value for this property.
                $record->$property = $definition['default'];
            } else if (!property_exists($record, $property) && !empty($definition['optional'])) {
                // Fine, this property can be omitted.
                continue;
            } else if (!property_exists($record, $property)) {
                // Whoops, we got something that wasn't defined.
                throw new coding_exception('Unexpected property ' . $property);

            });
 
            $forumid = $forum->get_id();
            $courseid = $forum->get_course_record()->id;
            $postsexporter = $this->exporterfactory->get_posts_exporter(
                $user,
                $forum,
                $discussion,
                $groupedposts,
                $authorsbyid,
                $authorcontextids,
                $attachmentsbypostid,
                $groupsbycourseandauthorid[$courseid],
                $readreceiptcollectionbyforumid[$forumid] ?? null,
                $tagsbypostid,
                $ratingbypostid,
                true,
                $inlineattachments
            );
            ['posts' => $exportedgroupedposts] = (array) $postsexporter->export($this->renderer);
            $exportedposts = array_merge($exportedposts, $exportedgroupedposts);
        }
 
        if (count($forums) == 1 && count($discussions) == 1) {
            // All of the posts belong to a single discussion in a single forum so
            // the exported order will match the given $posts array.
            return $exportedposts;
        } else {
            // Since we grouped the posts by discussion and forum the ordering of the
            // exported posts may be different to the given $posts array so we should
            // sort it back into the correct order for the caller.
            return $this->sort_exported_posts($posts, $exportedposts);
        }
    }
 
    /**
     * Group the posts by which discussion they belong to in order for them to be processed
     * in chunks by the exporting.
     *
     * Returns a list of groups where each group has a forum, discussion, and list of posts.

     * @param post_entity[] $posts The posts to render
     * @return string
     */
    public function render(
        stdClass $user,
        array $forums,
        array $discussions,
        array $posts
    ): string {
        // Format the forums and discussion to make them more easily accessed later.
        $forums = array_reduce($forums, function($carry, $forum) {
            $carry[$forum->get_id()] = $forum;
            return $carry;
        }, []);
        $discussions = array_reduce($discussions, function($carry, $discussion) {
            $carry[$discussion->get_id()] = $discussion;
            return $carry;
        }, []);
 
        $exportedposts = $this->exportedpostsbuilder->build(
            $user,
            $forums,
            $discussions,
            $posts
        );
 
        if ($this->postprocessfortemplate !== null) {
            // We've got some post processing to do!
            $exportedposts = ($this->postprocessfortemplate)($exportedposts, $forums, $discussions, $user);
        }
 
        return $this->renderer->render_from_template(
            $this->template,
            ['posts' => array_values($exportedposts)]
        );
    }
}
 

        }
 
        $posts = array_merge([$firstpost], array_values($replies));
 
        if ($this->postprocessfortemplate !== null) {
            $exporteddiscussion = ($this->postprocessfortemplate) ($this->discussion, $user, $this->forum);
        } else {
            $exporteddiscussion = $this->get_exported_discussion($user);
        }
 
        $hasanyactions = false;
        $hasanyactions = $hasanyactions || $capabilitymanager->can_favourite_discussion($user);
        $hasanyactions = $hasanyactions || $capabilitymanager->can_pin_discussions($user);
        $hasanyactions = $hasanyactions || $capabilitymanager->can_manage_forum($user);
 
        $exporteddiscussion = array_merge($exporteddiscussion, [
            'notifications' => $this->get_notifications($user),
            'html' => [
                'hasanyactions' => $hasanyactions,
                'posts' => $this->postsrenderer->render($user, [$this->forum], [$this->discussion], $posts),
                'modeselectorform' => $this->get_display_mode_selector_html($displaymode, $user),
                'subscribe' => null,
                'movediscussion' => null,
                'pindiscussion' => null,
                'neighbourlinks' => $this->get_neighbour_links_html(),
                'exportdiscussion' => !empty($CFG->enableportfolios) ? $this->get_export_discussion_html($user) : null
            ],
            'settingsselector' => true,
        ]);
 
        $capabilities = (array) $exporteddiscussion['capabilities'];
 
        if ($capabilities['move']) {
            $exporteddiscussion['html']['movediscussion'] = $this->get_move_discussion_html();
        }
 
        if (!empty($user->id)) {
            $loggedinuser = $entityfactory->get_author_from_stdClass($user);
            $exporteddiscussion['loggedinuser'] = [
                'firstname' => $loggedinuser->get_first_name(),

echo $OUTPUT->header();
if (!$isnestedv2displaymode) {
    if (!$PAGE->has_secondary_navigation()) {
        echo $OUTPUT->heading(format_string($forum->get_name()), 2);
    }
    $headinglevel = $PAGE->activityheader->get_heading_level();
    echo $OUTPUT->heading(format_string($discussion->get_name()), $headinglevel, 'discussionname');
}
 
$rendererfactory = mod_forum\local\container::get_renderer_factory();
$discussionrenderer = $rendererfactory->get_discussion_renderer($forum, $discussion, $displaymode);
$orderpostsby = $displaymode == FORUM_MODE_FLATNEWEST ? 'created DESC' : 'created ASC';
$replies = $postvault->get_replies_to_post($USER, $post, $capabilitymanager->can_view_any_private_reply($USER), $orderpostsby);
 
if ($move == -1 and confirm_sesskey()) {
    $forumname = format_string($forum->get_name(), true);
    echo $OUTPUT->notification(get_string('discussionmoved', 'forum', $forumname), 'notifysuccess');
}
 
echo $discussionrenderer->render($USER, $post, $replies);
echo $OUTPUT->footer();
 
if ($istracked && !$CFG->forum_usermarksread) {
    if ($displaymode == FORUM_MODE_THREADED) {
        forum_tp_add_read_record($USER->id, $post->get_id());
    } else {
        $postids = array_map(function($post) {
            return $post->get_id();
        }, array_merge([$post], array_values($replies)));
        forum_tp_mark_posts_read($USER, $postids);
    }
}