def test_question_deserializer_valid_json(self):
question_json = '{"id": 2, "question_text": "text", "question_catalogue": 1}'
stream = BytesIO(question_json)
data = JSONParser().parse(stream)
serializer = QuestionSerializer(data=data)
self.assertTrue(serializer.is_valid())
question = serializer.object
question.save()
#
question_from_db = Question.objects.get(pk=2)
self.assertEqual(question.question_text, "text")
self.assertEqual(question_from_db.question_text, "text")
#
self.assertTrue(type(question.question_catalogue) is QuestionCatalogue)
self.assertEqual(question.question_catalogue.pk,
self.question_catalogue.pk)
self.assertEqual(question.question_catalogue.catalogue_name,
self.question_catalogue.catalogue_name)
#
self.assertTrue(
type(question_from_db.question_catalogue) is QuestionCatalogue)
self.assertEqual(question_from_db.question_catalogue.pk,
self.question_catalogue.pk)
self.assertEqual(question_from_db.question_catalogue.catalogue_name,
self.question_catalogue.catalogue_name)
def save_question_data(data):
serializer = QuestionSerializer(data=data)
if serializer.is_valid():
try:
question = serializer.save()
# Save Question Choices
for i in range(1, 5):
question_choice_get = "question_choice_" + str(i)
choice_img_url = "question_choice_" + str(i) + "_image_url"
if i == int(data.get("correct_choice")):
QuestionChoice.objects.create(
choice_text=data.get(question_choice_get),
choice_img_url=data.get(choice_img_url),
is_right_choice=True,
question=question
)
else:
QuestionChoice.objects.create(
choice_text=data.get(question_choice_get),
choice_img_url=data.get(choice_img_url),
question=question
)
# Save Question Chapter Mapping
QuestionChapterMapping.objects.create(question=question, chapter_id=data.get("chapter_id"))
return Response(serializer.data, status=status.HTTP_201_CREATED)
except Exception as err:
print("Exception occurred in Question Post \n", err)
return Response(status=status.HTTP_400_BAD_REQUEST)
print("Exception in Question Post\n", serializer.errors)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_expected_fields(self):
"""Tests expected serializer fields
'title',
'body'
"""
question_data = factory.build(dict, FACTORY_CLASS=QuestionFactory)
serializer = QuestionSerializer(data=question_data)
is_valid = serializer.is_valid()
print("Keys: ", serializer.validated_data.keys())
print("Errors: ", serializer.errors)
assert is_valid, "serializer validation test"
assert serializer.validated_data.keys() == set(['title', 'body'])
def questions(self, request, pk=None):
lesson = self.get_object()
questions = Question.objects.filter(lesson=lesson.id)
serialized = QuestionSerializer(questions, many=True)
if not questions:
return Response(status=status.HTTP_404_NOT_FOUND, data={'message': 'This lesson has not questions'})
return Response(status=status.HTTP_200_OK, data=serialized.data)
class AnswerSerializer(ModelSerializer):
writer = UserOtherDetailsSerializer(read_only=True)
question = QuestionSerializer()
no_of_comments = SerializerMethodField()
class Meta:
model = Answer
fields = [
'id',
'question',
'writer',
'date_written',
'time_written',
'body',
'no_of_upvotes',
'no_of_downvotes',
'no_of_views',
'no_of_comments',
]
def get_no_of_comments(self, obj):
try:
return obj.getComments()
except:
return 0
class AudioSerializer(serializers.ModelSerializer):
tag = serializers.SlugRelatedField(many=True,
slug_field='name',
read_only=True)
update_tag = serializers.ListField(
child=serializers.CharField(max_length=100), write_only=True)
result = ResultSerializer(required=False)
question = QuestionSerializer(required=False, read_only=True)
def create(self, validated_data):
tag_name = validated_data.pop('update_tag')
instance = super().create(validated_data)
tags = []
for name in tag_name:
tag, created = Tag.objects.get_or_create(name=name)
tags.append(tag)
instance.tag.set(tags)
return instance
def update(self, instance, validated_data):
tag_name = validated_data.pop('update_tag')
instance = super().update(instance, validated_data)
tags = []
for name in tag_name:
tag, created = Tag.objects.get_or_create(name=name)
tags.append(tag)
instance.tag.set(tags)
return instance
class Meta:
model = Audio
exclude = []
read_only_fields = ['writer', 'result']
def get(self, request, format=None):
# Get a specific question
if request.GET.get('questionID') is not None:
questionID = int(request.GET.get('questionID'))
question = Question.objects.get(pk=questionID)
serializer = QuestionSerializer(question)
return Response(serializer.data)
def send_question_update(self):
current_round = self.get_current_round()
async_to_sync(self.channel_layer.group_send)(self.room_group_name, {
'type':
'question_update',
'data':
QuestionSerializer().to_representation(current_round.question)
})
def get(self, request, pk, format=None):
qid = FavouriteQuestion.objects.values_list(
'question_id', flat=True).filter(author_id=pk).all()
questions = Question.objects.filter(id__in=qid).all()
serializer = QuestionSerializer(questions,
context={'request': request},
many=True)
return Response(serializer.data)
async def send_question_update(self):
current_round = await self.get_current_round()
await self.channel_layer.group_send(
self.game_group, {
'type':
'question_update',
'data':
QuestionSerializer().to_representation(current_round.question)
})
def test_question_serializer(self):
question_json = '{"id": 1, "question_text": "text", "question_catalogue": 1}'
question = Question.objects.get(pk=1)
serializer = QuestionSerializer(question)
data = serializer.data
self.assertEqual(data['id'], 1)
self.assertEqual(data['question_text'], "text")
self.assertEqual(data['question_catalogue'],
self.question_catalogue.id)
self.assertEqual(JSONRenderer().render(data), question_json)
def get_question(request, pk):
try:
question = Question.objects.get(pk=pk)
except Question.DoesNotExist:
return Response({'Detail': 'Question not found'}, status=404)
if request.method == 'GET':
serializer = QuestionSerializer(question)
return JsonResponse(serializer.data)
def get(self, request, format=None):
search = request.GET.get('search', '')
if search == '':
question = Question.objects.all()
else:
question = Question.objects.filter(
Q(question__icontains=search)
| Q(author__username__icontains=search)).all()
serializer = QuestionSerializer(question,
context={'request': request},
many=True)
return Response(serializer.data)
def getAllQuestion(self, request):
questions = QuestionSerializer(Question.objects.all().order_by('create_time'), many=True ).data
for one in questions:
# 返回类型为OrdededDict, 键值对形式存储数据,
optionSet = OptionViewSet()
option_list = optionSet.getOptionById(one['question_id'])
one['option_list'] = option_list
one['right_answer'] = ["%s"%item['question_index'] for item in filter(lambda n:n['correctness']==True, option_list)]
res = {
'success':True,
'data':questions
}
return Response(res)
def create(self, request, *args, **kwargs):
try:
items_data = request.data['items']
except KeyError:
return response.Response({"questions": "not exists"},
status=status.HTTP_400_BAD_REQUEST)
serializer = self.get_serializer(data=request.data)
if not serializer.is_valid():
return response.Response({"test serializer": "error"},
status=status.HTTP_400_BAD_REQUEST)
with transaction.atomic():
serializer.save()
for item in items_data:
s = QuestionSerializer(data=item)
if not s.is_valid():
return response.Response({"question serializer": "error"},
status.HTTP_400_BAD_REQUEST)
s.save()
return response.Response(serializer.data,
status=status.HTTP_201_CREATED)
def question_list(request):
if request.method == 'GET':
questions = Question.objects.all()
questions_serializer = QuestionSerializer(questions, many=True)
return JSONResponse(questions_serializer.data)
elif request.method == 'POST':
question_data = JSONParser().parse(request)
if ('text' not in question_data):
return JSONError(message="'text' is not found in request data",
code=400, status=status.HTTP_400_BAD_REQUEST)
if ('answers' not in question_data):
return JSONError(message="'answers' is not found in request data",
code=400, status=status.HTTP_400_BAD_REQUEST)
question_serializer = QuestionSerializerPost(data=question_data)
if question_serializer.is_valid():
question_serializer.save()
return JSONResponse(question_serializer.data,
status=status.HTTP_201_CREATED)
return JSONResponse(question_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def question_answer_detail(request, pk):
try:
question = Question.objects.get(pk=pk)
except Question.DoesNotExist:
return HttpResponse(status=status.HTTP_404_NOT_FOUND)
if request.method == 'GET':
question_serializer = QuestionSerializer(question)
return JSONResponse(question_serializer.data)
elif request.method == 'PUT':
question_data = JSONParser().parse(request)
question_serializer = QuestionSerializer(question, data=question_data)
if question_serializer.is_valid():
question_serializer.save()
return JSONResponse(question_serializer.data)
return JSONResponse(question_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
question.delete()
return HttpResponse(status=status.HTTP_204_NO_CONTENT)
def get(self, request, *args, **kwargs):
user_id = request.user.id
chapter_id = request.query_params.get('chapter_id')
question_ids = QuestionChapterMapping.objects.filter(chapter_id=chapter_id).values_list(
'question_id', flat=True)
questions = Question.objects.filter(id__in=question_ids).order_by('id')
serializer = QuestionSerializer(questions, many=True)
for question_data in serializer.data:
try:
user_question_attempt = UserQuestionProgress.objects.get(user_id=user_id,
question_id=question_data['id'])
question_data['user_question_choice_id'] = user_question_attempt.question_choice_id
question_data['user_attempt_is_correct'] = user_question_attempt.is_correctly_solved
except UserQuestionProgress.DoesNotExist:
question_data['user_question_choice_id'] = None
question_data['user_attempt_is_correct'] = None
return Response(serializer.data)
def get(self, request, username, format=None):
# Get user's asked questions
if request.GET.get('type') == 'question':
startID = int(request.GET.get('startID'))
count = int(request.GET.get('count'))
user = A2AUser.objects.get(user__username=username)
posts = user.post_created.all().filter(type='question')
questions = [post.question for post in posts]
sorted(questions, key=self.getKey)
result = []
for index in range(len(questions) - 1, -1, -1):
question = questions[index]
if count <= 0:
break
if (question.id < startID) or (startID == 0):
result.append(question)
count -= 1
serializer = QuestionSerializer(result, many=True)
return Response(serializer.data)
elif request.GET.get('type') == 'answer':
user = A2AUser.objects.get(user__username=username)
startID = int(request.GET.get('startID'))
count = int(request.GET.get('count'))
user = A2AUser.objects.get(user__username=username)
if startID != 0:
posts = user.post_created.all().filter(
id__lt=startID, type='answer').order_by('-id')
else:
posts = user.post_created.all().filter(
type='answer').order_by('-id')
result = []
for post in posts:
if count <= 0:
break
result.append(post)
count -= 1
serializer = AnswerWithQuestionSerializer(result, many=True)
return Response(serializer.data)
def get(self, request):
search_term = request.GET.get('search_term')
sort_type = int(request.GET.get('sort_type'))
page = int(request.GET['page'])
splited_term = search_term.split()
if sort_type == 1:
q = Question.objects.filter(
Q(title__icontains=search_term)
| Q(question_details__icontains=search_term)).distinct(
).order_by('-no_of_answers')
pagination_class = Paginator(q, 5)
q = pagination_class.page(page)
serializer = QuestionSerializer(q, many=True)
return Response(serializer.data)
if sort_type == 2:
p = UserOtherDetails.objects.filter(
Q(user__username__icontains=search_term)
| Q(user__first_name__icontains=search_term)
| Q(user__last_name__icontains=search_term)).distinct()
pagination_class = Paginator(p, 2)
p = pagination_class.page(page)
serializer = UserOtherDetailsSerializer(p, many=True)
return Response(serializer.data)
if sort_type == 3:
t = Topic.objects.filter(
Q(title__icontains=search_term)
| Q(desc__icontains=search_term)).distinct()
pagination_class = Paginator(t, 3)
t = pagination_class.page(page)
serializer = TopicSerializer(t, many=True)
return Response(serializer.data)
return Response(None)
def question_answer_list(request):
if request.method == 'GET':
questions = Question.objects.all()
questions_serializer = QuestionSerializer(questions, many=True)
answers = Answer.objects.all()
answers_serializer = AnswerSerializer(answers, many=True)
json_response = {
'questions': questions_serializer.data,
'answers': answers_serializer.data,
}
return JSONResponse(json_response)
elif request.method == 'POST':
question_data = JSONParser().parse(request)
question_serializer = QuestionSerializer(data=question_data)
if question_serializer.is_valid():
question_serializer.save()
return JSONResponse(question_serializer.data,
status=status.HTTP_201_CREATED)
return JSONResponse(question_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
class AnswerSerializer(ModelSerializer):
writer = UserOtherDetailsSerializer(read_only=True)
question = QuestionSerializer()
no_of_comments = SerializerMethodField()
upvoted = SerializerMethodField()
downvoted = SerializerMethodField()
archived = SerializerMethodField()
thanked = SerializerMethodField()
edit_suggested = SerializerMethodField()
class Meta:
model = Answer
fields = [
'id',
'question',
'writer',
'date_written',
'time_written',
'body',
'no_of_upvotes',
'no_of_downvotes',
'no_of_views',
'no_of_comments',
'upvoted',
'downvoted',
'archived',
'thanked',
'edit_suggested',
'anonymous',
]
def get_no_of_comments(self, obj):
try:
return obj.getComments()
except:
return 0
def get_upvoted(self, obj):
try:
return obj.isUpvoted(self.context.get('request').user)
except:
return False
def get_downvoted(self, obj):
try:
return obj.isDownvoted(self.context.get('request').user)
except:
return False
def get_archived(self, obj):
try:
return obj.isArchived(self.context.get('request').user)
except:
return False
def get_thanked(self, obj):
try:
return obj.hasThanked(self.context.get('request').user)
except:
return False
def get_edit_suggested(self, obj):
try:
return obj.hasSuggested(self.context.get('request').user)
except:
return False
def get(self, request, pk, format=None):
questions = Question.objects.filter(author_id=pk).all()
serializer =\
QuestionSerializer(questions, context={'request': request},
many=True)
return Response(serializer.data)
class ResultSerializer(serializers.ModelSerializer):
quiz = QuestionSerializer()
class Meta:
model = Result
fields = ('quiz', 'user', 'score', 'incorrect_answers')
def create(self, request, *args, **kwargs):
serializer = QuestionSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
serializer.save()
return response.Response(serializer.data,
status=status.HTTP_201_CREATED)
def get_question_info(self, obj):
queryset = obj.question.all()
serializer = QuestionSerializer(queryset, many=True).data
return serializer
def test_question_catalogue_invalid_scope(self):
catalogue_json = '{"id": 2, "catalogue_scope": "wrong", "catalogue_name": "cat"}'
stream = BytesIO(catalogue_json)
data = JSONParser().parse(stream)
question_catalogue_serializer = QuestionSerializer(data=data)
self.assertFalse(question_catalogue_serializer.is_valid())
def question_detail(request, pk):
try:
question_id = int(pk)
question = get_object_or_None(Question, id=question_id)
except ValueError:
return JSONError(message="Question ID value is not an Integer",
code=400, status=status.HTTP_400_BAD_REQUEST)
if question is None:
return JSONError(message="Question is not found",
code=404, status=status.HTTP_404_NOT_FOUND)
print(question.text)
if request.method == 'GET':
question_serializer = QuestionSerializer(question)
return JSONResponse(question_serializer.data)
elif request.method == 'PUT':
ans_add = []
ans_rmv = []
try:
answer_data = JSONParser().parse(request)
if (("ans-add" not in answer_data) and
("ans-remove" not in answer_data)):
raise ValueError('Required key is not found in request data')
if ("ans-add" in answer_data):
if ((not isinstance(answer_data["ans-add"], (str, unicode))) or
(not (all(isinstance(int(x), int) for x in
answer_data["ans-add"].split(","))))):
raise ValueError('Value is wrong in the "ans-add" data')
else:
ans_add = answer_data["ans-add"].split(",")
if ("ans-remove" in answer_data):
if ((not isinstance(answer_data["ans-remove"],
(str, unicode))) or
(not all(isinstance(int(x), int) for x in
answer_data["ans-remove"].split(",")))):
raise ValueError('Value is wrong in the "ans-remove" data')
else:
ans_rmv = answer_data["ans-remove"].split(",")
for ans_r in ans_rmv:
answer_remove = get_object_or_None(Answer, pk=ans_r)
if answer_remove is None:
raise ValueError("{0} is not valid in 'ans-remove'".format(ans_r))
for ans_a in ans_add:
answer_add = get_object_or_None(Answer, pk=ans_a)
if answer_add is None:
raise ValueError("{0} is not valid in 'ans-add'".format(user_a))
for ans_r in ans_rmv:
answer_remove = Answer.objects.get(pk=ans_r)
question.answers.remove(answer_remove)
for ans_a in ans_add:
answer_add = Answer.objects.get(pk=ans_a)
question.answers.add(answer_add)
question.save()
question_serializer = QuestionSerializer(question, many=False)
return JSONResponse(question_serializer.data)
except ValueError, ve:
print(ve)
return JSONError(message=str(ve),
code=400, status=status.HTTP_400_BAD_REQUEST)
except Exception, e:
print(e)
return JSONError(message="Object is not updated",
code=403, status=status.HTTP_403_FORBIDDEN)
from questions.models import Question
question = Question(title='moon shot test is hard?')
question.save()
question = Question(title='Do you afraid from snakes?')
question.save()
#update data
from questions.serializers import QuestionSerializer
serializer = QuestionSerializer(question)
serializer.data
# {'pk': 3, 'description': u'', 'title': u'Do you afraid from snakes?'}
#get json from data
from rest_framework.renderers import JSONRenderer
content = JSONRenderer().render(serializer.data)
content
# '{"pk":3,"title":"Do you afraid from snakes?","description":""}'
def test_question_deserializer_invalid_json(self):
question_json = '{"question_catalogue": 1}'
stream = BytesIO(question_json)
data = JSONParser().parse(stream)
serializer = QuestionSerializer(data=data)
self.assertFalse(serializer.is_valid())
def get(self, request, pk, format=None):
question = self.get_object(pk)
serializer = QuestionSerializer(question, context={'request': request})
return Response(serializer.data)
