def edit_question(request, question_id):
existing_question = get_object_or_404(Question,
pk=question_id,
can_delete=True)
if not request.user == existing_question.user and \
not request.user.has_perm('questions.change_question'):
raise PermissionDenied
if request.method == 'POST':
if request.user == existing_question.user:
modified_question = DisabledQuestionForm(
request.POST, instance=existing_question)
else:
modified_question = QuestionForm(request.POST,
instance=existing_question)
modified_question.save()
return HttpResponseRedirect(
reverse('questions:show', args=(question_id, )))
else:
existing_question = get_object_or_404(Question, pk=question_id)
if request.user == existing_question.user:
form = DisabledQuestionForm(instance=existing_question)
else:
form = QuestionForm(instance=existing_question)
context = {'form': form, 'question_id': question_id}
return render(request, 'questions/edit.html', context)
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 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 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)
async def question_create(request):
"""
Question form
"""
u = User
c = Category
session_user = (
await u.select(u.id, u.username)
.where(u.username == request.user.username)
.first()
.run()
)
data = await request.form()
form = QuestionForm(data)
form.category.choices = [
(item["id"], item["name"]) for item in await c.select().run()
]
title = form.title.data
if request.method == "POST" and form.validate():
query = Question(
title=title,
slug="-".join(title.lower().split()),
description=form.description.data,
created_at=datetime.datetime.now(),
category=form.category.data,
user=session_user["id"],
)
await query.save().run()
return RedirectResponse(url="/questions", status_code=302)
return templates.TemplateResponse(
"questions/question_create.html", {"request": request, "form": form}
)
def new_question(request):
if request.user.is_authenticated():
form = QuestionForm()
context = {'form': form}
return render(request, 'questions/new.html', context)
else:
return redirect('accounts:sign_in')
def index(request):
joke=Joke.objects.filter(published=True).filter(adult=False).order_by('?').first()
question_form=QuestionForm()
formulae_form=FormulaeForm()
formulae=Formulae.objects.filter(published=True).order_by('?').first()
video=Url.objects.filter(url__contains="youtube").filter(url__contains="watch").order_by("?").first()
try:
intro = FlatPage.objects.get(url='/intro/')
except:
intro = False
try:
meta = ModelMeta.objects.get(slug='/intro/')
except:
meta = False
context = {
'meta':meta,
'intro':intro,
'video':video,
'formulae': formulae,
'question_form':question_form,
'formulae_form':formulae_form,
'joke':joke,
}
return render (request, 'index.html', context)
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 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 get(self, request, *args, **kwargs):
question_form = QuestionForm(self.request.GET or None)
select_tag_form = SelectTagForm(self.request.GET or None)
context = self.get_context_data(**kwargs)
context['question_form'] = question_form
context['select_tag_form'] = select_tag_form
return self.render_to_response(context)
def article(request, article_id):
article = Article.objects.get(id=article_id)
sameArticles = Article.objects.filter(Category__id=article.Category.id)[:6]
files = File.objects.filter(Article__id=article_id)
form = QuestionForm()
return render(request, 'article.html', locals())
def get(self, request, slug):
question = Question.objects.get(pk=slug)
question_form = QuestionForm(prefix=slug, instance=question)
choice_forms = [ChoiceLimitedForm(prefix=choice.pk, instance=choice)
for choice in Choice.objects.filter(question=question)]
data = {'title': 'Update a question', 'question_form': question_form, 'choice_forms': choice_forms,
'next': request.META['HTTP_REFERER']}
return render(request, 'questions/question_update_form.html', data)
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 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 development(request, development_id):
development = Development.objects.get(id=development_id)
sameDevelopments = Development.objects.filter(
Category__id=development.Category.id)[:9]
files = File.objects.filter(Development__id=development_id)
form = QuestionForm()
return render(request, 'development.html', locals())
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 contact(request):
articles = Article.objects.order_by('-Pub_date')[:9]
personalContacts = Contact.objects.filter(Category__id=1)
schoolContacts = Contact.objects.filter(Category__id=2)
school = Text.objects.get(id=4)
form = QuestionForm()
return render(request, 'contact.html', locals())
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 show_category(request, category_id):
if request.method == 'GET':
all_categories = get_all_categories()
context_data = get_question_by_category(
Category.objects.get(id=category_id))
context_data['categories'] = all_categories
context_data['showing_id'] = int(category_id)
return render(request, 'categories_index.html', context_data)
elif request.POST.get('add') != None:
return HttpResponseRedirect('/questions/add_category')
elif request.POST.get(u'action') == u'ویرایش':
request.session['question_before_edit_id'] = Question.objects.filter(
question=request.POST.get('question'))[0].question
options = Option.objects.filter(question=Question.objects.filter(
question=request.POST.get('question'))[0])
short_options = []
for option in options:
short_options.append({
'text': option.text,
'is_correct': option.is_correct
})
request.session['options_for_question_before_edit'] = short_options
request.session.save()
form = QuestionForm()
context_data = {
'question':
Question.objects.filter(question=request.POST.get('question'))[0],
"options":
options,
'showing_id':
int(category_id),
"category":
Category.objects.get(id=category_id),
'form':
form,
"done":
False
}
return render(request, 'edit_question.html', context_data)
elif request.POST.get(u'action') == u'حذف':
question = Question.objects.filter(
question=request.POST.get('question'))[0]
options = Option.objects.filter(question=question)
for option in options:
option.delete()
question.delete()
context_data = {
'categories': get_all_categories(),
'showing_id': int(category_id)
}
return render(request, 'categories_index.html', context_data)
else:
context_data = get_question_by_category(
get_category_by_name(name=request.POST.get('cat_name')))
context_data['cat_name'] = request.POST.get('cat_name')
return render(request, 'questions_index.html', context_data)
def edit_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(instance=question)
context = {'form': form, 'question': question}
return render(request, 'questions/edit.html', context)
def get_topic(request, topic_key):
topic = Topic.objects.get(key=topic_key)
latest_questions = topic.question_set.order_by('-created_at')[:5]
context = {
'latest_questions': latest_questions,
'topic': topic,
'question_form': QuestionForm(initial={"topic": topic}),
}
return render(request, 'questions/topic.html', context)
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 students(request):
articles = Article.objects.filter(Category__id=8).order_by('-Pub_date')[:9]
section = 'Ученикам'
img = Image.objects.get(id=8)
text = Text.objects.get(id=10)
quoteText = Text.objects.get(id=11)
quoteAuthor = Text.objects.get(id=12)
form = QuestionForm()
return render(request, 'others.html', locals())
def parents(request):
articles = Article.objects.filter(Category__id=7).order_by('-Pub_date')[:9]
section = 'Родителям'
img = Image.objects.get(id=7)
text = Text.objects.get(id=7)
quoteText = Text.objects.get(id=8)
quoteAuthor = Text.objects.get(id=9)
form = QuestionForm()
return render(request, 'others.html', locals())
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 edit_question(request, qid):
question = Question.objects.get(id=qid)
context = {
'qs': question.question_set,
'form': QuestionForm(instance=question),
'answers': AnswerFormSet(queryset=question.answer_set.all())
}
return render_to_response('questions/edit_question.html',
context,
context_instance=RequestContext(request))
def new_question(request, qs_id):
qs = QuestionSet.objects.get(id=qs_id)
question = Question.objects.create(question_set=qs)
context = {
'qs': qs,
'form': QuestionForm(instance=question),
}
return render_to_response('questions/edit_question.html',
context,
context_instance=RequestContext(request))
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 get(self, request):
if request.user.is_authenticated():
form = QuestionForm()
response = TemplateResponse(
request, 'ask.html', {
'title': 'amtrs - make a question',
'onpage_title': 'ask',
'form': form,
})
return response
else:
return HttpResponseRedirect('/login')
