ajax.php

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

/**
 * @package   turnitintooltwo
 * @copyright 2012 iParadigms LLC
 */

define('AJAX_SCRIPT', 1);
global $CFG;

require_once(__DIR__."/../../config.php");
require_once(__DIR__."/lib.php");
require_once($CFG->dirroot . '/mod/turnitintooltwo/turnitintooltwo_view.class.php');

require_login();
$action = required_param('action', PARAM_ALPHAEXT);

switch ($action) {
    case "check_anon":
        $assignmentid = required_param('assignment', PARAM_INT);
        $partid = required_param('part', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $part = $turnitintooltwoassignment->get_part_details($partid);

        $anondata = array(
            'anon' => $turnitintooltwoassignment->turnitintooltwo->anon,
            'unanon' => $part->unanon,
            'submitted' => $part->submitted
        );
        echo json_encode($anondata);
        break;

    case "edit_field":
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $assignmentid = required_param('assignment', PARAM_INT);
        $partid = required_param('pk', PARAM_INT);
        $return = array();

        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        if (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) {
            $fieldname = required_param('name', PARAM_ALPHA);
            switch ($fieldname) {
                case 'partname':
                    $fieldvalue = required_param('value', PARAM_TEXT);
                    break;

                case "maxmarks":
                    $fieldvalue = required_param('value', PARAM_RAW);
                    break;

                case "dtstart":
                case "dtdue":
                case "dtpost":
                    $fieldvalue = required_param('value', PARAM_RAW);
                    // We need to work out the users timezone or GMT offset.
                    $usertimezone = get_user_timezone();

                    if (is_numeric($usertimezone)) {
                        if ($usertimezone > 13) {
                            $usertimezone = "";
                        } else if ($usertimezone <= 13 && $usertimezone > 0) {
                            $usertimezone = "GMT+$usertimezone";
                        } else if ($usertimezone < 0) {
                            $usertimezone = "GMT$usertimezone";
                        } else {
                            $usertimezone = 'GMT';
                        }
                    }

                    $fieldvalue = strtotime($fieldvalue.' '.$usertimezone);
                    break;
            }

            $return = $turnitintooltwoassignment->edit_part_field($partid, $fieldname, $fieldvalue);
        } else {
            $return["aaData"] = '';
        }

        $partdetails = $turnitintooltwoassignment->get_parts();

        $unanonymised = ($turnitintooltwoassignment->turnitintooltwo->anon == 0 || time() > $partdetails[$partid]->dtpost);
        $return['export_option'] = ($unanonymised) ? "tii_export_options_show" : "tii_export_options_hide";

        echo json_encode($return);
        break;

    case "useragreement":
        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        if (has_capability('mod/turnitintooltwo:read', context_module::instance($cm->id))) {
            $user = new turnitintooltwo_user($USER->id, "Learner");
            echo turnitintooltwo_view::output_dv_launch_form("useragreement", 0, $user->tiiuserid, "Learner", "Submit", true);
        }
        break;

    case "acceptuseragreement":
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $message = optional_param('message', '', PARAM_ALPHAEXT);

        // Get the id from the turnitintooltwo_users table so we can update.
        $turnitinuser = $DB->get_record('turnitintooltwo_users', array('userid' => $USER->id));

        // Build user object for update.
        $eulauser = new \stdClass();
        $eulauser->id = $turnitinuser->id;
        $eulauser->user_agreement_accepted = 0;
        if ($message == 'turnitin_eula_accepted') {
            $eulauser->user_agreement_accepted = 1;
        }

        // Update the user using the above object.
        $DB->update_record('turnitintooltwo_users', $eulauser, false);
        break;

    case "downloadoriginal":
    case "default":
    case "origreport":
    case "grademark":
        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        if (has_capability('mod/turnitintooltwo:read', context_module::instance($cm->id))) {
            $submissionid = required_param('submission', PARAM_INT);
            $userrole = (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) ? 'Instructor' : 'Learner';

            $user = new turnitintooltwo_user($USER->id, $userrole);

            $launchform = turnitintooltwo_view::output_dv_launch_form($action, $submissionid, $user->tiiuserid, $userrole, '');
            if ($action == 'downloadoriginal') {
                echo $launchform;
            } else {
                $launchform = html_writer::tag("div", $launchform, array('style' => 'display: none'));
                echo json_encode($launchform);
            }
        }
        break;

    case "orig_zip":
    case "xls_inbox":
    case "origchecked_zip":
    case "gmpdf_zip":

        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        if (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) {

            $partid = optional_param('part', 0, PARAM_INT);
            if ($partid != 0 && ($action == "origchecked_zip" || $action == "gmpdf_zip")) {
                $partdetails = $turnitintooltwoassignment->get_part_details($partid, "moodle");
                $partid = $partdetails->tiiassignid;
            }

            $user = new turnitintooltwo_user($USER->id, 'Instructor');
            $user->edit_tii_user();

            if ($action == "orig_zip") {
                $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
                $partdetails = $turnitintooltwoassignment->get_part_details($partid, "turnitin");
                $submissions = $turnitintooltwoassignment->get_submissions($cm, $partdetails->id);

                $submissionids = array();
                foreach ($submissions[$partdetails->id] as $k => $v) {
                    if (!empty($v->submission_objectid)) {
                        $submissionids[] = $v->submission_objectid;
                    }
                }
            } else {
                $submissionids = optional_param_array('submission_ids', array(), PARAM_INT);
            }

            echo turnitintooltwo_view::output_download_launch_form($action, $user->tiiuserid, $partid, $submissionids);
        }
        break;

    case "get_users":
        $PAGE->set_context(context_system::instance());
        if (is_siteadmin()) {
            echo json_encode(turnitintooltwo_getusers());
        } else {
            throw new moodle_exception('accessdenied', 'admin');
        }
        break;

    case "get_assignments":
        include_once("classes/v1migration/v1migration.php");

        $PAGE->set_context(context_system::instance());
        if (is_siteadmin()) {
            echo json_encode(v1migration::turnitintooltwo_getassignments());
        } else {
            throw new moodle_exception('accessdenied', 'admin');
        }
        break;

    case "initialise_redraw":
        $PAGE->set_context(context_system::instance());
        $return["aaData"] = array();

        echo json_encode($return);
        break;

    case "sync_all_submissions":

        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }
        raise_memory_limit(MEMORY_EXTRA);

        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $parts = $turnitintooltwoassignment->get_parts();

        foreach ($parts as $part) {
            $i = 0;
            $turnitintooltwoassignment->get_submission_ids_from_tii($part, false);
            $total = count($_SESSION["TiiSubmissions"][$part->id]);

            while ($i < $total) {
                $turnitintooltwoassignment->refresh_submissions($cm, $part, $i, true);
                $i += TURNITINTOOLTWO_SUBMISSION_GET_LIMIT;
            }

            unset($_SESSION["TiiSubmissions"][$part->id]);
        }

        echo json_encode( array('success' => true) );
        break;

    case "get_submissions":

        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));
        $return = array();

        if (has_capability('mod/turnitintooltwo:read', context_module::instance($cm->id))) {
            $partid = required_param('part', PARAM_INT);
            $refreshrequested = required_param('refresh_requested', PARAM_INT);
            $start = required_param('start', PARAM_INT);
            $total = required_param('total', PARAM_INT);
            $parts = $turnitintooltwoassignment->get_parts();
            $updatefromtii = ($refreshrequested || $turnitintooltwoassignment->turnitintooltwo->autoupdates == 1) ? 1 : 0;
            $istutor = (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) ? true : false;

            if ($updatefromtii && $start == 0) {
                $turnitintooltwoassignment->get_submission_ids_from_tii($parts[$partid]);
                $total = count($_SESSION["TiiSubmissions"][$partid]);
            }

            if ($start < $total && $updatefromtii) {
                $turnitintooltwoassignment->refresh_submissions($cm, $parts[$partid], $start);
            }

            $PAGE->set_context(context_module::instance($cm->id));
            $turnitintooltwoview = new turnitintooltwo_view();
            
            $view = $turnitintooltwoview->get_submission_inbox($cm, $turnitintooltwoassignment, $parts, $partid, $start);
            $return["aaData"] = $view;
            $totalsubmitters = $DB->count_records('turnitintooltwo_submissions',
                                                    array('turnitintooltwoid' => $turnitintooltwoassignment->turnitintooltwo->id,
                                                            'submission_part' => $partid));
            $return["end"] = $start + TURNITINTOOLTWO_SUBMISSION_GET_LIMIT;
            $return["total"] = $_SESSION["num_submissions"][$partid];
            $return["nonsubmitters"] = $return["total"] - $totalsubmitters;

            // Remove any leftover submissions from session and update grade timestamp.
            if ($return["end"] >= $return["total"]) {
                unset($_SESSION["submissions"][$partid]);

                // Only update the timestamp if an instructor has refreshed.
                if ( $istutor ) {
                    $updatepart = new stdClass();
                    $updatepart->id = $partid;
                    // Set timestamp to 10 minutes ago to account for time taken to complete (somewhat exagerrated).
                    $updatepart->gradesupdated = time() - (60 * 10);
                    $DB->update_record('turnitintooltwo_parts', $updatepart);
                }
            }
        } else {
            $return["aaData"] = '';
        }

        echo json_encode($return);
        break;

    case "refresh_user_messages":
        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        if (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) {
            $turnitintooltwouser = new turnitintooltwo_user($USER->id, 'Instructor');
            $turnitintooltwouser->set_user_values_from_tii();

            echo $turnitintooltwouser->get_user_messages();
        } else {
            echo 0;
        }
        break;

    case "refresh_peermark_assignments":

        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        if (has_capability('mod/turnitintooltwo:read', context_module::instance($cm->id))) {
            $partid = required_param('part', PARAM_INT);
            $refreshrequested = optional_param('refresh_requested', 0, PARAM_INT);
            $partdetails = $turnitintooltwoassignment->get_part_details($partid);

            if ($refreshrequested) {
                $turnitintooltwoassignment->update_assignment_from_tii(array($partdetails->tiiassignid));
                $partdetails = $turnitintooltwoassignment->get_part_details($partid);
            }

            $PAGE->set_context(context_module::instance($cm->id));

            $turnitintooltwoview = new turnitintooltwo_view();
            $peermarkdata['peermark_table'] = $turnitintooltwoview->show_peermark_assignment($partdetails->peermark_assignments);
            $peermarkdata['no_of_peermarks'] = count($partdetails->peermark_assignments);
            $peermarkdata['peermarks_active'] = false;
            foreach ($partdetails->peermark_assignments as $peermarkassignment) {
                if (time() > $peermarkassignment->dtstart) {
                    $peermarkdata['peermarks_active'] = true;
                    break;
                }
            }
            echo json_encode($peermarkdata);
        }
        break;

    case "refresh_submission_row":

        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        if (has_capability('mod/turnitintooltwo:read', context_module::instance($cm->id))) {
            $partid = required_param('part', PARAM_INT);
            $userid = required_param('user', PARAM_INT);
            $istutor = (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) ? true : false;

            $parts = $turnitintooltwoassignment->get_parts();

            // Get the id of the submission in the row and update it from Turnitin then get the new details.
            $submission = $turnitintooltwoassignment->get_user_submissions($userid, $assignmentid, $partid);
            $submissionid = current(array_keys($submission));

            if (!empty($submissionid)) {
                $submission = new turnitintooltwo_submission($submissionid);
                $submission->update_submission_from_tii(true);

                // Get the submission details again in case the submission has been transferred within Turnitin.
                $submission = $turnitintooltwoassignment->get_user_submissions($userid, $assignmentid, $partid);
                $submissionid = current(array_keys($submission));
            }

            $submission = new turnitintooltwo_submission($submissionid);
            if (empty($submissionid)) {
                $user = new turnitintooltwo_user($userid, 'Learner', false);

                $submission->firstname = $user->firstname;
                $submission->lastname = $user->lastname;
                $submission->fullname = $user->fullname;
                $submission->userid = $user->id;
            }
            // Check if student is actually enrolled in the Moodle course.
            if ( !is_enrolled(context_module::instance($cm->id), $submission->userid, '', true) ) {
                $submission->nmoodle = 1;

                $submission->firstname = $submission->submission_nmfirstname;
                $submission->lastname = $submission->submission_nmlastname;
                $submission->fullname = $submission->firstname.' '.$submission->lastname;
            }

            $useroverallgrades = array();

            $PAGE->set_context(context_module::instance($cm->id));

            $turnitintooltwoview = new turnitintooltwo_view();
            $submissionrow["submission_id"] = $submission->submission_objectid;
            $submissionrow["row"] = $turnitintooltwoview->get_submission_inbox_row($cm, $turnitintooltwoassignment, $parts,
                                                                                $partid, $submission, $useroverallgrades,
                                                                                $istutor, 'refresh_row');

            echo json_encode($submissionrow);
        }
        break;

    case "enrol_all_students":

        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        if (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) {
            echo $turnitintooltwoassignment->enrol_all_students($cm);
        }
        break;

    case "refresh_rubric_select":
        $courseid = required_param('course', PARAM_INT);
        $assignmentid = required_param('assignment', PARAM_INT);
        $modulename = required_param('modulename', PARAM_ALPHA);

        $PAGE->set_context(context_course::instance($courseid));

        if (has_capability('moodle/course:update', context_course::instance($courseid))) {
            // Set Rubric options to instructor rubrics.
            $instructor = new turnitintooltwo_user($USER->id, 'Instructor');
            $instructor->set_user_values_from_tii();
            $instructorrubrics = $instructor->get_instructor_rubrics();

            $options = array('' => get_string('norubric', 'turnitintooltwo')) + $instructorrubrics;

            // Get rubrics that are shared on the Turnitin account.
            if ($modulename == "turnitintooltwo") {
                $turnitinclass = new turnitintooltwo_class($courseid);
            } else {
                require_once($CFG->dirroot.'/plagiarism/turnitin/lib.php');
                $turnitinclass = new turnitin_class($courseid);
            }
            $turnitinclass->read_class_from_tii();
			$sharedrubrics = $turnitinclass->sharedrubrics;

			foreach ($sharedrubrics as $group => $grouprubrics) {
				foreach ($grouprubrics as $rubricid => $rubricname) {
					$options[$group][$rubricid] = $rubricname;
				}
			}

            // Get assignment details.
            if (!empty($assignmentid)) {
                if ($modulename == "turnitintooltwo") {
                    $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
                } else {
                    $pluginturnitin = new plagiarism_plugin_turnitin();
                    $cm = get_coursemodule_from_instance($modulename, $assignmentid);
                    $plagiarismsettings = $pluginturnitin->get_settings($cm->id);
                }
            }

            // Add in selected rubric if it belongs to another instructor.
            if (!empty($assignmentid)) {
                if ($modulename == "turnitintooltwo") {
                    if (!empty($turnitintooltwoassignment->turnitintooltwo->rubric)) {
                        if (isset($options[$turnitintooltwoassignment->turnitintooltwo->rubric])) {
                            $rubricname = $options[$turnitintooltwoassignment->turnitintooltwo->rubric];
                        } else {
                            $rubricname = get_string('otherrubric', 'turnitintooltwo');
                        }
                        $options[$turnitintooltwoassignment->turnitintooltwo->rubric] = $rubricname;
                    }
                } else {
                    if (!empty($plagiarismsettings["plagiarism_rubric"])) {
                        if (isset($options[$plagiarismsettings["plagiarism_rubric"]])) {
                            $rubricname = $options[$plagiarismsettings["plagiarism_rubric"]];
                        } else {
                            $rubricname = get_string('otherrubric', 'turnitintooltwo');
                        }
                        $options[$plagiarismsettings["plagiarism_rubric"]] = $rubricname;
                    }
                }
            }
        } else {
            $options = array();
        }

        echo json_encode($options);
        break;

    case "get_files":
        $PAGE->set_context(context_system::instance());
        if (is_siteadmin()) {
            $modules = $DB->get_record('modules', array('name' => 'turnitintooltwo'));
            echo json_encode(turnitintooltwo_getfiles($modules->id));
        }
        break;

    case "get_members":
        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));

        $return["aaData"] = array();
        if (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) {
            $role = required_param('role', PARAM_ALPHA);
            $members = $turnitintooltwoassignment->get_tii_users_by_role($role);

            $PAGE->set_context(context_module::instance($cm->id));
            $turnitintooltwoview = new turnitintooltwo_view();
            $return["aaData"] = $turnitintooltwoview->get_tii_members_by_role($cm, $turnitintooltwoassignment, $members, $role);
        }
        echo json_encode($return);
        break;

    case "reveal_submission_name":
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $assignmentid = required_param('assignment', PARAM_INT);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);
        $PAGE->set_context(context_module::instance($cm->id));
        $return = array("status" => "fail", "msg" => get_string('unanonymiseerror', 'turnitintooltwo'));

        if (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) {
            $submissionid = required_param('submission_id', PARAM_INT);
            $reason = optional_param('reason', get_string('noreason', 'turnitintooltwo'), PARAM_TEXT);

            $turnitintooltwosubmission = new turnitintooltwo_submission($submissionid, "turnitin");
            if ($turnitintooltwosubmission->unanonymise_submission($reason)) {
                if ($turnitintooltwosubmission->userid == 0) {

                    $tmpuser = new stdClass();
                    $tmpuser->firstname = $turnitintooltwosubmission->nmfirstname;
                    $tmpuser->lastname = $turnitintooltwosubmission->nmlastname;

                    $return["name"] = fullname($tmpuser);
                } else {
                    $user = new turnitintooltwo_user($turnitintooltwosubmission->userid);
                    $return["name"] = fullname($user);
                }
                $return["status"] = "success";
                $return["userid"] = $turnitintooltwosubmission->userid;
                $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
                $return["courseid"] = $turnitintooltwoassignment->turnitintooltwo->course;
                $return["msg"] = "";
            }

            // Refresh submission and save.
            $turnitintooltwosubmission->update_submission_from_tii();
        }

        echo json_encode($return);
        break;

    case "search_classes":
        $PAGE->set_context(context_system::instance());
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $title = optional_param('course_title', '', PARAM_TEXT);
        $courseintegration = optional_param('course_integration', '', PARAM_ALPHANUM);
        $enddate = optional_param('course_end_date', null, PARAM_TEXT);
        $source = optional_param('request_source', 'mod', PARAM_TEXT);

        $modules = $DB->get_record('modules', array('name' => 'turnitintooltwo'));

        $return = turnitintooltwo_get_courses_from_tii($tiiintegrationids, $title, $courseintegration, $enddate, $source);
        echo json_encode($return);
        break;

    case "create_courses":
        $PAGE->set_context(context_system::instance());
        set_time_limit(0);
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        if (has_capability('moodle/course:create', context_system::instance())) {
            $coursecategory = optional_param('course_category', 0, PARAM_INT);
            $createassignments = optional_param('create_assignments', 0, PARAM_INT);
            $classids = required_param('class_ids', PARAM_SEQUENCE);
            $classids = explode(",", $classids);

            $i = 0;
            foreach ($classids as $tiiclassid) {
                $coursename = $_SESSION['tii_classes'][$tiiclassid];

                $course = turnitintooltwo_assignment::create_moodle_course($tiiclassid, $coursename, $coursename, $coursecategory);
                if ($createassignments == 1 && !empty($course)) {
                    $return = turnitintooltwo_get_assignments_from_tii($tiiclassid, "raw");

                    foreach ($return as $assignment) {
                        turnitintooltwo_assignment::create_migration_assignment(array($assignment["tii_id"]),
                                                                                $course->id, $assignment["tii_title"]);
                    }
                }
                $i++;
            }

            $result = new stdClass();
            $result->completed = $i;
            $result->total = count($classids);
            $msg = get_string('recreatemulticlassescomplete', 'turnitintooltwo', $result);
        } else {
            $msg = get_string('nopermissions', 'error', get_string('course:create', 'role'));
        }

        echo $msg;
        break;

    case "create_course":
        $PAGE->set_context(context_system::instance());
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        if (has_capability('moodle/course:create', context_system::instance())) {
            $tiicoursename = optional_param('tii_course_name', get_string('defaultcoursetiititle', 'turnitintooltwo'), PARAM_TEXT);
            $coursecategory = optional_param('course_category', 0, PARAM_INT);
            $tiicourseid = optional_param('tii_course_id', 0, PARAM_INT);
            $coursename = urldecode(optional_param('course_name', '', PARAM_TEXT));
            if (empty($coursename)) {
                $coursename = get_string('defaultcoursetiititle', 'turnitintooltwo')." (".$tiicourseid.")";
            }

            $course = turnitintooltwo_assignment::create_moodle_course($tiicourseid, urldecode($tiicoursename),
                                                                        $coursename, $coursecategory);

            $newcourse = array('courseid' => $course->id, 'coursename' => $course->fullname);
            echo json_encode($newcourse);
        } else {
            throw new moodle_exception('nopermissions', 'error', '', get_string('course:create', 'role'));
        }
        break;

    case "link_course":
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        if (has_capability('moodle/course:update', context_system::instance())) {
            $tiicoursename = optional_param('tii_course_name', get_string('defaultcoursetiititle', 'turnitintooltwo'), PARAM_TEXT);
            $tiicourseid = optional_param('tii_course_id', 0, PARAM_INT);
            $coursetolink = optional_param('course_to_link', 0, PARAM_INT);

            $turnitincourse = new stdClass();
            $turnitincourse->courseid = $coursetolink;
            $turnitincourse->ownerid = $USER->id;
            $turnitincourse->turnitin_cid = $tiicourseid;
            $turnitincourse->turnitin_ctl = urldecode($tiicoursename);
            $turnitincourse->course_type = 'TT';

            $PAGE->set_context(context_system::instance($coursetolink));

            if (!$insertid = $DB->insert_record('turnitintooltwo_courses', $turnitincourse)) {
                echo "0";
            } else {
                $course = $DB->get_record("course", array("id" => $coursetolink), 'fullname');
                $newcourse = array('courseid' => $coursetolink, 'coursename' => $course->fullname);

                echo json_encode($newcourse);
            }
        } else {
            throw new moodle_exception('nopermissions', 'error', '', get_string('course:update', 'role'));
        }
        break;

    case "get_assignments":
        set_time_limit(0);
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $PAGE->set_context(context_system::instance());

        if (has_capability('moodle/course:update', context_system::instance())) {
            $tiicourseid = required_param('tii_course_id', PARAM_INT);
            $return = turnitintooltwo_get_assignments_from_tii($tiicourseid, "json");
            $return["number_of_assignments"] = count($return["aaData"]);
        } else {
            $return["number_of_assignments"] = 0;
        }
        echo json_encode($return);
        break;

    case "create_assignment":
        set_time_limit(0);
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        if (has_capability('mod/turnitintooltwo:addinstance', context_system::instance())) {
            $partids = required_param('parts', PARAM_SEQUENCE);
            $courseid = optional_param('course_id', 0, PARAM_INT);
            $assignmentname = optional_param('assignment_name', '', PARAM_TEXT);
            if (empty($assignmentname)) {
                $assignmentname = get_string('defaultassignmenttiititle', 'turnitintooltwo');
            } else {
                $assignmentname = urldecode($assignmentname);
            }

            $partids = explode(',', $partids);
            if (is_array($partids)) {
                turnitintooltwo_assignment::create_migration_assignment($partids, $courseid, $assignmentname);
            }
        }
        break;

    case "edit_course_end_date":
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        if (has_capability('moodle/course:update', context_system::instance())) {
            $tiicourseid = required_param('tii_course_id', PARAM_INT);
            $tiicoursetitle = required_param('tii_course_title', PARAM_TEXT);
            $enddated = required_param('end_date_d', PARAM_INT);
            $enddatem = required_param('end_date_m', PARAM_INT);
            $enddatey = required_param('end_date_y', PARAM_INT);

            $enddate = mktime(00, 00, 00, $enddatem, $enddated, $enddatey);

            $PAGE->set_context(context_system::instance());

            if (turnitintooltwo_assignment::edit_tii_course_end_date($tiicourseid, $tiicoursetitle, $enddate)) {
                $return["status"] = "success";
                $return["end_date"] = userdate($enddate, get_string('strftimedate', 'langconfig'));
            } else {
                $return["status"] = "fail";
                $return["msg"] = get_string('unanonymiseerror', 'turnitintooltwo');
            }
        } else {
            $return["status"] = "fail";
            $return["msg"] = get_string('nopermissions', 'error', get_string('course:update', 'role'));
        }
        echo json_encode($return);
        break;

    case "check_upgrade":
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }
        $data = '';
        $currentversion = required_param('current_version', PARAM_INT);

        $PAGE->set_context(context_system::instance());

        if (is_siteadmin()) {
            $data = turnitintooltwo_updateavailable($currentversion);
        }
        echo json_encode($data);
        break;

    case "test_connection":
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }
        $data = array("connection_status" => "fail", "msg" => get_string('connecttestcommerror', 'turnitintooltwo'));

        $PAGE->set_context(context_system::instance());
        if (is_siteadmin()) {
            // Initialise API connection.

            $accountid = required_param('accountid', PARAM_RAW);
            $accountshared = required_param('accountshared', PARAM_RAW);
            $url = required_param('url', PARAM_RAW);

            $turnitincomms = new turnitintooltwo_comms($accountid, $accountshared, $url);

            $testingconnection = true; // Provided by Androgogic to override offline mode for testing connection.

            // We only want an API log entry for this if diagnostic mode is set to Debugging.
            if (empty($config)) {
                $config = turnitintooltwo_admin_config();
            }
            if ($config->enablediagnostic != 2) {
                $turnitincomms->set_diagnostic(0);
            }

            $tiiapi = $turnitincomms->initialise_api($testingconnection);

            $class = new TiiClass();
            $class->setTitle('Test finding a class to see if connection works');

            try {
                $response = $tiiapi->findClasses($class);
                $data["connection_status"] = "success";
                $data["msg"] = get_string('connecttestsuccess', 'turnitintooltwo');
            } catch (Exception $e) {
                $turnitincomms->handle_exceptions($e, 'connecttesterror', false);
            }
        }
        echo json_encode($data);
        break;

    case "submit_nothing":

        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $assignmentid = required_param('assignment', PARAM_INT);
        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);

        $PAGE->set_context(context_system::instance());

        if (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) {
            $partid = required_param('part', PARAM_INT);
            $userid = required_param('user', PARAM_INT);
            $turnitintooltwosubmission = new turnitintooltwo_submission();
            $data = $turnitintooltwosubmission->do_tii_nothing_submission($cm, $turnitintooltwoassignment, $partid, $userid);
        } else {
            header("HTTP/1.0 403 Forbidden");
            exit();
        }
        if ( !is_array( $data ) ) {
            header("HTTP/1.0 400 Bad Request");
            echo $data;
            exit();
        } else {
            echo json_encode($data);
        }
        break;

    case "deletesubmission":

        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $submissionid = required_param('paper', PARAM_INT);
        $part = required_param('part', PARAM_INT);
        $assignmentid = required_param('assignment', PARAM_INT);

        $turnitintooltwoassignment = new turnitintooltwo_assignment($assignmentid);
        $turnitintooltwosubmission = new turnitintooltwo_submission($submissionid, "moodle", $turnitintooltwoassignment);

        $cm = get_coursemodule_from_instance("turnitintooltwo", $assignmentid);

        if (has_capability('mod/turnitintooltwo:read', context_module::instance($cm->id))) {
            $istutor = (has_capability('mod/turnitintooltwo:grade', context_module::instance($cm->id))) ? true : false;
        }

        // Allow instructors to delete submission and students to delete if the submission hasn't gone to Turnitin.
        if (($istutor && $submissionid != 0) ||
            ($USER->id == $turnitintooltwosubmission->userid && empty($turnitintooltwosubmission->submission_objectid))) {
            $_SESSION["notice"] = $turnitintooltwosubmission->delete_submission();
        }
        exit();
        break;

    case "begin_migration":

        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $courseid = required_param('courseid', PARAM_INT);
        $turnitintoolid = required_param('turnitintoolid', PARAM_INT);

        include_once("classes/v1migration/v1migration.php");
        $turnitintool = $DB->get_record("turnitintool", array("id" => $turnitintoolid));

        $v1migration = new v1migration($courseid, $turnitintool);

        try {
            $turnitintooltwoid = $v1migration->migrate();
            $cm = get_coursemodule_from_instance("turnitintooltwo", $turnitintooltwoid);

            // The returned CMID will be used for the redirect.
            if ((int)$turnitintooltwoid > 0) {
                echo '{ "id": '.$cm->id.' }';
                exit();
            }
        } catch(Exception $e) {
            header("HTTP/1.0 400 Bad Request");

            $errorresponse = array(
                'error' => get_string('migrationtoolerror', 'turnitintooltwo'),
                'message' => $e->getMessage()
            );

            if ($CFG->debug == DEBUG_DEVELOPER) {
                $errorresponse = array_merge($errorresponse, array(
                    'exception' => $e,
                    'trace' => $e->getTrace()
                ));
            }

            echo json_encode($errorresponse);
            exit();
        }

    case "check_migrated":
        if (!confirm_sesskey()) {
            throw new moodle_exception('invalidsesskey', 'error');
        }

        $turnitintoolid = required_param('turnitintoolid', PARAM_INT);

        // Check if v1 id is linked to a v2 id in the session
        $turnitintooltwoid = 0;
        if ( isset( $_SESSION["migrationtool"][$turnitintoolid] ) && is_numeric( $_SESSION["migrationtool"][$turnitintoolid] ) ) {
            $turnitintooltwoid = intval( $_SESSION["migrationtool"][$turnitintoolid] );
        }
        
        if ( $turnitintooltwoid != 0 ) {
            $cm = get_coursemodule_from_instance("turnitintooltwo", $turnitintooltwoid);
            echo json_encode(array(
                    'migrated' => true,
                    'v2id' => $cm->id
            ));
        } else {
            echo json_encode(array(
                    'migrated' => false
            ));
        }
}