def contact_view(request):
context = {}
form = ContactForm()
context['form'] = form
if request.method == 'POST':
form = ContactForm(request.POST)
context['form'] = form
if form.is_valid():
name_v = form.cleaned_data['name']
email_v = form.cleaned_data['email']
phone_v = form.cleaned_data['phone']
message_v = form.cleaned_data['message']
# message_v = "Message from: %s\n Phone: %s\n Email: %s\n Message: %s\n" % name_v, phone_v, email_v, form.cleaned_data['message']
send_mail('STATES SITE MESSAGE FROM %s' % name_v,
message_v,
email_v,
[settings.EMAIL_HOST_USER],
fail_silently=False
)
context['message_success'] = "email sent"
else:
context['message_success'] = form.errors
elif request.method == 'GET':
form = ContactForm()
context['form'] = form
return render_to_response('contact_view.html', context,
context_instance=RequestContext(request))
def contact(request):
context = {}
form = ContactForm()
if request.method =='POST':
print 'post'
form = ContactForm(request.POST)
context['form'] = form
if form.is_valid():
print 'valid'
name = form.cleaned_data['name']
email = form.cleaned_data['email']
message = form.cleaned_data['message']
send_mail('PORTFOLIO SITE MESSAGE FROM %s' % name,
message, email,
[settings.EMAIL_HOST_USER],
fail_silently=False)
context['message'] = "email sent"
return redirect('/home/')
else:
print 'bad'
context['message'] = form.errors
elif request.method == 'GET':
print 'get'
form = ContactForm()
context['form'] = form
print 'done'
return render_to_response('contact.html', context, context_instance=RequestContext(request))
def contact(request):
contact_form = ContactForm(prefix='contact')
if contact_form.is_valid():
contact_form.save()
return Response(status=status.HTTP_200_OK)
else:
return Response(status=status.HTTP_403_FORBIDDEN)
def contact_view(request):
context = {}
form = ContactForm
context['form'] = form
if request.method == 'POST':
form = ContactForm(request.POST)
context['form'] = form
if form.is_valid():
name = form.cleaned.data['name']
email = form.cleaned.data['email']
phone = form.cleaned.data['phone']
message = form.cleaned.data['message']
send_mail('CEREAL SITE MESSAGE %s' %
message,
email,
[settings.EMAIL_HOST_USER],
fail_silently=False
)
context['message'] = "email sent thank you"
else:
context['errors'] = forms.errors
elif request.method == 'GET':
form = ContactForm()
context['form'] = form
return render_to_response('contact_view.html', context, context_instance=RequestContext(request))
def contact(request):
if request.is_ajax():
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
name = request.POST.get("name", "")
subject = "Contact from {0}".format(name)
from_email = request.POST.get("email", "")
body = """
Name: {0}
Phone Number: {1}
E-mail: {2}
Message: \n {3}""".format(
name, request.POST.get("phone", ""), from_email, request.POST.get("message", "")
)
try:
send_mail(subject, body, from_email, ["*****@*****.**"])
message = "FORM IS VALID"
except BadHeaderError:
message = "Invalid Header Found"
form.save()
else:
message = "Form is INVALID"
else:
raise Http404
return HttpResponse(message)
else:
raise Http404
def contact_view(request):
context = {}
form = ContactForm()
context['form'] = form
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
email = form.cleaned_data['email']
phone = form.cleaned_data['phone']
message = form.cleaned_data['message']
send_mail('MANUFACTURERS SIT MESSAGE FROM %s' % name,
message,
email,
[settings.EMAIL_HOST_USER],
fail_silently=False
)
context['message'] = "email sent"
else:
context['message'] = form.errors
elif request.method == 'GET':
form = ContactForm()
context['form'] = form
return render_to_response('contact_view.html', context, context_instance=RequestContext(request))
def contact(request, template_name = 'index.html'):
if request.method == 'POST':
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
post_data = contact_form.cleaned_data
nom = post_data.get('nom','')
tel = post_data.get('tel','')
from_email = post_data.get('email')
body = post_data.get('message')
recipient_list = list(settings.RECIPIENT_LIST)
subject = 'HorizonPlus : Vous avez recu un email de %s' % from_email
message = body
message += '<br />------------------------------------'
message += '<br />%s (%s)' % (nom, tel)
send_mail(subject, message, from_email, recipient_list)
message = '<strong>votre message a bien ete envoye. Nous vous repondrons dans les plus brefs delais.</strong>'
info(request, message, extra_tags='success')
else:
contact_form = ContactForm()
context = {
'contact_form' : contact_form,
}
return render(request, template_name, context)
def test_contact_form(self):
form = ContactForm(
data={
"name": "John Doe",
"email": "*****@*****.**",
"subject": "Test",
"text": "this is a test",
})
self.assertTrue(form.is_valid())
def contact(request):
form = ContactForm(request.POST or None)
if form.is_valid():
ContactMail(form)
return redirect('posts:index')
return render(request, 'main/contact.html', locals())
def post(self, *args, **kwargs):
data = self.request.POST
form = ContactForm(data)
if form.is_valid():
form.save()
# Response
return self.render_json_response({'sent': True})
else:
return self.render_json_response({'error': True})
def test_valid_contact_form(self):
form = ContactForm({
'name': 'Kimmy Granger',
'email': '*****@*****.**',
'content': 'How are you?'
})
self.assertTrue(form.is_valid())
with self.assertLogs('main.forms', level='INFO') as cm:
form.send_customer_service_email()
self.assertEqual(self.send_mail_celery_mock.delay.call_count, 1)
self.assertGreaterEqual(len(cm.output), 1)
def test_valid_contact_form_sends_email(self):
form = ContactForm({
'name': 'Innocent',
'message': 'At least four words',
})
self.assertTrue(form.is_valid())
form.send_mail()
self.assertEqual(len(mail.outbox), 1)
def message(request):
onas = Onas.objects.all()
problem = Problem.objects.all()
menu = get_list_or_404(Mainmenu)
home = get_list_or_404(Home)
contact = get_list_or_404(Contact)
form = ContactForm(request.POST or None)
if form.is_valid():
name = form.cleaned_data.get("name")
phone = form.cleaned_data.get("phone")
email = form.cleaned_data.get("sender")
theme = form.cleaned_data.get("theme")
message = form.cleaned_data.get("message")
from_email = settings.EMAIL_HOST_USER
to_email = ['*****@*****.**']
contact_message = "Контакты: имя - %s, телефон - %s, email - %s.\nСообщение: %s" % (
name, phone, email, message)
try:
send_mail(theme,
contact_message,
from_email,
to_email,
fail_silently=False)
except BadHeaderError:
return HttpResponse('Invalid header found')
form = ContactForm()
context = {
"onas": onas,
"problem": problem,
"menu": menu[0],
"one": Submenu.objects.filter(menu__isnull=True),
"more": Submenu.objects.filter(menu__isnull=False),
"uslugi": get_list_or_404(Uslugi),
"home": home[0],
"form": form,
"thanks": "Спасибо, ваша заявка отправлена!",
"contact": contact[0],
"feeds": feedparser.parse('http://4pda.ru/feed/')
}
return render(request, "main/form.html", context)
context = {
"onas": onas,
"problem": problem,
"menu": menu[0],
"one": Submenu.objects.filter(menu__isnull=True),
"more": Submenu.objects.filter(menu__isnull=False),
"uslugi": get_list_or_404(Uslugi),
"home": home[0],
"form": form,
"contact": contact[0],
"feeds": feedparser.parse('http://4pda.ru/feed/')
}
return render(request, "main/form.html", context)
def post(self, request):
form = ContactForm(request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
email = form.cleaned_data['email']
message = form.cleaned_data['message']
try:
send_mail(subject, message, email, ['*****@*****.**', '*****@*****.**'])
except BadHeaderError:
return HttpResponse('Invalid header found.')
return redirect(reverse('main:success'))
return render(request, 'main/contact.html', {'form': form})
def contact_view(request):
form = ContactForm(request.POST or None)
title = 'Contact Form'
message = None
if form.is_valid():
name = form.cleaned_data['name']
email = form.cleaned_data['email']
comment = form.cleaned_data['comment']
title = 'Thanks!'
message = 'Thanks for your comment {0}. Will get back to you!'.format(
name)
context = {'form': form, 'title': title, 'message': message}
template_name = 'main/contact.html'
return render(request, template_name, context)
def feedback(request):
contact_form = ContactForm(request.POST)
if request.POST:
print "NotError"
if contact_form.is_valid():
print "NotError"
c = Contacts()
c.name = contact_form.cleaned_data['name']
c.email = contact_form.cleaned_data['email']
c.phone = contact_form.cleaned_data['phone']
c.comment = contact_form.cleaned_data['comment']
c.save()
return JsonResponse(dict(success=True, message='Успешно!!'))
return JsonResponse(dict(success=False, message='Форма не валидна'))
def contact(request):
if request.method == 'POST' and request.is_ajax():
form = ContactForm(request.POST)
logger.debug(request.POST)
if form.is_valid():
form.save()
response = 'Dziękujemy, twoja wiadomość została wysłana.'
return HttpResponse(response, 'text/html')
else:
template = 'main/contact.html'
context = RequestContext(request, dict(form=form))
response = render_to_string(template, context)
return HttpResponse(response, 'text/html')
def test_valid_contact_us_forms_sends_email(self):
form = ContactForm({
'name': 'Olumide Ogundele',
'message': 'Hello There',
})
self.assertTrue(form.is_valid())
# using a context manager to send the mail
with self.assertLogs('main.forms', level='INFO') as cm:
form.send_mail()
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(mail.outbox[0].subject, 'Site message')
self.assertGreaterEqual(len(cm.output), 1)
def contact(request):
if not request.user.is_authenticated():
return redirect(reverse(index))
else:
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
send_mail(cd['subject'], cd['message'],
'*****@*****.**',
['*****@*****.**', cd['email']])
return redirect(reverse(index))
else:
form = ContactForm()
return render(request, 'contact.html', locals())
def get(self, request):
form = ContactForm()
context = {'form': form}
if(self.lang == 'pt-br'):
return render(request, 'pt-br/contact.html', context)
return render(request, 'contact.html', context)
def index(request):
request.session['page_id'] = 1
banner = Banner.objects.all()
about_us = AboutUs.objects.all()[:1]
members = Members.objects.all()
paginator = Paginator(News.objects.all().order_by('-date'), 8)
_news = paginator.page(1)
page_count = paginator.num_pages
info_title = InformationTitle.objects.all()
service = Service.objects.order_by('id')
contact_form = ContactForm(request.POST)
slider = Slider.objects.order_by('id')
post = Emails.objects.all()
number = Phones.objects.all()
params = {
'banner': banner,
'about_us': about_us,
'members': members,
'news': _news,
'page_count': page_count,
'type': info_title,
'service': service,
'form': contact_form,
'slider': slider,
'post': post,
'number': number,
}
return render(request, 'app/index.html', params)
def post(self, request):
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
sender = contact_form.cleaned_data['sender']
cc_myself = contact_form.cleaned_data['cc_myself']
recipients = ['*****@*****.**']
if cc_myself:
recipients.append(sender)
context = {}
request.session.update(contact_form.cleaned_data)
request.session.update({'recipients': recipients})
return redirect(reverse('main:index'))
def index_page(request):
works_list = Works.objects.all()
# works_list = Works.objects.filter(category=2).order_by("-start_date")
paginator = Paginator(works_list, 40)
page = request.GET.get("page")
try:
works = paginator.page(page)
except PageNotAnInteger:
works = paginator.page(1)
except EmptyPage:
works = paginator.page(paginator.num_pages)
errors = []
if request.method == "POST":
if not request.POST.get("name", ""):
errors.append("Введите ваше имя")
if not request.POST.get("email", ""):
errors.append("Введите ваш e-mail")
if not request.POST.get("message", ""):
errors.append("Введите ваше сообщение")
form = ContactForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
send_mail(cd["name"], cd["message"], cd.get("email", "*****@*****.**"), ["*****@*****.**"])
form.save()
return HttpResponseRedirect("/thanks/")
else:
form = ContactForm()
return render(
request,
"main.html",
{
"services": Services.objects.all(),
"works": works,
"client_list": Clients.objects.all(),
"slides_list": Slider.objects.all(),
"form": form,
"errors": errors,
"about": About.objects.all(),
},
)
def contact(request):
form = ContactForm()
if form.is_valid():
name = form.cleaned_data['name']
from_email = form.cleaned_data['email']
subject = form.cleaned_data['subject']
message = form.cleaned_data['message']
recipient_list = ['*****@*****.**']
try:
send_mail(subject, message, from_email, recipient_list)
return response('Email sent successfully')
except SMTPException as e:
return response('There was an error sending an email: ', e)
return render(request, 'contact.html', {'form': form})
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
# send_mail(
# cd['subject'],
# cd['message'],
# cd.get('email', '*****@*****.**'),
# ['*****@*****.**'],
# )
return HttpResponseRedirect('/contact/thanks/')
else:
form = ContactForm(
initial={'subject': 'I love your site!'}
)
return render(request,'contact_form.html', {'form': form})
def contact(request):
template = 'contact.html'
if request.method == 'POST':
form = ContactForm()
else:
form = ContactForm(request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
name = form.cleaned_data['name']
email = form.cleaned_data['email']
message = form.cleaned_data['message']
try:
send_mail(subject, message, email, ['*****@*****.**'])
except BadHeaderError:
return HttpResponse('Invalid header found.')
return redirect('sucess')
return render(request, template, {'form': form})
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
# email myself
customer_email = form.cleaned_data.get('from_email')
content = form.cleaned_data.get('message')
to_email = '*****@*****.**'
from_email = '*****@*****.**'
subject = "SolidComposer Contact Message from {0}".format(
customer_email)
message = get_template('contact_message.txt').render(
Context({
'email': customer_email,
'content': content
}))
msg = EmailMessage(subject,
message,
from_email, [to_email],
headers={'Reply-To': customer_email})
msg.send(fail_silently=True)
return render_to_response('contact_thanks.html',
locals(),
context_instance=RequestContext(request))
else:
if request.user.is_authenticated():
form = ContactForm(initial={'from_email': request.user.email})
else:
form = ContactForm()
return render_to_response('contact.html',
locals(),
context_instance=RequestContext(request))
def test_post_invalid_form(
self,
monkeypatch,
client,
name: str,
contact_email: str,
subject: str,
message: str,
):
"""
When invalid forms are submitted, ensures we have a page rediction
(return code 302) and that the email function is not called,
"""
mock_send_mail = Mock()
monkeypatch.setattr("main.views.send_mail", mock_send_mail)
invalid_form = ContactForm()
invalid_form.name = name
invalid_form.contact_email = contact_email
invalid_form.subject = subject
invalid_form.message = message
contact_us_url = reverse("contact_us")
response = client.post(
contact_us_url,
data=invalid_form.json(),
HTTP_REFERER=contact_us_url,
)
mock_send_mail.assert_not_called()
assert "main/contact_us.html" in (t.name for t in response.templates)
assert response.status_code == 200
def contact_view(request):
context = {}
form = ContactForm()
context['form'] = form
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
email = form.cleaned_data['email']
phone = form.cleaned_data['phone']
message = form.cleaned_data['message']
send_mail('STATES SIT MESSAGE FROM %s' % name,
message,
email, [settings.EMAIL_HOST_USER],
fail_silently=False)
context['message'] = "email sent"
else:
context['message'] = form.errors
elif request.method == 'GET':
form = ContactForm()
context['form'] = form
return render_to_response('contact_view.html',
context,
context_instance=RequestContext(request))
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
contactInfo = ContactInfo.objects.get()
context['contactInfo'] = contactInfo
context['form'] = ContactForm()
if self.request.GET.get('objectName'):
print('asdasdasdsadasd', self.request.GET.get('objectName'))
context['objName'] = self.request.GET.get('objectName')
return context
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
topic = form.cleaned_data['topic']
message = form.cleaned_data['message']
sender = form.cleaned_data.get('sender', '*****@*****.**')
from django.core.mail import send_mail
send_mail(
'Feedback from your site, topic: {}'.format(topic),
message, sender,
['*****@*****.**']
)
return HttpResponseRedirect('/contact/thanks/')
else:
form = ContactForm()
return render(request,'main/contact.html', {'form': form,
'widgets': [{'img':'images/contact.png','style':'margin-top:50px;'}]})
def test_contact_form(self):
data = {
'name': 'ABC',
'email': '*****@*****.**',
'phone': '9876543210',
'subject': 'abc',
'message': 'xys'
}
self.assertTrue(ContactForm(data=data).is_valid())
response = self.client.post(reverse('main:contact'), data, follow=True)
self.assertRedirects(response, reverse('main:contact'))
def contacts(request, subj_code=0):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
sender = form.cleaned_data['sender']
message = form.cleaned_data['message']
result_message = "{0}\nОт: {1}\n{2}-версия".format(message, sender, settings.ENV_ROLE)
from_email = settings.EMAIL_HOST_USER
recipients = [from_email]
try:
send_mail(subject, result_message, from_email, recipients)
except BadHeaderError:
return HttpResponse('Invalid header found')
return render(request, 'contacts/thanks.html')
else:
form = ContactForm(subj_code=subj_code)
context = {'form': form}
return render(request, 'contacts/form.html', context)
def profile_show(request, user_id):
"""
Profile page
"""
user = get_object_or_404(User, id=user_id)
context = {
'user': user,
'contactform': ContactForm(),
'fav': FavMovies.objects.filter(user__id=user_id)
}
return render(request, 'main/profile_show.html', context)
def contact(request):
context = {}
if request.method == "POST":
form = ContactForm(request.POST)
context["form"] = form
if form.is_valid():
name = form.cleaned_data["name"]
email = form.cleaned_data["email"]
phone = form.cleaned_data["phone"]
message = form.cleaned_data["message"]
send_mail(
"MUSICAPP MESSAGE FROM %s" % name, message, email, [settings.EMAIL_HOST_USER], fail_silently=False
)
context["message"] = "email sent"
else:
context["message"] = form.errors
elif request.method == "GET":
form = ContactForm()
context["form"] = form
return render_to_response("contact.html", context, context_instance=RequestContext(request))
def contact(request):
status=""
template = "main/content/contact.html"
form = ContactForm()
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
email = EmailMessage('Dennis Wester Translating Contact',
cd["message"],
settings.EMAIL_HOST_USER,
['*****@*****.**'], #[email protected]
headers = {'Reply-To': cd["email"]})
email.send()
status = "sent"
form = ContactForm()
return render(request, template, {'form':form, 'status':status})
def contact(request):
""" Send contact emails """
if request.method == "POST": # If the form has been submitted...
form = ContactForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
#name = form.cleaned_data['name']
subject = form.cleaned_data['subject']
message = form.cleaned_data['message']
sender = form.cleaned_data['sender']
cc_myself = form.cleaned_data['cc_myself']
recipients = ['*****@*****.**']
if cc_myself:
recipients.append(sender)
send_mail(subject, message, sender, recipients)
return HttpResponseRedirect('/app/email/thanks/') # Redirect after POST
else:
form = ContactForm() # An unbound form
return render(request, 'contact.html', {'form': form,})
def contact(request):
form = ContactForm(request.POST or None)
if form.is_valid():
instance = form.save(commit=False)
name = instance.name
email = instance.email
message = instance.message
EmailMessage(
'New message from %s' % name,
'Hi admin, new message form this email address: %s\n\n Message: %s'
% (email, message),
conf_settings.EMAIL_HOST_USER,
[
'*****@*****.**',
],
).send()
form.save()
messages.success(request, 'Your message has been sent!')
return redirect('contact')
context = {'form': form}
return render(request, 'main/contact.html', context)
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
# email myself
customer_email = form.cleaned_data.get('from_email')
content = form.cleaned_data.get('message')
to_email = '*****@*****.**'
from_email = '*****@*****.**'
subject = "SolidComposer Contact Message from {0}".format(customer_email)
message = get_template('contact_message.txt').render(Context({'email': customer_email, 'content': content}))
msg = EmailMessage(subject, message, from_email, [to_email], headers={'Reply-To': customer_email})
msg.send(fail_silently=True)
return render_to_response('contact_thanks.html', locals(), context_instance=RequestContext(request))
else:
if request.user.is_authenticated():
form = ContactForm(initial={'from_email': request.user.email})
else:
form = ContactForm()
return render_to_response('contact.html', locals(), context_instance=RequestContext(request))
def mock_contact_form() -> ContactForm:
"""Fixture for a valid ContactForm"""
mock_form = ContactForm()
mock_form.name = "dummy name"
mock_form.contact_email = "*****@*****.**"
mock_form.subject = "dummy subject"
mock_form.message = "dummy content"
return mock_form
def home(request):
if request.method == 'POST':
form = ContactForm(request.POST or None)
if form.is_valid():
form.save()
return HttpResponse('OK')
else:
form = ContactForm()
context = {
'form': form,
}
return render(request, 'home.html', {'form': form})
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
context = {'form': form,
'subject': request.POST.get('subject', ''),
'message': request.POST.get('message', ''),
}
if form.is_valid():
cd = form.cleaned_data
return HttpResponse(render_to_string('home.html', context))
else:
form = ContactForm(initial={'subject': 'I love your'})
context = {'form': form,
'subject': request.POST.get('subject', ''),
'message': request.POST.get('message', ''),
}
t = loader.get_template('contact_form.html')
#return render_to_response('contact_form.html', {'form': form})
request_context = RequestContext(request, context)
return HttpResponse(t.template.render(request_context))
# t = loader.get_template('search.html')
# errors = []
# context = {
# 'errors': errors,
# 'subject': request.POST.get('subject', ''),
# 'message': request.POST.get('message', ''),
# }
# if request.method == 'POST':
# if not request.POST.get('subject', ''):
# errors.append('Enter a subject.')
# if not request.POST.get('message', ''):
# errors.append('Enter a message.')
# if not errors:
# request_context = RequestContext(request, context)
# return HttpResponse(t.template.render(request_context))
def contact_view(request):
context = {}
if request.method =='POST':
form = ContactForm(request.POST)
context['form'] = form
if form.is_valid():
name = form.cleaned_data['name']
email = form.cleaned_data['email']
phone = form.cleaned_data['phone']
message = form.cleaned_data['message']
send_mail("Jay's Junky Jewels: from %s" % email,
'Message from %s, %s, %s' % (name, email, phone) + '\n\n' + message, email,
[settings.EMAIL_HOST_USER],
fail_silently=False)
context['message'] = "Your email has been sent!"
else:
context['message'] = form.errors
elif request.method == 'GET':
form = ContactForm()
context['form'] = form
return render_to_response('contact_view.html', context, context_instance=RequestContext(request))
def contact(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
name = form.cleaned_data["name"]
email = form.cleaned_data["email"]
tel = form.cleaned_data["tel"]
message = form.cleaned_data["message"]
form.save()
try:
send_mail("prise de rdv", message, email, ["*****@*****.**"])
except ConnectionRefusedError:
print("ConnectionRefusedError")
return redirect(accueil)
except BadHeaderError:
return HttpResponse("invalid header found.")
return redirect(accueil)
else:
return render(request, "main/contact.html", {"form": form})
else:
form = ContactForm()
print("test")
return render(request, "main/contact.html", {"form": form})
def valid_contact_form_send_confirmation(self):
data = {
'name': 'Jimmy Test',
'email': '*****@*****.**',
'message': 'This is a test message.'
}
form = ContactForm(data=data)
form.is_valid()
form.send_confirmation()
def contact_view(request):
# если метод GET, вернем форму
if request.method == 'GET':
form = ContactForm()
elif request.method == 'POST':
# если метод POST, проверим форму и отправим письмо
form = ContactForm(request.POST)
if form.is_valid():
subject = 'Reservation'
from_email = form.cleaned_data['from_email']
message = 'Телефон: ' + form.cleaned_data[
'phone'] + '\nСтолик: ' + form.cleaned_data[
'chill_time'] + '\nПожелание: ' + form.cleaned_data[
'delicion']
try:
send_mail(f'{subject} от {from_email}', message,
DEFAULT_FROM_EMAIL, RECIPIENTS_EMAIL)
except BadHeaderError:
return HttpResponse('Ошибка в теме письма.')
return redirect('success')
else:
return HttpResponse('Неверный запрос.')
return render(request, "reservation.html", {'form': form})
def contact(request):
form = ContactForm(request.POST or None)
if form.is_valid():
# instance = form.save(commit=False)
# name = instance.name
# email = instance.email
# message = instance.message
# EmailMessage(
# 'New message from %s', %name,
# 'Hi admin, This is my message from this email address: %s\n\n Message: %s', %(email, message),
# conf_settings.EMAIL_HOST_USER,
# ['*****@*****.**'],
# ).send()
form.save()
messages.success(request, 'Your message has been sent!')
return redirect('contact')
context = {'form':form}
return render(request, 'main/contact.html', context)
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
context = {
'form': form,
'subject': request.POST.get('subject', ''),
'message': request.POST.get('message', ''),
}
if form.is_valid():
cd = form.cleaned_data
return HttpResponse(render_to_string('home.html', context))
else:
form = ContactForm(initial={'subject': 'I love your'})
context = {
'form': form,
'subject': request.POST.get('subject', ''),
'message': request.POST.get('message', ''),
}
t = loader.get_template('contact_form.html')
#return render_to_response('contact_form.html', {'form': form})
request_context = RequestContext(request, context)
return HttpResponse(t.template.render(request_context))
def contact(request):
""" Send contact emails """
if request.method == "POST": # If the form has been submitted...
form = ContactForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
#name = form.cleaned_data['name']
subject = form.cleaned_data['subject']
message = form.cleaned_data['message']
sender = form.cleaned_data['sender']
cc_myself = form.cleaned_data['cc_myself']
recipients = ['*****@*****.**']
if cc_myself:
recipients.append(sender)
send_mail(subject, message, sender, recipients)
return HttpResponseRedirect(
'/app/email/thanks/') # Redirect after POST
else:
form = ContactForm() # An unbound form
return render(request, 'contact.html', {
'form': form,
})
def test_post_valid_form(self, monkeypatch, client,
mock_contact_form: ContactForm):
"""
Test the `Go Back Home` page is rendered when user submit valid form
and that send_mail is called when a valid form is posted
"""
mock_send_mail = Mock()
monkeypatch.setattr("main.views.send_mail", mock_send_mail)
response = client.post(reverse("contact_us"),
data=mock_contact_form.json())
mock_send_mail.assert_called()
assert "main/go_back_home.html" in (t.name for t in response.templates)
assert response.status_code == 200
def contact(request):
success = False
form = ContactForm()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.send()
success = True
form = ContactForm()
return render_to_response('contact.html', RequestContext(request, {
'form': form,
'success': success,
}))
def talent_contact(request, username):
if request.user.username == username:
raise Http404
profile = get_object_or_404(UserProfile, user__username=username)
form = ContactForm()
success = False
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.send(recipient=profile.user.email)
success = True
form = ContactForm()
return render_to_response('talent_contact.html', RequestContext(request, {
'profile': profile,
'form': form,
'success': success,
}))
def edit_contact(request):
""" Edit contact """
#Get contact
try:
contact = Contact.objects.get(pk=1)
except Contact.DoesNotExist:
return HttpResponseRedirect('/')
#Handle request
if request.method == 'POST':
form = ContactForm(request.POST, instance=contact)
if form.is_valid():
try:
form.save()
form.result = True
form.message = ugettext(u'Contact updated successfully')
except DatabaseError:
form.result = False
form.message = ugettext(u'Contact save error. Try again.')
else:
form.result = False
form.message = ugettext(u"Correct errors, please")
if request.is_ajax():
response = {'message': form.message}
if not form.result:
response['result'] = 'error'
response['errors'] = form.errors
else:
response['result'] = 'ok'
return HttpResponse(dumps(response))
else:
form = ContactForm(instance=contact)
form.message = ''
return {'contact_form': form}
def property(request, pk, slug, action = None):
'''
displays the full listing for properties and functions such as contact owner,
or set up a reservation. Need to gather the property information room/pictures
and forms
'''
property = get_object_or_404(Property, id=pk)
save_impression(imp_type="P", imp_property=property)
contact = property.get_contact_user()
#perform certain actions that are passed in in the action kwarg
if action == "reserve":
load_modal = "propertyReserveModal"
elif action == "contact":
load_modal = "propertyContactModal"
elif action == "schedule":
load_modal = "propertyScheduleModal"
else:
load_modal = slug
favorited = get_favorites(request.user)
template = 'propertycontent/property.html'
base_dir = settings.BASE_DIR
related_properties = property.get_related_properties()
# get the images, videos, rooms for properties
property_images = PropertyImage.objects.filter(property=pk, floorplan=False)
floorplan_images = PropertyImage.objects.filter(property=pk, floorplan=True)
property_rooms = PropertyRoom.objects.filter(property=pk)
property_videos = PropertyVideo.objects.filter(property=pk)
# add nearby businesses to display in the nearby section. Right now there
# is no logic, but we will need to build in a model method
try:
nearby = Property.objects.filter(school=property.school, type="BUS")[0:4]
except:
nearby = []
walkscore_json = get_walkscore(property)
for p in related_properties:
save_impression(imp_type="S", imp_property=p)
#set form defaults based on if the user is logged in
if request.user.is_authenticated():
email = request.user.email
first_name = request.user.first_name
last_name = request.user.last_name
else:
email = None
first_name = None
last_name = None
#shared initial values dictionary to be used on multiple forms
initial_dict = {'first_name':first_name, 'last_name':last_name, 'email':email}
#set contact forms to use
contact_form = ContactForm()
initial_contact_form = ContactForm(initial=initial_dict)
#filter room choices and set the reserve forms
room_choices = PropertyRoom.objects.filter(property=property.id)
reserve_form = ReserveForm()
reserve_form.fields["floor_plan"].queryset = room_choices
initial_reserve_form = ReserveForm(initial=initial_dict)
initial_reserve_form.fields["floor_plan"].queryset = room_choices
#setup for the schedule form
schedule_form = ScheduleForm()
initial_schedule_form = ScheduleForm(initial=initial_dict)
'''
build a shared dictionary to be used with all renders. We will tack on other
values to the dictionary, but these will be included in all
'''
render_dict = {'property':property, 'property_images':property_images,
'property_rooms':property_rooms, 'favorited':favorited, 'contact_form':contact_form,
'reserve_form':reserve_form, 'floorplan_images':floorplan_images,
'related_properties': related_properties,
'schedule_form':schedule_form, 'property_videos':property_videos,
'nearby':nearby, 'contact':contact}
if request.method == "POST":
'''
If we're receiving a POST request, that means that one of the actions
has been taken on the property page. The user might be sending a contact
email or scheduling a tour
'''
#only send to property contact if in production
internal_email = settings.EMAIL_HOST_USER
if base_dir == "/home/studentrentit/rvprod":
# In Prod Environment, email contact
email_to = [property.get_contact_user().email]
email_bcc = [internal_email]
else:
# Not in Prod, email test/developer
email_to = ['*****@*****.**']
email_bcc = []
if 'body' in request.POST:
#handle if contact form was submitted
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
#handle if ContactForm was submitted
cd = contact_form.cleaned_data
body_footer = "<p>" + cd["first_name"] + " " + cd["last_name"] + \
" is interested in " + str(property) + " and can be reached by email at " + cd['email'] \
+ " or calling their phone at " + cd['phone_number'] + '.'
headers = {'Reply-To': cd['email']}
email_to.append(cd['email'])
#build the email and send it
msg = EmailMessage('RentVersity.com - Property Contact',
get_template('email/default.html').render(
Context({
'body':cd['body'] + body_footer,
'webURLroot' : settings.WEB_URL_ROOT,
'email_header' : 'Property Contact from RentVersitys.com'
})
),
settings.EMAIL_HOST_USER,
email_to,
headers=headers
)
msg.content_subtype = "html" # Main content is now text/html
msg.send()
contact = contact_form.save(commit=False)
contact.property = property
contact.save()
return render(request, template,
dict(render_dict, **{'contact_form':initial_contact_form, 'status':'sent'}))
else:
#contact_form errors
return render(request, template,
dict(render_dict, **{'contact_form':contact_form, 'status':'error',
'load_modal':'propertyContactModal'}))
elif 'schedule_date' in request.POST:
#handle if the schedule form was submitted
schedule_form = ScheduleForm(request.POST)
if schedule_form.is_valid():
schedule = schedule_form.save(commit=False)
schedule.property = property
#save the user if logged in
try:
schedule.user = get_user_model().objects.get(username = request.user)
except get_user_model().DoesNotExist:
pass
schedule.save()
cd = schedule_form.cleaned_data
headers = {'Reply-To': cd['email']}
body_footer = "<p>They can be reached by email at " + cd['email'] + " or calling their phone at " + cd['phone_number'] + '.'
email_to.append(cd['email'])
#build up body text
body = cd["first_name"] + " " + cd["last_name"] + ' has scheduled a tour on ' + cd['schedule_date'].strftime('%b %d %Y') + \
' at ' + cd['schedule_time'].strftime('%I:%M %p') + ' for ' + str(property) + \
'. Please follow up with them to confirm or change the appointment.'\
+ body_footer
#build the email and send it
msg = EmailMessage('RentVersity.com - Apartment Tour',
get_template('email/default.html').render(
Context({
'body' : body,
'webURLroot' : settings.WEB_URL_ROOT,
'email_header' : 'Tour Scheduled from RentVersity.com'
})
),
settings.EMAIL_HOST_USER,
email_to,
email_bcc,
headers=headers
)
msg.content_subtype = "html" # Main content is now text/html
msg.send()
return render(request, template,
dict(render_dict, **{'schedule_form':initial_schedule_form, 'status':'scheduled'}))
else:
#schedule_form errors
return render(request, template,
dict(render_dict, **{'schedule_form':schedule_form, 'status':'error',
'load_modal':'propertyScheduleModal'}))
return render(request, template,
dict(render_dict, **{'reserve_form':initial_reserve_form,
'contact_form':initial_contact_form, 'schedule_form':initial_schedule_form,
'walkscore':walkscore_json, 'contact':contact, 'load_modal':load_modal }))
