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 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_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 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):
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 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 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 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 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 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 test_invalid_contact_form(self):
form = ContactForm({
'name': 'Innocent',
'message': 'do',
})
self.assertFalse(form.is_valid())
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 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):
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 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 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 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 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():
form = ContactForm(request.form)
if form.validate_on_submit():
model = ContactModel()
form.populate_obj(model)
model.send()
flash_success(gettext(u'Twoja wiadomość została wysłana. Skontaktuję się z Tobą w najbliższym czasie.'))
return redirect(url_for('front.contact'))
return render_template('pages/contact.html', form=form)
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 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 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):
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_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_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 index(request):
enterpriseEmail = "*****@*****.**"
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
name = form.cleaned_data["Name"]
email = form.cleaned_data["Email"]
message = form.cleaned_data["Message"]
form = ContactForm()
server = smtplib.SMTP_SSL('smtp.gmail.com', 465)
server.login(enterpriseEmail, "aG7nOp4FhG")
msg = name + "\n" + email + "\n" + message
msg = msg.encode('utf-8')
server.sendmail(msg=msg,
from_addr=email,
to_addrs=[enterpriseEmail])
return render(request, 'index.html', {'form': form})
else:
form = ContactForm()
return render(request, 'index.html', {'form': form})
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)
