You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
533 lines
20 KiB
533 lines
20 KiB
<?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/>.
|
|
|
|
/**
|
|
* Provides the {@link mod_workshop_portfolio_caller} class.
|
|
*
|
|
* @package mod_workshop
|
|
* @category portfolio
|
|
* @copyright Loc Nguyen <ndloc1905@gmail.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
require_once($CFG->libdir . '/portfolio/caller.php');
|
|
|
|
/**
|
|
* Workshop portfolio caller class to integrate with portfolio API.
|
|
*
|
|
* @package mod_workshop
|
|
* @copyright Loc Nguyen <ndloc1905@gmail.com>
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
class mod_workshop_portfolio_caller extends portfolio_module_caller_base {
|
|
|
|
/** @var workshop The workshop instance where the export is happening. */
|
|
protected $workshop;
|
|
|
|
/** @var int ID if the exported submission, set via the constructor. */
|
|
protected $submissionid;
|
|
|
|
/** @var object The submission being exported. */
|
|
protected $submission;
|
|
|
|
/** @var array of objects List of assessments of the exported submission. */
|
|
protected $assessments = [];
|
|
|
|
/**
|
|
* Explicit constructor to set the properties declared by the parent class.
|
|
*
|
|
* Firstly we call the parent's constructor to set the $this->id property
|
|
* from the passed argument. Then we populate the $this->cm so that the
|
|
* default parent class methods work well.
|
|
*
|
|
* @param array $callbackargs
|
|
*/
|
|
public function __construct($callbackargs) {
|
|
|
|
// Let the parent class set the $this->id property.
|
|
parent::__construct($callbackargs);
|
|
// Populate the $this->cm property.
|
|
$this->cm = get_coursemodule_from_id('workshop', $this->id, 0, false, MUST_EXIST);
|
|
}
|
|
|
|
/**
|
|
* Return array of expected callback arguments and whether they are required or not.
|
|
*
|
|
* The 'id' argument is supposed to be our course module id (cmid) - see
|
|
* the parent class' properties.
|
|
*
|
|
* @return array of (string)callbackname => (bool)required
|
|
*/
|
|
public static function expected_callbackargs() {
|
|
return [
|
|
'id' => true,
|
|
'submissionid' => true,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Load data required for the export.
|
|
*/
|
|
public function load_data() {
|
|
global $DB, $USER;
|
|
|
|
// Note that require_login() is normally called later as a part of
|
|
// portfolio_export_pagesetup() in the portfolio/add.php file. But we
|
|
// load various data depending of capabilities so it makes sense to
|
|
// call it explicitly here, too.
|
|
require_login($this->get('course'), false, $this->cm, false, true);
|
|
|
|
if (isguestuser()) {
|
|
throw new portfolio_caller_exception('guestsarenotallowed', 'core_error');
|
|
}
|
|
|
|
$workshoprecord = $DB->get_record('workshop', ['id' => $this->cm->instance], '*', MUST_EXIST);
|
|
$this->workshop = new workshop($workshoprecord, $this->cm, $this->get('course'));
|
|
|
|
$this->submission = $this->workshop->get_submission_by_id($this->submissionid);
|
|
|
|
// Is the user exporting her/his own submission?
|
|
$ownsubmission = $this->submission->authorid == $USER->id;
|
|
|
|
// Does the user have permission to see all submissions (aka is it a teacher)?
|
|
$canviewallsubmissions = has_capability('mod/workshop:viewallsubmissions', $this->workshop->context);
|
|
$canviewallsubmissions = $canviewallsubmissions && $this->workshop->check_group_membership($this->submission->authorid);
|
|
|
|
// Is the user exporting a submission that she/he has peer-assessed?
|
|
$userassessment = $this->workshop->get_assessment_of_submission_by_user($this->submission->id, $USER->id);
|
|
if ($userassessment) {
|
|
$this->assessments[$userassessment->id] = $userassessment;
|
|
$isreviewer = true;
|
|
}
|
|
|
|
if (!$ownsubmission and !$canviewallsubmissions and !$isreviewer) {
|
|
throw new portfolio_caller_exception('nopermissions', 'core_error');
|
|
}
|
|
|
|
// Does the user have permission to see all assessments (aka is it a teacher)?
|
|
$canviewallassessments = has_capability('mod/workshop:viewallassessments', $this->workshop->context);
|
|
|
|
// Load other assessments eventually if the user can see them.
|
|
if ($canviewallassessments or ($ownsubmission and $this->workshop->assessments_available())) {
|
|
foreach ($this->workshop->get_assessments_of_submission($this->submission->id) as $assessment) {
|
|
if ($assessment->reviewerid == $USER->id) {
|
|
// User's own assessment is already loaded.
|
|
continue;
|
|
}
|
|
if (is_null($assessment->grade) and !$canviewallassessments) {
|
|
// Students do not see peer-assessment that are not graded.
|
|
continue;
|
|
}
|
|
$this->assessments[$assessment->id] = $assessment;
|
|
}
|
|
}
|
|
|
|
// Prepare embedded and attached files for the export.
|
|
$this->multifiles = [];
|
|
|
|
$this->add_area_files('submission_content', $this->submission->id);
|
|
$this->add_area_files('submission_attachment', $this->submission->id);
|
|
|
|
foreach ($this->assessments as $assessment) {
|
|
$this->add_area_files('overallfeedback_content', $assessment->id);
|
|
$this->add_area_files('overallfeedback_attachment', $assessment->id);
|
|
}
|
|
|
|
$this->add_area_files('instructauthors', 0);
|
|
|
|
// If there are no files to be exported, we can offer plain HTML file export.
|
|
if (empty($this->multifiles)) {
|
|
$this->add_format(PORTFOLIO_FORMAT_PLAINHTML);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepare the package ready to be passed off to the portfolio plugin.
|
|
*/
|
|
public function prepare_package() {
|
|
|
|
$canviewauthornames = has_capability('mod/workshop:viewauthornames', $this->workshop->context, $this->get('user'));
|
|
|
|
// Prepare the submission record for rendering.
|
|
$workshopsubmission = $this->workshop->prepare_submission($this->submission, $canviewauthornames);
|
|
|
|
// Set up the LEAP2A writer if we need it.
|
|
$writingleap = false;
|
|
|
|
if ($this->exporter->get('formatclass') == PORTFOLIO_FORMAT_LEAP2A) {
|
|
$leapwriter = $this->exporter->get('format')->leap2a_writer();
|
|
$writingleap = true;
|
|
}
|
|
|
|
// If writing to HTML file, accumulate the exported hypertext here.
|
|
$html = '';
|
|
|
|
// If writing LEAP2A, keep track of all entry ids so we can add a selection element.
|
|
$leapids = [];
|
|
|
|
$html .= $this->export_header($workshopsubmission);
|
|
$content = $this->export_content($workshopsubmission);
|
|
// Get rid of the JS relics left by moodleforms.
|
|
$content = preg_replace('#<script(.*?)>(.*?)</script>#is', '', $content);
|
|
$html .= $content;
|
|
|
|
if ($writingleap) {
|
|
$leapids[] = $this->export_content_leap2a($leapwriter, $workshopsubmission, $content);
|
|
}
|
|
|
|
// Export the files.
|
|
foreach ($this->multifiles as $file) {
|
|
$this->exporter->copy_existing_file($file);
|
|
}
|
|
|
|
if ($writingleap) {
|
|
// Add an extra LEAP2A selection entry. In Mahara, this maps to a journal.
|
|
$selection = new portfolio_format_leap2a_entry('workshop'.$this->workshop->id,
|
|
get_string('pluginname', 'mod_workshop').': '.s($this->workshop->name), 'selection');
|
|
$leapwriter->add_entry($selection);
|
|
$leapwriter->make_selection($selection, $leapids, 'Grouping');
|
|
$leapxml = $leapwriter->to_xml();
|
|
$name = $this->exporter->get('format')->manifest_name();
|
|
$this->exporter->write_new_file($leapxml, $name, true);
|
|
|
|
} else {
|
|
$this->exporter->write_new_file($html, 'submission.html', true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper method to add all files from the given location to $this->multifiles
|
|
*
|
|
* @param string $filearea
|
|
* @param int $itemid
|
|
*/
|
|
protected function add_area_files($filearea, $itemid) {
|
|
|
|
$fs = get_file_storage();
|
|
$areafiles = $fs->get_area_files($this->workshop->context->id, 'mod_workshop', $filearea, $itemid, null, false);
|
|
if ($areafiles) {
|
|
$this->multifiles = array_merge($this->multifiles, array_values($areafiles));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Render the header of the exported content.
|
|
*
|
|
* This is mainly used for the HTML output format. In case of LEAP2A
|
|
* export, this is not used as the information is stored in metadata and
|
|
* displayed as a part of the journal and entry title in Mahara.
|
|
*
|
|
* @param workshop_submission $workshopsubmission
|
|
* @return string HTML
|
|
*/
|
|
protected function export_header(workshop_submission $workshopsubmission) {
|
|
|
|
$output = '';
|
|
$output .= html_writer::tag('h2', get_string('pluginname', 'mod_workshop').': '.s($this->workshop->name));
|
|
$output .= html_writer::tag('h3', s($workshopsubmission->title));
|
|
|
|
$created = get_string('userdatecreated', 'workshop', userdate($workshopsubmission->timecreated));
|
|
$created = html_writer::tag('span', $created);
|
|
|
|
if ($workshopsubmission->timemodified > $workshopsubmission->timecreated) {
|
|
$modified = get_string('userdatemodified', 'workshop', userdate($workshopsubmission->timemodified));
|
|
$modified = ' | ' . html_writer::tag('span', $modified);
|
|
} else {
|
|
$modified = '';
|
|
}
|
|
|
|
$output .= html_writer::div($created.$modified);
|
|
$output .= html_writer::empty_tag('br');
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Render the content of the submission.
|
|
*
|
|
* @param workshop_submission $workshopsubmission
|
|
* @return string
|
|
*/
|
|
protected function export_content(workshop_submission $workshopsubmission) {
|
|
|
|
$output = '';
|
|
|
|
if (!$workshopsubmission->is_anonymous()) {
|
|
$author = username_load_fields_from_object((object)[], $workshopsubmission, 'author');
|
|
$output .= html_writer::div(get_string('byfullnamewithoutlink', 'mod_workshop', fullname($author)));
|
|
}
|
|
|
|
$content = $this->format_exported_text($workshopsubmission->content, $workshopsubmission->contentformat);
|
|
$content = portfolio_rewrite_pluginfile_urls($content, $this->workshop->context->id, 'mod_workshop',
|
|
'submission_content', $workshopsubmission->id, $this->exporter->get('format'));
|
|
$output .= html_writer::div($content);
|
|
|
|
$output .= $this->export_files_list('submission_attachment');
|
|
|
|
$strategy = $this->workshop->grading_strategy_instance();
|
|
|
|
$canviewauthornames = has_capability('mod/workshop:viewauthornames', $this->workshop->context, $this->get('user'));
|
|
$canviewreviewernames = has_capability('mod/workshop:viewreviewernames', $this->workshop->context, $this->get('user'));
|
|
|
|
foreach ($this->assessments as $assessment) {
|
|
$mform = $strategy->get_assessment_form(null, 'assessment', $assessment, false);
|
|
$options = [
|
|
'showreviewer' => $canviewreviewernames,
|
|
'showauthor' => $canviewauthornames,
|
|
'showform' => true,
|
|
'showweight' => true,
|
|
];
|
|
if ($assessment->reviewerid == $this->get('user')->id) {
|
|
$options['showreviewer'] = true;
|
|
}
|
|
|
|
$workshopassessment = $this->workshop->prepare_assessment($assessment, $mform, $options);
|
|
|
|
if ($assessment->reviewerid == $this->get('user')->id) {
|
|
$workshopassessment->title = get_string('assessmentbyyourself', 'mod_workshop');
|
|
} else {
|
|
$workshopassessment->title = get_string('assessment', 'mod_workshop');
|
|
}
|
|
|
|
$output .= html_writer::empty_tag('hr');
|
|
$output .= $this->export_assessment($workshopassessment);
|
|
}
|
|
|
|
if (trim($this->workshop->instructauthors)) {
|
|
$output .= html_writer::tag('h3', get_string('instructauthors', 'mod_workshop'));
|
|
$content = $this->format_exported_text($this->workshop->instructauthors, $this->workshop->instructauthorsformat);
|
|
$content = portfolio_rewrite_pluginfile_urls($content, $this->workshop->context->id, 'mod_workshop',
|
|
'instructauthors', 0, $this->exporter->get('format'));
|
|
$output .= $content;
|
|
}
|
|
|
|
return html_writer::div($output);
|
|
}
|
|
|
|
/**
|
|
* Render the content of an assessment.
|
|
*
|
|
* @param workshop_assessment $assessment
|
|
* @return string HTML
|
|
*/
|
|
protected function export_assessment(workshop_assessment $assessment) {
|
|
|
|
$output = '';
|
|
|
|
if (empty($assessment->title)) {
|
|
$title = get_string('assessment', 'workshop');
|
|
} else {
|
|
$title = s($assessment->title);
|
|
}
|
|
|
|
$output .= html_writer::tag('h3', $title);
|
|
|
|
if ($assessment->reviewer) {
|
|
$output .= html_writer::div(get_string('byfullnamewithoutlink', 'mod_workshop', fullname($assessment->reviewer)));
|
|
$output .= html_writer::empty_tag('br');
|
|
}
|
|
|
|
if ($this->workshop->overallfeedbackmode) {
|
|
if ($assessment->feedbackauthorattachment or trim($assessment->feedbackauthor) !== '') {
|
|
$output .= html_writer::tag('h3', get_string('overallfeedback', 'mod_workshop'));
|
|
$content = $this->format_exported_text($assessment->feedbackauthor, $assessment->feedbackauthorformat);
|
|
$content = portfolio_rewrite_pluginfile_urls($content, $this->workshop->context->id, 'mod_workshop',
|
|
'overallfeedback_content', $assessment->id , $this->exporter->get('format'));
|
|
$output .= $content;
|
|
|
|
$output .= $this->export_files_list('overallfeedback_attachment');
|
|
}
|
|
}
|
|
|
|
if ($assessment->form) {
|
|
$output .= $assessment->form->render();
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Export the files in the given file area in a list.
|
|
*
|
|
* @param string $filearea
|
|
* @return string HTML
|
|
*/
|
|
protected function export_files_list($filearea) {
|
|
|
|
$output = '';
|
|
$files = [];
|
|
|
|
foreach ($this->multifiles as $file) {
|
|
if ($file->is_directory()) {
|
|
continue;
|
|
}
|
|
if ($file->get_filearea() !== $filearea) {
|
|
continue;
|
|
}
|
|
if ($file->is_valid_image()) {
|
|
// Not optimal but looks better than original images.
|
|
$files[] = html_writer::tag('li', $this->exporter->get('format')->file_output($file,
|
|
['attributes' => ['style' => 'max-height:24px; max-width:24px']]).' '.s($file->get_filename()));
|
|
} else {
|
|
$files[] = html_writer::tag('li', $this->exporter->get('format')->file_output($file));
|
|
}
|
|
}
|
|
|
|
if ($files) {
|
|
$output .= html_writer::tag('ul', implode('', $files));
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Helper function to call {@link format_text()} on exported text.
|
|
*
|
|
* We need to call {@link format_text()} to convert the text into HTML, but
|
|
* we have to keep the original @@PLUGINFILE@@ placeholder there without a
|
|
* warning so that {@link portfolio_rewrite_pluginfile_urls()} can do its work.
|
|
*
|
|
* @param string $text
|
|
* @param int $format
|
|
* @return string HTML
|
|
*/
|
|
protected function format_exported_text($text, $format) {
|
|
|
|
$text = str_replace('@@PLUGINFILE@@', '@@ORIGINALPLUGINFILE@@', $text);
|
|
$html = format_text($text, $format, portfolio_format_text_options());
|
|
$html = str_replace('@@ORIGINALPLUGINFILE@@', '@@PLUGINFILE@@', $html);
|
|
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* Add a LEAP2A entry element that corresponds to a submission including attachments.
|
|
*
|
|
* @param portfolio_format_leap2a_writer $leapwriter Writer object to add entries to.
|
|
* @param workshop_submission $workshopsubmission
|
|
* @param string $html The exported HTML content of the submission
|
|
* @return int id of new entry
|
|
*/
|
|
protected function export_content_leap2a(portfolio_format_leap2a_writer $leapwriter,
|
|
workshop_submission $workshopsubmission, $html) {
|
|
|
|
$entry = new portfolio_format_leap2a_entry('workshopsubmission'.$workshopsubmission->id, s($workshopsubmission->title),
|
|
'resource', $html);
|
|
$entry->published = $workshopsubmission->timecreated;
|
|
$entry->updated = $workshopsubmission->timemodified;
|
|
$entry->author = (object)[
|
|
'id' => $workshopsubmission->authorid,
|
|
'email' => $workshopsubmission->authoremail
|
|
];
|
|
username_load_fields_from_object($entry->author, $workshopsubmission);
|
|
|
|
$leapwriter->link_files($entry, $this->multifiles);
|
|
$entry->add_category('web', 'resource_type');
|
|
$leapwriter->add_entry($entry);
|
|
|
|
return $entry->id;
|
|
}
|
|
|
|
/**
|
|
* Return URL for redirecting the user back to where the export started.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_return_url() {
|
|
|
|
$returnurl = new moodle_url('/mod/workshop/submission.php', ['cmid' => $this->cm->id, 'id' => $this->submissionid]);
|
|
return $returnurl->out();
|
|
}
|
|
|
|
/**
|
|
* Get navigation that logically follows from the place the user was before.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function get_navigation() {
|
|
|
|
$navlinks = [
|
|
['name' => s($this->submission->title)],
|
|
];
|
|
|
|
return [$navlinks, $this->cm];
|
|
}
|
|
|
|
/**
|
|
* How long might we expect this export to take.
|
|
*
|
|
* @return string such as PORTFOLIO_TIME_LOW
|
|
*/
|
|
public function expected_time() {
|
|
return $this->expected_time_file();
|
|
}
|
|
|
|
/**
|
|
* Make sure that the current user is allowed to do the export.
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public function check_permissions() {
|
|
return has_capability('mod/workshop:exportsubmissions', context_module::instance($this->cm->id));
|
|
}
|
|
|
|
/**
|
|
* Return the SHA1 hash of the exported content.
|
|
*
|
|
* @return string
|
|
*/
|
|
public function get_sha1() {
|
|
|
|
$identifier = 'submission:'.$this->submission->id.'@'.$this->submission->timemodified;
|
|
|
|
if ($this->assessments) {
|
|
$ids = array_keys($this->assessments);
|
|
sort($ids);
|
|
$identifier .= '/assessments:'.implode(',', $ids);
|
|
}
|
|
|
|
if ($this->multifiles) {
|
|
$identifier .= '/files:'.$this->get_sha1_file();
|
|
}
|
|
|
|
return sha1($identifier);
|
|
}
|
|
|
|
/**
|
|
* Return a nice name to be displayed about this export location.
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function display_name() {
|
|
return get_string('pluginname', 'mod_workshop');
|
|
}
|
|
|
|
/**
|
|
* What export formats the workshop generally supports.
|
|
*
|
|
* If there are no files embedded/attached, the plain HTML format is added
|
|
* in {@link self::load_data()}.
|
|
*
|
|
* @return array
|
|
*/
|
|
public static function base_supported_formats() {
|
|
return [
|
|
PORTFOLIO_FORMAT_RICHHTML,
|
|
PORTFOLIO_FORMAT_LEAP2A,
|
|
];
|
|
}
|
|
}
|
|
|