def post(self, request):
contact_form = ContactForm(request.POST)
request.session.update(
{'is_last_form_submit_valid': contact_form.is_valid()})
if contact_form.is_valid():
request.session.update(contact_form.cleaned_data)
return redirect(reverse('main:index'))
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 test_contact_send(self):
form = ContactForm(
data={
'name': 'John Doe',
'email': '*****@*****.**',
'subject': 'Test',
'text': 'this is a test'
})
with override_settings(CONTACT_EMAIL='*****@*****.**'):
form.is_valid()
with self.assertNotRaises(SMTPException):
form.send()
def test_contact_send(self):
form = ContactForm(
data={
"name": "John Doe",
"email": "*****@*****.**",
"subject": "Test",
"text": "this is a test",
})
with override_settings(CONTACT_EMAIL="*****@*****.**"):
form.is_valid()
with self.assertNotRaises(SMTPException):
form.send()
def profile_contact(request, user_id):
if request.method == 'POST':
user = User.objects.get(id=user_id)
contact_form = ContactForm(request.POST)
print('1')
if contact_form.is_valid():
body = render_to_string(template_name='email/contactmessage.txt',
context={
'name':
user.get_full_name(),
'sender':
contact_form.cleaned_data['name'],
'sender_email':
contact_form.cleaned_data['email'],
'message':
contact_form.cleaned_data['message']
})
email = EmailMessage(
subject=contact_form.cleaned_data['subject'],
body=body,
to=[user.email, contact_form.cleaned_data['email']],
from_email='*****@*****.**')
email.send()
messages.success(request, "E-Mail erfolgreich gesendet!")
return redirect("profile_show", user_id)
else:
messages.error(request,
"Ihre E-Mail konnte nicht gesendet werden!")
return render(request, 'main/movie_new.html',
{'contact_form': contact_form})
else:
print('2')
return redirect("profile_show", user_id)
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):
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.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 test_invalid_contact_form(self):
form = ContactForm({
'name': 'Innocent',
'message': 'do',
})
self.assertFalse(form.is_valid())
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 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 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 test_invalid_contact_form(self):
form = ContactForm({
'name': 'Kali Rose',
'content': 'Hi'
})
self.assertFalse(form.is_valid())
self.assertEqual(self.send_mail_celery_mock.delay.call_count, 0)
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_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 index(request):
form = ContactForm(request.POST or None)
data = {}
if request.is_ajax():
if form.is_valid():
form.save()
data['name'] = form.cleaned_data.get('name')
data['status'] = 'ok'
return JsonResponse(data)
def get_ip(request):
address = request.META.get('HTTP_X_FORWARDED_FOR')
if address:
ip = address.split(',')[-1].strip()
else:
ip = request.META.get('REMOTE_ADDR')
return ip
ip = get_ip(request)
u = User(user=ip)
print(ip)
result = User.objects.filter(Q(user__icontains=ip))
if len(result) == 1:
print('user exits')
elif len(result) > 1:
print('users exists')
else:
u.save()
print('This is a new user')
count = User.objects.all().count()
print('total visitors', count)
context = {'form': form, 'count': count}
return render(request, 'main/index.html', context)
def message(request):
contact = Contact.objects.all()
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\nКонтакты: имя - %s, телефон - %s, email - %s\nСообщение: %s" % (
theme, 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 = {
"services": Service.objects.all(),
"form": form,
"thanks": "Спасибо, ваша заявка отправлена!",
"contact": contact[0],
}
return render(request, "main/form.html", context)
context = {
"services": Service.objects.all(),
"form": form,
"contact": contact[0],
}
return render(request, "main/form.html", context)
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)
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 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_contact_form_invalid(self):
form = ContactForm(
data={
'name': 'John Doe',
'email': 'not_an_email',
'subject': 'Test',
'text': 'this is a test'
})
self.assertFalse(form.is_valid())
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 test_contact_form_invalid(self):
form = ContactForm(
data={
"name": "John Doe",
"email": "not_an_email",
"subject": "Test",
"text": "this is a test",
})
self.assertFalse(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 test_contact_form(self):
form = ContactForm(
data={
"name": "John Doe",
"email": "*****@*****.**",
"subject": "Test",
"text": "this is a test",
})
self.assertTrue(form.is_valid())
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_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 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 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 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):
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 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 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 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 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 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 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 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 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 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(reguest):
#if reguest.is_ajax():
if reguest.method == 'POST':
form = ContactForm(reguest.POST)
if form.is_valid():
subject = form.cleaned_data['name']
sender = form.cleaned_data['email']
message = form.cleaned_data['message']
try:
send_mail(sender, subject, message)
except BadHeaderError:
return HttpResponse('Invalid header found')
#return render(reguest, 'ok.html')
form.save()
return HttpResponse({'message': 'success'})
else:
form = ContactForm()
return render(reguest, 'contact.html', {'form': form})
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 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 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):
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):
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 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 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 }))
