def edit_question(question_id=-1):
form = NewQuestionForm(request.form)
#answerzip = zip(form.answers, form.validities)
answers = []
if request.method == 'POST' and form.validate_on_submit():
for answer in form.answers:
answers.append(
Answer(text=answer.answer.data,
is_correct=answer.is_correct.data))
question = Question.query.get(question_id)
question.text = form.question.data
Answer.query.filter(Answer.question_id == question.id).delete()
question.answers = answers
db.session.add(question)
db.session.commit()
return redirect(url_for('topic_questions', topic_id=question.topic.id))
question = Question.query.get(question_id)
for i in range(2):
form.answers.pop_entry()
form.question.data = question.text
for answer in question.answers:
answer_form = AnswerForm()
answer_form.answer = answer.text
answer_form.is_correct = answer.is_correct
form.answers.append_entry(answer_form)
return render_template('question.html', title='New Question', form=form)
def answer(request) :
if request.method == "POST" :
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save()
url = '/question/' + form.question
return HttpResponseRedirect(url)
def answer(request):
form = AnswerForm(request.POST)
if form.is_valid():
a = form.save()
url = '/question/%s/' % a.question.pk
return HttpResponseRedirect(url)
return HttpResponseRedirect('/answer/')
def create_answer(request, article_id):
a = Article.objects.get(id=article_id)
if request.POST:
f = AnswerForm(request.POST)
if f.is_valid():
c = f.save(commit=False)
c.pub_date = timezone.now()
c.related_article = a
c.posted_by = request.user
c.save()
a.num_answers += 1
a.answers.add(c)
a.save()
return HttpResponseRedirect('/get/%s' % article_id)
else:
f = CommentForm()
args = {}
args.update(csrf(request))
args['article'] = a
args['form'] = f
return render(request, 'add_comment.html', args)
def answer(request):
form = AnswerForm(request.POST)
form._user = request.user
if form.is_valid():
answer = form.save()
url = answer.get_question_url()
return HttpResponseRedirect(url)
def answer(request, quest):
if request.method == 'POST':
form = AnswerForm(request.POST)
form._user = request.user
if form.is_valid():
form.save()
return HttpResponseRedirect(quest.get_url())
def answer(request, id=None):
if request.method != 'POST':
return redirect('polling.views.question_list')
if UserReply.objects.filter(user=request.user, question_id=id).exists():
return redirect('polling.views.question_list')
form = AnswerForm(request.POST, question_id=id)
if form.is_valid() and len(form.cleaned_data['answers']) <= 7:
UserReply.objects.create(user=request.user, question_id=id)
key = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(6))
reply = Reply.objects.create(key=key, question_id=id)
for answer_id in form.cleaned_data['answers']:
rd_key = hashlib.sha1(str(datetime.datetime.now()) + key).hexdigest()
ReplyData.objects.create(
key=rd_key,
reply=reply,
answer_id=answer_id
)
success = True
else:
success = False
return TemplateResponse(request, 'answer.html', locals())
def newanswer(request): url = '/question/' if request.method == "POST": newanswer = AnswerForm(request.POST) if newanswer.is_valid(): url = url + str(newanswer.save()) + '/' return HttpResponseRedirect(url)
def create_answer(request, article_id):
a = Article.objects.get(id=article_id)
if request.POST:
f = AnswerForm(request.POST)
if f.is_valid():
c = f.save(commit=False)
c.pub_date = timezone.now()
c.related_article = a
c.posted_by = request.user
c.save()
a.num_answers += 1
a.answers.add(c)
a.save()
return HttpResponseRedirect('/get/%s' % article_id)
else:
f = CommentForm()
args = {}
args.update(csrf(request))
args['article'] = a
args['form'] = f
return render(request, 'add_comment.html', args)
def answer(request):
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save(commit=False)
answer.author = request.user
answer.save()
return redirect(answer.question)
def answer_add(request):
if request.method == 'POST':
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save()
url = question.get_url()
return HttpResponseRedirect(reverse(url))
return HttpResponseRedirect('/')
def add_answer(request):
query = QueryDict(request.POST.urlencode(), mutable=True)
query.__setitem__('author', str(request.user.id))
form = AnswerForm(query)
if form.is_valid():
answer = form.save()
url = answer.get_question_url()
return HttpResponseRedirect(url)
def question_details(request, qid, *args, **kwargs):
question = get_object_or_404(Question, id=qid)
form = AnswerForm(initial={'question': qid})
form._user = request.user
return render(request, 'question_details.html', {
'question': question,
'form': form
})
def newanswer (request, *args, **kwargs):
form = AnswerForm(request.POST)
form.user = request.user
if form.is_valid():
question_id = form.save()
return HttpResponseRedirect(reverse('question', kwargs={'question_id': question_id}))
else:
return question(request, **{'form' : form, 'question_id': form.get_question_id()})
def answer(request, *args, **kwargs):
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
form.cleaned_data['author'] = request.user
a = form.save()
return HttpResponseRedirect(a.question.get_absolute_url())
return render(request, "form.html", {'url':request.path, 'form':form})
def add_answer(request):
if request.method == 'POST':
form = AnswerForm(request.POST)
form._user = request.user
if form.is_valid():
answer = form.save()
return HttpResponseRedirect(answer.get_url())
return HttpResponseRedirect(request.META.get('HTTP_REFERER', '/'))
def post_answer_add(request):
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
post = form.save()
#url = post.get_url()
return HttpResponseRedirect('/question/'+request.GET.get('question')+'/')
else:
return HttpResponseRedirect('/')
def answer_question(request):
form = AnswerForm(request.POST)
form._user = request.user
if form.is_valid():
answer = form.save()
url = answer.question.get_url()
return HttpResponseRedirect(url)
else:
return HttpResponseBadRequest()
def answer(questionid):
form = AnswerForm()
question = Question.objects.get_or_404(id=questionid)
if form.validate_on_submit():
question.answer = form.answer.data
question.save()
flash("Your answer has been saved.")
return redirect(url_for("index"))
return render_template("answer.html", form=form, question=question)
def answers():
form = AnswerForm()
if form.validate_on_submit():
answer = Answer(body=form.answer.data, question_id=form.question_id.data)
db.session.add(answer)
db.session.commit()
flash('Answer was added')
return redirect(url_for('index'))
answers_all = Answer.query.all()
return render_template('answers.html', title='Answers', form=form, answers=answers_all)
def answer_add(request):
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save(request)
url = reverse('question-with-answers', args=(answer.question.id,))
return HttpResponseRedirect(url)
else:
form = AnswerForm()
return HttpResponseRedirect('/')
def question(request, *args, **kwargs):
qid = int(kwargs['id'])
try:
q, title, text, answers = get_questions(qid)
form = AnswerForm()
form.initial['question'] = q
form.fields['question'].widget = HiddenInput()
except Question.DoesNotExist:
return HttpResponseNotFound('Question %d does not exist' % qid)
return render(request, 'answers.html', {'title': title, 'text':text, 'answers':answers, 'url':reverse('answer'), 'form':form})
def answer(request):
form = AnswerForm(request.POST)
question = get_object_or_404(Question, pk=form.question_id)
if form.is_valid():
form._user = request.user
answer = form.save()
url = answer.get_url()
return HttpResponseRedirect(url)
return render(request, 'qa/question.html', {
'question': question,
'form': form,
})
def answer(request, *args, **kwargs):
if (request.method == "GET"):
return HttpResponseRedirect("/")
answer = AnswerForm(request.POST)
answer._user = request.user
if answer.is_valid():
answer = answer.save(HTTP_REFERER = request.META.get('HTTP_REFERER'))
url = answer.get_absolute_url()
return HttpResponseRedirect(url)
else:
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
def answer_form(request):
if request.method == 'POST':
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save()
url = answer.get_url()
return HttpResponsePermanentRedirect(url)
else:
form = AnswerForm()
return render(request, 'ask/answer_form.html', {
'form': form,
})
def addAnswer(request):
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
print str(datetime.datetime.now()).split('.')[0]
newAnswer = Answer( question_id = form.cleaned_data['question_id'], answerer_id = form.cleaned_data['answerer_id'], content = form.cleaned_data['content'])
newAnswer.answer_time = str(datetime.datetime.now()).split('.')[0]
newAnswer.save()
return HttpResponseRedirect('/admin')
else:
form = AnswerForm()
return render(request, 'polls/addAnswer.html', {'form': form})
def answer_add(request):
if request.method == "POST":
form = AnswerForm(request.POST)
form._user = request.user
if form.is_valid():
answer = form.save()
url = answer.get_url()
return HttpResponseRedirect(url)
else:
form = AnswerForm()
return render(request, 'qa/answer_add.html', {
'form': form
})
def editAnswer(request, project_id, question_id, answer_id):
p = get_object_or_404(Project, pk = project_id, owner = request.user)
q = get_object_or_404(Question, pk = question_id)
a = get_object_or_404(Answer, pk = answer_id)
#answer = Answer.objects.get(pk=p)
if request.method == 'POST': # If the form has been submitted...
form = AnswerForm(request.POST, instance = a) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
form.save()
return HttpResponseRedirect('/flow/' + project_id + '/' + question_id + '/#' + question_id) # Redirect after POST
else:
form = AnswerForm(instance=a) # An unbound form
variables = RequestContext(request, { 'form': form, 'url_project' : p, 'url_question' : q, 'url_answer' : a})
return render_to_response('flow/editanswer.html', variables)
def post(id):
form = AnswerForm()
post_=Post.query.filter_by(id=id).first()
answers=post_.answers.all()
if request.method == 'POST':
if form.validate_on_submit():
answer = Answer(body = form.answer.data, timestamp = datetime.utcnow(), author = g.user, question=post_)
db.session.add(answer)
db.session.commit()
flash('Your post is now live!')
return redirect(url_for('post', id=post_.id))
#return redirect(url_for('post', post=post, answers=answers, form=form))
return render_template('post.html', post=post_, answers=answers, form=form)
def answer_add(request):
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
answ = form.save()
print 'try get url from answer %s' % (answ)
url = answ.question.get_url()
print 'redirect to %s' % (url)
return HttpResponseRedirect(url)
print 'answer_add if but not valid'
else:
form = AnswerForm()
print 'answer add else'
return Http404
def game(id, attempt):
form = AnswerForm()
week = session['week']
fix_list = init_game(week)
name = session['name']
score = session['score']
if form.validate_on_submit():
plr_answer = form.answer.data
currId = id
correct_result = get_correct_result(currId, fix_list)
if id <= 9:
if attempt == 1:
if plr_answer != correct_result:
flash(f'Wrong answer {name}, you have one more attempt',
'dark')
return redirect(url_for('game', id=id, attempt=2))
else:
flash(f'You are correct {name}', 'success')
session['score'] = session['score'] + plr_answer
return redirect(url_for('game', id=id + 1, attempt=1))
elif attempt == 2:
if plr_answer != correct_result:
flash(f'Wrong answer {name}', 'dark')
return redirect(url_for('game', id=id + 1, attempt=1))
else:
flash(f'You are correct {name}', 'success')
session['score'] = session['score'] + 1
return redirect(url_for('game', id=id + 1, attempt=1))
elif id == 10:
if attempt == 1:
if plr_answer != correct_result:
flash(f'Wrong answer {name}, you have one more attempt',
'dark')
return redirect(url_for('game', id=10, attempt=2))
else:
score = score + plr_answer
return redirect(url_for('winner'))
if attempt == 2:
if plr_answer != correct_result:
return redirect(url_for('winner'))
else:
session['score'] = session['score'] + 1
return redirect(url_for('winner'))
return render_template('game.html',
form=form,
id=id,
fix_list=fix_list,
name=name,
week=week)
def answer(request):
if request.method == "POST":
form = AnswerForm(request.POST)
print form.data
if form.is_valid():
answer = form.save()
url = answer.get_url()
print url
return HttpResponseRedirect(url)
else:
raise Http404
# return HttpResponseRedirect(reverse('question'), [question_id])
else:
raise Http404
def answer_view(request):
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save()
url = '/question/' + str(answer.question_id)
#url = '/question/123/'
return HttpResponseRedirect(url)
else:
form = AnswerForm()
c = { 'form':form }
c.update(csrf(request))
return render(request, '/home/box/web/ask/qa/templates/answer.html', c)
def answer_question(request, question_id):
question = get_object_or_404(Question, id=question_id)
form = AnswerForm()
if request.method == 'POST':
form = AnswerForm(request.POST)
if form.is_valid():
if request.user.is_authenticated():
form.instance.user = request.user
form.instance.question = question
form.instance.ip = request.META['REMOTE_ADDR']
form.save()
return HttpResponseRedirect(reverse('view_question', args=[question_id]))
return request_response(request, 'answers/answer_question.html',
{'form': form, 'question': question})
def detail(id):
question = Question.query.get(id)
form = AnswerForm()
if form.validate_on_submit():
user = User.query.filter_by(email=session['email']).first()
answer = Answer(form.answer.data, question, user)
db.session.add(answer)
db.session.commit()
flash('Successfully added answer ')
return redirect(url_for('detail', id=question.id))
if question is None:
flash('Q not found')
return redirect(url_for('index'))
return render_template('question.html', question=question, form=form)
def puzzle_call_in_answer(request, puzzle_id):
puzzle = Puzzle.objects.get(id=puzzle_id)
if request.method == 'POST':
form = AnswerForm(request.POST, request.FILES)
if form.is_valid():
handle_puzzle_answer(puzzle, request.user, form.cleaned_data['answer'], form.cleaned_data['backsolved'], form.cleaned_data['phone'], request=False)
return redirect(reverse('puzzles.views.puzzle_info', args=[puzzle_id]))
else:
callback_phone = Config.objects.get().callback_phone
form = AnswerForm(initial={'phone': callback_phone})
if callback_phone:
form.fields['phone'].initial = callback_phone
return render_to_response('puzzles/puzzle-call-in-answer.html', puzzle_context(request, {
'form': form,
'puzzle': puzzle
}))
def full_question(request, id):
question = get_object_or_404(Question, id=id)
form = AnswerForm(initial={'question': id, 'author': request.user.id})
return render(request, 'question.html', {
'question': question,
'answers': Answer.objects.get_answers(question.id),
'form': form,
})
def add_answer(request):
f = open('req.log', 'a')
form = AnswerForm(request.POST)
f.write('form is created\n')
if form.is_valid:
f.write('form is valid\n')
f.close()
answer = form.save()
url = answer.get_url()
f = open('req.log', 'a')
f.write('url = %s\n' % url)
f.close()
return HttpResponseRedirect(url)
else:
pk = form.question
url = '/question/%s/' % pk
f.close()
return HttpResponseRedirect(url)
def question_detail(request, pk):
qs = get_object_or_404(Question, id=pk)
answers = qs.answer_set.all()
form = AnswerForm(initial={'question': str(pk)})
return render(request, 'detail.html', {
'question': qs,
'answers': answers,
'form': form,
})
def questions():
filter_form = FilterForm()
creator = request.args.get('creator', None)
text = None
if request.method == 'POST' and filter_form.validate_on_submit():
creator = filter_form.creator.data if filter_form.creator.data else None
text = filter_form.text.data if filter_form.text.data else None
return render_template('questions.html', questions=get_questions_list(creator, text, status='Active'),
form=AnswerForm(), current_user=current_user.username, filter_form=filter_form)
def post_details(request, slug=0, *args, **kwargs):
if request.method == 'POST':
add_answer(request)
question = get_object_or_404(Question, id=slug)
answers = Answer.objects.filter(question_id=question.id)
form = AnswerForm(initial={'question': question.id})
return render(request, 'one_post.html',
{'post': question,
'answers': answers[:],
'form': form,}
)
def question(question_id):
form = AnswerForm()
question = Question.query.get_or_404(question_id)
answers = Answer.query.filter_by(questionId=question_id)
if form.validate_on_submit():
new_answer = Answer(questionId=question_id,
datetime=datetime.now(),
authorId=question.author.id,
vote=0,
answer=form.answer.data,
authorName=current_user.username)
db.session.add(new_answer)
db.session.commit()
flash('Your answer has been submitted!', 'success')
return redirect(url_for('question', question_id=question_id))
return render_template('question.html',
form=form,
title=question.question,
question=question,
answers=answers)
def question_page(request, id):
try:
question = Question.objects.get(id=id)
except Question.DoesNotExist:
raise Http404
try:
answers = question.answer_set.all()
except Answer.DoesNotExist:
answers = None
if request.method == 'POST':
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save(request.user)
url = '/question/' + str(id) + '/'
return HttpResponseRedirect(url)
else:
form = AnswerForm({'question': id})
return render(request, 'question_page.html', {
'question': question,
'answers': answers,
'form': form,
})
def question_review(id):
# Get the question
question = Question.query.get_or_404(id)
# All answers in this question
answers = Answer.query.filter_by(question_id=id)
author_question = User.query.get(question.user_id)
# author_answer = User.query.get(answers.user_id)
# was form posted?
if request.method == 'POST':
form = AnswerForm(request.form)
if form.validate_on_submit():
answer = Answer(text=request.form['text'],
date=datetime.now(),
question_id=id,
user_id=current_user.id)
# Answer save in db
db.session.add(answer)
db.session.commit()
return redirect(url_for('question_review', id=id))
else:
# Show errors in form
flash_errors(form)
else:
form = AnswerForm()
return render_template('question_review.html',
form=form,
question=question,
answers=answers,
author_question=author_question,
users=User)
def QuestAnswerAdd(request, name):
context = RequestContext(request)
n = name
add = 0
answer_form = AnswerForm()
er = []
quest = get_object_or_404(Question, id=n)
if request.method == 'POST':
answer_form = AnswerForm(data=request.POST)
if answer_form.is_valid():
answer = answer_form.save(commit=False)
answer._setAdd(request.user)
#quest._setActiveFalse()
answer._setLink(quest.link)
answer._setActiveTrue()
answer._setQuest(quest)
answer.save()
add = 1
else:
er.append(answer_form.errors)
dict = {
'template': template(),
'footer_dc': footer_dc(),
'answer_form': answer_form,
'er': er,
'add': add,
'quest': quest
}
return render_to_response((template() + '/questsions/addAnswer.html'),
dict, context)
def question(request, **question):
id = question['question_id']
title = get_object_or_404(Question, id=id)
text = Question.objects.values_list('text', flat=True).get(id=id)
answers = Answer.objects.filter(question_id=id)
form = AnswerForm(initial={'question': id})
return render(request, 'qa/question.html', {
'title': title,
'text': text,
'answers': answers,
'form': form
})
