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)