def model_solution(request, task_id):
""" View in the admin """
task = get_object_or_404(Task, pk=task_id)
if request.method == "POST":
solution = Solution(task=task, author=request.user)
formset = ModelSolutionFormSet(request.POST,
request.FILES,
instance=solution)
if formset.is_valid():
try:
solution.save()
# no deleting the old solution:
# delete will cascade on db level deleting checker results and checker
# as this isn't easily prevented just keep the old solution around until the task is deleted
formset.save()
solution.check_solution(request.session)
task.model_solution = solution
task.save()
except:
solution.delete() # delete files
raise # don't commit db changes
else:
formset = ModelSolutionFormSet()
context = {
"formset": formset,
"task": task,
'title': "Model Solution",
'is_popup': True,
}
return render(request, "admin/tasks/task/model_solution.html", context)
def model_solution(request, task_id):
""" View in the admin """
task = get_object_or_404(Task,pk=task_id)
if request.method == "POST":
solution = Solution(task = task, author=request.user)
formset = ModelSolutionFormSet(request.POST, request.FILES, instance=solution)
if formset.is_valid():
try:
solution.save();
# no deleting the old solution:
# delete will cascade on db level deleting checker results and checker
# as this isn't easily prevented just keep the old solution around until the task is deleted
formset.save()
solution.check_solution(request.session)
task.model_solution = solution;
task.save()
except:
solution.delete() # delete files
raise # dont commit db changes
else:
formset = ModelSolutionFormSet()
context = {"formset": formset, "task": task, 'title': "Model Solution", 'is_popup': True, }
return render(request, "admin/tasks/task/model_solution.html", context)
class Grader:
def __init__(self, proformatask, namespace=None):
self._proformatask = proformatask
self.result = None
self.solution = None
self.namespace = namespace
def _save_solution(self, fileDict, version_control=None):
# solution object for submission
logger.debug("save solution")
DEFINED_USER = "******"
self.solution = Solution(
task=self._proformatask,
author=User.objects.get(username=DEFINED_USER))
# save the solution model in the database
self.solution.save()
for index in range(len(fileDict)):
# create solution_file
solution_file = SolutionFile(solution=self.solution)
#save solution in enviroment and get the path
filename = list(fileDict.keys())[index]
#logger.debug('save file ' + filename)
#logger.debug('-> save file ' + filename + ': <' + str(fileDict.values()[index]) + '>')
data = list(fileDict.values())[index]
saved_solution = _save_file(data, solution_file, filename)
#remove the upload path
shorter_saved_solution = saved_solution[len(
settings.UPLOAD_ROOT):] # todo besser +1 und doku
#remove the beginnning slash -> relative path
super_short_solution = shorter_saved_solution[1:]
#save solution file
solution_file.file = super_short_solution
solution_file.save()
if version_control != None:
self.solution.versioncontrol = version_control
def grade(self, fileDict, version_control, subtest_results):
self.solution_files = fileDict
self._save_solution(fileDict, version_control)
logger.debug("grade solution")
#start the checking process
if settings.DETAILED_UNITTEST_OUTPUT:
ProFormAChecker.retrieve_subtest_results = subtest_results
else:
ProFormAChecker.retrieve_subtest_results = False
ProFormAChecker.xml_namespace = self.namespace
self.solution.check_solution(True, keep_sandbox)
logger.debug('get results...')
self.result = self.solution.allCheckerResults()
def get_result(self, response_template, remove_CopyFileChecker=True):
#fileNameList = []
#fileNameList.append("submission.zip")
logger.debug("create response with " + response_template)
lcxml = self._get_solution_xml(self.solution_files, response_template,
remove_CopyFileChecker)
logger.debug("file_grader_post finished")
return lcxml
def __del__(self):
logger.debug("delete")
if self.solution != None:
self.solution.delete()
self.solution = None
def _get_solution_xml(self, file_name, response_template,
remove_CopyFileChecker):
result = self.result
solution = self.solution
# have to set it manually because it will only check visible tests
false_required_hidden_test = False
solution.seperate = True
from datetime import datetime
solution.timestamp = datetime.now().isoformat()
# solution.versioncontrol = True
grader = dict()
grader.update({"name": "praktomat"})
grader.update({"version": version})
for index in range(len(result)):
if result[index].checker.required and not result[
index].checker.public:
if not result[index].passed:
solution.accepted = False
false_required_hidden_test = True
logger.debug("Checker " + str(result[index].checker.order) + ": " +
str(result[index].checker))
# remove 'None' tests from proforma2
res_arr = list(result)
max = len(res_arr) - 1
for index in range(len(res_arr)):
indexReverse = max - index
if not hasattr(res_arr[indexReverse].checker,
'proforma_id') and remove_CopyFileChecker:
# CopyFile checker has no attribute passed!
if not res_arr[indexReverse].passed:
# # todo if fail add Error-Message
logger.error('Checker None FAILED!')
else:
logger.debug("remove Checker: " +
str(res_arr[indexReverse].checker))
res_arr.remove(res_arr[indexReverse])
logger.debug("Remaining Checkers: ")
for index in range(len(res_arr)):
logger.debug("Checker: " + str(res_arr[index].checker))
response_xml = render_to_string(
response_template, {
"solution": solution,
"testResultList":
res_arr if remove_CopyFileChecker else result,
"fileName": file_name,
"grader": grader,
"namespace": self.namespace,
"required_hidden": false_required_hidden_test
})
return response_xml
