/**
* Adds an exercise.
*
* Called when this component receives an HTTP POST request to
* /exercise(/).
* The request body should contain a JSON object representing an array of exercises
*/
public function addExercise()
{
$header = $this->app->request->headers->all();
$body = json_decode($this->app->request->getBody(), true);
$allright = true;
$result = array();
if (isset($body) == true && empty($body) == false) {
foreach ($body as $subexercise) {
// create exercise in DB
$FileTypesArrayTemp = null;
if (isset($subexercise['fileTypes'])) {
$FileTypesArrayTemp = $subexercise['fileTypes'];
unset($subexercise['fileTypes']);
}
$subexerciseJSON = json_encode($subexercise);
$URL = $this->lURL . '/DB/exercise';
$method = 'POST';
if (isset($subexercise['id']) && $subexercise['id'] !== null) {
$method = 'PUT';
$URL = $this->lURL . '/DB/exercise/' . $subexercise['id'];
}
$subexerciseAnswer = Request::custom($method, $URL, $header, $subexerciseJSON);
if ($subexerciseAnswer['status'] == 201) {
$subexerciseOutput = json_decode($subexerciseAnswer['content'], true);
if (isset($subexercise['id'])) {
$result[] = $subexercise;
$subexerciseOutput = $subexercise;
} else {
$result[] = Exercise::decodeExercise($subexerciseAnswer['content']);
}
if (isset($subexerciseOutput['id'])) {
$linkid = $subexerciseOutput['id'];
}
// create attachement in DB and FS
if (isset($subexercise['attachments']) && !empty($subexercise['attachments'])) {
foreach ($subexercise['attachments'] as &$attachment) {
$attachment['exerciseId'] = $linkid;
}
$attachments = $subexercise['attachments'];
$tempAttachments = array();
foreach ($attachments as $attachment) {
$temp = Attachment::createAttachment(null, $attachment['exerciseId'], null, null);
$temp->setFile($attachment);
$tempAttachments[] = $temp;
}
$res = Request::routeRequest('POST', '/attachment', $header, Attachment::encodeAttachment($tempAttachments), $this->_postAttachment, 'attachment');
// checks the correctness of the query
if ($res['status'] >= 200 && $res['status'] <= 299) {
// ...
} else {
$allright = false;
break;
}
}
// create ExerciseFileTypes
if (isset($FileTypesArrayTemp) && !empty($FileTypesArrayTemp)) {
foreach ($FileTypesArrayTemp as $fileType) {
$myExerciseFileType = ExerciseFileType::createExerciseFileType(NULL, $fileType['text'], $linkid);
$myExerciseFileTypeJSON = ExerciseFileType::encodeExerciseFileType($myExerciseFileType);
$URL = $this->lURL . "/DB/exercisefiletype";
$FileTypesAnswer = Request::custom('POST', $URL, $header, $myExerciseFileTypeJSON);
if ($FileTypesAnswer['status'] != 201) {
$allright = false;
break;
}
}
}
if ($allright == false) {
break;
}
} else {
$allright = false;
break;
}
}
}
if ($allright == true) {
$this->app->response->setBody(Exercise::encodeExercise($result));
$this->app->response->setStatus(201);
} else {
$this->app->response->setStatus(409);
}
}
public static function ExtractExerciseFileType($data, $singleResult = false, $FileTypeExtension = '', $isResult = true)
{
// generates an assoc array of an exercise file type by using a defined
// list of its attributes
$res = DBJson::getResultObjectsByAttributes($data, ExerciseFileType::getDBPrimaryKey(), ExerciseFileType::getDBConvert(), $FileTypeExtension);
if ($isResult) {
// to reindex
$res = array_merge($res);
$res = ExerciseFileType::decodeExerciseFileType($res, false);
if ($singleResult == true) {
// only one object as result
if (count($res) > 0) {
$res = $res[0];
}
}
}
return $res;
}
/**
* Processes a submissions
*
* Called when this component receives an HTTP POST request to
* /submission(/).
*/
public function postSubmission()
{
$this->app->response->setStatus(201);
$body = $this->app->request->getBody();
$submissions = Submission::decodeSubmission($body);
// always been an array
$arr = true;
if (!is_array($submissions)) {
$submissions = array($submissions);
$arr = false;
}
$res = array();
foreach ($submissions as $submission) {
$fail = false;
$process = new Process();
$process->setRawSubmission($submission);
$eid = $submission->getExerciseId();
// load processor data from database
$result = Request::routeRequest('GET', '/process/exercise/' . $eid, array(), '', $this->_processorDb, 'process');
$processors = null;
if ($result['status'] >= 200 && $result['status'] <= 299) {
$processors = Process::decodeProcess($result['content']);
} else {
if ($result['status'] != 404) {
$submission->addMessage("Interner Fehler");
$res[] = $submission;
$this->app->response->setStatus(409);
continue;
}
}
$result2 = Request::routeRequest('GET', '/exercisefiletype/exercise/' . $eid, array(), '', $this->_getExerciseExerciseFileType, 'exercisefiletype');
$exerciseFileTypes = null;
if ($result2['status'] >= 200 && $result2['status'] <= 299) {
$exerciseFileTypes = ExerciseFileType::decodeExerciseFileType($result2['content']);
if (!is_array($exerciseFileTypes)) {
$exerciseFileTypes = array($exerciseFileTypes);
}
$filePath = null;
if ($submission->getFile() != null) {
$file = $submission->getFile()->getBody(true);
if ($file !== null) {
$fileHash = sha1($file);
$filePath = '/tmp/' . $fileHash;
if ($submission->getFile()->getDisplayName() != null) {
LProcessor::generatepath($filePath);
file_put_contents($filePath . '/' . $submission->getFile()->getDisplayName(), $file);
$filePath .= '/' . $submission->getFile()->getDisplayName();
} else {
LProcessor::generatepath($filePath);
file_put_contents($filePath . '/tmp', $file);
$filePath .= '/tmp';
}
}
}
// check file type
if ($filePath != null) {
$found = false;
$types = array();
$mimeType = MimeReader::get_mime($filePath);
$foundExtension = isset(pathinfo($filePath)['extension']) ? pathinfo($filePath)['extension'] : '-';
foreach ($exerciseFileTypes as $type) {
$types[] = $type->getText();
$type = explode(' ', str_replace('*', '', $type->getText()));
//echo MimeReader::get_mime($filePath);
if (strpos($mimeType, $type[0]) !== false && (!isset($type[1]) || '.' . $foundExtension == $type[1])) {
$found = true;
break;
}
}
if (!$found && count($exerciseFileTypes) > 0) {
$submission->addMessage("falscher Dateityp \nGefunden: " . $mimeType . " ." . $foundExtension . "\nErlaubt: " . implode(',', $types));
$res[] = $submission;
$this->app->response->setStatus(409);
unlink($filePath);
continue;
}
unlink($filePath);
}
} else {
if ($result2['status'] != 404) {
$submission->addMessage("Interner Fehler");
$res[] = $submission;
$this->app->response->setStatus(409);
continue;
}
}
// process submission
if ($processors !== null) {
if (!is_array($processors)) {
$processors = array($processors);
}
foreach ($processors as $pro) {
$component = $pro->getTarget();
if ($process->getExercise() === null) {
$process->setExercise($pro->getExercise());
}
$process->setParameter($pro->getParameter());
$process->setAttachment($pro->getAttachment());
$process->setTarget($pro->getTarget());
$process->setWorkFiles($pro->getWorkFiles());
//echo Process::encodeProcess($process)."_______";// return;
$result = Request::post($component->getAddress() . '/process', array(), Process::encodeProcess($process));
//echo $result['content'].'_______';
if ($result['status'] >= 200 && $result['status'] <= 299) {
$process = Process::decodeProcess($result['content']);
} else {
$fail = true;
$submission->addMessage("Beim Verarbeiten der Einsendung ist ein Fehler aufgetreten");
if (isset($result['content'])) {
$content = Process::decodeProcess($result['content']);
$submission->setStatus($content->getStatus());
$submission->addMessages($content->getMessages());
}
break;
}
}
}
if ($fail) {
if (isset($submission)) {
$submission->setFile(null);
}
$res[] = $submission;
$this->app->response->setStatus(409);
continue;
}
// upload submission
$uploadSubmission = $process->getSubmission();
if ($uploadSubmission === null) {
$uploadSubmission = $process->getRawSubmission();
if ($uploadSubmission->getFile() != null) {
$file = $uploadSubmission->getFile();
if ($file->getDisplayName() == null) {
$file->setDisplayName($submission->getExerciseName());
}
}
}
if ($uploadSubmission !== null) {
///echo Submission::encodeSubmission($uploadSubmission);return;
$result = Request::routeRequest('POST', '/submission', array(), Submission::encodeSubmission($uploadSubmission), $this->_submission, 'submission');
//var_dump($result);return;
// checks the correctness of the query
if ($result['status'] >= 200 && $result['status'] <= 299) {
$queryResult = Submission::decodeSubmission($result['content']);
$uploadSubmission->setId($queryResult->getId());
$uploadSubmission->setFile($queryResult->getFile());
if ($process->getMarking() !== null) {
$process->getMarking()->setSubmission($queryResult);
}
} else {
$uploadSubmission->addMessage("Beim Speichern der Einsendung ist ein Fehler aufgetreten.");
//var_dump($uploadSubmission); return;
if (isset($result['content'])) {
$content = Submission::decodeSubmission($result['content']);
$uploadSubmission->setStatus($content->getStatus());
$uploadSubmission->addMessages($content->getMessages());
}
$uploadSubmission->setStatus(409);
$res[] = $uploadSubmission;
$this->app->response->setStatus(409);
continue;
}
}
// upload marking
if ($process->getMarking() !== null) {
//echo Marking::encodeMarking($process->getMarking());
$result = Request::routeRequest('POST', '/marking', array(), Marking::encodeMarking($process->getMarking()), $this->_marking, 'marking');
// checks the correctness of the query
if ($result['status'] >= 200 && $result['status'] <= 299) {
$queryResult = Marking::decodeMarking($result['content']);
} else {
$uploadSubmission->addMessage("Beim Speichern der Korrektur ist ein Fehler aufgetreten");
if (isset($result['content'])) {
$content = Marking::decodeMarking($result['content']);
$uploadSubmission->addMessages($content->getMessages());
}
$res[] = $uploadSubmission;
$this->app->response->setStatus(409);
continue;
}
}
$rr = $process->getSubmission();
if ($rr === null) {
$rr = $process->getRawSubmission();
}
$res[] = $rr;
}
if (!$arr && count($res) == 1) {
$this->app->response->setBody(Submission::encodeSubmission($res[0]));
} else {
$this->app->response->setBody(Submission::encodeSubmission($res));
}
}
public function get($functionName, $linkName, $params = array(), $checkSession = true)
{
$positive = function ($input) {
//$input = $input[count($input)-1];
$result = Model::isEmpty();
$result['content'] = array();
foreach ($input as $inp) {
if ($inp->getNumRows() > 0) {
// extract ExerciseFileType data from db answer
$res = ExerciseFileType::ExtractExerciseFileType($inp->getResponse(), false);
$result['content'] = array_merge($result['content'], is_array($res) ? $res : array($res));
$result['status'] = 200;
}
}
return $result;
};
$params = DBJson::mysql_real_escape_string($params);
return $this->_component->call($linkName, $params, '', 200, $positive, array(), 'Model::isProblem', array(), 'Query');
}
if ($mimeType == '') {
continue;
}
$mimeType = explode('.', trim(strtolower($mimeType)));
$ending = isset($mimeType[1]) ? $mimeType[1] : null;
$mimeType = $mimeType[0];
if (FILE_TYPE::checkSupportedFileType($mimeType) == false) {
$errormsg = Language::Get('main', 'invalidFileType', $langTemplate);
array_push($notifications, MakeNotification('warning', $errormsg));
$correctExercise = true;
//break;
} else {
// if mime-type is supported add mimeTypes
$mimes = FILE_TYPE::getMimeTypeByFileEnding(trim(strtolower($mimeType)));
foreach ($mimes as &$mime) {
$mime = ExerciseFileType::createExerciseFileType(null, $mime . '' . (isset($ending) ? ' *.' . $ending : ''), null);
}
$mimeTypes = array_merge($mimeTypes, $mimes);
}
}
}
// save mimeTypes in validated Exercises
$validatedExercises[$key1][$key2]['mime-type'] = $mimeTypes;
}
}
}
$forms = array();
$processors = array();
if (isset($_POST['action'])) {
if ($correctExercise == true) {
// get sheetPDF
public static function ExtractExercise($data, $singleResult = false, $ExerciseExtension = '', $AttachmentExtension = '', $SubmissionExtension = '', $FileTypeExtension = '', $isResult = true)
{
// generates an assoc array of an exercise by using a defined
// list of its attributes
$exercise = DBJson::getObjectsByAttributes($data, Exercise::getDBPrimaryKey(), Exercise::getDBConvert(), $ExerciseExtension);
// generates an assoc array of files by using a defined
// list of its attributes
$attachments = DBJson::getObjectsByAttributes($data, File::getDBPrimaryKey(), File::getDBConvert(), $AttachmentExtension);
// generates an assoc array of submissions by using a defined
// list of its attributes
$submissions = DBJson::getObjectsByAttributes($data, Submission::getDBPrimaryKey(), Submission::getDBConvert(), $SubmissionExtension . '2');
// generates an assoc array of exercise file types by using a defined
// list of its attributes
$fileTypes = DBJson::getObjectsByAttributes($data, ExerciseFileType::getDBPrimaryKey(), ExerciseFileType::getDBConvert(), $FileTypeExtension);
// sets the selectedForGroup attribute
foreach ($submissions as &$submission) {
if (isset($submission['selectedForGroup'])) {
if (isset($submission['id']) && $submission['id'] == $submission['selectedForGroup']) {
$submission['selectedForGroup'] = (string) 1;
} else {
unset($submission['selectedForGroup']);
}
}
}
// concatenates the exercise and the associated filetypes
$exercise = DBJson::concatObjectListResult($data, $exercise, Exercise::getDBPrimaryKey(), Exercise::getDBConvert()['E_fileTypes'], $fileTypes, ExerciseFileType::getDBPrimaryKey(), $FileTypeExtension, $ExerciseExtension);
// concatenates the exercise and the associated attachments
$res = DBJson::concatObjectListResult($data, $exercise, Exercise::getDBPrimaryKey(), Exercise::getDBConvert()['E_attachments'], $attachments, File::getDBPrimaryKey(), $AttachmentExtension, $ExerciseExtension);
// concatenates the exercise and the associated submissions
$res = DBJson::concatObjectLists($data, $res, Exercise::getDBPrimaryKey(), Exercise::getDBConvert()['E_submissions'], $submissions, Submission::getDBPrimaryKey(), $SubmissionExtension . '2', $ExerciseExtension);
if ($isResult) {
// to reindex
$res = array_values($res);
$res = Exercise::decodeExercise($res, false);
if ($singleResult) {
// only one object as result
if (count($res) > 0) {
$res = $res[0];
}
}
}
return $res;
}
