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 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 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 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 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 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):
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save(commit=False)
answer.author = request.user
answer.save()
return redirect(answer.question)
def question_details(request, id):
try:
question = Question.objects.get(pk=id)
except Question.DoesNotExist:
raise Http404
if request.method == "POST":
user = request.user
if not user.is_authenticated():
return HttpResponseRedirect('/login/')
form = AnswerForm(request.POST)
form.setUser(user)
if form.is_valid():
answer = form.save()
question = answer.question
url = question.get_absolute_url()
return HttpResponseRedirect(url)
else:
default_data = {'question': question.id}
form = AnswerForm(initial=default_data);
answers = Answer.objects.filter(question=question).order_by('-added_at')
return render(request, 'question.html', {
'question': question,
'answers': answers,
'form': form,
})
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 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, *args, **kwargs):
quest_id = kwargs['pk']
# print 'in answer'
if request.method == "POST":
# print 'post on answer'
form = AnswerForm(request.POST)
if request.user.is_authenticated():
form._user=request.user
if form.is_valid():
form.save()
redir_url = '/question/'+str(quest_id)+'/'
return HttpResponseRedirect(redir_url)
else:
# print 'get on answer'
try:
question = Question.objects.get(id=quest_id)
# print 'from anser'
# user = request.user
# print user
form=AnswerForm(initial={'question': question})
# form = AnswerForm(initial={'question': question, 'author': user})
answers = question.answer_set.all()
ans= (answers.values('text'))
l=[l['text'] for l in ans]
#answers =str(answers).decode('utf8')
# print repr(answers).decode("unicode_escape")
except Question.DoesNotExist:
raise Http404
return render(request, 'question_old.html', {'form': form, 'quest_title': question.title, 'quest_text': question.text, 'answers':l,})
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 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 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 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 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 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 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 question(request, quest_id):
quest = get_object_or_404(Question, id=quest_id)
if request.method == 'POST':
form = AnswerForm(request.POST)
form.set_author(request.user)
if form.is_valid():
form.save()
else:
form = AnswerForm()
return render(request, "question_detail.html", {'question': quest, 'form': form})
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 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(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_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 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 answer(request):
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save()
answer.author = request.user
answer.save()
url = answer.get_url()
return HttpResponseRedirect(url)
else:
form = AnswerForm()
return render(request, 'answer.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 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 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 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 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 question(request, num):
question = get_object_or_404(Question, id=num)
if request.method == 'POST':
form = AnswerForm(request.POST)
if form.is_valid():
form = form.save()
url = form.get_url()
return HttpResponseRedirect(url)
else:
form = AnswerForm(initial={'question': question.id})
return render(request, 'question.html', {
'question': question,
'answers': form,
})
def answer(request):
if request.method == "POST":
form = AnswerForm(request.POST)
print form.data
if form.is_valid():
user_id = request.COOKIES['sessionid']
answer = form.save(user_id)
url = answer.get_url()
print url
return HttpResponseRedirect(url)
else:
raise Http404
# return HttpResponseRedirect(reverse('question'), [question_id])
else:
raise Http404
def question(request, pk_question):
gs = get_object_or_404(Question, id=pk_question)
answers = gs.answer_set.all()
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
_ = form.save()
redirect_url = gs.get_absolute_url()
return HttpResponseRedirect(redirect_url)
else:
form = AnswerForm(initial={'question': str(pk_question)})
return render(
request, 'question.html',
{'question': gs, 'form': form, 'answers': answers,
'user': request.user, 'session': request.session})
def answer_question(request, question_id):
if request.user.is_authenticated():
if request.method == 'POST':
form = AnswerForm(request.POST)
if form.is_valid():
question = Question.objects.get(id = question_id)
author = request.user
text = form.cleaned_data['answer']
answer = Answer(text = text, author = author,
question = question)
answer.save()
return view_question(request, question_id)
else:
pass #TODO: validar cuando el formulario de errores.
else:
return HttpResponseRedirect('/cuentas/login')
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 qpool_add_answer(request, id):
form = AnswerForm()
question = get_object_or_404(Question, pk=id)
if request.method == 'POST':
answer = AnswerForm(request.POST, instance=question)
if answer.is_valid():
answer.save(id=question)
return redirect('question_edit', id=question.id)
else:
form = answer
return render_to_response('cpanel/add_answer.html', {
'form': form,
'question': question,
'module': 'qpool'
},
context_instance=RequestContext(request))
def question(request, id):
question = get_object_or_404(Question, id=id)
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save()
answer.author = request.user
answer.save()
url = question.get_url()
return HttpResponseRedirect(url)
else:
form = AnswerForm(initial={'question': question.id})
return render(request, 'question.html', {
'question': question,
'answers': question.answer_set.all(),
'form': form
})
def question(request, pk_question):
try:
gs = Question.objects.get(id=pk_question)
except Question.DoesNotExist:
raise Http404
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
form._user = request.user
_ = form.save()
redirect_url = gs.get_url()
return HttpResponseRedirect(redirect_url)
else:
form = AnswerForm(initial={'question': gs.id})
return render(
request, 'question.html',
{'question': gs, 'form': form})
def question_details(request, q_id):
question = get_object_or_404(Question, pk=q_id)
answers = question.answer_set.all
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
form.cleaned_data['author'] = request.user
form.cleaned_data['question'] = question
answer = form.save()
url = answer.question.get_url()
return HttpResponseRedirect(url)
else:
form = AnswerForm({'question': q_id})
return render(request, 'question.html', {
'question': question,
'answers': answers,
'form': form
})
def question_answers(request, *args, **kwargs):
question_id = args[0]
question = get_object_or_404(Question, pk=question_id)
if request.method == "POST":
form = AnswerForm(request.POST)
if form.is_valid():
answer = form.save()
url = question.get_url()
return HttpResponseRedirect(url)
else:
return HttpResponse('OK')
else:
form = AnswerForm(initial={'question': question_id})
answers = Answer.objects.filter(question=question).all()
return render(request, 'qa/question.html', {
'question': question,
'answers': answers,
'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, form.cleaned_data['answer'],
form.cleaned_data['phone'])
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'].widget = forms.HiddenInput()
return render_to_response(
'puzzles/puzzle-call-in-answer.html',
puzzle_context(request, {
'form': form,
'puzzle': puzzle
}))
def create_answer(request, question_id=None, answer_id=None):
'''create or update an answer'''
user = request.user
if request.POST:
#save form
answer = None
answer_id = request.POST["answer_id"]
if answer_id:
#editing
answer = Answer.objects.get(id=answer_id)
form = AnswerForm(request.POST, instance=answer)
if form.is_valid():
author = user.username
answer = form.save(commit=False)
answer.author = user
answer.question = Question.objects.get(pk=question_id)
answer.save()
return HttpResponseRedirect('/hello/question/%s' % question_id)
else:
args = {}
answer = None
if answer_id:
#edit current
answer = Answer.objects.get(id=answer_id)
args['question_id'] = answer.question.id
args['answer'] = answer
args['command'] = "Update"
else:
#show new form
args['question_id'] = question_id
args['command'] = "Create"
form = AnswerForm(instance=answer)
args['form'] = form
return render_to_response("create_answer.html",
args,
context_instance=RequestContext(request))
def question(request, question_pk):
template = 'question.html'
question = get_object_or_404(Question, pk=question_pk)
user = request.user
if request.method == 'POST':
answer_form = AnswerForm(request.POST)
if answer_form.is_valid():
user = request.user
if not user.is_authenticated():
return redirect('login')
answer = answer_form.save(user=user)
#return redirect('question', question.pk)
else:
answer_form = AnswerForm(initial={'question': question.pk})
context = {
'user': user,
'question': question,
'answer_form': answer_form,
}
return render(request, template, context)
