def service_list_by_category_view(request, category):
"""Shows services for a chosen category.
If url doesn't link to existing category, return user to categories list"""
template_name = 'services/service-list-by-category.html'
if request.method == "POST":
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
contact_form.save()
return redirect(reverse('accounts:profile'))
else:
if request.user.is_authenticated:
initial_data = {
"user": request.user,
"name": request.user.first_name + " " + request.user.last_name,
"email": request.user.email
}
form = ContactForm(request.POST or None, initial=initial_data)
else:
form = ContactForm()
try:
obj = ServiceCategory.objects.get(name=category)
queryset = Service.objects.filter(category=obj.pk)
context = {
"obj": obj,
"queryset": queryset,
"form": form,
}
except ServiceCategory.DoesNotExist:
messages.error(request, 'No category named <em>' + category + '</em>.')
return redirect("services:services_list")
return render(request, template_name=template_name, context=context)
def test_contact_form_escaped_tags(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
request.META['REMOTE_ADDR'] = '127.0.0.1'
recipient_email = settings.POOTLE_CONTACT_EMAIL
specified_subject = "My <tag> subject"
subject = "[%s] %s" % (settings.POOTLE_TITLE, specified_subject)
data = {
'name': admin.full_name,
'email': admin.email,
'email_subject': specified_subject,
'body': "First <tag> of message.",
}
form = ContactForm(request=request, data=data)
assert form.is_valid()
form.save()
assert len(mailoutbox) == 1
message = mailoutbox[0]
assert message.from_email == settings.DEFAULT_FROM_EMAIL
reply_to = u'%s <%s>' % (data['name'], data['email'])
assert reply_to == message.extra_headers['Reply-To']
assert [recipient_email] == message.recipients()
assert escape(subject) == message.subject
assert escape(data['body']) in message.body
assert "Your question or comment:" not in message.body
def edit(request):
try:
contact = Contact.objects.all()[0]
except IndexError:
raise Http404
if request.method == "POST":
form = ContactForm(request.POST, request.FILES, instance=contact)
if form.is_valid():
form.save()
if request.is_ajax():
response = {'status': 'OK'}
data = {'name': 'photo', 'value': contact.photo}
response['image'] = form.fields['photo'].widget.render(**data)
return HttpResponse(simplejson.dumps(response))
return redirect(reverse('index'))
else:
if request.is_ajax():
response = {'status': 'BAD'}
errors = dict()
for label_id, error in form.errors.items():
errors[label_id] = error
response['errors'] = errors
return HttpResponse(simplejson.dumps(response))
else:
form = ContactForm(instance=contact)
return render_to_response('edit.html', {'form': form,
'number': FORM_SPLIT_BY}, context_instance=RequestContext(request))
def post(self, request):
form = ContactForm(request.POST)
bot = Bot.objects.get(number=1)
contact = Contact.objects.last()
if contact and contact.phone == request.POST.get('phone'):
print('errror')
if contact and contact.email == request.POST.get('email'):
print('errror')
else:
if form.is_valid():
# Отправляем данные в телеграм
url = f'{bot.url}' + 'sendMessage'
chat_id = bot.chat_id
name = request.POST.get('name') # Поучаем имя
title = request.POST.get('title') # Получаем заголовок страницы
phone = request.POST.get('phone') # Получаем Телефон
contact_url = request.POST.get('url') # Получаем адрес страницы комментария
text = f'Заявка на обратную связь \n \n Имя: {name} \n ' \
f'Телефон: {phone} \n \n Страница: \n {title} \n \n Адрес: {contact_url}'
if name is None:
answer = {'chat_id': chat_id, 'text': 'У нас новый подписчик!'}
else:
answer = {'chat_id': chat_id, 'text': text}
requests.post(url, answer)
# Сохраняем форму
form.save()
return form
def contact(request):
if request.method == 'POST':
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
name = contact_form.cleaned_data['name']
message = contact_form.cleaned_data['message']
sender = contact_form.cleaned_data['sender']
recipients = ['*****@*****.**']
send_mail(name, message, sender, recipients)
contact_form.save()
messages.success(request, 'Message sent successfully')
return redirect('contact:success')
else:
messages.error(request, 'Error sending your Message')
else:
contact_form = ContactForm()
context = {
"contact_form": contact_form,
}
template = 'contact/contact.html'
return render(request, template, context)
def contactpage(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
# Sending email.
subject = form.cleaned_data['subject']
email = [form.cleaned_data['email'], settings.EMAIL_HOST_USER, ]
message = form.cleaned_data['message']
send_mail(subject, message, settings.EMAIL_HOST_USER, email, fail_silently=False)
url = reverse('contact:message-sent')
return HttpResponseRedirect(url)
else:
form = ContactForm(
initial={
'name': u'Kolo\u017ei Robert',
'email': u'*****@*****.**',
'subject': u'[Django] Test from gmail to eunet.rs subject',
'message': u'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas et nunc id felis condimentum ullamcorper nec a orci. Morbi placerat convallis pharetra. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin volutpat id massa et pulvinar. Etiam est ligula, imperdiet sed sollicitudin vitae, vehicula id nunc. Maecenas at sollicitudin nunc, at fringilla nisi. Duis egestas lorem tristique, suscipit nisi nec, commodo sem. Nulla ac eros nec leo tincidunt bibendum a eget felis. Nunc consectetur enim ligula, vel egestas quam rutrum in.',
'web_site': u'http://www.robertkolozsi.org'
}
)
context = {
'form': form,
}
return render_to_response('contact/index.html',
context,
context_instance=RequestContext(request))
def index(request, template_name='content/index.html'):
page_title = 'Contact DanuGroup.org'
form=ContactForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/contact/thankyou.html')
else:
return render_to_response(template_name, {'form': ContactForm()}, context_instance=RequestContext(request))
def contact(request):
form = ContactForm()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
# messages.success(request, 'Account created successfully')
return HttpResponseRedirect(reverse('home:home'))
return render(request,'contact/contact.html', {'form': form})
def post(self, request, *args, **kwargs):
print(request.POST)
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Ευχαριστούμε για την ')
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
context.update(locals())
return context
def contact_new(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return redirect('contact_sent')
else:
form = ContactForm()
return render(request, 'contact/contact.html', {'form': form})
def message(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Thank you! Your message has been saved!')
return redirect('contact')
else:
form = ContactForm()
return render(request, 'contact/contact.html', {'form': form})
def ContactCreateView(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
messages.success(request, 'Your message has been sent!')
form.save()
return redirect('index')
else:
form = ContactForm()
return render(request, "contact/contact.html", {'form': form})
def addContact(request):
form = ContactForm()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Contact Saved Successfully')
else:
messages.error(request, form.errors)
return redirect('add_contact')
return render(request, 'add_contact.html', {'form': form})
def index(request):
teams = Team.objects.order_by('-timestamp').filter(is_published=True)
proposals = Proposal.objects.order_by('-reload').filter(
is_published=True)[:1]
listings = Listing.objects.order_by('-list_date').filter(
is_published=True)[:6]
posts = Post.objects.order_by('-date_posted').filter(is_published=True)[:3]
topbars = Topbar.objects.order_by('-reload').filter(is_published=True)[:1]
header_carousel_picss = header_carousel_pics.objects.order_by(
'-reload').filter(is_published=True)[:1]
footers = Footer.objects.order_by('-reload').filter(is_published=True)[:1]
#listings prime plots
mvp_listings = Listing.objects.all().filter(is_mvp=True)
#property links
property_links = Property_link.objects.order_by('link_date').filter(
is_published=True)
#construction link
links = Link.objects.order_by('link_date').filter(is_published=True)
background_images = Background_image.objects.order_by('link_date').filter(
is_published=True)[:1]
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Your message has been sent')
return redirect('index')
else:
form = ContactForm()
context = {
'proposals': proposals,
'background_images': 'background_images',
'property_links': property_links,
'topbars': topbars,
'header_carousel_picss': header_carousel_picss,
'footers': footers,
'links': links,
'posts': posts,
'listings': listings,
'town_choices': town_choices,
'location_choices': location_choices,
'plot_size_choices': plot_size_choices,
'price_choices': price_choices,
'mvp_listings': mvp_listings,
'teams': teams,
'form': form
}
return render(request, 'pages/index.html', context)
def mentorsandsupporters(request):
if request.method == "POST":
formmentor = ContactForm(request.POST)
if formmentor.is_valid():
formmentor.save()
return redirect('contact_sent')
else:
formmentor = ContactForm()
return render(request, 'contact/mentorsandsupporters.html',
{'formmentor': formmentor})
def contact(request):
ctxt = dict()
template = "contact.html"
form = ContactForm(request.POST or None)
if request.method == "POST":
if form.is_valid():
form.save()
messages.success(request, "Thanks! We will contact you shortly.")
return redirect("home")
messages.error(request, "You must complete all required fields")
ctxt["form"] = form
return render(request, template, ctxt)
def contact(request):
from contact.forms import ContactForm
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('contact_thanks'))
else:
form = ContactForm()
return render_to_response('contact.phtml',{'form':form},context_instance=RequestContext(request))
def post(self, request, *args, **kwargs):
form = ContactForm(request.POST)
if form.is_valid():
form.save(commit=False)
send_mail(request.POST.get('name') +" Omaha ", request.POST.get('comment'),request.POST.get('email'), ['*****@*****.**'])
data = {
'form': form,
'app_name': settings.APP_NAME
}
return render(request, self.template_name, data)
def homepage(request):
if request.method == "POST":
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
contact_form.save()
return redirect("homepage")
else:
print(contact_form.errors)
else:
contact_form = ContactForm()
context = {"title": "SS CONSULTING", "form": contact_form}
return render(request, "homepage.html", context)
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(request,'your request have been successfully submited ')
return redirect('contactus')
else:
return render(request, 'contact.html', {'form': form})
else:
form = ContactForm()
return render(request, 'contact.html', {'form': form, })
def contact(request):
form = ContactForm(request.POST or None)
if form.is_valid():
form.save()
messages.success(request, "Mesaj başarıyla gönderildi.")
return redirect('post:index')
return render(
request,
"contact.html",
{"form": form},
)
def index(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
akis = Akismet(key=settings.AKISMET_KEY)
data = {"user_ip": request.META["REMOTE_ADDR"], "user_agent": request.META["HTTP_USER_AGENT"]}
if akis.comment_check(comment=form.cleaned_data.get("message"), data=data) == False:
form.save()
return redirect("contact_thanks")
else:
form = ContactForm()
return render_to_response("contact/index.html", {"form": form}, context_instance=RequestContext(request))
def addContactMessage(request):
if request.POST:
form=ContactForm(request.POST)
if form.is_valid():
form.save(commit=True)
messages.success(request,'Thanks for contacting us!')
return HttpResponseRedirect('/')
form=ContactForm()
args={}
args.update(csrf(request))
args['form']=form
return render(request,'contact/contact.html',args)
def contact_edit(request):
contact = get_object_or_404(Contact)
if request.method == 'POST':
form = ContactForm(request.POST, instance=contact)
if form.is_valid():
form.save()
if request.is_ajax():
return HttpResponse("redirect")
else:
return redirect(reverse('contact.views.index'))
else:
form = ContactForm(instance=contact)
return render(request, 'contact_edit.html', {'form': form})
def contact(request, template_name='contact/contact.html'):
# sticks in a POST or renders an empty form
form = ContactForm(request.POST or None)
if form.is_valid():
subject = form.cleaned_data['subject']
cc = form.cleaned_data['cc']
print subject
print cc
# custom business logic
form.save()
return HttpResponseRedirect('/contact/thanks/')
return render(request, template_name, {'form' : form})
def ContactView(request):
form = ContactForm(request.POST or None)
if form.is_valid():
form.save()
form = ContactForm()
info = Information.objects.all()
context = {
'form' : form,
'info' : info,
}
return render(request, "contact/contact.html", context)
def gallery_list_view(request):
gallery_object_list = Gallery.objects.all()
if request.method == 'POST':
contact_form = ContactForm(request.POST)
booking_form = BookingForm(request.POST)
if contact_form.is_valid():
contact_form.save()
name = contact_form.cleaned_data.get('name')
email = contact_form.cleaned_data.get('email')
phone_number = contact_form.cleaned_data.get('phone_number')
message = contact_form.cleaned_data.get('message')
messages.success(
request,
f'{name}, your details has been sent!, We will get to you as soon as possible. Thank You!'
)
send_mail(
'Contact Request',
f' {name} has requested to contact you. Contact Info:{phone_number}, {email}. He has left a message : {message}',
'*****@*****.**', ['*****@*****.**'],
fail_silently=True)
return redirect('gallery_list')
if booking_form.is_valid():
booking_form.save()
name = booking_form.cleaned_data.get('name')
room = booking_form.cleaned_data.get('room')
check_in = booking_form.cleaned_data.get('check_in')
check_out = booking_form.cleaned_data.get('check_out')
adult = booking_form.cleaned_data.get('adult')
child = booking_form.cleaned_data.get('child')
messages.success(
request,
f' {name}, Your Booking has been successful for {room}, from {check_in} to {check_out} with {adult} adults and {child} childrens.Thank You!!!'
)
send_mail(
f'Booking BY {name} ',
f'A booking has been made for {room} , from {check_in} to {check_out} with {adult} adults and {child} childrens.',
'*****@*****.**', ['*****@*****.**'],
fail_silently=True)
return redirect('gallery_list')
else:
contact_form = ContactForm()
booking_form = BookingForm()
context = {
'booking_form': booking_form,
'contact_form': contact_form,
'gallery_object_list': gallery_object_list
}
return render(request, 'gallery/gallery_list.html', context)
def update_contact_form(request, id):
contact = Contact.objects.get(id=id)
if request.method == 'GET':
form = ContactForm(instance=contact)
return render(request, 'contact/contact.html', context={'form': form})
else:
form = ContactForm(request.POST, request.FILES, instance=contact)
if form.is_valid():
form.save()
return render(request, 'contact/thankyou.html')
else:
return render(request,
'contact/contact.html',
context={'form': form})
def adicionar_contact(request):
form = ContactForm(request.POST or None)
if form.is_valid():
# form.fields['name']
if form.fields['name'] == '': form.fields['name'] = 'Anonymous'
if form.fields['email'] == '': form.fields['email'] = 'Anonymous'
form.save()
form = ContactForm()
context = {
'form': form
}
return render(request, 'contact.html', context)
def contact(request):
form = ContactForm()
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
form.save(commit=True)
# Send email
send_mail(
'Contact Inquiry',
'There has been an inquiry. Sign into the admin panel for more info.',
'*****@*****.**',
['*****@*****.**'],
)
return thanks(request)
return render(request, 'pages/contact.html', {'form': form})
def save_contact(request):
if request.method == 'POST':
contact = Contact()
form = ContactForm(request.POST, instance=contact)
if form.is_valid():
try:
form.save()
except Exception:
return mail_response('false')
sendmail(form)
return mail_response('true')
else:
return mail_response('false')
else:
raise Http404
def contact_create_or_edit(request, id=None):
if id:
title = _('Edit a contact')
contact = get_object_or_404(Contact, pk=id, owner=request.user)
address = contact.address
else:
title = _('Add a contact')
contact = None
address = None
PhoneNumberFormSet = inlineformset_factory(Contact,
PhoneNumber,
form=PhoneNumberForm,
fk_name="contact",
extra=1)
contacts = Contact.objects.filter(owner=request.user)
if contact:
contacts = contacts.exclude(pk=contact.id)
if request.method == 'POST':
contactForm = ContactForm(request.POST, instance=contact, prefix="contact")
contactForm.fields['contacts'].queryset = contacts
addressForm = AddressForm(request.POST, instance=address, prefix="address")
phonenumberformset = PhoneNumberFormSet(request.POST, instance=contact)
if contactForm.is_valid() and addressForm.is_valid() and phonenumberformset.is_valid():
user = request.user
address = addressForm.save(commit=False)
address.save(user=user)
contact = contactForm.save(commit=False)
contact.address = address
contact.save(user=user)
contactForm.save_m2m()
for phonenumberform in phonenumberformset.forms:
phonenumber = phonenumberform.save(commit=False)
if phonenumber.type:
phonenumber.contact = contact
phonenumber.save(user=user)
for deleted_phonenumberrowform in phonenumberformset.deleted_forms:
deleted_phonenumberrowform.cleaned_data['ownedobject_ptr'].delete()
messages.success(request, _('The contact has been saved successfully'))
return redirect(reverse('contact_detail', kwargs={'id': contact.id}))
else:
messages.error(request, _('Data provided are invalid'))
else:
contactForm = ContactForm(instance=contact, prefix="contact")
contactForm.fields['contacts'].queryset = contacts
addressForm = AddressForm(instance=address, prefix="address")
phonenumberformset = PhoneNumberFormSet(instance=contact)
return render_to_response('contact/edit.html',
{'active': 'contact',
'title': title,
'contactForm': contactForm,
'addressForm': addressForm,
'phonenumberformset': phonenumberformset},
context_instance=RequestContext(request))
def serve(self, request):
from contact.forms import ContactForm, ContactMatterForm
if request.method == 'POST':
contact_form = ContactForm(request.POST)
contact_matter_form = ContactMatterForm(request.POST)
if contact_form.is_valid() and contact_matter_form.is_valid():
contact = contact_form.save()
matter = contact_matter_form.save(commit=False)
matter.contact = contact
matter.save()
messages.success(
request, self.success_messages['successful_submission'])
return redirect(self.url)
else:
contact_form = ContactForm()
contact_matter_form = ContactMatterForm()
return render(
request, 'contact/contact_page.html', {
'page': self,
'contact_form': contact_form,
'contact_matter_form': contact_matter_form
})
def contact(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Your message has been sent')
return redirect('contact')
else:
form = ContactForm()
context = {
'form': form,
}
return render(request, "booking/contact.html", context)
def post(self, request, id):
cek_session(request)
if request.session.get('active_elder') is not None and request.session[
'active_elder'] != 0:
elder = Elder.objects.get(pk=request.session.get('active_elder'))
elders = Elder.get_cared_elder(user=CareGiver.objects.get(
user=request.user))
contact = Contact.objects.filter(
elder=elder,
id=id,
added_by=CareGiver.objects.get(user=request.user))
if contact:
form = ContactForm(request.POST, instance=contact[0])
if form.is_valid():
contact = form.save()
return render(
request, 'contact_edit.html', {
'elders': elders,
'success': "Data berhasil dirubah",
'active_elder': elder,
'contact': contact
})
return render(
request, 'contact_edit.html', {
'elders': elders,
'active_elder': elder,
'error': form.errors,
'contact': contact[0]
})
return HttpResponseRedirect(reverse('contact'))
return HttpResponseRedirect(reverse('index'))
def post(self, request):
cek_session(request)
elder = None
if request.session.get('active_elder') is not None and request.session[
'active_elder'] != 0:
elder = Elder.objects.get(pk=request.session.get('active_elder'))
caregiver = CareGiver.objects.get(user=request.user)
elders = Elder.get_cared_elder(user=caregiver)
form = ContactForm(request.POST)
contact = Contact.objects.filter(elder=elder).order_by('-id')
if form.is_valid():
new = form.save(commit=False)
new.elder = elder
new.added_by = caregiver
new.save()
contact = Contact.objects.filter(elder=elder).order_by('-id')
return render(
request, 'contact.html', {
'elders': elders,
'success': "Data berhasil ditambahkan",
'active_elder': elder,
'contact': contact
})
else:
return render(
request, 'contact.html', {
'elders': elders,
'error': form.errors,
'active_elder': elder,
'contact': contact
})
else:
return HttpResponseRedirect(reverse('index'))
def homepage(request):
categories = Category.objects.all()
articles = Article.objects.all()[:3]
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
else:
form = ContactForm()
return render(request, "home.html", {
'form': form,
'categories': categories,
'articles': articles
})
def home(request):
form = ContactForm()
if request.method == 'POST':
form = ContactForm(request.POST)
# return HttpResponse(str(form))
if form.is_valid():
if form.save():
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.')
messages.success(request, 'Profile details updated.')
return render(request, 'contact.html')
else:
return HttpResponse(
"""your form is wrong, reload on <a href = "{{ url : 'index'}}">reload</a>"""
)
else:
return render(request, 'contact.html')
class ContactFormTest(TestCase):
""" Tests the contact form.
Instance variables:
val_from_name -- valid from name
val_from_email -- valid email address
val_to_name -- valid choice for who it's going to
val_message -- valid message
valid_form -- a valid form
"""
def setUp(self):
"""Set up contact test."""
# Set environment variable so that we can get around recaptcha
os.environ["RECAPTCHA_TESTING"] = "True"
# Make a bunch of valid fields for the valid form
self.val_from_name = "AT test val_from_name"
self.val_from_email = "*****@*****.**"
self.val_to_name = "HO"
self.val_message = "This is an automated test from test_valid_data"
# Make a dictionary of all the valid fields which can be used later
self.valid_dict = {
"from_name": self.val_from_name,
"from_email": self.val_from_email,
"to_name": self.val_to_name,
"message": self.val_message,
"g-recaptcha-response": "PASSED",
}
# Create the valid form
self.valid_form = ContactForm(self.valid_dict)
def test_valid_data_equals_valid_form(self):
""" Tests that form is valid. """
self.assertTrue(self.valid_form.is_valid())
def test_data_goes_into_object(self):
""" Tests all fields go into object model correctly. """
saved_comment = self.valid_form.save()
self.assertEqual(saved_comment.from_name, self.val_from_name)
self.assertEqual(saved_comment.from_email, self.val_from_email)
self.assertEqual(saved_comment.to_name, self.val_to_name)
self.assertEqual(saved_comment.message, self.val_message)
# TODO: This probable belongs ina model test.
contact_queryset = Contact.objects.filter(message__exact=self.val_message)
first_object = contact_queryset[0]
self.assertEqual(first_object.from_name, self.val_from_name)
def tearDown(self):
""" Unset everything that needs to be unset before next test. """
os.environ["RECAPTCHA_TESTING"] = "False"
def index(request):
template = "contact/index.html"
form = ContactForm()
context = {"form": form}
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(
request,
f'Your message was sent successfully, We will respond to you as soon as possible Thank you for contacting us!'
)
return redirect('contact:contact')
return render(request, template, context)
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('core:index') + '?ok')
# var = form['name']
# import pdb
# pdb.set_trace()
else:
# import pdb
# pdb.set_trace()
return redirect(reverse('core:index') + '?notok')
# return render(request, 'core/index.html', {'form':form})
return redirect('/')
def add(request):
contact_list = Contact.objects.all
context_dict = {'contacts' : contact_list}
form = ContactForm()
if request.POST:
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Employee details added successfully')
return render(request, 'contact/list.html', context=context_dict)
else:
messages.error(request, 'Oops Check form again')
return render(request, 'contact/add.html', {'form': form})
return render(request, 'contact/add.html', {
'form': form,
})
def about(request):
Instructors = Instructor.objects.all()
form = ContactForm()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
# messages.success(request, 'Account created successfully')
return HttpResponseRedirect(reverse('about:about'))
context = {
'Instructors': Instructors,
'form': form,
}
return render(request, 'about/about.html', context)
def test_contact_form(admin, rf, mailoutbox):
request = rf.request()
request.user = admin
data = {
'name': admin.full_name,
'email': admin.email,
'email_subject': "My subject",
'body': "First paragraph of message\n\nSecond paragraph of message.",
}
form = ContactForm(request=request, data=data)
assert form.is_valid()
form.save()
assert len(mailoutbox) == 1
message = mailoutbox[0]
reply_to = u'%s <%s>' % (data['name'], data['email'])
assert reply_to == message.extra_headers['Reply-To']
subject = u'[%s] %s' % (settings.POOTLE_TITLE, data['email_subject'])
assert subject == message.subject
assert data['body'] in message.body
def add_contact(request):
# Get the context from the request.
context = RequestContext(request)
context_dict = {}
# A HTTP POST?
if request.method == 'POST':
form = ContactForm(request.POST)
# Have we been provided with a valid form?
if form.is_valid():
# Save the new category to the database.
print form.cleaned_data
mes=form.data['name']+form.data['phone']+ form.data['message']
umes=unicode(mes)
form.save(commit=True)
import smsru
cli = smsru.Client()
cli.send("+79526646699", umes )
# Now call the index() view.
# The user will be shown the homepage.
return index(request)
else:
# The supplied form contained errors - just print them to the terminal.
print form.errors
else:
# If the request was not a POST, display the form to enter details.
form = ContactForm()
# Bad form (or form details), no form supplied...
# Render the form with error messages (if any).
context_dict['form'] = form
return render_to_response('contact/add_contact.html', context_dict, context)
def test_success(self):
data = {
'name': 'Ade Oluwa',
'email': '*****@*****.**',
'phone_number': '08033445566',
'comment': 'Keep up the good work!'
}
form = ContactForm(data)
self.assertTrue(form.is_valid())
c = form.save()
self.assertEqual(repr(c), '<Contact: Ade Oluwa : Keep up the good work!>')
def contact_form(request):
contact_form = loader.render_to_string("contact_form.html", {"form":ContactForm()})
tpl = ContactMessage.get_intro()
contact_content = tpl.replace('{{form}}', contact_form)
model=ContactMessage
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
item = form.save()
msg_key = "success_%s_new" % ContactForm._meta.model.object_name()
message = util.get_message(msg_key, 'success_content_new')
util.success(request, message)
return http.HttpResponseRedirect(ContactMessage.form_url())
c = template.RequestContext(request, locals())
return render_to_response('contact_send.html', c)
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
#send mail to steamboatlabs
send_mail(
cd['subject'],
cd['message'],
cd['email'],
#emails that will recieve correspondence from contact form
['*****@*****.**'],
)
message = form.save()
message
message_id = message.id
url = '/contact/thanks/' + str(message_id)
return HttpResponseRedirect(url)
else:
form = ContactForm()
return render(request, 'contact/contact_form.html', {'form': form})
def contact_form(request, template_name):
"""
Renders a contact form, validates its input and sends an email
from it.
To specify the form class to use, pass the ``form_class`` keyword
argument; if no ``form_class`` is specified, the base
``ContactForm`` class will be used.
To specify the template to use for rendering the form (*not* the
template used to render the email message sent from the form,
which is handled by the form class), pass the ``template_name``
keyword argument; if not supplied, this will default to
``contact_form/contact_form.html``.
To specify a URL to redirect to after a successfully-sent message,
pass the ``success_url`` keyword argument; if not supplied, this
will default to ``/contact/sent/``.
To allow only registered users to use the form, pass a ``True``
value for the ``login_required`` keyword argument.
To suppress exceptions raised during sending of the email, pass a
``True`` value for the ``fail_silently`` keyword argument. This is
**not** recommended.
Template::
Passed in the ``template_name`` argument.
Context::
form
The form instance.
"""
try:
current_site = Site.objects.get_current()
contact_data = ContactConfig.objects.get()
except ContactConfig.DoesNotExist:
contact_data = ''
# cool, you can try a value and fallback to another if it doesn't exist
#page_title = getattr(contact_data, 'title', _('Contact'))
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
message = form.save(commit=False)
message.ip = request.META.get('REMOTE_ADDR')
message.save()
success_url = urlresolvers.reverse('contact_sent')
return HttpResponseRedirect(success_url)
else:
form = ContactForm(initial = {
'nombre' : u'Nombre',
'email' : u'Correo Electrónico',
'mensaje' : u'Me gustaría saber más información acerca de...',
})
return render_to_response(template_name,
{
'form': form,
'contact_data': contact_data,
},
context_instance = RequestContext(request))
