def edit_question(request, course_id, question_id):
question = Question.objects.get(id=question_id)
if request.user.username == question.owner:
ChoiceFormSet = modelformset_factory(Choice, ChoiceForm, extra=0)
course = Course.objects.get(id=course_id)
choices = Choice.objects.filter(question=question)
question_form = QuestionForm(instance=question)
choice_formset = ChoiceFormSet(queryset=Choice.objects
.filter(question=question))
if request.method == 'POST' and 'update' in request.POST:
question_form = QuestionForm(instance=question, data=request.POST)
choice_formset = ChoiceFormSet(data=request.POST)
if question_form.is_valid() and choice_formset.is_valid():
Choice.objects.filter(question=question).delete()
update(question_form, question, choice_formset)
messages.success(request, 'Question updated successfully!')
return redirect('/courses/' + course_id + '/questions/')
if request.method == 'POST' and 'delete' in request.POST:
question.delete()
Choice.objects.filter(question=question).delete()
messages.success(request, 'Question deleted successfully!')
return redirect('/courses/' + course_id + '/questions/')
return render(request, 'edit_question.html', {'form': question_form,
'choice_formset': choice_formset,'course': course,
'question': question, 'choices': choices })
return redirect('/courses/' + course_id)
def post(self, request):
form = QuestionForm(request.POST, request.FILES)
if form.is_valid():
# Actions
this = form.save()
# Add sentences
_add_sentences(this)
# Views
if request.POST['html'] == 'false':
return HttpResponse(str(this.pk))
else:
return redirect(request.POST['next'])
else:
# Do nothing
# Views
if request.POST['html'] == 'false':
return HttpResponse('-1')
else:
data = {'title': 'Failed',
'message': 'Question upload failed.',
'link': reverse('questions-upload'),
'linkdes': 'Go back and upload the question again.'}
return render(request, 'result.html', data)
def question_create(request):
if request.method == 'POST':
question_form = QuestionForm(request.POST)
if question_form.is_valid():
question_post = question_form.save(commit=False)
question_post.author = request.user
question_post.save()
tag_ids = request.POST.get('tags').split(',')
print(tag_ids)
for tag_id in tag_ids:
if tag_id == None:
tag_id = 8
question_tag = QuestionTag(tag_id=tag_id, question_id=question_post.id)
question_tag.save()
messages.success(
request, f'Your question has been added!', extra_tags='success')
return redirect('questions-home')
else:
messages.error(request, f'Something went wrong!',
extra_tags='danger')
else:
question_form = QuestionForm()
context = {
'question_form': question_form,
}
return render(request, 'questions/question_create.html', context)
def show_question(request, pk_meeting, pk_quiz):
question_form = QuestionForm(request.POST or None)
meeting = get_object_or_404(Meeting, pk=pk_meeting)
quiz = get_object_or_404(Quiz, pk=pk_quiz)
list_questions = quiz.question_questionnaires.all()
if question_form.is_valid():
question = question_form.save(commit=False)
question.question = question_form.cleaned_data.get('question')
question.answer = ''
question.save()
quiz.question_questionnaires.add(question)
messages.success(request, 'Pergunta Adicionada Com Sucesso!')
return redirect('/ver_questionario/' + str(meeting.id) + '/' +
str(quiz.id))
quiz_form = QuestionForm()
return render(
request, 'questions/show_quiz.html', {
'form': quiz_form,
'meeting': meeting,
'list_questions': list_questions,
'quiz': quiz
})
def edit_question(request, course_id, question_id):
course = Course.objects.get(id=course_id)
question = Question.objects.get(id=question_id)
if request.user == course.owner:
ChoiceFormSet = modelformset_factory(Choice, ChoiceForm, extra=0)
choices = Choice.objects.filter(question=question)
question_form = QuestionForm(instance=question)
choice_formset = ChoiceFormSet(queryset=Choice.objects.filter(
question=question))
if request.method == 'POST' and 'update' in request.POST:
question_form = QuestionForm(instance=question, data=request.POST)
choice_formset = ChoiceFormSet(data=request.POST)
if question_form.is_valid() and choice_formset.is_valid():
Choice.objects.filter(question=question).delete()
update(question_form, question, choice_formset)
messages.success(request, 'Question updated successfully!')
return redirect('/courses/' + course_id + '/questions/')
if request.method == 'POST' and 'delete' in request.POST:
question.delete()
Choice.objects.filter(question=question).delete()
messages.success(request, 'Question deleted successfully!')
return redirect('/courses/' + course_id + '/questions/')
return render(
request, 'edit_question.html', {
'form': question_form,
'choice_formset': choice_formset,
'course': course,
'question': question,
'choices': choices
})
return redirect('/courses/' + course_id)
def register_question(request):
form = QuestionForm()
if request.method == "POST":
username = None
form = QuestionForm(request.POST)
if request.user.is_authenticated():
username = request.user.username
if form.is_valid():
title = form.cleaned_data['title']
body = form.cleaned_data['body']
tags = form.cleaned_data['tags'].split(",")
user = User.objects.get(username=username)
quest = Question.objects.create(title=title, body=body, user=user)
#add tags one by one
for tag in tags:
quest.tags.add(tag)
# when you submit one question, you are redirected back to the main page
return redirect('/questions')
else:
form = QuestionForm()
return render(request, 'question_submission.html',{'form': form,})
def question_create(request):
if request.method == 'GET':
form = QuestionForm()
return render(request, 'questions/question_create.html', {'form': form})
elif request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
text = form.cleaned_data['text']
tags = form.cleaned_data['tags']
author = request.user
question = Question(name=name, text=text, author=author)
question.save()
splited_tags = tags.split(u'@@', -1)
for tag_name in splited_tags:
is_tag_new = True
for tag in Tag.objects.all():
if tag.name == tag_name:
question.tags.add(tag)
is_tag_new = False
break
if is_tag_new:
question.tags.add(make_new_tag(tag_name))
question.save()
return redirect('question_detail', id=question.id)
else:
return render(request, 'questions/question_create.html', {'form': form})
def test_valid_question_form(self):
data = {
'name': 'Example name',
'category': 'Examples',
'question_text': 'Example text'
}
form = QuestionForm(data=data)
self.assertTrue(form.is_valid())
def test_if_not_valid_on_empty_question_text(self):
form_data = {
'name': 'Example name',
'category': 'Examples',
'question_text': ''
}
form = QuestionForm(data=form_data)
self.assertFalse(form.is_valid())
def test_if_valid_on_all_required_fields(self):
form_data = {
'name': 'Example name',
'category': 'Examples',
'question_text': 'Example question text'
}
form = QuestionForm(data=form_data)
self.assertTrue(form.is_valid())
def edit_question(request, reviewprogram_id, mocktest_id, mocktestsection_id,
mocktestsubsection_id, question_id):
reviewprogram = ReviewProgram.objects.get(id=reviewprogram_id)
reviewprogram = ReviewProgram.objects.get(id=reviewprogram_id)
mocktest = MockTest.objects.get(id=mocktest_id)
mocktestsection = MockTestSection.objects.get(id=mocktestsection_id)
mocktestsubsection = MockTestSubSection.objects.get(
id=mocktestsubsection_id)
question = Question.objects.get(id=question_id)
mocktestsentence = MockTestSentence.objects.filter(
id=question.mocktestsentence_id)
if request.user == reviewprogram.instructor:
ChoiceFormSet = modelformset_factory(Choice, ChoiceForm, extra=0)
choices = Choice.objects.filter(question=question)
question_form = QuestionForm(instance=question)
question_form.fields[
'mocktestsentence'].queryset = MockTestSentence.objects.filter(
mocktestsubsection_id=mocktestsubsection)
choice_formset = ChoiceFormSet(queryset=Choice.objects.filter(
question=question))
if request.method == 'POST' and 'update' in request.POST:
question_form = QuestionForm(instance=question,
data=request.POST,
files=request.FILES)
choice_formset = ChoiceFormSet(data=request.POST,
files=request.FILES)
if question_form.is_valid() and choice_formset.is_valid():
Choice.objects.filter(question=question).delete()
update(question_form, question, choice_formset)
messages.success(request, 'Question updated successfully!')
return redirect('/manage/' + reviewprogram_id + '/mocktests/' +
mocktest_id + '/sections/' +
mocktestsection_id + '/subsections/' +
mocktestsubsection_id + '/questions')
if request.method == 'POST' and 'delete' in request.POST:
question.delete()
Choice.objects.filter(question=question).delete()
messages.success(request, 'Question deleted successfully!')
return redirect('/manage/' + reviewprogram_id + '/mocktests/' +
mocktest_id + '/sections/' + mocktestsection_id +
'/subsections/' + mocktestsubsection_id +
'/questions')
return render(
request, 'edit_question.html', {
'form': question_form,
'mocktest_sentences': mocktestsentence,
'choice_formset': choice_formset,
'question': question,
'choices': choices,
'reviewprogram': reviewprogram,
'mocktest': mocktest,
'mocktestsection': mocktestsection,
'mocktestsubsection': mocktestsubsection
})
return redirect('/manage/' + reviewprogram_id)
def post(self, request):
form = QuestionForm(self.request.POST, instance=self.question)
if form.is_valid():
self.question = form.save(commit=False)
self.question.author = self.request.user
self.question.save()
return redirect('questions:question_detail', question_id=self.question.id)
else:
return render(request, 'questions/add_question.html', self.get_context(form))
def create(request):
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
text = form.cleaned_data['text']
Question.objects.create(text=text, created=timezone.now())
return HttpResponseRedirect(reverse('questions:list'))
else:
form = QuestionForm
return render(request, 'questions/create.html', {'form': form})
def post(self, request, question_id):
question = get_object_or_404(Question, id=question_id, author=self.request.user)
form = QuestionForm(request.POST, instance=question)
if form.is_valid():
question = form.save()
if question.is_archive == 0:
return redirect('questions:question_detail', question_id=question.id)
else:
return redirect('questions:question_list')
else:
return render(request, 'questions/question_edit.html', self.get_context(form))
def test_question_updating(self):
course = Course.objects.create(name="Example name")
question = Question.objects.create(
name="Example question", category="Examples", question_text="Text", course=course
)
data = {"name": "Example name", "category": "Examples", "question_text": "Changed text"}
form = QuestionForm(instance=question, data=data)
self.assertTrue(form.is_valid())
question = form.save(commit=False)
question.course = course
question.save()
self.assertEqual(question.question_text, "Changed text")
def ask(request):
if request.user.is_authenticated:
if request.POST:
form = QuestionForm(request.POST)
if form.is_valid():
question = form.save()
return redirect('/')
else:
form= QuestionForm()
else:
return render(request,'questions/pageError.html')
return render(request, 'questions/ask.html',{'form':form})
def add_q(request):
if request.method == "POST":
form = QuestionForm(request.POST)
if form.is_valid():
q = form.save(commit=False)
q.adder = request.user
q.save()
return redirect_to_next(request, "my_questions")
else:
form = QuestionForm()
return render_to_response("questions/add_q.html", {"form":form},
context_instance=RequestContext(request))
def post(self, request):
form = QuestionForm(request.POST)
if form.is_valid():
current_id = form.save(request.user)
return HttpResponseRedirect('/question/' + str(current_id))
else:
response = TemplateResponse(
request, 'ask.html', {
'title': 'amtrs - make a question',
'onpage_title': 'ask',
'form': form,
})
return response
def handle_question_submission(request):
form = QuestionForm(request.POST)
if check_candidate(request):
return redirect('questions:index')
if Question.objects.filter(author__id=request.user.id).exclude(
status='rejected').exists():
return redirect('questions:index')
if not form.is_valid():
return show_questions(request, form)
question = form.save(commit=False)
question.author = request.user
question.save()
return redirect('questions:index')
def ask_question(request):
form = QuestionForm(request.POST or None)
if form.is_valid():
question = form.save(commit=False)
question.user = request.user
question.save()
# messages.success(request, 'Question was Posted.')
# return redirect(question.get_absolute_url())
return redirect("/")
context = {"form": form,
"title": "Ask Question"
}
return render(request, "questions/ask.html", context)
def add_tag_to_question(request):
questionform = QuestionForm(request.POST)
if questionform.is_valid():
question = questionform.save(commit=False)
question.user_id = request.user.id
question.save()
tagform = SelectTagForm(request.POST)
if tagform.is_valid():
tags = tagform.cleaned_data.get('Tags')
for tag_instance in tags:
tag = get_object_or_404(Tag, pk=int(tag_instance))
tag.question.add(question)
tag.save()
def ask_question(request):
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
if request.user.is_authenticated():
q = form.save(commit=False)
q.user = request.user
q.save()
else:
form.save()
return HttpResponseRedirect(reverse(index))
else:
form = QuestionForm()
return render_to_response('questions/ask.html', {'question_form': form,}, context_instance = RequestContext(request))
def create_question(request):
if request.method == 'POST':
# Set the submission_date automatically.
form = QuestionForm(request.POST)
if form.is_valid():
print form.cleaned_data
form.save()
return HttpResponseRedirect(reverse('questions:list'))
else:
context = {'form': form}
return render(request, 'questions/new.html', context)
else:
form = QuestionForm()
context = {'form': form}
return render(request, 'questions/new.html', context)
def post(self, request):
form = QuestionForm(request.POST)
if form.is_valid():
question = Question(
title=form.cleaned_data["title"],
text=form.cleaned_data["text"],
topic=form.cleaned_data["topic"],
author=request.user,
)
question.save()
return redirect("question", question.id)
context = {
'question_form': form,
}
return render(request, 'questions/new_question.html', context)
def save_question(request, qid):
question = Question.objects.get(id=qid)
question.updated = datetime.now()
question_form = QuestionForm(request.REQUEST,
files=request.FILES,
instance=question)
if question_form.is_valid():
question_form.save()
#answers = AnswerFormSet(data=request.REQUEST, files=request.FILES)
#for form in answers:
# if form.is_valid():
# form.save()
return redirect(list_questions, question_form.instance.question_set.id)
def submit(request):
class BaseAnswerFormSet(BaseFormSet):
def clean(self):
blanks = []
print "clean called"
for i in range(0, self.total_form_count()):
form = self.forms[i]
try:
answer = form.cleaned_data['answer']
print "answer: %s" %answer
except:
blanks.append(form)
print "found %s blanks" %len(blanks)
if len(blanks) >= 4:
raise forms.ValidationError("Must have at least two answer choices")
AnswerFormSet = formset_factory(AnswerForm, max_num=5, extra = 5, formset = BaseAnswerFormSet)
user = request.user.userprofile
if request.method == 'POST': # If the form has been submitted...
question_form = QuestionForm(request.POST) # A form bound to the POST data
# Create a formset from the submitted data
answer_formset = AnswerFormSet(request.POST, request.FILES)
print "answer formset %s" %answer_formset
print "non form errors %s" %answer_formset.non_form_errors()
print "form errors %s" %answer_formset.errors
if question_form.is_valid() and not any(answer_formset.non_form_errors()):
question = question_form.save(commit=False)
question.submitter = user
question.save()
for form in answer_formset.forms:
try:
form.cleaned_data["answer"]
answer = form.save(commit=False)
answer.question = question
answer.save()
user.save()
except:
pass
return redirect('profile')
else:
question_form = QuestionForm()
answer_formset = AnswerFormSet()
c = {'question_form': question_form,
'answer_formset': answer_formset,
}
c.update(csrf(request))
return render_to_response('submit.html', c, context_instance = RequestContext(request))
def add_question(request, pk):
context = RequestContext(request)
registered = False
if request.method == 'POST':
question_form = QuestionForm(data=request.POST, initial={'user': request.user, 'company': pk})
if question_form.is_valid():
question_form.instance.user = request.user
question_form.instance.company = Company.objects.get(id=pk)
question_form.save()
registered = True
else:
print question_form.errors
else:
question_form = QuestionForm()
return render(request, 'question/new.html', {
'question_form': question_form, 'registered': registered})
def newQuestion(request):
if request.method == "POST":
form = QuestionForm(request.POST)
if form.is_valid():
q = form.save(request.user)
return HttpResponseRedirect(
reverse('questions:answer', kwargs={'qid': q.id}))
else:
form = QuestionForm()
topMembers = UserImaged.objects.order_by('-rating').all()[:5]
topTags = Tag.objects.get_popular_tags()
context = {'form': form, 'topMembers': topMembers, 'topTags': topTags}
return render(request, 'question/question.html', context)
def question_create_view(request):
"""
Show from for sending in a question
"""
if request.method == 'POST':
form = QuestionForm(request.POST, request.FILES, user=request.user)
if form.is_valid():
form.save()
question_title = form.cleaned_data['title']
question = get_object_or_404(Question, title=question_title, author=request.user)
return render(request, 'questions/question-create.html',
{'form': None, 'question': question})
else:
form = QuestionForm()
return render(request, 'questions/question-create.html',
{'form': form})
def ask(request):
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
question = Question()
question.user = request.user
question.title = form.cleaned_data.get('title')
question.description = form.cleaned_data.get('description')
question.save()
tags = form.cleaned_data.get('tags')
question.create_tags(tags)
return redirect('/questions/')
else:
return render(request, 'questions/ask.html', {'form': form})
else:
form = QuestionForm()
return render(request, 'questions/ask.html', {'form': form})
def ask(request):
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
question = Question()
question.user = request.user
question.title = form.cleaned_data.get('title')
question.description = form.cleaned_data.get('description')
question.save()
tags = form.cleaned_data.get('tags')
question.create_tags(tags)
return redirect('/questions/')
else:
return render(request, 'questions/ask.html', {'form': form})
else:
form = QuestionForm()
return render(request, 'questions/ask.html', {'form': form})
def post(self, request, slug):
question = Question.objects.get(pk=slug)
question_form = QuestionForm(request.POST, prefix=slug, instance=question)
choice_forms = [ChoiceLimitedForm(request.POST, prefix=choice.pk, instance=choice)
for choice in Choice.objects.filter(question=question)]
if question_form.is_valid() and all(form.is_valid() for form in choice_forms):
question_form.save()
for form in choice_forms: form.save()
reset_question(question)
return redirect(request.POST['next'])
else:
kwargs = {'slug': slug}
data = {'title': 'Failure',
'message': 'Question update failed.',
'link': reverse('questions-update', kwargs=kwargs),
'linkdes': 'Go back to update page.',}
return render(request, 'result.html', data)
def question_update(request, pk):
question = Question.objects.get(id=pk)
question_form = QuestionForm(instance=question)
if request.method == 'POST':
question_form = QuestionForm(request.POST, instance=question)
if question_form.is_valid():
# form = request.POST
# print("form=",form,request.user.id)
# question = Question.objects.get(id=pk)
# print("done=done",question)
question_form.save()
messages.success(
request, f'Your question has been updated!', extra_tags='success')
return redirect('questions-detail', pk=pk)
else:
messages.error(request, f'Something went wrong!',
extra_tags='danger')
return render(request, 'questions/question_edit.html', {'question_form':question_form})
def ask(request):
"""
Ask POST-only handler
"""
data = {'questionform': None}
# check if POST
if request.method != 'POST':
return HttpResponseForbidden()
# вытаскиваем теги из поля
tag_list = request.POST.get('tags', '').split(',')
if '' in tag_list:
tag_list.remove('')
form = QuestionForm(request.POST)
data['questionform'] = form
data['form_tags'] = tag_list
if form.is_valid():
user = request.user
question_user = QuestionsUser.objects.filter(user=user)
# check if questionsUser exists
if len(question_user) == 0:
return HttpResponseForbidden()
# create new question
title = form.cleaned_data['title']
content = form.cleaned_data['content']
q = Question(author=question_user[0], title=title, content=content)
q.save()
# adding tags after save to have id
q.add_tags(tag_list)
return json({'status': 'ok', 'url': q.get_absolute_url()})
return json({'status': 'error', 'html':
render_to_string("ask.html", RequestContext(request, data))})
def create_question(request):
if request.user.is_authenticated():
form = QuestionForm(request.POST)
if form.is_valid():
new_question = form.save(commit=False)
new_question.date = datetime.datetime.now()
new_question.user = request.user
new_question.save()
tags = form.cleaned_data['tags']
new_question.tags.clear()
for tag in tags:
new_question.tags.add(tag)
new_question.save()
return redirect('questions:show', question_id=new_question.id)
else:
return redirect('questions:new')
else:
return redirect('/')
def update_question(request, question_id):
question = get_object_or_404(Question, pk=question_id)
if not request.user == question.user:
return redirect('questions:show', question)
form = QuestionForm(request.POST)
if form.is_valid():
tags = form.cleaned_data['tags']
question.tags.clear()
for tag in tags:
question.tags.add(tag)
question.date_updated = datetime.datetime.now()
question.text = form.cleaned_data['text']
question.save()
return redirect('questions:show', question_id=question_id)
else:
return redirect('questions:edit', question_id=question_id)
def edit_question(request, pk_question, pk_meeting, pk_quiz):
question = get_object_or_404(Question, pk=pk_question)
question_form = QuestionForm(request.POST or None, instance=question)
meeting = get_object_or_404(Meeting, pk=pk_meeting)
quiz = get_object_or_404(Quiz, pk=pk_quiz)
if question_form.is_valid():
question_form.save()
messages.success(request,
'Informações da Pergunta Alterada Com Sucesso!')
return redirect('/ver_questionario/' + str(meeting.id) + '/' +
str(quiz.id))
return render(request, 'questions/edit_question.html', {
'question': question,
'meeting': meeting,
'quiz': quiz
})
def create_question(request, course_id):
ChoiceFormSet = modelformset_factory(Choice, ChoiceForm, extra=2)
course = Course.objects.get(id=course_id)
question_form = QuestionForm()
choice_formset = ChoiceFormSet(queryset=Choice.objects.none())
if request.method == 'POST':
question_form = QuestionForm(data=request.POST)
choice_formset = ChoiceFormSet(data=request.POST)
if question_form.is_valid() and choice_formset.is_valid():
question = question_form.save(commit=False)
question.owner = request.user
question.course = course
question.save()
for choice_form in choice_formset.forms:
choice = choice_form.save(commit=False)
choice.question = question
choice.save()
messages.success(request, 'Question created successfully!')
return redirect('/courses/' + course_id + '/questions/')
return render(request, 'create_question.html', {'form': question_form,
'choice_formset': choice_formset, 'course': course })
def edit_question(request, category_id):
done = False
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid(): # and request.user.is_authenticated():
options, question = create_question_from_form(
category_id, form, request)
question_from_db = Question.objects.filter(
question=request.session['question_before_edit_id'])[0]
question_from_db.question = question.question
question_from_db.options = question.options
question_from_db.creation_date = question.creation_date
question_from_db.category = question.category
question_from_db.creator = question.creator
question_from_db.save()
options_from_db = Option.objects.filter(question=question_from_db)
for i in xrange(0, len(options)):
option = options_from_db[i]
option.is_correct = options[i].is_correct
option.text = options[i].text
option.question = question_from_db
option.save()
done = True
else:
print "form is invalid"
else:
form = QuestionForm()
context_data = {
'form': form,
"done": done,
'showing_id': int(category_id),
"category": Category.objects.get(id=category_id)
}
return render(request, 'edit_question.html', context_data)
def create_question(request, reviewprogram_id, mocktest_id, mocktestsection_id,
mocktestsubsection_id):
ChoiceFormSet = modelformset_factory(Choice, ChoiceForm, extra=4)
reviewprogram = ReviewProgram.objects.get(id=reviewprogram_id)
mocktest = MockTest.objects.get(id=mocktest_id)
mocktestsection = MockTestSection.objects.get(id=mocktestsection_id)
mocktestsubsection = MockTestSubSection.objects.get(
id=mocktestsubsection_id)
question_form = QuestionForm()
question_form.fields[
'mocktestsentence'].queryset = MockTestSentence.objects.filter(
mocktestsubsection_id=mocktestsubsection)
choice_formset = ChoiceFormSet(queryset=Choice.objects.none())
if request.method == 'POST':
question_form = QuestionForm(data=request.POST, files=request.FILES)
choice_formset = ChoiceFormSet(data=request.POST, files=request.FILES)
if question_form.is_valid() and choice_formset.is_valid():
question = question_form.save(commit=False)
question.mocktestsubsection = mocktestsubsection
question.save()
for choice_form in choice_formset.forms:
choice = choice_form.save(commit=False)
choice.question = question
choice.save()
messages.success(request, 'Question created successfully!')
return redirect('/manage/' + reviewprogram_id + '/mocktests/' +
mocktest_id + '/sections/' + mocktestsection_id +
'/subsections/' + mocktestsubsection_id +
'/questions/create')
return render(
request, 'create_question.html', {
'form': question_form,
'choice_formset': choice_formset,
'reviewprogram': reviewprogram,
'mocktest': mocktest,
'mocktestsection': mocktestsection,
'mocktestsubsection': mocktestsubsection
})
def question_create_view(request):
if request.method == 'POST' and request.user.is_authenticated():
parent_id = request.POST.get('parent_id')
video_id = request.POST.get('video_id')
instance_location_destination = request.POST.get('instance_location_destination')
form = QuestionForm(request.POST)
try:
video = Video.objects.get(id=video_id)
except Exception as e:
video = None
parent_question = None
if parent_id is not None:
try:
parent_question = Question.objects.get(id=parent_id)
except Exception as e:
parent_question = None
if parent_question is not None and parent_question.video is not None:
video = parent_question.video
if form.is_valid():
question_text = form.cleaned_data['question']
if parent_question is not None:
new_question = Question.objects.create_question(
user = request.user,
destination = parent_question.get_instance_location,
text = question_text,
video = video,
parent = parent_question
)
affected_users = parent_question.get_affected_users()
notify.send(
request.user,
action=new_question,
target = parent_question,
recipient=parent_question.user,
affected_users = affected_users,
verb = 'replied to ',
)
messages.success(request, "<strong>Reply</strong> posted successfully, Thank you for your reply.", extra_tags='html_safe')
return HttpResponseRedirect(parent_question.get_absolute_url())
else:
new_question = Question.objects.create_question(
user = request.user,
destination = instance_location_destination,
text = question_text,
video = video,
)
notify.send(
request.user,
action=new_question,
target = new_question.video,
recipient=request.user,
verb = 'Commented on ',
)
#notify.send(request.user, recipient=request.user, action='new comment added')
messages.success(request, "<strong>Comment</strong> posted successfully, Thank you for your comment.", extra_tags='html_safe')
return HttpResponseRedirect(new_question.get_absolute_url())
else:
messages.error(request, "<strong>Oops!</strong>, an error occurred in your comment, please try again.", extra_tags='html_safe')
return HttpResponseRedirect(instance_location_destination)
else:
raise Http404
def test_valid_question_form(self):
data = {"name": "Example name", "category": "Examples", "question_text": "Example text"}
form = QuestionForm(data=data)
self.assertTrue(form.is_valid())
def test_if_valid_on_all_required_fields(self):
form_data = {'name': 'Example name', 'category': 'Examples',
'question_text': 'Example question text'}
form = QuestionForm(data=form_data)
self.assertTrue(form.is_valid())
def test_if_not_valid_on_empty_question_text(self):
form_data = {'name': 'Example name', 'category': 'Examples',
'question_text': ''}
form = QuestionForm(data=form_data)
self.assertFalse(form.is_valid())
