<?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/>.

/**
 * Bulk course registration script from a comma separated file
 *
 * @package    tool
 * @subpackage uploadcoursecategory
 * @copyright  2004 onwards Martin Dougiamas (http://dougiamas.com)
 * @copyright  2012 Piers Harding
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

require('../../../config.php');
require_once($CFG->libdir.'/adminlib.php');
require_once($CFG->libdir.'/csvlib.class.php');
require_once($CFG->dirroot.'/course/lib.php');
require_once($CFG->libdir . '/filelib.php');
require_once('locallib.php');
require_once('coursecategory_form.php');

$iid         = optional_param('iid', '', PARAM_INT);
$previewrows = optional_param('previewrows', 10, PARAM_INT);

@set_time_limit(60*60); // 1 hour should be enough
raise_memory_limit(MEMORY_HUGE);

require_login();
admin_externalpage_setup('tooluploadcoursecategory');
require_capability('moodle/category:manage', context_system::instance());

$strcoursecategoryrenamed             = get_string('coursecategoryrenamed', 'tool_uploadcoursecategory');
$strcoursecategorynotrenamedexists    = get_string('coursecategorynotrenamedexists', 'tool_uploadcoursecategory');
$strcoursecategorynotrenamedmissing   = get_string('coursecategorynotrenamedmissing', 'tool_uploadcoursecategory');
$strcoursecategorynotrenamedoff       = get_string('coursecategorynotrenamedoff', 'tool_uploadcoursecategory');

$strcoursecategoryupdated             = get_string('coursecategoryupdated', 'tool_uploadcoursecategory');
$strcoursecategorynotupdated          = get_string('coursecategorynotupdatederror', 'tool_uploadcoursecategory');
$strcoursecategorynotupdatednotexists = get_string('coursecategorynotupdatednotexists', 'tool_uploadcoursecategory');

$strcoursecategoryuptodate            = get_string('coursecategoryuptodate', 'tool_uploadcoursecategory');

$strcoursecategoryadded               = get_string('newcoursecategory', 'tool_uploadcoursecategory');
$strcoursecategorynotadded            = get_string('coursecategorynotadded', 'tool_uploadcoursecategory');
$strcoursecategorynotaddederror       = get_string('coursecategorynotaddederror', 'tool_uploadcoursecategory');

$strcoursecategorydeleted             = get_string('coursecategorydeleted', 'tool_uploadcoursecategory');
$strcoursecategorynotdeletederror     = get_string('coursecategorynotdeletederror', 'tool_uploadcoursecategory');
$strcoursecategorynotdeletedmissing   = get_string('coursecategorynotdeletedmissing', 'tool_uploadcoursecategory');
$strcoursecategorynotdeletedoff       = get_string('coursecategorynotdeletedoff', 'tool_uploadcoursecategory');
$errorstr                     = get_string('error');

$returnurl = new moodle_url('/admin/tool/uploadcoursecategory/index.php');
$bulknurl  = new moodle_url('/admin/tool/uploadcoursecategory/index.php');

$today = time();
$today = make_timestamp(date('Y', $today), date('m', $today), date('d', $today), 0, 0, 0);

// array of all valid fields for validation
$STD_FIELDS = array('name', 'description', 'idnumber', 'theme', 'visible',
        'deleted',     // 1 means delete course category
        'oldname', // for renaming
    );


if (empty($iid)) {
    $mform1 = new admin_uploadcoursecategory_form1();

    if ($formdata = $mform1->get_data()) {
        $iid = csv_import_reader::get_new_iid('uploadcoursecategory');
        $cir = new csv_import_reader($iid, 'uploadcoursecategory');

        $content = $mform1->get_file_content('coursefile');

        $readcount = $cir->load_csv_content($content, $formdata->encoding, $formdata->delimiter_name);
        unset($content);

        if ($readcount === false) {
            print_error('csvloaderror', '', $returnurl);
        } else if ($readcount == 0) {
            print_error('csvemptyfile', 'error', $returnurl);
        }
        // test if columns ok
        $filecolumns = cc_validate_coursecategory_upload_columns($cir, $STD_FIELDS, $returnurl);
        // continue to form2

    } else {
        echo $OUTPUT->header();

        echo $OUTPUT->heading_with_help(get_string('uploadcoursecategories', 'tool_uploadcoursecategory'), 'uploadcoursecategories', 'tool_uploadcoursecategory');

        $mform1->display();
        echo $OUTPUT->footer();
        die;
    }
} else {
    $cir = new csv_import_reader($iid, 'uploadcoursecategory');
    $filecolumns = cc_validate_coursecategory_upload_columns($cir, $STD_FIELDS, $returnurl);
}

$frontpagecontext = context_course::instance(SITEID);
$mform2 = new admin_uploadcoursecategory_form2(null, array('contextid'=>$frontpagecontext->id, 'columns'=>$filecolumns, 'data'=>array('iid'=>$iid, 'previewrows'=>$previewrows)));

// If a file has been uploaded, then process it
if ($formdata = $mform2->is_cancelled()) {
    $cir->cleanup(true);
    redirect($returnurl);

} else if ($formdata = $mform2->get_data()) {
    // Print the header
    echo $OUTPUT->header();
    echo $OUTPUT->heading(get_string('uploadcoursecategoriesresult', 'tool_uploadcoursecategory'));

    $optype = $formdata->cctype;

    $updatetype        = isset($formdata->ccupdatetype) ? $formdata->ccupdatetype : 0;
    $allowrenames      = (!empty($formdata->ccallowrenames) and $optype != CC_COURSE_ADDNEW and $optype != CC_COURSE_ADDINC);
    $allowdeletes      = (!empty($formdata->ccallowdeletes) and $optype != CC_COURSE_ADDNEW and $optype != CC_COURSE_ADDINC);
    $bulk              = isset($formdata->ccbulk) ? $formdata->ccbulk : 0;
    $standardnames     = $formdata->ccstandardnames;

    // verification moved to two places: after upload and into form2
    $coursecategoriesnew      = 0;
    $coursecategoriesupdated  = 0;
    $coursecategoriesuptodate = 0; //not printed yet anywhere
    $coursecategorieserrors   = 0;
    $deletes       = 0;
    $deleteerrors  = 0;
    $renames       = 0;
    $renameerrors  = 0;
    $coursecategoriesskipped  = 0;
    $weakpasswords = 0;

    // caches
    $ccache         = array(); // course cache - do not fetch all courses here, we  will not probably use them all anyway!
    $cohorts        = array();
    $manualcache    = array(); // cache of used manual enrol plugins in each course

    // clear bulk selection
    if ($bulk) {
        $SESSION->bulk_coursecategories = array();
    }

    // init csv import helper
    $cir->init();
    $linenum = 1; //column header is first line

    // init upload progress tracker
    $upt = new cc_progress_tracker();
    $upt->start(); // start table

    while ($line = $cir->next()) {
        $upt->flush();
        $linenum++;

        $upt->track('line', $linenum);

        $coursecategory = new stdClass();

        // add fields to course object
        foreach ($line as $keynum => $value) {
            if (!isset($filecolumns[$keynum])) {
                // this should not happen
                continue;
            }
            $key = $filecolumns[$keynum];
            $coursecategory->$key = $value;

            if (in_array($key, $upt->columns)) {
                // default value in progress tracking table, can be changed later
                $upt->track($key, s($value), 'normal');
            }
        }

        if (!isset($coursecategory->name)) {
            // prevent warnings bellow
            $coursecategory->name = '';
        }

        // normalize name
        $originalname = $coursecategory->name;
        if ($standardnames) {
            $coursecategory->name = clean_param($coursecategory->name, PARAM_MULTILANG);
        }

        // make sure we really have name
        if (empty($coursecategory->name)) {
            $upt->track('status', get_string('missingfield', 'error', 'name'), 'error');
            $upt->track('name', $errorstr, 'error');
            $coursecategorieserrors++;
            continue;
        }

        // validate category parent
        $coursecategory->pathname = $coursecategory->name;
        $categories = explode('/', $coursecategory->name);
        $coursecategory->parent = 0;
        // take off this categories name
        $coursecategory->name = trim(array_pop($categories));
        // check that they haven't explicitly specified the 'Top' parent category
        if (count($categories) > 0) {
            if ($categories[0]== get_string('top')) {
                array_shift($categories);
            }
        }
        // walk the hierachy
        $error = false;
        if (count($categories) > 0) {
            foreach ($categories as $cat) {
                $cat = trim($cat);
                // does the category (for parent) exist - does the category hierachy make sense
                $category = $DB->get_record('course_categories', array('name'=>trim($cat), 'parent' => $coursecategory->parent));
                if (empty($category)) {
                    $upt->track('status', get_string('invalidvalue', 'tool_uploadcoursecategory', 'name'), 'error');
                    $upt->track('name', $errorstr, 'error');
                    $error = true;
                    break;
                }
                $coursecategory->parent = $category->id;
            }
        }
        if ($error) {
            $coursecategorieserrors++;
            continue;
        }

        if ($optype == CC_COURSE_ADDNEW or $optype == CC_COURSE_ADDINC) {
            // course creation is a special case - the name may be constructed from templates using firstname and lastname
            // better never try this in mixed update types
            $error = false;
            if (!isset($coursecategory->description) or $coursecategory->description === '') {
                $upt->track('status', get_string('missingfield', 'error', 'description'), 'error');
                $upt->track('description', $errorstr, 'error');
                $error = true;
            }
            if ($error) {
                $coursecategorieserrors++;
                continue;
            }
            // we require name too - we might use template for it though
            if (empty($coursecategory->name) and !empty($formdata->ccname)) {
                $coursecategory->name = cc_process_template($formdata->ccname, $coursecategory);
                $upt->track('name', s($coursecategory->name));
            }
        }

        // find category
        if ($existingcategory = $DB->get_record('course_categories', array('name'=>trim($coursecategory->name), 'parent' => $coursecategory->parent))) {
            $upt->track('id', $existingcategory->id, 'normal', false);
        }

        // find out in name incrementing required
        if ($existingcategory and $optype == CC_COURSE_ADDINC) {
            $coursecategory->name = cc_increment_name($coursecategory->name);
            if (!empty($coursecategory->idnumber)) {
                $oldidnumber = $coursecategory->idnumber;
                $coursecategory->idnumber = cc_increment_idnumber($coursecategory->idnumber);
                if ($coursecategory->idnumber !== $oldidnumber) {
                    $upt->track('idnumber', s($oldidnumber).'-->'.s($coursecategory->idnumber), 'info');
                }
            }
            $existingcategory = false;
        }

        // check duplicate idnumber
        if (!$existingcategory and isset($coursecategory->idnumber)) {
            if ($DB->record_exists('course_categories', array('idnumber' => $coursecategory->idnumber))) {
                $upt->track('status', get_string('idnumbernotunique', 'tool_uploadcoursecategory'), 'error');
                $upt->track('idnumber', $errorstr, 'error');
                $error = true;
            }
        }
        $categories[]= $coursecategory->name;
        $newname = implode('/', $categories);

        // notify about any name changes
        if ($originalname !== $newname) {
            $upt->track('name', '', 'normal', false); // clear previous
            $upt->track('name', s($originalname).'-->'.s($coursecategory->name), 'info');
        } else {
            $upt->track('name', s($coursecategory->name), 'normal', false);
        }

        // add default values for remaining fields
        $formdefaults = array();
        foreach ($STD_FIELDS as $field) {
            if (isset($coursecategory->$field)) {
                continue;
            }
            // all validation moved to form2
            if (isset($formdata->$field)) {
                $coursecategory->$field = $formdata->$field;
                $formdefaults[$field] = true;
                if (in_array($field, $upt->columns)) {
                    $upt->track($field, s($coursecategory->$field), 'normal');
                }
            }
            else {
                // process templates
                if (isset($formdata->{"cc".$field}) && !empty($formdata->{"cc".$field}) && empty($coursecategory->$field)) {
                    $coursecategory->$field = cc_process_template($formdata->{"cc".$field}, $coursecategory);
                }
            }
        }

        // delete course category
        if (!empty($coursecategory->deleted)) {
            if (!$allowdeletes) {
                $coursecategoriesskipped++;
                $upt->track('status', $strcoursecategorynotdeletedoff, 'warning');
                continue;
            }
            if ($existingcategory) {
                require_capability('moodle/category:manage', get_category_or_system_context((int)$existingcategory->parent));
                $deletecat = coursecat::get($existingcategory->id, MUST_EXIST);
                $deletecat->delete_full(false);
                $upt->track('status', $strcoursecategorydeleted);
                $deletes++;
            } else {
                $upt->track('status', $strcoursecategorynotdeletedmissing, 'error');
                $deleteerrors++;
            }
            continue;
        }
        // we do not need the deleted flag anymore
        unset($coursecategory->deleted);

        // renaming requested?
        if (!empty($coursecategory->oldname) ) {
            if (!$allowrenames) {
                $coursecategoriesskipped++;
                $upt->track('status', $strcoursecategorynotrenamedoff, 'warning');
                continue;
            }

            if ($existingcategory) {
                $upt->track('status', $strcoursecategorynotrenamedexists, 'error');
                $renameerrors++;
                continue;
            }

            // validate category parent
            $categories = explode('/', $coursecategory->oldname);
            $coursecategory->oldparent = 0;
            // take off this categories name
            $coursecategory->oldname = trim(array_pop($categories));
            // check that they haven't explicitly specified the 'Top' parent category
            if (count($categories) > 0) {
                if ($categories[0]== get_string('top')) {
                    array_shift($categories);
                }
            }
            // walk the hierachy
            if (count($categories) > 0) {
                foreach ($categories as $cat) {
                    $cat = trim($cat);
                    // does the category (for parent) exist - does the category hierachy make sense
                    $category = $DB->get_record('course_categories', array('name'=>trim($cat), 'parent' => $coursecategory->oldparent));
                    if (empty($category)) {
                        $upt->track('status', get_string('invalidvalue', 'tool_uploadcoursecategory', 'oldname'), 'error');
                        $upt->track('oldname', $errorstr, 'error');
                        $error = true;
                        break;
                    }
                    $coursecategory->oldparent = $category->id;
                }
            }

            if ($standardnames) {
                $oldname = clean_param($coursecategory->oldname, PARAM_MULTILANG);
            } else {
                $oldname = $coursecategory->oldname;
            }


            // no guessing when looking for old name, it must be exact match
            if ($oldcoursecategory = $DB->get_record('course_categories', array('name'=>trim($coursecategory->oldname), 'parent' => $coursecategory->oldparent))) {
                $upt->track('id', $oldcoursecategory->id, 'normal', false);
                require_capability('moodle/category:manage', get_category_or_system_context((int)$oldcoursecategory->parent));
                $DB->set_field('course_categories', 'name', $coursecategory->name, array('id'=>$oldcoursecategory->id));
                // update hierarchy pointer if necessary
                if ($coursecategory->parent != $coursecategory->oldparent) {
                    require_capability('moodle/category:manage', get_category_or_system_context((int)$coursecategory->parent));
                    $parent_cat = $DB->get_record('course_categories', array('id' => $coursecategory->parent));
                    $coursecategory->id = $oldcoursecategory->id;
                    move_category($coursecategory, $parent_cat);
                    $existingcategory->context = context_coursecat::instance($oldcoursecategory->id);
                    $existingcategory->context->mark_dirty();
                }
                $upt->track('name', '', 'normal', false); // clear previous
                $upt->track('name', s($oldname).'-->'.s($coursecategory->name), 'info');
                $upt->track('status', $strcoursecategoryrenamed);
                $renames++;
            } else {
                $upt->track('status', $strcoursecategorynotrenamedmissing, 'error');
                $renameerrors++;
                continue;
            }
            $existingcategory = $oldcoursecategory;
            $existingcategory->name = $coursecategory->name;
        }

        // can we process with update or insert?
        $skip = false;
        switch ($optype) {
            case CC_COURSE_ADDNEW:
                if ($existingcategory) {
                    $coursecategoriesskipped++;
                    $upt->track('status', $strcoursecategorynotadded, 'warning');
                    $skip = true;
                }
                break;

            case CC_COURSE_ADDINC:
                if ($existingcategory) {
                    //this should not happen!
                    $upt->track('status', $strcoursecategorynotaddederror, 'error');
                    $coursecategorieserrors++;
                    $skip = true;
                }
                break;

            case CC_COURSE_ADD_UPDATE:
                break;

            case CC_COURSE_UPDATE:
                if (!$existingcategory) {
                    $coursecategoriesskipped++;
                    $upt->track('status', $strcoursecategorynotupdatednotexists, 'warning');
                    $skip = true;
                }
                break;

            default:
                // unknown type
                $skip = true;
        }

        if ($skip) {
            continue;
        }

        if ($existingcategory) {
            $coursecategory->id = $existingcategory->id;
            require_capability('moodle/category:manage', get_category_or_system_context((int)$existingcategory->parent));

            $upt->track('name', html_writer::link(new moodle_url('/course/index.php', array('categoryid'=>$existingcategory->id)), s($existingcategory->name)), 'normal', false);

            $existingcategory->timemodified = time();
            // do NOT mess with timecreated or firstaccess here!
            $doupdate = false;

            if ($updatetype != CC_UPDATE_NOCHANGES) {
                foreach ($STD_FIELDS as $column) {
                    if ($column === 'name') {
                        // these can not be changed here
                        continue;
                    }
                    if (!property_exists($coursecategory, $column) or !property_exists($existingcategory, $column)) {
                        // this should never happen
                        continue;
                    }
                    if ($updatetype == CC_UPDATE_MISSING) {
                        if (!is_null($existingcategory->$column) and $existingcategory->$column !== '') {
                            continue;
                        }
                    } else if ($updatetype == CC_UPDATE_ALLOVERRIDE) {
                        // we override everything

                    } else if ($updatetype == CC_UPDATE_FILEOVERRIDE) {
                        if (!empty($formdefaults[$column])) {
                            // do not override with form defaults
                            continue;
                        }
                    }
                    if ($existingcategory->$column !== $coursecategory->$column) {
                        if (in_array($column, $upt->columns)) {
                            $upt->track($column, s($existingcategory->$column).'-->'.s($coursecategory->$column), 'info', false);
                        }
                        $existingcategory->$column = $coursecategory->$column;
                        $doupdate = true;
                    }
                }
            }

            if ($doupdate) {
                // we want only courses that were really updated
                $DB->update_record('course_categories', $existingcategory);
                $existingcategory->context = context_coursecat::instance($existingcategory->id);
                $existingcategory->context->mark_dirty();
                fix_course_sortorder();
                $upt->track('status', $strcoursecategoryupdated);
                $coursecategoriesupdated++;

                events_trigger('coursecategory_updated', $existingcategory);

                if ($bulk == CC_BULK_UPDATED or $bulk == CC_BULK_ALL) {
                    if (!in_array($coursecategory->id, $SESSION->bulk_coursecategories)) {
                        $SESSION->bulk_coursecategories[] = $coursecategory->id;
                    }
                }

            } else {
                // no course information changed
                $upt->track('status', $strcoursecategoryuptodate);
                $coursecategoriesuptodate++;

                if ($bulk == CC_BULK_ALL) {
                    if (!in_array($coursecategory->id, $SESSION->bulk_coursecategories)) {
                        $SESSION->bulk_coursecategories[] = $coursecategory->id;
                    }
                }
            }

        } else {
            // save the new course to the database
            $coursecategory->timemodified = time();
            $coursecategory->timecreated  = time();


            // create course - insert_record ignores any extra properties
            try {
                $coursecategory->sortorder = 999;
                $coursecategory->id = $DB->insert_record('course_categories', $coursecategory);
                $coursecategory->context = context_coursecat::instance($coursecategory->id);
                $coursecategory->context->mark_dirty();
                fix_course_sortorder();
            }
            catch (moodle_exception $e) {
                $upt->track('status', $e->getMessage(), 'error');
                $coursecategorieserrors++;
                $skip = true;
                continue;
            }
            $upt->track('name', html_writer::link(new moodle_url('/course/index.php', array('categoryid'=>$coursecategory->id)), s($coursecategory->name)), 'normal', false);

            $upt->track('status', $strcoursecategoryadded);
            $upt->track('id', $coursecategory->id, 'normal', false);
            $coursecategoriesnew++;

            if ($bulk == CC_BULK_NEW or $bulk == CC_BULK_ALL) {
                if (!in_array($coursecategory->id, $SESSION->bulk_coursecategories)) {
                    $SESSION->bulk_coursecategories[] = $coursecategory->id;
                }
            }
        }
    }

    $upt->close(); // close table

    $cir->close();
    $cir->cleanup(true);

    echo $OUTPUT->box_start('boxwidthnarrow boxaligncenter generalbox', 'uploadresults');
    echo '<p>';
    if ($optype != CC_COURSE_UPDATE) {
        echo get_string('coursecategoriescreated', 'tool_uploadcoursecategory').': '.$coursecategoriesnew.'<br />';
    }
    if ($optype == CC_COURSE_UPDATE or $optype == CC_COURSE_ADD_UPDATE) {
        echo get_string('coursecategoriesupdated', 'tool_uploadcoursecategory').': '.$coursecategoriesupdated.'<br />';
    }
    if ($allowdeletes) {
        echo get_string('coursecategoriesdeleted', 'tool_uploadcoursecategory').': '.$deletes.'<br />';
        echo get_string('deleteerrors', 'tool_uploadcoursecategory').': '.$deleteerrors.'<br />';
    }
    if ($allowrenames) {
        echo get_string('coursecategoriesrenamed', 'tool_uploadcoursecategory').': '.$renames.'<br />';
        echo get_string('renameerrors', 'tool_uploadcoursecategory').': '.$renameerrors.'<br />';
    }
    if ($coursecategoriesskipped) {
        echo get_string('coursecategoriesskipped', 'tool_uploadcoursecategory').': '.$coursecategoriesskipped.'<br />';
    }
    echo get_string('errors', 'tool_uploadcoursecategory').': '.$coursecategorieserrors.'</p>';
    echo $OUTPUT->box_end();

    if ($bulk) {
        echo $OUTPUT->continue_button($bulknurl);
    } else {
        echo $OUTPUT->continue_button($returnurl);
    }
    echo $OUTPUT->footer();
    die;
}

// Print the header
echo $OUTPUT->header();

echo $OUTPUT->heading(get_string('uploadcoursecategoriespreview', 'tool_uploadcoursecategory'));

// NOTE: this is JUST csv processing preview, we must not prevent import from here if there is something in the file!!
//       this was intended for validation of csv formatting and encoding, not filtering the data!!!!
//       we definitely must not process the whole file!

// preview table data
$data = array();
$cir->init();
$linenum = 1; //column header is first line
while ($linenum <= $previewrows and $fields = $cir->next()) {
    $linenum++;
    $rowcols = array();
    $rowcols['line'] = $linenum;
    foreach($fields as $key => $field) {
        $rowcols[$filecolumns[$key]] = s($field);
    }
    $rowcols['status'] = array();

    if (isset($rowcols['name'])) {
        $stdname = clean_param($rowcols['name'], PARAM_MULTILANG);
        if ($rowcols['name'] !== $stdname) {
            $rowcols['status'][] = get_string('invalidnameupload');
        }
        if ($coursecategoryid = $DB->get_field('course_categories', 'id', array('name'=>$stdname))) {
            $rowcols['name'] = html_writer::link(new moodle_url('/course/view.php', array('id'=>$coursecategoryid)), $rowcols['name']);
        }
    } else {
        $rowcols['status'][] = get_string('missingname');
    }

    $rowcols['status'] = implode('<br />', $rowcols['status']);
    $data[] = $rowcols;
}
if ($fields = $cir->next()) {
    $data[] = array_fill(0, count($fields) + 2, '...');
}
$cir->close();

$table = new html_table();
$table->id = "ccpreview";
$table->attributes['class'] = 'generaltable';
$table->tablealign = 'center';
$table->description = get_string('uploadcoursecategoriespreview', 'tool_uploadcoursecategory');
$table->head = array();
$table->data = $data;

$table->head[] = get_string('cccsvline', 'tool_uploadcoursecategory');
foreach ($filecolumns as $column) {
    $table->head[] = $column;
}
$table->head[] = get_string('status');

echo html_writer::tag('div', html_writer::table($table), array('class'=>'flexible-wrap'));

/// Print the form

$mform2->display();
echo $OUTPUT->footer();
die;