/**
* Checks if we are allowed to turn on the 'default icon' option. You can
* only have one of these for a given MIME type.
*
* @param string $mimetype MIME type
* @param string $oldextension File extension name (before any change)
*/
public static function is_defaulticon_allowed($mimetype, $oldextension = '')
{
$mimeinfo = get_mimetypes_array();
if ($oldextension !== '') {
unset($mimeinfo[$oldextension]);
}
foreach ($mimeinfo as $extension => $values) {
if ($values['type'] !== $mimetype) {
continue;
}
if (!empty($values['defaulticon'])) {
return false;
}
}
return true;
}
/**
* Adds RSS Media Enclosures for "podcasting" by including attachments that
* are specified in the item->attachments field.
*
* @param stdClass $item representing an RSS item
* @return string RSS enclosure tags
*/
function rss_add_enclosures($item)
{
global $CFG;
$returnstring = '';
// list of media file extensions and their respective mime types
include_once $CFG->libdir . '/filelib.php';
$mediafiletypes = get_mimetypes_array();
// take into account attachments (e.g. from forum) - with these, we are able to know the file size
if (isset($item->attachments) && is_array($item->attachments)) {
foreach ($item->attachments as $attachment) {
$extension = strtolower(substr($attachment->url, strrpos($attachment->url, '.') + 1));
if (isset($mediafiletypes[$extension]['type'])) {
$type = $mediafiletypes[$extension]['type'];
} else {
$type = 'document/unknown';
}
$returnstring .= "\n<enclosure url=\"{$attachment->url}\" length=\"{$attachment->length}\" type=\"{$type}\" />\n";
}
}
return $returnstring;
}
/**
* Tests for get_mimetype_for_sending function.
*/
public function test_get_mimetype_for_sending()
{
// Without argument.
$this->assertEquals('application/octet-stream', get_mimetype_for_sending());
// Argument is null.
$this->assertEquals('application/octet-stream', get_mimetype_for_sending(null));
// Filename having no extension.
$this->assertEquals('application/octet-stream', get_mimetype_for_sending('filenamewithoutextension'));
// Test using the extensions listed from the get_mimetypes_array function.
$mimetypes = get_mimetypes_array();
foreach ($mimetypes as $ext => $info) {
if ($ext === 'xxx') {
$this->assertEquals('application/octet-stream', get_mimetype_for_sending('SampleFile.' . $ext));
} else {
$this->assertEquals($info['type'], get_mimetype_for_sending('SampleFile.' . $ext));
}
}
}
/** determine the mimetype of a file
*
* This routine tries to discover the mimetype of a file.
* First we try to determine the mimetype via the fileinfo extension.
* If that doesn't work, we try the deprecated mime_content_type() function.
* If that doesn't work, we try to shell out to file(1).
* If that doesn't work, we resort to "guessing" the mimetype based
* on the extension of the file or else we return the generic
* 'application/octet-stream'.
*
* Note that in step 3 we shell out and try to execute the file(1) command.
* The results are checked against a pattern to assert that we are
* really dealing with a mime type. The pattern is described in RFC2616
* (see sections 3.7 and 2.2):
*
*<pre>
* media-type = type "/" subtype *( ";" parameter )
* type = token
* subtype = token
* token = 1*<any CHAR except CTLs or separators>
* separators = "(" | ")" | "<" | ">" | "@"
* | "," | ";" | ":" | "\" | <">
* | "/" | "[" | "]" | "?" | "="
* | "{" | "}" | SP | HT
* CHAR = <any US-ASCII character (octets 0 - 127)>
* CTL = <any US-ASCII control character
* (octets 0 - 31) and DEL (127)>
* SP = <US-ASCII SP, space (32)>
* HT = <US-ASCII HT, horizontal-tab (9)>
* <"> = <US-ASCII double-quote mark (34)>
*</pre>
*
* This description means we should look for two tokens containing
* letters a-z or A-Z, digits 0-9 and these special characters:
* ! # $ % & ' * + - . ^ _ ` | or ~. That's it.
*
* Note that file(1) may return a mime type with additional parameters.
* e.g. 'text/plain; charset=US-ASCII'. This fits the pattern, because
* it starts with a token, a slash and another token.
*
* The optional parameter $name is used to determine the mimetype based
* on the extension (as a last resort), even when the current name of the
* file is meaningless, e.g. when uploading a file, the name of the file
* (from $_FILES['file0']['tmp_name']) is something like '/tmp/php4r5dwfw',
* even though $_FILES['file0']['name'] might read 'S6301234.JPG'.
* If $name is not specified (i.e. is empty), we construct it from $path.
*
* @param string $path fully qualified path to the file to test
* @param string $name name of the file, possibly different from $path
* @return string mimetype of the file $path
* @todo there is room for improvement here:
* the code in step 1 and step 2 is largely untested
*/
function get_mimetype($path, $name = '')
{
// 0 -- quick check for file of type 'image/*' (suppress annoying warning message from getimagesize())
if (($imagesize = @getimagesize($path)) !== FALSE && is_array($imagesize) && isset($imagesize['mime'])) {
$mimetype = $imagesize['mime'];
// logger(sprintf('%d: %s(): path=%s name=%s mime=%s',0,__FUNCTION__,$path,$name,$mimetype),WLOG_DEBUG);
return $mimetype;
}
// 1 -- try the finfo-route if it is available
if (function_exists('finfo_open') && function_exists('finfo_file') && function_exists('finfo_close') && defined(FILEINFO_MIME)) {
$finfo = finfo_open(FILEINFO_MIME);
if ($finfo !== FALSE) {
$mimetype = finfo_file($finfo, $path);
$finfo_close($finfo);
if ($mimetype !== FALSE) {
// logger(sprintf('%d: %s(): path=%s name=%s mime=%s',1,__FUNCTION__,$path,$name,$mimetype),WLOG_DEBUG);
return $mimetype;
}
}
}
// 2 -- now try the deprecated mime_content_type method
if (function_exists('mime_content_type')) {
$mimetype = mime_content_type($path);
// logger(sprintf('%d: %s(): path=%s name=%s mime=%s',2,__FUNCTION__,$path,$name,$mimetype),WLOG_DEBUG);
return $mimetype;
}
// 3 -- now try to shell out and use the file command
$command = sprintf('file -b -i %s', escapeshellarg($path));
// -b = brief output, -i = output mime type strings
$dummy = array();
$retval = 0;
$mimetype = exec($command, $dummy, $retval);
if ($retval == 0) {
// now assert that the result looks like a mimetype and not an error message
if (get_mediatype($mimetype) !== FALSE) {
// logger(sprintf('%d: %s(): path=%s name=%s mime=%s',3,__FUNCTION__,$path,$name,$mimetype),WLOG_DEBUG);
return $mimetype;
}
}
// 4 -- take a wild guess; boldly assume that the file extension carries any meaning whatsoever
$ext = strtolower(pathinfo(empty($name) ? $path : $name, PATHINFO_EXTENSION));
$mimetypes = get_mimetypes_array();
$mimetype = isset($mimetypes[$ext]) ? $mimetypes[$ext] : 'application/octet-stream';
// logger(sprintf('%d: %s(): path=%s name=%s mime=%s',4,__FUNCTION__,$path,$name,$mimetype),WLOG_DEBUG);
return $mimetype;
}
/**
* Deletes a file type from the config list (or, for a standard one, marks it
* as deleted).
*
* @param string $extension File extension without dot, e.g. 'doc'
* @throws coding_exception If the extension does not exist, or otherwise invalid
*/
public static function delete_type($extension)
{
// Extension must exist.
$mimetypes = get_mimetypes_array();
if (!array_key_exists($extension, $mimetypes)) {
throw new coding_exception('Extension ' . $extension . ' not found');
}
// Get existing custom filetype list.
$customs = self::get_custom_types();
// Remove any entries for this extension.
foreach ($customs as $key => $custom) {
if ($custom->extension === $extension && empty($custom->deleted)) {
unset($customs[$key]);
}
}
// If it was a standard entry (doesn't have 'custom' set) then add a
// deleted marker.
if (empty($mimetypes[$extension]['custom'])) {
$customs[] = (object) array('extension' => $extension, 'deleted' => true);
}
// Save and reset cache.
self::set_custom_types($customs);
}
/**
* Adds RSS Media Enclosures for "podcasting" by examining links to media files,
* and attachments which are media files. Please note that the RSS that is
* produced cannot be strictly valid for the linked files, since we do not know
* the files' sizes and cannot include them in the "length" attribute. At
* present, the validity (and therefore the podcast working in most software)
* can only be ensured for attachments, and not for links.
* Note also that iTunes does some things very badly - one thing it does is
* refuse to download ANY of your files if you're using "file.php?file=blah"
* and can't use the more elegant "file.php/blah" slasharguments setting. It
* stops after ".php" and assumes the files are not media files, despite what
* is specified in the "type" attribute. Dodgy coding all round!
*
* @param $item object representing an RSS item
* @return string RSS enclosure tags
* @author Hannes Gassert <*****@*****.**>
* @author Dan Stowell
*/
function rss_add_enclosures($item)
{
global $CFG;
$returnstring = '';
$rss_text = $item->description;
// list of media file extensions and their respective mime types
include_once $CFG->libdir . '/filelib.php';
$mediafiletypes = get_mimetypes_array();
// regular expression (hopefully) matching all links to media files
$medialinkpattern = '@href\\s*=\\s*(\'|")(\\S+(' . implode('|', array_keys($mediafiletypes)) . '))\\1@Usie';
// take into account attachments (e.g. from forum) - with these, we are able to know the file size
if (isset($item->attachments) && is_array($item->attachments)) {
foreach ($item->attachments as $attachment) {
$extension = strtolower(substr($attachment->url, strrpos($attachment->url, '.') + 1));
if (isset($mediafiletypes[$extension]['type'])) {
$type = $mediafiletypes[$extension]['type'];
} else {
$type = 'document/unknown';
}
$returnstring .= "\n<enclosure url=\"{$attachment->url}\" length=\"{$attachment->length}\" type=\"{$type}\" />\n";
}
}
if (!preg_match_all($medialinkpattern, $rss_text, $matches)) {
return $returnstring;
}
// loop over matches of regular expression
for ($i = 0; $i < count($matches[2]); $i++) {
$url = htmlspecialchars($matches[2][$i]);
$extension = strtolower($matches[3][$i]);
if (isset($mediafiletypes[$extension]['type'])) {
$type = $mediafiletypes[$extension]['type'];
} else {
$type = 'document/unknown';
}
// the rss_*_tag functions can't deal with methods, unfortunately
$returnstring .= "\n<enclosure url='{$url}' type='{$type}' />\n";
}
return $returnstring;
}
/**
* Get information about a filetype based on the icon file.
* @param string $element Desired information (usually 'icon')
* @param string $icon Icon file path.
* @return string Requested piece of information from array
*/
function mimeinfo_from_icon($element, $icon)
{
static $mimeinfo;
$mimeinfo = get_mimetypes_array();
if (preg_match("/\\/(.*)/", $icon, $matches)) {
$icon = $matches[1];
}
$info = $mimeinfo['xxx'][$element];
// Default
foreach ($mimeinfo as $values) {
if ($values['icon'] == $icon) {
if (isset($values[$element])) {
$info = $values[$element];
}
//No break, for example for 'excel.gif' we don't want 'csv'!
}
}
return $info;
}
// 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/>.
/**
* Display the custom file type settings page.
*
* @package tool_filetypes
* @copyright 2014 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
require __DIR__ . '/../../../config.php';
require_once $CFG->libdir . '/adminlib.php';
admin_externalpage_setup('tool_filetypes');
// Page settings.
$title = get_string('pluginname', 'tool_filetypes');
$context = context_system::instance();
$PAGE->set_url(new \moodle_url('/admin/tool/filetypes/index.php'));
$PAGE->set_context($context);
$PAGE->set_pagelayout('admin');
$PAGE->set_title($SITE->fullname . ': ' . $title);
$renderer = $PAGE->get_renderer('tool_filetypes');
// Is it restricted because set in config.php?
$restricted = array_key_exists('customfiletypes', $CFG->config_php_settings);
// Display the page.
echo $renderer->header();
echo $renderer->edit_table(get_mimetypes_array(), core_filetypes::get_deleted_types(), $restricted);
echo $renderer->footer();
/**
* Tests the get_mimetypes_array function.
*/
public function test_get_mimetypes_array()
{
$mimeinfo = get_mimetypes_array();
// Test example MIME type (doc).
$this->assertEquals('application/msword', $mimeinfo['doc']['type']);
$this->assertEquals('document', $mimeinfo['doc']['icon']);
$this->assertEquals(array('document'), $mimeinfo['doc']['groups']);
$this->assertFalse(isset($mimeinfo['doc']['string']));
$this->assertFalse(isset($mimeinfo['doc']['defaulticon']));
$this->assertFalse(isset($mimeinfo['doc']['customdescription']));
// Check the less common fields using other examples.
$this->assertEquals('image', $mimeinfo['png']['string']);
$this->assertEquals(true, $mimeinfo['txt']['defaulticon']);
}
/**
* Get the media mimetype
*
* Uses a built-in moodle mimetype helper
* @return string
*/
public function get_mimetype()
{
if (function_exists('get_mimetypes_array')) {
$mimetypes =& get_mimetypes_array();
$container = $this->get_primary_file_container();
if (isset($mimetypes[$container])) {
return $mimetypes[$container]['type'];
}
}
return 'video/mp4';
}
/** try to make sure that the extension of file $name makes sense or matches the actual filetype
*
* this checks or changes the $name of the file in line with the
* mimetype of the actual file (as established by get_mimetype()).
*
* The reason to do this is to make it harder to 'smuggle in' files
* with deceptive filenames/extensions. Quite often the extension is
* used to determine the type of the file, even by browsers that should
* know better. By uploading a malicious .PDF using an innocuous extension
* like .TXT, a browser may be tricked into rendering that .PDF inline.
* By changing the extension from .TXT to .PDF we can mitigate that risk,
* at least a little bit. (People somehow trust an extension even though
* they should know better and file(1) says so...)
*
* Strategy is as follows. If the mimetype based on the $name matches the
* actual mimetype, we can simply allow the name provided.
*
* If there is a difference, we try to find an extension that maps to the
* same mimetype as that of the actual file. IOW: we put more trust in the
* mimetype of the actual file than we do in the mimetype suggested by the
* extension.
*
* @param string $path full path to the actual file (from $_FILES[$i]['tmp_name'])
* @param string $name the requested name of the file to examine (from $_FILES[$i]['name'])
* @param string $type the suggested filetype of the file (from $_FILES[$i]['type'])
* @return string the sanitised name and extension based on the file type
*/
function sanitise_filetype($path, $name, $type)
{
// 0 -- initialise: isolate the $filename and $ext
if (strpos($name, '.') === FALSE) {
// not a single dot -> filename without extension
$filename = $name;
$extension = '';
} else {
$components = explode('.', $name);
$extension = array_pop($components);
$filename = implode('.', $components);
unset($components);
}
// 1 -- does actual file mimetype agree with the file extension?
$type_path = get_mediatype(get_mimetype($path, $name));
$ext = utf8_strtolower($extension);
$mimetypes = get_mimetypes_array();
$type_name = isset($mimetypes[$ext]) ? get_mediatype($mimetypes[$ext]) : 'application/octet-stream';
if (strcmp($type_path, $type_name) == 0) {
return $name;
}
// 2 -- No, we change the extension based on the actual mimetype of the file
// 2A - lookup the first extension matching type, or use '' (which implies application/octet-stream)
$new_extension = array_search($type_path, $mimetypes);
if ($new_extension === FALSE || is_null($new_extension)) {
$new_extension = '';
logger(sprintf('%s.%s(): mimetype \'%s\' not recognised; using \'%s\' instead', __CLASS__, __FUNCTION__, $type_path, $mimetypes[$new_extension]));
}
// 2B - avoid tricks with double extensions (eg. upload of "malware.exe.txt")
if ($new_extension == '') {
if ($type_name == 'application/octet-stream') {
// preserve original extension and case because the original
// extension will yield 'application/octet-stream' when served via file.php,
// i.e. there is no need to lose the extension if it yields the same mimetype anyway
$new_name = $name;
} elseif (strpos($filename, '.') === FALSE) {
// filename has no dot =>
// no part of existing filename can be mistaken for an extension =>
// don't add anything at all
$new_name = $filename;
} else {
// bare $filename already contains an extension =>
// add '.bin' to force 'application/octet-stream'
$new_name = $filename . '.bin';
}
} else {
$new_name = $filename . '.' . $new_extension;
}
logger(sprintf('%s.%s(): namechange %s -> %s (%s)', __CLASS__, __FUNCTION__, $name, $new_name, $type_path), WLOG_DEBUG);
return $new_name;
}
function generate_roster_file()
{
global $cm, $iru, $COURSE, $USER;
// Only teachers/admins can view iclicker that is not their own.
if (!has_capability('mod/iclickerregistration:viewenrolled', context_module::instance($cm->id))) {
echo json_encode(array("status" => "access denied"));
return;
}
// RESOURCE LOCK.
// For more info: https://docs.moodle.org/dev/Lock_API
// Get an instance of the currently configured lock_factory.
$resource = 'user: '******'mod_iclickerregistration');
// ACQUIRE LOCK.
$lock = $lockfactory->get_lock("{$resource}", 5);
$allusers = $iru->get_all_users_left_join_iclickers(array("courseid" => $COURSE->id));
$responsetext = "";
foreach ($allusers as $iclickeruser) {
$responsetext .= "{$iclickeruser->lastname}, {$iclickeruser->firstname}, {$iclickeruser->idnumber}\r\n";
}
$fs = get_file_storage();
$fs->delete_area_files($cm->id, 'mod_iclickerregistration');
$dummyfilename = 'roster.txt';
$fs = get_file_storage();
$filerecord = array('contextid' => $cm->id, 'component' => 'mod_iclickerregistration', 'filearea' => 'intro', 'itemid' => 0, 'filepath' => '/', 'filename' => $dummyfilename, 'timecreated' => time(), 'timemodified' => time());
$file = $fs->create_file_from_string($filerecord, $responsetext);
// RELEASE LOCK.
$lock->release();
if (!$file) {
return false;
// File don't exist.
}
// Force it to be csv. Otherwise, moodle throws an error for some reason.
send_file($file, $dummyfilename, 0, true, false, false, get_mimetypes_array()['csv']['type']);
}
/**
* Get information about a filetype based on the icon file.
* @param string $element Desired information (usually 'icon')
* @param string $icon Icon file path.
* @param boolean $all return all matching entries (defaults to false - last match)
* @return string Requested piece of information from array
*/
function mimeinfo_from_icon($element, $icon, $all = false)
{
$mimeinfo = get_mimetypes_array();
if (preg_match("/\\/(.*)/", $icon, $matches)) {
$icon = $matches[1];
}
$info = array($mimeinfo['xxx'][$element]);
// Default
foreach ($mimeinfo as $values) {
if ($values['icon'] == $icon) {
if (isset($values[$element])) {
$info[] = $values[$element];
}
//No break, for example for 'excel.gif' we don't want 'csv'!
}
}
if ($all) {
return $info;
}
return array_pop($info);
// Return last match (mimicking behaviour/comment inside foreach loop)
}
public function test_revert_type_to_default()
{
$this->resetAfterTest();
// Delete and then revert.
core_filetypes::delete_type('doc');
$this->assertArrayNotHasKey('doc', get_mimetypes_array());
core_filetypes::revert_type_to_default('doc');
$this->assertArrayHasKey('doc', get_mimetypes_array());
// Update and then revert.
core_filetypes::update_type('asm', 'asm', 'text/plain', 'sourcecode', array(), '', 'An asm file');
$types = get_mimetypes_array();
$this->assertEquals('An asm file', $types['asm']['customdescription']);
core_filetypes::revert_type_to_default('asm');
$types = get_mimetypes_array();
$this->assertArrayNotHasKey('customdescription', $types['asm']);
// Test reverting a non-default type causes exception.
try {
core_filetypes::revert_type_to_default('frog');
$this->fail();
} catch (coding_exception $e) {
$this->assertContains('not a default type', $e->getMessage());
$this->assertContains('frog', $e->getMessage());
}
}
* Display the file type updating page.
*
* @package tool_filetypes
* @copyright 2014 The Open University
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
*/
require __DIR__ . '/../../../config.php';
require_once $CFG->libdir . '/adminlib.php';
require_once 'edit_form.php';
admin_externalpage_setup('tool_filetypes');
$oldextension = optional_param('oldextension', '', PARAM_ALPHANUMEXT);
$mform = new tool_filetypes_form('edit.php', array('oldextension' => $oldextension));
$title = get_string('addfiletypes', 'tool_filetypes');
if ($oldextension) {
// This is editing an existing filetype, load data to the form.
$mimetypes = get_mimetypes_array();
if (!array_key_exists($oldextension, $mimetypes)) {
throw new moodle_exception('error_notfound', 'tool_filetypes');
}
$typeinfo = $mimetypes[$oldextension];
$formdata = array('extension' => $oldextension, 'mimetype' => $typeinfo['type'], 'icon' => $typeinfo['icon'], 'oldextension' => $oldextension, 'description' => '', 'groups' => '', 'corestring' => '', 'defaulticon' => 0);
if (!empty($typeinfo['customdescription'])) {
$formdata['description'] = $typeinfo['customdescription'];
}
if (!empty($typeinfo['groups'])) {
$formdata['groups'] = implode(', ', $typeinfo['groups']);
}
if (!empty($typeinfo['string'])) {
$formdata['corestring'] = $typeinfo['string'];
}
if (!empty($typeinfo['defaulticon'])) {
/**
* Get information about a filetype based on the icon file.
*
* @param string $element Desired information (usually 'icon')
* @param string $icon Icon file name without extension
* @param boolean $all return all matching entries (defaults to false - best (by ext)/last match)
* @return string Requested piece of information from array
*/
function mimeinfo_from_icon($element, $icon, $all = false)
{
$mimeinfo = get_mimetypes_array();
if (preg_match("/\\/(.*)/", $icon, $matches)) {
$icon = $matches[1];
}
// Try to get the extension
$extension = '';
if (($cutat = strrpos($icon, '.')) !== false && $cutat < strlen($icon) - 1) {
$extension = substr($icon, $cutat + 1);
}
$info = array($mimeinfo['xxx'][$element]);
// Default
foreach ($mimeinfo as $key => $values) {
if ($values['icon'] == $icon) {
if (isset($values[$element])) {
$info[$key] = $values[$element];
}
//No break, for example for 'excel' we don't want 'csv'!
}
}
if ($all) {
if (count($info) > 1) {
array_shift($info);
// take off document/unknown if we have better options
}
return array_values($info);
// Keep keys out when requesting all
}
// Requested only one, try to get the best by extension coincidence, else return the last
if ($extension && isset($info[$extension])) {
return $info[$extension];
}
return array_pop($info);
// Return last match (mimicking behaviour/comment inside foreach loop)
}
/**
* Returns array of elements of type $element in type group(s)
*
* @param string $element name of the element we are interested in, usually 'type' or 'extension'
* @param string|array $groups one group or array of groups/extensions/mimetypes
* @return array
*/
function file_get_typegroup($element, $groups)
{
static $cached = array();
if (!is_array($groups)) {
$groups = array($groups);
}
if (!array_key_exists($element, $cached)) {
$cached[$element] = array();
}
$result = array();
foreach ($groups as $group) {
if (!array_key_exists($group, $cached[$element])) {
// retrieive and cache all elements of type $element for group $group
$mimeinfo =& get_mimetypes_array();
$cached[$element][$group] = array();
foreach ($mimeinfo as $extension => $value) {
$value['extension'] = '.' . $extension;
if (empty($value[$element])) {
continue;
}
if (($group === '.' . $extension || $group === $value['type'] || !empty($value['groups']) && in_array($group, $value['groups'])) && !in_array($value[$element], $cached[$element][$group])) {
$cached[$element][$group][] = $value[$element];
}
}
}
$result = array_merge($result, $cached[$element][$group]);
}
return array_values(array_unique($result));
}
function setup_elements(&$mform)
{
global $CFG, $COURSE;
// Get extra settings
if ($update = optional_param('update', 0, PARAM_INT)) {
if (!($cm = get_record("course_modules", "id", $update))) {
error("This course module doesn't exist");
}
$assignment_extra = get_record('assignment_peerreview', 'assignment', $cm->instance);
if (record_exists('assignment_submissions', 'assignment', $cm->instance)) {
$mform->addElement('html', '<div style="color:#ff6600;background:#ffff00;margin:5px 20px;padding:5px;text-align:center;font-weight:bold;">' . get_string('settingschangewarning', 'assignment_peerreview') . '</div>');
}
}
// Submission format
$submissionFormats = array();
$submissionFormats[self::SUBMIT_DOCUMENT] = get_string('submissionformatdocument', 'assignment_peerreview');
$submissionFormats[self::ONLINE_TEXT] = get_string('submissionformatonlinetext', 'assignment_peerreview');
$mform->addElement('select', 'var3', get_string('submissionformat', 'assignment_peerreview'), $submissionFormats);
$mform->setDefault('var3', self::SUBMIT_DOCUMENT);
// Filesize restriction
$choices = get_max_upload_sizes($CFG->maxbytes, $COURSE->maxbytes);
$choices[0] = get_string('courseuploadlimit') . ' (' . display_size($COURSE->maxbytes) . ')';
$mform->addElement('select', 'maxbytes', get_string('maximumsize', 'assignment_peerreview'), $choices);
$mform->setDefault('maxbytes', $CFG->assignment_maxbytes);
$mform->disabledIf('maxbytes', 'var3', 'eq', self::ONLINE_TEXT);
// Get the list of file extensions and mime types
$fileExtensions = array();
require_once "{$CFG->dirroot}/lib/filelib.php";
// for file types
$mimeTypes = get_mimetypes_array();
$longestExtension = max(array_map('strlen', array_keys($mimeTypes)));
foreach ($mimeTypes as $extension => $mimeTypeAndIcon) {
if ($extension != 'xxx') {
$padding = '';
for ($i = 0; $i < $longestExtension - strlen($extension); $i++) {
$padding .= ' ';
}
$fileExtensions[$extension] = $extension . $padding . ' (' . $mimeTypeAndIcon['type'] . ')';
}
}
ksort($fileExtensions, SORT_STRING);
// File type restrinction
$attributes = array('style' => 'font-family:monospace;width:99%;');
$mform->addElement('select', 'fileextension', get_string('fileextension', 'assignment_peerreview'), $fileExtensions, $attributes);
$mform->setType('fileextension', PARAM_TEXT);
$mform->setDefault('fileextension', isset($assignment_extra) ? $assignment_extra->fileextension : 'doc');
$mform->disabledIf('fileextension', 'var3', 'eq', self::ONLINE_TEXT);
// Value of each review
$options = array();
for ($i = 0; $i <= 50; $i++) {
$options[$i] = "{$i}";
}
$mform->addElement('select', 'var1', get_string('valueofreview', 'assignment_peerreview'), $options);
$mform->setDefault('var1', '10');
$mform->setHelpButton('var1', array('valueofreview', get_string('valueofreview', 'assignment_peerreview'), 'assignment/type/peerreview/'));
// Practice Review
// $mform->addElement('selectyesno', 'var2', get_string('practicereview', 'assignment_peerreview'));
// $mform->setDefault('var2', 'no');
// $mform->setAdvanced('var2');
}
