def put(self, request, pk, format=None):
question = self.get_question(pk, request.user)
serializer = QuestionSerializer(question, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def test_new_questions(self):
P_ID = 1
url = '/api/submit/' + str(P_ID) + '/questions'
data = [{
"number": "1a"
}, {
"number": "1b"
}, {
"number": "2ai"
}, {
"number": "2aii"
}, {
"number": "2b"
}]
response = self.client.post(url, data, format='json')
# Test status code
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
# Test response data valid
serializer = QuestionSerializer(data=response.data,
many=True,
context={'paper_id': P_ID})
self.assertTrue(serializer.is_valid(), msg=serializer.errors)
# Test response data correct
self.assertEqual(response.data[0]['number'], "1a")
self.assertEqual(response.data[1]['number'], "1b")
self.assertEqual(response.data[2]['number'], "2ai")
self.assertEqual(response.data[3]['number'], "2aii")
self.assertEqual(response.data[4]['number'], "2b")
def post(self, request, paper_id):
serializer = QuestionSerializer(data=request.data,
many=True,
context={'paper_id': paper_id})
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
def question_list(request):
"""
List all validated questions (return them in a semi-random order)
Optional query parameters:
- 'category' (string)
- 'tag' (string)
- 'author' (string)
"""
# get only the validated questions
questions = Question.objects.validated()
# order by difficulty, then random inside
questions = questions.order_by("difficulty", "?")
# filters
if request.GET.get("category"):
questions = questions.for_category(request.GET.get("category"))
if request.GET.get("tag"):
questions = questions.for_tag(request.GET.get("tag"))
if request.GET.get("author"):
questions = questions.for_author(request.GET.get("author"))
if request.GET.get("full"):
serializer = QuestionFullStringSerializer(questions, many=True)
else:
serializer = QuestionSerializer(questions, many=True)
return Response(serializer.data)
def get_question(request, question_id):
try:
question = Question.objects.get(id=question_id)
serializer = QuestionSerializer(question)
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as e:
return Response({}, status=status.status.HTTP_400_BAD_REQUEST)
def question_random(request):
"""
Retrieve a random question
Optional query parameters:
- 'current' (question id)
- 'category' (string)
- 'tag' (string)
- 'author' (string)
"""
questions = Question.objects.validated()
if request.GET.get("current"):
questions = questions.exclude(pk=request.GET.get("current"))
if request.GET.get("category"):
questions = questions.for_category(request.GET.get("category"))
if request.GET.get("tag"):
questions = questions.for_tag(request.GET.get("tag"))
if request.GET.get("author"):
questions = questions.for_author(request.GET.get("author"))
questions_ids = questions.values_list("id", flat=True)
questions_random_id = random.sample(list(questions_ids), 1)
question_random = Question.objects.get(pk=questions_random_id[0])
if request.GET.get("full"):
serializer = QuestionFullStringSerializer(question_random)
else:
serializer = QuestionSerializer(question_random)
return Response(serializer.data)
def get_questions(request):
try:
questions = Question.objects.all()
serializer = QuestionSerializer(questions)
return Response(serializer.data, status=status.HTTP_200_OK)
except Exception as e:
return Response({}, status=status.status.HTTP_400_BAD_REQUEST)
def test_contains_expected_fields(self):
serializer = QuestionSerializer(instance=self.question,
context={'request': self.request})
expected_keys = [
'id', 'user', 'tags', 'votes', 'title', 'text', 'created'
]
self.assertCountEqual(serializer.data.keys(), expected_keys)
def post(self, request, room_number, question_id):
request.session.save()
session = Session.objects.get(session_key=request.session.session_key)
json = JSONParser().parse(request)
question = get_or_none(Question, pk=question_id)
if question and question.room.number == room_number:
vote = Question.objects.get(pk=question_id).vote_set.filter(owner=session).all().first()
if vote:
return Response({'error': 'you have already vote for this question'}, status=403)
else:
value = json['value']
if value > 0:
question.balance += 1
elif value < 0:
question.balance -= 1
question.save()
vote = Vote(question=question, owner=session)
vote.save()
Group('room-%s' % question.room.number).send({
'text': dumps({
'type': 'question',
'action': 'update',
'data': QuestionSerializer(question).data
})
})
return Response({}, status=204)
else:
return Response({'error': 'no matching question found'}, status=404)
def QuestionResponse(userid, questionid):
"""@brief Function for getting the particular question for a logged in user
@details It takes a question id and a user id as input and outputs the question along with a list of all the answers for this question and all the votes which are given for some answer of this question
@param userid the user id in db
@param questionid the question id in db
@return the question along with a list of answers for the question and a list of votes by the user on answer for this question
"""
question = Question.objects.filter(id=questionid)
qdata = QuestionSerializer(question, many=True)
answers = Answer.objects.filter(question=questionid)
answer_list = answers.values_list('id', flat=True).order_by('id')
adata = AnswerSerializer(answers, many=True)
uservotes = Vote.objects.filter(user=userid)
ans_list = uservotes.values_list('answer', flat=True).order_by('answer')
alist = [ans for ans in answer_list if ans in ans_list]
votes = uservotes.filter(answer__in=alist)
vdata = VoteSerializer(votes, many=True)
return Response({
"Question": qdata.data,
"Answers": adata.data,
"Votes": vdata.data,
})
def question_create(request):
"""
Create a one question.
"""
user = request.user
question = Question(author=user)
if request.method == 'POST':
serializer = QuestionSerializer(question, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_405_METHOD_NOT_ALLOWED)
def test_authorized_user(self):
self.client.force_authenticate(user=self.user1)
response = self.client.get(
reverse('api_question_detail', kwargs={'pk': self.question1.id}))
serializer_data = QuestionSerializer(instance=self.question1).data
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer_data)
def get(self, request, room_number):
request.session.save()
room = get_or_none(Room, number=room_number)
if room:
return Response(QuestionSerializer(room.question_set.all(), many=True), status=200)
else:
return Response({'error': 'room not found'}, status=404)
class ParsonsSubmissionSerializer(serializers.ModelSerializer):
class Meta:
model = ParsonsSubmission
fields = ['pk', 'submission_time', 'answer', 'grade', 'is_correct', 'is_partially_correct', 'finalized',
'status', 'tokens_received', 'token_value', 'question', 'get_decoded_stderr', 'get_decoded_results',
'get_formatted_test_results', 'get_passed_test_results', 'get_failed_test_results', 'get_num_tests',
'formatted_tokens_received', 'answer_files', 'show_answer', 'show_detail', 'status_color']
question = QuestionSerializer()
def test_get_questions_correctly(self):
P_COURSE = 'C141'
P_YEAR = '2015'
response = self.client.get('/api/' + P_COURSE + '/' + P_YEAR +
'/questions')
# Test GET response OK
self.assertEqual(response.status_code, status.HTTP_200_OK)
data = response.json()
# Test response data can be serialized
serializer = QuestionSerializer(data=data, many=True)
self.assertTrue(serializer.is_valid(), msg=str(serializer.errors))
# Test response data correct
for i in range(0, 4):
self.assertEquals(data[i]['id'], i)
self.assertEquals(data[i]['number'], str(i))
def test_get_question(self):
# Given
question = Question.objects.get(summary='test question')
serializer = QuestionSerializer(question)
# When
self.client.login(username=self.username, password=self.password)
response = self.client.get(
reverse('api:question', kwargs={'pk': question.id}))
# Then
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, serializer.data)
def question_list(request):
"""
List all questions
"""
if request.method == 'GET':
questions = Question.objects.all()
serializer = QuestionSerializer(questions, many=True)
return Response(serializer.data)
else:
return Response(status=status.HTTP_405_METHOD_NOT_ALLOWED)
def add_question(request, user_id):
mentee = Mentee.objects.get(id=user_id)
question = Question()
question.author = mentee
question.title = request.data['title']
question.description = request.data['description']
question.language = request.data['language']
question.save()
return Response(QuestionSerializer(question).data,
status=status.HTTP_201_CREATED)
def test_get_all_questions(self):
# Given
questions = Question.objects.filter(user=self.user)
serializer = QuestionSerializer(questions, many=True)
# When
self.client.login(username=self.username, password=self.password)
response = self.client.get(reverse('api:questions'))
# Then
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
self.assertEqual(response.data, serializer.data)
def question_detail(request, pk):
"""
Retrieve a question
"""
try:
question = Question.objects.get(pk=pk)
except Question.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer = QuestionSerializer(question)
return Response(serializer.data)
class MultipleChoiceSubmissionSerializer(serializers.ModelSerializer):
class Meta:
model = MultipleChoiceSubmission
fields = [
'pk', 'submission_time', 'answer', 'grade', 'is_correct',
'is_partially_correct', 'finalized', 'status', 'tokens_received',
'token_value', 'question', 'answer_display', 'show_answer',
'show_detail', 'status_color'
]
question = QuestionSerializer()
class ExerciseSerializer(serializers.ModelSerializer):
questions = QuestionSerializer(many=True, source='question_data')
test_sheet = serializers.SlugRelatedField(slug_field='name',
read_only=True)
def create(self, validated_data):
pass
#
class Meta:
model = ExerciseModel
fields = ('name', 'questions', 'material_url', 'test_sheet')
def question_list(request):
"""
List all questions (return them in a random order)
Optional query parameters:
- 'category' (string)
"""
questions = Question.objects.published().order_by("?")
if request.GET.get("category"):
questions = questions.for_category(request.GET.get("category"))
serializer = QuestionSerializer(questions, many=True)
return Response(serializer.data)
def post(self, request, room_number):
request.session.save()
json = JSONParser().parse(request)
room = get_or_none(Room, number=room_number)
if room:
question = Question(room=room, title=json['title'], balance=0)
question.save()
Group('room-%s' % question.room.number).send({
'text': dumps({
'type': 'question',
'action': 'create',
'data': QuestionSerializer(question).data
})
})
return Response(QuestionSerializer(question).data, status=201)
else:
return Response({"error": "no room " + room_number + " found"}, status=404)
def get(self, request, *args, **kwargs):
page = self.request.query_params.get("page")
query = self.request.query_params.get("query")
ques_qs = Questions.objects.filter(query=query)
if ques_qs.exists():
ques_object = ques_qs.first()
serialized_data = QuestionSerializer(ques_object)
data = serialized_data.data['data']
return Response(data, status=status.HTTP_200_OK)
adv_res = GetStackExchange()
adv_res = adv_res.advance_search(query, page)
return Response(adv_res, status=status.HTTP_200_OK)
def test_serializer2(self):
paper = Paper.objects.get(course="C212", year=2015)
questions = Question.objects.filter(paper=paper)
# Serialise into (question id, question number)
serializer = QuestionSerializer(questions, many=True)
self.assertEqual(serializer.data, [
OrderedDict([('id', 5), ('number', '1ai')]),
OrderedDict([('id', 6), ('number', '2ai')]),
OrderedDict([('id', 7), ('number', '3ai')]),
OrderedDict([('id', 8), ('number', '4ai')])
])
def test_serializer1(self):
paper = Paper.objects.get(course="C212", year=2016)
questions = Question.objects.filter(paper=paper)
# Serialise into (question id, question number)
serializer = QuestionSerializer(questions, many=True)
self.assertEqual(serializer.data, [
OrderedDict([('id', 1), ('number', '1')]),
OrderedDict([('id', 2), ('number', '2')]),
OrderedDict([('id', 3), ('number', '3')]),
OrderedDict([('id', 4), ('number', '4')])
])
def Feed(userid):
"""!@brief Function that returns the feed output for the user with id userid
@details the function will search for questions with tagged topics in the list of subscribed_topics for the user as well as the questions that he asked himself and the questions will be displayed in sorted order based on their timestamps
@param the userid of the logged in user
@return a list of questions which need to be displayed to the user on his feed
"""
subtopics = User.objects.filter(id=userid).values_list('subscribed_topics',
flat=True)
q1 = Question.objects.filter(user=userid)
q2 = Question.objects.filter(topics__in=subtopics).distinct()
q3 = q1.union(q2)
qdata = QuestionSerializer(q3, many=True)
return Response(qdata.data)
def question_update(request, pk=None):
"""
Update all fields of question
"""
try:
question = Question.objects.get(pk=pk)
except Question.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
# verifying user of this question
user = request.user
if question.author != user:
return Response({'error': 'You do not have permission to update this question.'})
if request.method == 'PUT':
serializer = QuestionSerializer(question, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_405_METHOD_NOT_ALLOWED)
def PostQuestion(request):
"""!@brief Function which is called when a user adds a question
@details the function takes a question object as part of the request body, extracts the object and then creates a new entry in the question table. Since the topics is a many-to-many field, the topics need to be added one by one
@return returns the feed output for the given user
"""
serializer = QuestionSerializer(data=request.data)
if serializer.is_valid():
ques = serializer.validated_data
user = ques['user']
question = Question(user=user,
username=user.name,
userdepartment=user.department,
userbio=user.bio,
userdegree=user.degree,
userspecialization=user.specialization,
question=ques['question'],
description=ques['description'])
question.save()
for topic in ques['topics']:
question.topics.add(topic)
return Feed(user.id)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer = QuestionSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
