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 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 get_event_task(self, pk):
task_cache = CacheProduct("get_event_task")
key = pk
event_task = task_cache.get(key, None)
if event_task:
return event_task
event_task = event_models.EventTask.objects.filter(event=pk)
if event_task:
task_cache.set(key, event_task, DEFAULT_CACHE_TIME)
return event_task
def get_event_by_id(id):
event_cache = CacheProduct('event')
key = 'get_event_id_%s' % id
event = event_cache.get(key, None)
if event:
return event
try:
event = event_models.Event.objects.get(id=id)
except event_models.Event.DoesNotExist as e:
return None
if event:
event_cache.set(key, event, DEFAULT_CACHE_TIME)
return event
def clear_cls_cache(cls):
# 暂时删除所有缓存
from django.core.cache import cache
cache.clear()
if not isinstance(cls, (list, tuple)):
cls = [cls]
for c in cls:
if isinstance(c, (six.string_types, six.text_type)):
try:
c = import_string(c)
except:
continue
cache_view_name = _generate_cache_view_name(c)
cache = CacheProduct(cache_view_name)
delete_cache(cache)
def cache(self):
if not hasattr(self, '_cache'):
cls = self.__class__
self._cache = CacheProduct('{}.{}'.format(cls.__module__,
cls.__name__))
return self._cache
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)
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})
from rest_framework.decorators import api_view
from rest_framework.permissions import IsAuthenticated
from rest_framework.viewsets import ReadOnlyModelViewSet
from rest_framework.response import Response
from common_auth.models import User
from common_framework.utils.cache import CacheProduct, delete_cache, cache_wrapper
from common_framework.utils.rest.mixins import CacheModelMixin
from common_message.models import Message
from common_message.serializer import MessageSerializer
MESSAGE_TYPE_SYSTEM = 0
MESSAGE_TYPE_APP = 1
_cache_instance = CacheProduct("common_message")
logger = logging.getLogger(__name__)
def get_users(user, faculty, major, classes, team):
users = []
if not user:
queryset = User.objects.filter()
if team:
queryset |= queryset.filter(team=team)
if major:
queryset |= queryset.filter(major=major)
if faculty:
def delete_event_cache(id):
event_cache = CacheProduct('event')
key = 'get_event_id_%s' % id
event_cache.set(key, None, DEFAULT_CACHE_TIME)
from common_framework.utils.cache import CacheProduct, cache_wrapper
from common_framework.utils.constant import Status
from course import models as course_models
_cache_instance = CacheProduct("course")
@cache_wrapper(_cache_instance, cache_age=20)
def get_lesson(course_id):
return course_models.Lesson.objects.filter(course__id=course_id,
status=Status.NORMAL)
def __new__(cls, *args, **kwargs):
obj = super(CacheModelMixin, cls).__new__(cls, *args, **kwargs)
view_name = _generate_cache_view_name(cls)
obj.cache = CacheProduct(view_name)
return obj