class LessonMeta(object):
check = [{
'get_conflict_obj': lambda resource: resource.model.objects.filter(
hash=resource.obj.hash,
status=Status.NORMAL
).first(),
'conflict_consistency_check': lambda obj, conflict_obj: \
obj.name == conflict_obj.name
and obj.course == conflict_obj.course
}]
belong_to = [{
'root':
'course.models.Course',
'parent':
'course.models.Course',
'get':
lambda self_model, course: self_model.objects.filter(
course=course, status=Status.NORMAL),
'set':
lambda self, course: setattr(self, 'course', course),
}]
subsidiary = [{
'force': {
'creater_id': None,
'last_edit_user_id': None,
},
'subsidiary': {
'practice': {
'get':
lambda self: get_task_object(self.practice),
'set':
lambda self, task: setattr(self, 'practice', task.hash
if task else None),
},
'homework': {
'get':
lambda self: get_task_object(self.homework),
'set':
lambda self, task: setattr(self, 'homework', task.hash
if task else None),
},
'envs': {
'many_to_many':
True,
'get':
lambda self: self.envs.filter(env__status=Env.Status.TEMPLATE),
'set':
lambda self, lesson_envs: self.envs.add(*lesson_envs),
},
},
}]
def get_homework(self, request):
lesson_id =self.query_data.get('lesson', int)
taskArrary = course_modules.LessonPaperTask.objects.filter(lesson__id=lesson_id,
type=course_modules.LessonPaperTask.Type.EXERCISE)
category = self.query_data.get('category')
question_type = self.query_data.get('question_type_list', int)
task_list = []
for t in taskArrary:
task = get_task_object(t.task_hash)
if not task:
continue
if self.query_data.get('search'):
keyword = self.query_data.get('search').strip()
if int(task.hash.split(".")[-1]) == AppType.THEROY:
if keyword in task.content:
task = task
else:
continue
else:
if keyword in task.title:
task = task
else:
continue
task_filter = None
if category:
category_id = category.split("_")[0]
category_type = category.split("_")[-1]
if int(category_id) == int(task.category.id) and int(task.hash.split(".")[-1]) == int(category_type):
if question_type is not None:
if int(question_type) != TestpaperType.OPERATION:
if int(task.hash.split(".")[-1]) == AppType.THEROY:
if int(question_type) == int(task.multiple):
task_filter = task
else:
if int(task.hash.split(".")[-1]) != AppType.THEROY:
task_filter = task
else:
task_filter = task
else:
if question_type is not None:
if int(question_type) != TestpaperType.OPERATION:
if int(task.hash.split(".")[-1]) == AppType.THEROY:
if int(question_type) == int(task.multiple):
task_filter = task
else:
if int(task.hash.split(".")[-1]) != AppType.THEROY :
task_filter = task
else:
task_filter = task
if task_filter is not None:
task_list.append(task_filter)
language = self.request.LANGUAGE_CODE
rows = [serializers.SerializerNew(task, task.score, language).data for task in task_list]
return Response({'rows':rows})
def delay_task_env(request):
try:
task_hash = request.data['task_hash']
except Exception as e:
raise exceptions.ParseError(error.INVALID_PARAMS)
task = get_task_object(task_hash)
if not task:
raise exceptions.NotFound(error.TASK_NOT_EXIST)
try:
env_handler = EnvHandler(request.user)
except MsgException as e:
raise exceptions.NotFound(e.message)
try:
env = env_handler.delay(task)
except MsgException as e:
raise exceptions.PermissionDenied(e.message)
except Exception as e:
raise exceptions.APIException(error.DELAY_TASKENV_ERROR)
data = {
'destroy_time': env.destroy_time,
'remain_seconds': get_remain_seconds(env.destroy_time),
}
return Response(data)
class LessonPaperTaskMeta(object):
"""
课后练习只是导出理论题型， 其它的暂时不考虑
"""
check = [{
'get_conflict_obj':
lambda resource: resource.model.
objects.filter(task_hash=resource.obj.task_hash,
lesson=resource.obj.lesson).first(),
}]
belong_to = [{
'root':
'course.models.Course',
'parent':
'course.models.Lesson',
# 'get': lambda self_model, lesson: self_model.objects.filter(lesson=lesson, task_hash__endswith='.0'),
'get':
lambda self_model, lesson: self_model.objects.filter(lesson=lesson),
'set':
lambda self, lesson: setattr(self, 'lesson', lesson)
}]
subsidiary = [{
'subsidiary': {
'lessonpapertask': {
# todo 保留理论基础题目
'get':
lambda self: getTaskEvent(get_task_object(self.task_hash)),
'set':
lambda self, task: setattr(self, 'task_hash', task.hash
if task else None),
},
},
}]
def web_task_note(video_names, screen_size, resource, user_id):
if not video_names:
return
from django.conf import settings
from common_remote.setting import _GUACAMOLE_RECORDING_DIR_NAME
from x_note.models import Note
note = Note.objects.filter(user_id=user_id,
resource='%s' % resource).first()
if note:
content = note.content
for video_name in video_names:
content = content + '\n<video src="{video_file}" data-screen-size="{screen_size}" style="width: 100%;min-height: 600px;" controls></video>\n'.format(
video_file=os.path.join(settings.MEDIA_URL,
_GUACAMOLE_RECORDING_DIR_NAME,
video_name),
screen_size=screen_size,
)
note.content = content
try:
note.save()
except:
pass
else:
# 通知更新报告
try:
task = get_task_object(resource)
except:
pass
else:
practice_message.send_task_user_data(
task, note.user, practice_message.MESSAGE_CODE.CONVERTED)
def get_correct_answer(self, event, pk):
test_list_cache = CacheProduct("test_list_cache")
test_score_cache = CacheProduct("test_score_cache")
key = "%d_%d" % (int(pk), event.id)
test_list_dateil = test_list_cache.get(key, None)
test_score_dateil = test_score_cache.get(key, None)
if test_list_dateil is None or test_score_dateil is None:
task_arrary = self.get_event_task(pk)
answer_dict = {}
score_dict = {}
for t in task_arrary:
task = practice_api.get_task_object(t.task_hash)
score_dict[int(task.id)] = t.task_score
if task.answer is None:
is_dynamic_env = hasattr(task, "is_dynamic_env") if hasattr(task, "is_dynamic_env") else False
if is_dynamic_env:
task_answer = _("x_dynamic_answer")
else:
task_answer = _("x_answer_not_generated")
else:
task_answer = task.answer
answer_dict[int(task.id)] = str(task_answer)
test_list_cache.set(key, answer_dict, DEFAULT_CACHE_TIME)
test_score_cache.set(key, score_dict, DEFAULT_CACHE_TIME)
else:
answer_dict = test_list_dateil
score_dict = test_score_dateil
return answer_dict, score_dict
def execute_script(request):
try:
task_hash = request.data['task_hash']
backend_admin = bool(request.data.get('from_backend'))
vm_id = request.data['vm_id']
mode = int(request.data['mode'])
except Exception as e:
raise exceptions.ParseError(error.INVALID_PARAMS)
task = get_task_object(task_hash)
if not task:
raise exceptions.NotFound(error.TASK_NOT_EXIST)
try:
env_handler = EnvHandler(request.user,
backend_admin=backend_admin,
remote=True)
except MsgException as e:
raise exceptions.NotFound(e.message)
try:
result = env_handler.execute_script(task, vm_id, mode)
except MsgException as e:
raise exceptions.PermissionDenied(e.message)
except Exception as e:
logger.error(
'execute script error[task_hash=%s, user_id=%s, vm_id=%s]: %s' %
(task_hash, request.user.id, vm_id, e))
raise exceptions.APIException(error.EXECUTE_ENVTERMINAL_SCRIPT_ERROR)
data = {'result': result}
return Response(data)
def create_env(user_id, task_hash, backend_admin):
try:
user = User.objects.get(pk=user_id)
except User.DoesNotExist as e:
raise exceptions.NotFound(error.USER_NOT_EXIST)
task = get_task_object(task_hash)
if not task:
raise exceptions.NotFound(error.TASK_NOT_EXIST)
executor = get_executor(user_id, task_hash, backend_admin)
try:
env_handler = EnvHandler(user,
backend_admin=backend_admin,
executor=executor)
except MsgException as e:
raise exceptions.NotFound(e.message)
try:
task_env = env_handler.create(task)
except MsgException as e:
raise exceptions.PermissionDenied(e.message)
except PoolFullException as e:
raise exceptions.PermissionDenied(json.dumps(e.executor_info),
code='PoolFull')
except Exception as e:
logger.error('create taskenv error[task_hash=%s, user_id=%s]: %s' %
(task_hash, user.id, e))
raise exceptions.APIException(error.CREATE_TASK_ENV_ERROR)
return task_env
def markdown(request, **kwargs):
context = kwargs.get('menu')
# type_id = request.GET.get("type_id")
task_hash = request.GET.get("task_hash")
if task_hash:
task = get_task_object(task_hash)
wp_base64 = base64.b64encode(task.official_writeup)
context.update({"markdown": wp_base64})
return render(request, 'practice/web/markdown.html', context)
def check_auth(request, *args, **kwargs):
user = request.user
practice = get_task_object(kwargs.get('task_hash'))
practice_event = practice.event
if not user.is_superuser and not practice_event.create_user == user:
if not practice_event.auth == AuthAndShare.AuthMode.ALL_AUTH_MODE:
if user.faculty not in practice_event.auth_faculty.all() and user.major not in practice_event.auth_major.all() and user.classes not in practice_event.auth_classes.all():
return render(request, 'web/404.html', context={})
return func(request, *args, **kwargs)
def get_task(task_hash):
cache = CacheProduct("get_task")
task = cache.get(task_hash)
if task:
return task
task = practice_api.get_task_object(task_hash)
if task:
cache.set(task_hash, task, 300)
return task
def task_detail(request, typeid, task_hash, **kwargs):
context = {
'menu': kwargs.get('menu').get('menu'),
'type_id': typeid,
'task_hash': task_hash,
}
knowledges_list = None
if int(typeid) == 0:
task = get_task_object(task_hash)
if task.knowledges:
knowledges_list = task.knowledges.split(",")
ua.practice_task(
request.user,
type=_(TYPE_NAME_MAP[int(typeid)]),
task=task.content,
)
context.update({
'knowledges_list':knowledges_list,
})
return render(request, 'practice/web/do_task.html', context)
else:
from common_env.models import Env
task = get_task_object(task_hash)
if task.knowledges:
knowledges_list = task.knowledges.split(",")
ua.practice_task(
request.user,
type=_(TYPE_NAME_MAP[int(typeid)]),
task=task.title,
)
task_env = task.envs.filter(
env__status__in=Env.ActiveStatusList,
env__user=request.user
).first()
context.update({
'task': task,
'task_env': task_env,
'markdown': task.markdown,
'knowledges_list': knowledges_list,
})
return render(request, 'practice/web/do_task2.html', context)
def task_network(request, typeid, task_hash):
context = {}
url = request.GET.get('url', '')
if url == '':
raise Exception('url not find')
task = get_task_object(task_hash)
context['task'] = task
context['guacamole_url'] = url
context['task_hash'] = task_hash
context['type_id'] = str(typeid)
return render(request, 'practice/web/practice_network.html', context)
def lesson_categories(self,request):
lesson_id = request.GET.get("lesson_id")
taskArrary = course_modules.LessonPaperTask.objects.filter(lesson__id=lesson_id, type=course_modules.LessonPaperTask.Type.EXERCISE)
task_list = []
lesson_categories_list = []
for t in taskArrary:
task = get_task_object(t.task_hash)
if task.category not in lesson_categories_list:
lesson_categories_list.append(task.category)
task_list.append(task)
rows = [serializers.LessonCategoriesSerializer(task.category, task.hash).data for task in task_list]
return Response({'rows': rows})
def copy_task(taskhash):
p_type = get_type_by_hash(taskhash)
try:
new_task = get_task_object(taskhash)
except:
return None
new_task.pk = None
new_task.is_copy = True
new_task.hash = generate_task_hash(type=p_type)
new_task.save()
return new_task.hash
def exampaper_task(self, request, pk):
exercise = self.request.query_params.get('exercise', None)
try:
lesson_obj = course_modles.Lesson.objects.get(pk=pk)
except:
raise Http404()
lesson_paper_task_type = course_modles.LessonPaperTask.Type.EXERCISE if exercise else lesson_obj.type
taskArrary = course_modles.LessonPaperTask.objects.filter(
lesson=lesson_obj, type=lesson_paper_task_type)
rows = []
done = False
score = 0
all_score = 0
myAnswer = []
tprs = course_modles.LessonPaperRecord.objects.filter(
lesson=pk, submit_user=request.user)
if tprs.exists():
done = True
for tpr in tprs:
right_answer = practice_api.get_task_answer(
tpr.task_hash, request.user)
tmp = {
'taskId': tpr.task_hash,
'answer': tpr.answer,
'rightAnswer': right_answer
}
score = score + tpr.score
myAnswer.append(tmp)
for t in taskArrary:
task = practice_api.get_task_object(t.task_hash)
rows.append(Serializer(task, t).data)
all_score = all_score + t.score
return Response({
'response_data': {
'tasks': rows,
'done': done,
'myAnswer': myAnswer,
'score': score,
'all_score': all_score
},
'error_code': 0
})
def testpaper_task(self, request, pk):
taskArrary = TestPaperTask.objects.filter(test_paper=pk)
rows = []
done = False
score = 0
all_score = 0
myAnswer = []
tprs = TestPaperRecord.objects.filter(test_paper=pk, submit_user=request.user)
if tprs.exists():
done = True
for tpr in tprs:
right_answer = practice_api.get_task_answer(tpr.task_hash, request.user)
tmp = {
'taskId': tpr.task_hash,
'answer': tpr.answer,
'rightAnswer': right_answer
}
score = score + tpr.score
myAnswer.append(tmp)
for t in taskArrary:
task = practice_api.get_task_object(t.task_hash)
rows.append(Serializer(task, t).data)
all_score = all_score + t.score
return Response(
{
'response_data':
{
'tasks': rows, 'done': done,
'myAnswer': myAnswer, 'score': score,
'all_score': all_score
},
'error_code': 0
})
class EventViewSet(base_api.EventViewSet):
serializer_class = mserializers.EventSerializer
@detail_route(methods=['get'], )
@api_auth_permission
def exam_task(self, request, pk):
try:
event = event_models.Event.objects.get(pk=pk)
except Exception, e:
raise exceptions.PermissionDenied(error.EVENT_NOT_START)
taskArrary = event_models.EventTask.objects.filter(event=pk)
rows = []
done = False
score = 0
all_score = 0
myAnswer = []
eus = event_models.EventUserSubmitLog.objects.filter(event_task__event=pk, user=request.user)
if eus.exists():
done = True
try:
x_note = Note.objects.get(resource=event.hash, user=request.user)
writeup_score = x_note.score
except:
writeup_score = 0
score = score + writeup_score
for e in eus:
right_answer = practice_api.get_task_answer(e.event_task.task_hash, request.user)
tmp = {
'taskId': e.event_task.task_hash,
'answer': e.answer,
}
if event.extendevent.ans_display_method == 0:
tmp['rightAnswer'] = right_answer
if event.extendevent.ans_display_method == 1:
if event.end_time < timezone.now():
tmp['rightAnswer'] = right_answer
score = score + e.score
myAnswer.append(tmp)
for t in taskArrary:
task = practice_api.get_task_object(t.task_hash)
rows.append(Serializer(task, t).data)
all_score = all_score + t.task_score
'''
获取试卷状态：1.已经结束；2.正在进行；3.尚未开始
'''
now = timezone.now().strftime('%Y-%m-%d %H:%M:%S')
if (event.start_time.strftime('%Y-%m-%d %H:%M:%S') <= now) and (
event.end_time.strftime('%Y-%m-%d %H:%M:%S') > now):
process = 0
elif (event.start_time.strftime('%Y-%m-%d %H:%M:%S') > now):
process = 1
else:
process = 2
return Response(
{
'response_data':
{
'tasks': rows, 'done': done,
'myAnswer': myAnswer, 'score': score,
'all_score': all_score,
'score_status': event.extendevent.score_status,
'rank_status': event.extendevent.rank_status
},
'error_code': 0,
'process': process
})
def generate_docx(request):
rows = []
scores = []
context = {}
single_selections = []
multiple_selections = []
judgment_selections = []
analysis_questions = []
base_path = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
download_path = 'media/word/testpaper{}.docx'.format(int(time.time()))
save_path = os.path.join(base_path, download_path)
language = getattr(request, 'LANGUAGE_CODE', u'zh-hans')
if language == 'en':
JudgeTitle = 'Part 1:Judgment Problem'
SingleChoice = 'Part 2:Single Choice'
MultipleChoice = 'Part 3:Multiple Choice'
ScoreCount = '{} tasks and {} PTS in total'
Score = '({}PT for this task)'
else:
JudgeTitle = u'一、判断题'
SingleChoice = u'二、单项选择题'
MultipleChoice = u'三、多项选择题'
ScoreCount = u'共{}赛题 满分{}PT'
Score = u'（本题{}PT）'
testpaper_id = int(request.GET.get("data"))
testpaper = capability_models.TestPaper.objects.filter(
id=testpaper_id).first()
if testpaper:
taskArrary = TestPaperTask.objects.filter(test_paper=testpaper)
if taskArrary.exists():
for t in taskArrary:
task = get_task_object(t.task_hash)
rows.append(Serializer(task, t).data)
context['tasks'] = rows
for task in context["tasks"]:
if task.has_key("is_choice_question"):
scores.append(task['score'])
if _judgment_question_type(
task["hash"]
) == theory_models.ChoiceTask.TopicProblem.SINGLE:
single_selections.append(task)
elif _judgment_question_type(
task["hash"]
) == theory_models.ChoiceTask.TopicProblem.MULTIPLE:
multiple_selections.append(task)
else:
judgment_selections.append(task)
else:
analysis_questions.append(task)
context['name'] = testpaper.name
context['allScore'] = sum(scores)
context['number'] = len(single_selections) + len(
multiple_selections) + len(judgment_selections)
document = Document()
document.styles['Normal'].font.name = u'宋体'
document.styles['Normal']._element.rPr.rFonts.set(
qn('w:eastAsia'), u'宋体')
p = document.add_heading(context['name'])
p.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
document.add_heading(
ScoreCount.format(context['number'], context['allScore']), 4)
document.add_heading(JudgeTitle, 2)
for t in judgment_selections:
document.add_paragraph(
str(judgment_selections.index(t) + 1) + u'、' +
t["content"])
document.add_paragraph(Score.format(t['score']))
for num, value in t["options_dsc"].items():
document.add_paragraph(u"{}、".format(num) +
t["options_dsc"][num])
document.add_heading(SingleChoice, 2)
for t in single_selections:
document.add_paragraph(
str(single_selections.index(t) + 1) + u'、' + t["content"])
document.add_paragraph(Score.format(t['score']))
for num, value in t["options_dsc"].items():
document.add_paragraph(u"{}、".format(num) +
t["options_dsc"][num])
document.add_heading(MultipleChoice, 2)
for t in multiple_selections:
document.add_paragraph(
str(multiple_selections.index(t) + 1) + u'、' +
t["content"])
document.add_paragraph(Score.format(t['score']))
for num, value in t["options_dsc"].items():
document.add_paragraph(u"{}、".format(num) +
t["options_dsc"][num])
# document.add_heading(u'四、分析题', 2)
# for t in analysis_questions:
# document.add_paragraph(str(analysis_questions.index(t) + 1) + u'、' + t.get("title", None))
# document.add_paragraph(u'（本题{}PT）'.format(t['score']))
# document.add_paragraph(t.get("content", None))
# 保存文件
if os.path.exists(os.path.join(base_path, 'media/word')):
document.save(save_path)
else:
os.makedirs(os.path.join(base_path, 'media/word'))
document.save(save_path)
has_analysis = "yes" if analysis_questions else "no"
return Response(data={
"url": download_path,
"has_analysis": has_analysis,
"paper_name": testpaper.name
},
status=status.HTTP_200_OK)
def ret_testpaper_detail(request, testpaper_id):
if request.method == "GET":
context = {}
single_selections = []
multiple_selections = []
judgment_selections = []
analysis_questions = []
testpaper_id = int(testpaper_id)
testpaper = capability_models.TestPaper.objects.get(id=testpaper_id)
context['name'] = testpaper.name
context['number'] = testpaper.task_number
context['allScore'] = testpaper.task_all_score
taskArrary = TestPaperTask.objects.filter(test_paper=testpaper)
rows = []
for t in taskArrary:
task = get_task_object(t.task_hash)
rows.append(Serializer(task, t).data)
context['tasks'] = rows
for task in context["tasks"]:
if task.has_key("is_choice_question"):
if _judgment_question_type(
task["hash"]
) == theory_models.ChoiceTask.TopicProblem.SINGLE:
single_selections.append(task)
elif _judgment_question_type(
task["hash"]
) == theory_models.ChoiceTask.TopicProblem.MULTIPLE:
multiple_selections.append(task)
else:
judgment_selections.append(task)
else:
analysis_questions.append(task)
tasks = dict(judgment_selections=judgment_selections,
single_selections=single_selections,
multiple_selections=multiple_selections,
analysis_questions=analysis_questions)
context['tasks'] = tasks
return response.Response({'error_code': 0, 'response_data': context})
elif request.method == "POST":
name = request.data['examname']
if int(testpaper_id) == 0 and TestPaper.objects.filter(
name=name).exists():
return response.Response({'error_code': 1})
questions = request.data['questions']
list = questions.values()
list.sort(key=lambda k: (k.get('qorder', 0)))
number = 0
allScore = 0
for questions in list:
number = number + 1
allScore = allScore + int(questions['score'])
event_teachers = request.data.get('teacher')
if int(testpaper_id) > 0:
testPaper = TestPaper.objects.get(id=testpaper_id)
testPaper.name = name
testPaper.task_number = number
testPaper.task_all_score = allScore
testPaper.teacher = ",".join(
event_teachers) if event_teachers else None
testPaper.save()
tpt = TestPaperTask.objects.filter(test_paper=testPaper)
for t in tpt:
t.delete()
else:
testPaper = TestPaper.objects.create(
name=name,
task_number=number,
task_all_score=allScore,
create_time=timezone.now(),
create_user=request.user,
public=True,
)
for questions in list:
TestPaperTask.objects.create(test_paper=testPaper,
task_hash=questions['hash'],
score=questions['score'])
cache = CacheProduct(
"%s-%s" % (TestPaperViewSet.__module__, TestPaperViewSet.__name__))
delete_cache(cache)
return response.Response({'error_code': 1})
def get_task(**kwargs):
task_hash = kwargs.get('task_hash', None)
task = get_task_object(task_hash)
return task
def handler_task_list(request, pk):
examname = request.data.get('examname', '')
examDescription = request.data.get('examDescription', '')
datas = request.data.get('data', '')
event_exam_id = int(pk)
if request.method == "GET":
rows = []
copyCap = request.query_params.get('copyCap', '')
if copyCap.isdigit():
taskArrary = TestPaperTask.objects.filter(test_paper__id=copyCap)
for t in taskArrary:
task = get_task_object(t.task_hash)
data = SerializerNew(task, t, 'TestPaperTask').data
rows.append(data)
else:
taskArrary = event_models.EventTask.objects.filter(
event__id=event_exam_id)
for t in taskArrary:
task = get_task_object(t.task_hash)
data = SerializerNew(task, t).data
rows.append(data)
return Response(data=rows, status=status.HTTP_200_OK)
if not datas or not json.loads(datas):
raise exceptions.ParseError(ExamResError.NO_EXAM_QUESTIONS)
datas = json.loads(datas)
if not examname:
raise exceptions.ParseError(ExamResError.WARN_MESSAGES_8)
if event_models.Event.objects.filter(
type=event_models.Event.Type.EXAM,
name=examname).exclude(pk=event_exam_id).exists():
raise exceptions.ParseError(ExamResError.WARN_MESSAGES_9)
event_exam = event_models.Event.objects.filter(id=event_exam_id)
if not event_exam:
raise exceptions.NotFound(ExamResError.NOT_FOUND_EXAM)
event_exam = event_exam[0]
event_exam.name = examname
event_exam.description = examDescription
event_exam.save()
event_task_list = event_models.EventTask.objects.filter(event=event_exam)
if event_task_list:
# 判断原来是否存在初始数据, 批量删除
try:
event_models.EventTask.objects.filter(event=event_exam).delete()
except ProtectedError:
raise exceptions.ParseError(ExamResError.CANNT_CHANGE_HAS_DONE)
task_hashs = []
for data in datas:
task_hashs.append(data['hash'])
task_copy_hashs = practice_api.copy_task_by_hash(task_hashs)
event_task_list = []
new_topic_list = []
for data in datas:
task_type = TaskHandler.get_type_by_hash(data['hash'])
event_task = event_models.EventTask(
event=event_exam,
task_hash=task_copy_hashs[task_hashs.index(data['hash'])],
task_score=data['score'],
type=task_type,
seq=1,
)
event_task_list.append(event_task)
new_topic_dict = {}
if TaskHandler.get_type_by_hash(data.get("hash")) == 0:
new_topic = ChoiceTask.objects.filter(hash=task_copy_hashs[
task_hashs.index(data.get("hash"))]).first()
if new_topic is None:
raise exceptions.ParseError(ExamResError.TESTPAPER_ABNORMAL)
try:
new_topic_dict["content"] = new_topic.content
new_topic_dict["id"] = new_topic.id
new_topic_dict["option"] = new_topic.option
new_topic_dict["score"] = data['score']
new_topic_dict["multiple"] = new_topic.multiple
new_topic_list.append(new_topic_dict)
except ProtectedError:
raise exceptions.ParseError(ExamResError.TESTPAPER_ABNORMAL)
else:
tmp = practice_api.get_task_info(task_copy_hashs[task_hashs.index(
data.get("hash"))],
backend=True)
if tmp is None:
raise exceptions.ParseError(ExamResError.TESTPAPER_ABNORMAL)
try:
new_topic_dict["title"] = tmp["title"]
new_topic_dict["content"] = tmp["content"]
new_topic_dict["id"] = tmp['id']
new_topic_dict["hash"] = tmp["hash"]
new_topic_dict["file_url"] = tmp["file_url"] if tmp.has_key(
"file_url") else None
new_topic_dict["attach_url"] = tmp["file_url"].get(
"url", None) if tmp.get("file_url", None) else None
new_topic_dict["url"] = tmp["url"] if tmp.get("url",
None) else None
new_topic_dict["is_dynamic_env"] = tmp["is_dynamic_env"]
new_topic_dict["solving_mode"] = tmp["solving_mode"]
new_topic_dict["option"] = None
new_topic_dict["score"] = data['score']
new_topic_dict["multiple"] = 4
new_topic_list.append(new_topic_dict)
except ProtectedError:
raise exceptions.ParseError(ExamResError.TESTPAPER_ABNORMAL)
datas = json.dumps(new_topic_list)
json_name = str(event_exam.hash + ".json")
json_url = os.path.join(settings.BASE_DIR,
'media/event_exam/json/{}'.format(json_name))
with open(
json_url,
"w",
) as f:
f.write(datas)
f.close()
event_models.EventTask.objects.bulk_create(event_task_list)
return Response(data={'type': 'success'}, status=status.HTTP_200_OK)
def task_env(request):
if request.method == 'GET':
try:
task_hash = request.query_params['task_hash']
backend_admin = bool(request.query_params.get('from_backend'))
is_complete = bool(request.query_params.get('is_complete'))
except Exception as e:
raise exceptions.ParseError(error.INVALID_PARAMS)
task = get_task_object(task_hash)
if not task:
raise exceptions.NotFound(error.TASK_NOT_EXIST)
try:
env_handler = EnvHandler(request.user,
backend_admin=backend_admin,
remote=True)
except MsgException as e:
raise exceptions.NotFound(e.message)
try:
data = env_handler.get(task, is_complete=is_complete)
except MsgException as e:
raise exceptions.NotFound(e.message)
return Response(data)
elif request.method == 'POST':
try:
task_hash = request.data['task_hash']
backend_admin = bool(request.data.get('from_backend'))
_mode = request.data.get('_mode')
except Exception as e:
raise exceptions.ParseError(error.INVALID_PARAMS)
if _mode == 'remove_queue':
executor = get_executor(request.user.id, task_hash, backend_admin)
pool.remove_executor(executor)
return Response({})
task_env = create_env(request.user.id, task_hash, backend_admin)
data = {'task_env_id': task_env.id, 'env_id': task_env.env.id}
return Response(data)
else:
try:
task_hash = request.data['task_hash']
backend_admin = bool(request.data.get('from_backend'))
except Exception as e:
print e
raise exceptions.ParseError(error.INVALID_PARAMS)
task = get_task_object(task_hash)
if not task:
raise exceptions.NotFound(error.TASK_NOT_EXIST)
try:
env_handler = EnvHandler(request.user,
backend_admin=backend_admin,
remote=True)
except MsgException as e:
raise exceptions.NotFound(e.message)
try:
env_handler.delete(task)
except MsgException as e:
raise exceptions.PermissionDenied(e.message)
except Exception as e:
logger.error('delete taskenv error[task_hash=%s, user_id=%s]: %s' %
(task_hash, request.user.id, e))
raise exceptions.APIException(error.DELETE_TASK_ENV_ERROR)
return Response({})
def handler_task_list(request, testpaper_id):
examname = request.data.get('examname', '')
examDescription = request.data.get('examDescription', '')
datas = request.data.get('data', '')
testpaper_id = int(testpaper_id)
if request.method == "GET":
rows = []
if testpaper_id != 0:
taskArrary = TestPaperTask.objects.filter(
test_paper__id=testpaper_id)
for t in taskArrary:
task = get_task_object(t.task_hash)
if not task:
continue
data = SerializerNew(task, t).data
rows.append(data)
return Response(data=rows, status=status.HTTP_200_OK)
if not datas or not json.loads(datas):
raise exceptions.ParseError(PracticeResError.NO_EXAM_QUESTIONS)
if not examname:
raise exceptions.ParseError(PracticeResError.WARN_MESSAGES_7)
if capability_models.TestPaper.objects.filter(
status=capability_models.TestPaper.Status.NORMAL,
name=examname).exclude(pk=testpaper_id).exists():
raise exceptions.ParseError(PracticeResError.WARN_MESSAGES_6)
datas = json.loads(datas)
number = 0
allScore = 0
for data in datas:
number = number + 1
allScore = allScore + float(data['score'])
logo_url = request.data.get("logo", None)
if testpaper_id == 0:
# 新增
# 创建一张试卷
if logo_url is not None and logo_url != '':
logo = save_image(logo_url)
else:
logo = None
testPaper = capability_models.TestPaper.objects.create(
name=examname,
task_number=number,
task_all_score=allScore,
introduction=examDescription,
create_time=timezone.now(),
create_user=request.user,
logo=logo,
public=True,
)
else:
testPaper = capability_models.TestPaper.objects.filter(id=testpaper_id)
if not testPaper:
raise exceptions.NotFound(PracticeResError.NOT_FOUND_EXAM)
testPaper = testPaper[0]
testPaper.name = examname
testPaper.task_number = number
testPaper.task_all_score = allScore
testPaper.introduction = examDescription
if logo_url is not None and logo_url != '':
logos = save_image(logo_url)
testPaper.logo = logos
testPaper.save()
event_task_list = TestPaperTask.objects.filter(test_paper=testPaper)
if event_task_list:
# 判断原来是否存在初始数据, 批量删除
try:
event_task_list.delete()
except ProtectedError:
raise exceptions.ParseError(
PracticeResError.CANNT_CHANGE_HAS_DONE)
event_task_list = []
for data in datas:
# copy_hash = copy_task(data['hash'])
# if not copy_hash:
# continue
hash_list = []
if int(data['hash'].split('.')[-1]) != 0:
hash_list.append(data['hash'])
task_handler_class = TaskHandler
copy_hash = task_handler_class.handle_tasks(hash_list)
copy_hash = copy_hash[0]
else:
copy_hash = copy_task(data['hash'])
if not copy_hash:
continue
event_task = TestPaperTask(test_paper=testPaper,
task_hash=copy_hash,
score=data['score'])
event_task_list.append(event_task)
TestPaperTask.objects.bulk_create(event_task_list)
cache = CacheProduct(
"%s-%s" % (TestPaperViewSet.__module__, TestPaperViewSet.__name__))
delete_cache(cache)
return Response(data={'type': 'success'}, status=status.HTTP_200_OK)
