def ask(request):
user = get_authenticate_user(request)
context = {'user': user}
form = QuestionForm()
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
question = Question.objects.create(
author=user,
title=form.cleaned_data.get('title'),
content=form.cleaned_data.get('content'),
created=datetime.now()
)
tags = form.cleaned_data.get('tags').split(',')
for tag in tags:
try:
if ' ' in tag:
tag = tag.replace(' ', '_')
t = Tag.objects.get(title=tag)
except Tag.DoesNotExist:
t = Tag.objects.create(title=tag)
t.save()
question.tags.add(t)
question.save()
return HttpResponseRedirect('/question/' + str(question.id))
context.update({'form': form})
return render(request, 'ask.html', context)
def add_question(request):
# Get the context from the request.
context = RequestContext(request)
# A HTTP POST?
if request.method == 'POST':
question_form = QuestionForm(request.POST)
#choice_form = ChoiceForm(request.POST,question_form)
# Have we been provided with a valid form?
if question_form.is_valid(): # and choice_form.is_valid():
# Save the new category to the database.
question_form.save(commit=True)
#choice_form.save(commit=True)
# Now call the index() view.
# The user will be shown the homepage.
return HttpResponseRedirect('/polls/')
else:
# The supplied form contained errors - just print them to the terminal.
print question_form.errors#,choice_form.errors
else:
# If the request was not a POST, display the form to enter details.
# form = QuestionForm()
question_form = QuestionForm()
choice_form = ChoiceForm()
# Bad form (or form details), no form supplied...
# Render the form with error messages (if any).
return render_to_response('polls/add_question.html', {'question_form': question_form }, context)
def updateqn(request, id):
polls = Question.objects.get(id=id)
form = QuestionForm(request.POST, instance = polls)
if form.is_valid():
form.save()
return redirect('/polls/viewqn')
return render(request, 'editqn.html', {'form': form})
def get_question(request):
# if this is a POST request we need to process the form data
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = QuestionForm(request.POST)
# check whether it's valid:
if form.is_valid():
question_body = request.POST.get('your_question', '')
new_question = Question(question_text=question_body, pub_date=timezone.now())
new_question.save()
characters = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w',
'x','y','z']
for i in range(0, 5):
answer_text = 'your_answer_' + characters[i]
new_answer = request.POST.get(answer_text, '')
if new_answer != '':
new_choice = Choice(question=new_question, choice_text=new_answer, votes=0)
new_choice.save()
# process the data in form.cleansed_data as required
# ...
# redirect to a new URL:
return HttpResponseRedirect('/polls/')
# if a GET (or any other method) we'll create a blank form
else:
form = QuestionForm()
return render(request, 'polls/question.html', {'form': form})
def post(self, request):
form = QuestionForm(request.POST)
if form.is_valid():
question_text = form.cleaned_data["question_text"]
pub_date = form.cleaned_data["pub_date"]
Question.objects.create(question_text=question_text,
pub_date=pub_date)
return HttpResponseRedirect(reverse("polls:my-questions"))
return render(request,
template_name="my_name.html",
context={"form": form})
def new_question(request):
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, "Question ajoutée")
else:
messages.error(request, "Formulaire invalide")
else:
messages.error(request, "Formulaire non trouvé")
return redirect('polls:list')
def add_question(request):
if request.method == 'POST':
form = QuestionForm(data=request.POST, user=request.user)
if form.is_valid():
form.save(commit=True)
return HttpResponseRedirect('/polls/')
#return IndexView(request)
else:
print form.errors
else:
form = QuestionForm(user=request.user);
return render(request, 'polls/add_question.html',{'form': form})
def question_create(request):
if request.method == 'GET':
return redirect(reverse_lazy('question_list'))
poll_id = request.POST.get('poll')
question_form = QuestionForm(request.POST)
if question_form.is_valid():
question_form.save()
return redirect(reverse_lazy('poll_item', args=[poll_id]))
return render(request, 'question/form.html', {'form': question_form})
def get_question(request):
form = QuestionForm(request.POST or None)
if request.method == "POST":
if form.is_valid():
question_text = form.cleaned_data["question_text"]
pub_date = form.cleaned_data["pub_date"]
Question.objects.create(question_text=question_text,
pub_date=pub_date)
return HttpResponseRedirect(reverse("polls:question_form"))
return render(request,
template_name="my_name.html",
context={"form": form})
def post(self, request, *args, **kwargs):
"""
Handles POST requests. Instantiates a form instance and its inline
formsets with the passed POST inputs, then checks for
validity.
"""
self.object = None
form = QuestionForm(self.request.POST)
choice_form = ChoiceInlineFormSet(self.request.POST)
if (form.is_valid() and choice_form.is_valid()):
return self.form_valid(form, choice_form)
else:
return self.form_invalid(form, choice_form)
def ask_question(req):
if req.user.is_authenticated:
if req.method == 'POST':
form = QuestionForm(req.POST,profile=req.user.profile)
if form.is_valid():
form.save()
render_to = req.GET.get('next')
return HttpResponseRedirect(render_to)
else:
form = QuestionForm()
return render(req,'q.html', {'form':form})
else:
render_to = req.GET.get('next')
return HttpResponseRedirect(render_to)
def add_poll(request):
if request.user.is_authenticated():
if request.method == "POST":
form = QuestionForm(request.POST)
if form.is_valid():
form.save(commit=True)
return index(request)
else:
print form.errors
else:
form = QuestionForm
return render(request, 'polls/add_poll.html', {'form':form})
else:
return HttpResponseRedirect('/polls/')
def question_update(request):
if request.method == "POST":
question_id = request.POST.get('record', '')
poll_id = request.POST.get('poll')
info = get_object_or_404(Questions, id=question_id)
question_form = QuestionForm(request.POST, instance=info)
if question_form.is_valid():
question_form.save()
return redirect(reverse_lazy('poll_item', args=[poll_id]))
return render(request, 'question/form.html', {'form': question_form})
def contact(request):
form = QuestionForm(request.POST or None)
title = "Contact form"
confirm_message = None
if form.is_valid():
name = form.cleaned_data["name"]
subject = form.cleaned_data["subject"]
emailFrom = form.cleaned_data["email"]
emailTo = [settings.EMAIL_HOST_USER]
send_mail(name, subject, emailFrom, emailTo, fail_silently=True)
title = "Thanks!"
confirm_message = "Thanks for sending message!"
form = None
# context = {'title':title, 'confirm_message':confirm_message, 'form':form}
template = "polls/contact.html"
return render(request, template, {"title": title, "confirm_message": confirm_message, "form": form})
def list(request):
questions = Question.objects.all()
context = {
'questions': questions,
'form': QuestionForm(),
}
return render(request, 'polls/list.html', context)
def post(request):
if request.method == 'POST':
question_form = QuestionForm(request.POST)
choice_form = ChoicesForm(request.POST)
if all([question_form.is_valid(), choice_form.is_valid()]):
question = Question(
question_text=question_form.cleaned_data['question_text'],
pub_date=timezone.now())
question.save()
choices = request.POST.getlist('choices_text')
for choice in choices:
question.choices_set.create(
choices_text=choice,
votes=0)
return HttpResponse("saved")
else:
return HttpResponse('f**k')
def get(self, request, *args, **kwargs):
"""
Handles GET requests. Instantiates blank versions of the form
and its inline formsets.
"""
self.object = None
form = QuestionForm()
choice_form = ChoiceInlineFormSet()
return self.render_to_response(
self.get_context_data(form=form, choice_form=choice_form))
def edit_questions(request, poll_name):
"""
Editing form and handler for adding new questions.
"""
poll = Poll.objects.get(url=poll_name)
ChoiceForms = inlineformset_factory(Question, Choice, fields=('value',))
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
q = form.save(commit=False)
cf = ChoiceForms(request.POST, instance=q)
if cf.is_valid():
q.save()
cf.save()
QLink.objects.create(
poll=poll,
question=q
)
return redirect('poll-edit-questions', poll.url)
else:
cf = ChoiceForms()
else:
form = QuestionForm()
cf = ChoiceForms()
return render(
request,
'polls/poll/questions.html',
{
'poll': poll,
'questions': poll.questions_in_order().all(),
'form': form,
'choice_forms': cf,
'old_questions': Question.objects.all()
}
)
def registerQ(request):
#로그인 여부를 체크하는 코드
if 'loginstate' in request.session:
if request.method == "GET": #해당 뷰를 GET 방식으로 요청시(페이지 접근)
#QuestionForm 객체를 생성 - HTML에서 form 태그 컨텐츠안에 넣으면 됨
obj = QuestionForm()
return render(request, 'polls/registerQ.html', {'form': obj})
else: #해당 뷰를 POST방식으로 요청시
#request.POST.get("") form내에 있는 특정 변수값을 가져올때
#request.POST form내에 있는 모든 값을 사용
#POST방식으로 온 데이터를 QuestionForm에 삽입
obj = QuestionForm(request.POST, request.FILES)
#obj.is_valid() : 사용자가 <form>에 있는 양식을 잘 작성했는지 확인(True,False)
if obj.is_valid(): #값이 유효한가?
#obj.save() : QuestionForm을 Question 객체로 변환 후,데이터베이스에 저장
#obj.save(commit = False) : QuestionForm을 Question객체로 변환
user = get_object_or_404(CustomUser,
pk=request.session['username'])
question = obj.save(commit=False)
question.pub_date = datetime.now()
question.customuser = user #CustomUser 객체를 매칭
question.save() #데이터베이스에 반영
return HttpResponseRedirect(reverse('polls:index'))
else: #값이 유효하지 않을때 처리
return render(request, 'polls/registerQ.html', {
'form': obj,
'error_message': "비정상적인 값입니다."
})
else: #세션에 loginstate값이 없는 경우(비로그인 상태)
return render(request, 'polls/error.html',
{'error': '로그인 후 접근할 수 있는 페이지입니다.'})
def post(self, request):
form = QuestionForm(request.POST)
if form.is_valid():
question = form.save(commit=false)
text = form.cleaned_data['question']
form = QuestionForm()
#return redirect('polls:polls')
args = {'form': form, 'text': text}
return render(request, self.template_name, args)
def create(request):
if request.method == 'POST': # form 에서 요청이 POST로 오면
form = QuestionForm(request.POST)
if form.is_valid():
q = form.save(commit=False)
q.author = request.user
q.pub_date = timezone.now()
q.save()
return redirect('polls:index')
else: # form 에서 요청이 GET으로 오면 아래 form 형식을 출력하여 사용자가 입력하게끔
form = QuestionForm()
return render(request, 'polls/create.html', {
'form': form,
})
def add(request):
# Implementamos el flujo GET
if request.method == 'GET':
# Creamos el formulario para preguntas
form = QuestionForm()
# Renderizamos el add.html con el formulario limpio
return render(request, 'polls/add.html', {'form': form})
# Implementamos el flujo POST
elif request.method == 'POST':
# Cargamos los datos posteados en un formulario
form = QuestionForm(request.POST)
# Guardamos los datos
form.save()
# Renderizamos el add.html con el formulario limpio y un mensaje de éxito
return render(request, 'polls/add.html', {
'form': QuestionForm(),
'message': 'Datos guardados correctamente'
})
def pollqn(request):
if request.method == "POST":
print("POST4")
form = QuestionForm(request.POST)
#print(form.cleaned_data['question_text'])
print("POST3")
if form.is_valid():
print("POST1")
try:
form.save()
print("POST2")
return redirect('/polls/viewqn')
except:
pass
else:
print("GET")
form = QuestionForm()
return render(request,'indexqn.html',{'form':form})
def registerQ(request):
if request.session['loginstate'] == True:
if request.method =="GET":
obj = QuestionForm()
return render(request, 'polls/registerQ.html', {'form' : obj })
else:
obj = QuestionForm(request.POST,request.FILES)
if obj.is_valid():
user = get_object_or_404(CustomUser, pk = request.session['username'])
question = obj.save(commit=False)
question.pub_date = datetime.now()
question.customuser = user
question.save()
return HttpResponseRedirect(reverse('polls:index'))
else:
return render(request, 'polls/registerQ.html',
{'form' : obj, 'error_message' : "비정상적인 값입니다."})
else:
return render(request,'polls/error.html', {'error': '로그인 후 접근할 수 있는 페이지입니다.'})
def edit_questions(request, poll_name):
"""
Editing form and handler for adding new questions.
"""
poll = Poll.objects.get(url=poll_name)
ChoiceForms = inlineformset_factory(Question, Choice, fields=('value', ))
if request.method == 'POST':
form = QuestionForm(request.POST)
if form.is_valid():
q = form.save(commit=False)
cf = ChoiceForms(request.POST, instance=q)
if cf.is_valid():
q.save()
cf.save()
QLink.objects.create(poll=poll, question=q)
return redirect('poll-edit-questions', poll.url)
else:
cf = ChoiceForms()
else:
form = QuestionForm()
cf = ChoiceForms()
return render(
request, 'polls/poll/questions.html', {
'poll': poll,
'questions': poll.questions_in_order().all(),
'form': form,
'choice_forms': cf,
'old_questions': Question.objects.all()
})
def get_question(request):
print request.user
form = QuestionForm(instance=Question.objects.all().last())
return render(request, 'question.html', {'form': form})
def create_question(request):
question = Question.objects.get_or_create(question_text='hello')[0]
form = QuestionForm(instance=question)
return render(request, 'question.html', {'form': form})
def get_latest_question(request):
form = QuestionForm(instance=Question.objects.all().latest("pub_date"))
return render(request, 'question.html', {'form': form})
def get(self, request):
form = QuestionForm()
return render(request, self.template_name, {'form': form})
def get(self, request): #read - pokazuje o co prosimy
form = QuestionForm()
return render(request,
template_name="my_name.html",
context={"form": form})
