def test_email_confirm(self):
vals = {
'first_name': 'foo',
'last_name': 'bar',
'email': '*****@*****.**',
'confirm_email': '*****@*****.**'}
form = ContactForm(vals)
form.is_valid()
form.clean()
def test_confirm_email_fail(self):
vals = {
'first_name': 'foo',
'last_name': 'bar',
'email': '*****@*****.**',
'confirm_email': '*****@*****.**'}
form = ContactForm(vals)
form.is_valid()
self.assertRaises(
ValidationError,
form.clean)
def contact_list(request):
# Contact creation
form = ContactForm(request.POST or None)
if '_create' in request.POST and form.is_valid():
contact = form.save(commit=False)
contact.user = request.user
contact.save()
msg = _('Your new contact was created')
messages.success(request, msg)
return redirect('contact_list')
# Contact deletion
qs = Contact.objects.filter(user=request.user)
if '_delete' in request.POST:
ids = request.POST.getlist('id')
qs.filter(id__in=ids).delete()
msg = _('Selected reminders were deleted')
messages.success(request, msg)
return redirect('contact_list')
table = ContactTable(qs)
return {
'table': table,
'form': form,
}
def contact(request):
'''Creates a view for adding contact, and saves the new contact to database.'''
contacts = Contact.objects.all()
contracts = Contract.objects.all()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
firstname = form.cleaned_data['firstname']
lastname = form.cleaned_data['lastname']
email = form.cleaned_data['email']
options = request.POST.getlist('contract')
try:
contact = Contact()
contact.firstname = firstname
contact.lastname = lastname
contact.email = email
contract_dates = [str(x) for x in options]
for cd in contract_dates:
if cd:
cr = Contract.objects.get(from_date = cd)
contact.contract = cr
contact.save()
except:
pass
return HttpResponseRedirect(reverse('index'))
else:
form = ContactForm()
context = {'contacts' : contacts, 'contracts': contracts, 'form' :form}
return render(request, 'contacts/contact.html', context )
def edit_contact(request, address_id):
message = None
contacttypes = ContactType.objects.all()
categories = Category.objects.all()
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
adr = Address(id=address_id, adr_searchname=form.cleaned_data['searchname'],
adr_email=form.cleaned_data['email'])
adr.save()
# TODO: ct_type proof need to be implemented
for ct_type in contacttypes:
cd_id = ContactData.objects.filter(cd_contacttype_id__id=ct_type.id, cd_address_id__id=address_id)
if len(cd_id) > 0:
ctdata = ContactData(id=cd_id, cd_contacttype_id=ct_type,
cd_textfield=form.cleaned_data['{index}'.format(index=ct_type.id)],
cd_address_id=adr)
else:
ctdata = ContactData(cd_contacttype_id=ct_type,
cd_textfield=form.cleaned_data['{index}'.format(index=ct_type.id)],
cd_address_id=adr)
print (ctdata, cd_id)
ctdata.save()
return redirect('all_contacts')
else:
adr = get_object_or_404(Address, pk=address_id)
datadict = {'searchname': adr.adr_searchname, 'email': adr.adr_email}
adr_data = ContactData.objects.filter(cd_address_id=address_id).order_by('cd_contacttype_id__ct_sort_id')
for adr_element in adr_data:
datadict['{index}'.format(index=adr_element.cd_contacttype_id.id)] = adr_element.cd_textfield
form = ContactForm(initial=datadict) # TODO: datadict index out of contacttype_id and catagory_id for Tab's
# or send filtered by category and ordered and give a list with the stop-point
return render(request, 'contacts/edit_contact.html', {'address': adr, 'message': message, 'form': form, 'categories': categories})
def update(request, id):
contactData = Contacts.objects.get(id=id)
form = ContactForm(request.POST, instance = contactData)
if form.is_valid():
form.save()
return redirect("/show")
return render(request, 'edit.html', {'contactData': contactData})
def found_item_details(request, id):
f_item = get_object_or_404(Item, id=id)
related_found_item = Item.objects.filter(status__icontains='phone')[1:2]
# Contact Models ---------------------#
form = ContactForm(request.POST or None)
errors = None
if form.is_valid():
form.save()
messages.add_message(
request, messages.SUCCESS,
'Your message has been sent successfully, We will cantact you in a short time'
)
return HttpResponseRedirect(request.META.get("HTTP_REFERER"))
if form.errors:
errors = form.errors
messages.add_message(request, messages.ERROR,
'Please give the correct information')
# End of contact -----------------------------------------------------------------------
context = {
'f_item': f_item,
'related_found_item': related_found_item,
'form': form,
'errors': errors
}
return render(request, 'found-item-details.html', context)
def contact_view(request):
# user = request.user
contact = Contact.objects.all().order_by('-created_date')
contact_count = Contact.objects.all().count()
paginator = Paginator(contact, 10)
page = request.GET.get('page')
try:
contact_list = paginator.page(page)
except PageNotAnInteger:
contact_list = paginator.page(1)
except EmptyPage:
contact_list = paginator.page(paginator.num_pages)
form = ContactForm(request.POST)
if request.method == 'POST':
if form.is_valid():
contact = form.save(commit=False)
contact.user = request.user
contact.save()
messages.success(request, "Contact enregistrées!")
# redirect to a new URL:
return HttpResponseRedirect(reverse('contacts:contact_view'))
else:
form = ContactForm()
context = {
'form': form,
'contact_list': contact_list,
'contact_count': contact_count
}
template_name = 'pages/contacts/contact_view.html'
return render(request, template_name, context)
def contact_list(request):
# Contact creation
form = ContactForm(request.POST or None)
if '_create' in request.POST and form.is_valid():
contact = form.save(commit=False)
contact.user = request.user
contact.save()
msg = _('Your new contact was created')
messages.success(request, msg)
return redirect('contact_list')
# Contact deletion
qs = Contact.objects.filter(user=request.user)
if '_delete' in request.POST:
ids = request.POST.getlist('id')
qs.filter(id__in=ids).delete()
msg = _('Selected reminders were deleted')
messages.success(request, msg)
return redirect('contact_list')
table = ContactTable(qs)
return {
'table': table,
'form': form,
}
def add_contact(request):
#organization = Organization.objects.filter()
users = User.objects.filter(is_active=True).order_by('email')
form = ContactForm(assigned_to=users)
#form = ContactForm(assigned_to=users, orgnization=organization)
address_form = BillingAddressForm()
teams = Team.objects.all()
assignedto_list = request.POST.getlist('assigned_to')
teams_list = request.POST.getlist('teams')
if request.method == 'POST':
form = ContactForm(request.POST, assigned_to=users)
#form = ContactForm(request.POST, assigned_to=users, orgnization=organization)
address_form = BillingAddressForm(request.POST)
if form.is_valid() and address_form.is_valid():
address_obj = address_form.save()
contact_obj = form.save(commit=False)
contact_obj.address = address_obj
contact_obj.created_by = request.user
contact_obj.save()
contact_obj.assigned_to.add(*assignedto_list)
contact_obj.teams.add(*teams_list)
if request.is_ajax():
return JsonResponse({'error': False})
if request.POST.get("savenewform"):
return HttpResponseRedirect(reverse("contacts:add_contact"))
else:
return HttpResponseRedirect(reverse('contacts:list'))
else:
if request.is_ajax():
return JsonResponse({
'error': True,
'contact_errors': form.errors
})
return render(
request,
'contacts/create_contact.html',
{
'contact_form': form,
'address_form': address_form,
#'organization': organization,
'countries': COUNTRIES,
'teams': teams,
'users': users,
'assignedto_list': assignedto_list,
'teams_list': teams_list
})
else:
return render(
request,
'contacts/create_contact.html',
{
'contact_form': form,
'address_form': address_form,
#'organization': organization,
'countries': COUNTRIES,
'teams': teams,
'users': users,
'assignedto_list': assignedto_list,
'teams_list': teams_list
})
def contact(request):
'''Creates a view for adding contact, and saves the new contact to database.'''
contacts = Contact.objects.all()
contracts = Contract.objects.all()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
firstname = form.cleaned_data['firstname']
lastname = form.cleaned_data['lastname']
email = form.cleaned_data['email']
options = request.POST.getlist('contract')
try:
contact = Contact()
contact.firstname = firstname
contact.lastname = lastname
contact.email = email
contract_dates = [str(x) for x in options]
for cd in contract_dates:
if cd:
cr = Contract.objects.get(from_date=cd)
contact.contract = cr
contact.save()
except:
pass
return HttpResponseRedirect(reverse('index'))
else:
form = ContactForm()
context = {'contacts': contacts, 'contracts': contracts, 'form': form}
return render(request, 'contacts/contact.html', context)
def home(request):
section = 'home'
published_services = Service.objects.all().filter(publish_on_home=True)[0:3]
services = Service.objects.all()
contact_form = ContactForm()
clients = ServiceClient.objects.all()
if request.method == 'POST':
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
cd = contact_form.cleaned_data
name = cd['en_contact_name']
email = cd['email']
subject = cd['subject'] + ' from website'
sent_message = cd['message']
message = """
Message from : {} \n
Email address : {} \n
subject : {} \n
message : {}
""".format(name, email, subject, sent_message)
send_mail(subject, message, '*****@*****.**', ['*****@*****.**'])
contact = Contact.objects.filter(email=email)
if not contact:
Contact.objects.create(en_contact_name=name, email=email, subject=subject, message='message')
return redirect('/#contact')
else:
contact.subject = subject
contact.message = message
contact.save()
return redirect('/#contact')
return render(request, 'home/home.html', {'section': section,
'published_services': published_services,
'services': services,
'contact_form': contact_form,
'clients': clients})
def add(request):
if request.method == 'GET':
form = ContactForm()
return render_to_response('contacts/New_contact.html',
context_instance=RequestContext(
request, {'form': form}))
else:
cnt = Contact()
form = ContactForm(request.POST, request.FILES, instance=cnt)
if form.is_valid():
form.save()
send_mail('new contact', 'there is a new contact',
settings.EMAIL_HOST_USER, ['*****@*****.**'])
return render_to_response('contacts/New_contact.html',
context_instance=RequestContext(
request, {
'form': form,
'status': 'saved'
}))
else:
return render_to_response('contacts/New_contact.html',
context_instance=RequestContext(
request, {
'form': form,
'status': 'error'
}))
def contactView(request):
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']
copy = form.cleaned_data['copy']
plus = message +' '+ sender
recipients = ['*****@*****.**']
#Если пользователь захотел получить копию себе, добавляем его в список получателей
if copy:
recipients.append(sender)
try:
send_mail(subject, plus, '*****@*****.**', ['*****@*****.**'])
except BadHeaderError: #Защита от уязвимости
return HttpResponse('Invalid header found')
#Переходим на другую страницу, если сообщение отправлено
return render(request, 'thanks.html')
else:
#Заполняем форму
form = ContactForm()
#Отправляем форму на страницу
return render(request, 'contact.html', {'form': form, 'username': auth.get_user(request).username})
def post(self, request, *args, **kwargs):
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
contact_form.save()
return redirect(reverse('contacts:contact_list'))
else:
return render(request, 'contacts/contact_new.html', status=422)
def ContactEdit(request, pk):
form = ContactForm(request.POST or None,
instance=Contact.objects.get(pk=pk))
if form.is_valid():
contact = form.save()
messages.success(request, 'success')
return redirect('contact_edit', pk=contact.pk)
return render(request, 'contacts/contact_form.html', {'form': form})
def test_mismatch_email_is_valid(self): form_data = flatten_to_dict(ContactForm()) form_data['first_name'] = 'Foo' form_data['last_name'] = 'Bar' form_data['email'] = '*****@*****.**' form_data['confirm_email'] = '*****@*****.**' bound_form = ContactForm(data=form_data) self.assertFalse(bound_form.is_valid())
def kyc_view(request):
formContact = ContactForm(request.POST)
if request.method == 'POST':
if formContact.is_valid():
contact = formContact.save(commit=False)
contact.user = request.user
contact.save()
# messages.success(request, "Contact enregistrées!")
return JsonResponse({'contact': 'success'})
def test_mismatch_email_is_invalid(self):
form = ContactForm(
data={
'first_name': 'A',
'last_name': 'B',
'email': '*****@*****.**',
'confirm_email': 'a@different_email.org',
})
self.assertFalse(form.is_valid())
def test_matching_email_is_valid(self):
form = ContactForm(
data={
'first_name': 'A',
'last_name': 'B',
'email': '*****@*****.**',
'confirm_email': '*****@*****.**',
})
self.assertTrue(form.is_valid())
def create_contact(request):
if request.method == 'POST':
createfor = ContactForm(request.POST)
if createfor.is_valid():
createfor.save()
return redirect(reverse('list'))
else:
return render(request, 'contacts/create_contact.html', {'createfor': createfor})
createfor = ContactForm()
return render(request, 'contacts/create_contact.html', {'createfor': createfor})
def add_contact(request):
if request.method == 'GET':
form = ContactForm()
else:
form = ContactForm(data=request.POST)
if form.is_valid():
form.save()
return redirect(to='list_contacts')
return render(request, "contacts/add_contact.html", {"form": form})
def contact_view(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return HttpResponse('Good Form', status=status.HTTP_201_CREATED)
else:
form = ContactForm()
return render(request, 'contact.html', {'form': form})
def contacts(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
success = 'Pregunta enviada, Ponto te responderemos'
products = Product.objects.all()
return render(request=request, template_name='contacts/contacts.html')
def edit_contact(request, pk):
contact_obj = get_object_or_404(Contact, id=pk)
address_obj = get_object_or_404(Address, id=contact_obj.address.id)
organizations = Organization.objects.all()
users = User.objects.filter(is_active=True).order_by('email')
# form = ContactForm(instance=contact_obj, assigned_to=users)
form = ContactForm(instance=contact_obj, assigned_to=users, organization=organizations)
address_form = BillingAddressForm(instance=address_obj)
teams = Team.objects.all()
assignedto_list = request.POST.getlist('assigned_to')
teams_list = request.POST.getlist('teams')
if request.method == 'POST':
form = ContactForm(request.POST, instance=contact_obj, assigned_to=users, organization=organizations)
#form = ContactForm(request.POST, instance=contact_obj, assigned_to=users, organization=organization)
address_form = BillingAddressForm(request.POST, instance=address_obj)
if form.is_valid() and address_form.is_valid():
addres_obj = address_form.save()
contact_obj = form.save(commit=False)
contact_obj.address = addres_obj
contact_obj.created_by = request.user
contact_obj.save()
contact_obj.assigned_to.clear()
contact_obj.assigned_to.add(*assignedto_list)
contact_obj.teams.clear()
contact_obj.teams.add(*teams_list)
if request.is_ajax():
return JsonResponse({'error': False})
return HttpResponseRedirect(reverse('contacts:list'))
else:
if request.is_ajax():
return JsonResponse({'error': True, 'contact_errors': form.errors})
return render(request, 'crm/contacts/create_contact.html', {
'contact_form': form,
'address_form': address_form,
'contact_obj': contact_obj,
'organizations': organizations,
'countries': COUNTRIES,
'teams': teams,
'users': users,
'assignedto_list': assignedto_list,
'teams_list': teams_list
})
else:
return render(request, 'crm/contacts/create_contact.html', {
'contact_form': form,
'address_form': address_form,
'contact_obj': contact_obj,
'address_obj': address_obj,
'organizations': organizations,
'countries': COUNTRIES,
'teams': teams,
'users': users,
'assignedto_list': assignedto_list,
'teams_list': teams_list
})
def test_same_email_is_valid(self):
form_data = flatten_to_dict(ContactForm)
form_data['first_name'] = 'Foo'
form_data['last_name'] = 'Bar'
form_data['email'] = '*****@*****.**'
form_data['confirm_email'] = '*****@*****.**'
bound_form = ContactForm(data=form_data)
self.assert_(bound_form.is_valid())
def edit_contact(request , id_contact):
contact = Contact.objects.get(id=id_contact)
if request.method == 'POST':
contactform = ContactForm(request.POST, instance=contact)
if contactform.is_valid():
contactform.save()
return HttpResponse('Editado!')
else:
return render(request, 'contacts/edit_contact.html', {'contactform': contactform} )
else:
contactform = ContactForm(instance=contact)
return render(request, 'contacts/edit_contact.html' , {'contactform': contactform} )
def create(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
try:
form.save()
return redirect('/show')
except:
pass
else:
form = ContactForm()
return render(request,'create.html',{'form':form})
def sendMessage(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
#save to the database
instance = form.save(commit=False)
instance.user = request.user
instance.save()
return redirect('contacts:sendMessage')
else:
form = ContactForm()
return render(request, 'contacts/contact.html', {'form': form})
def contacts_add(request):
if request.method == 'POST':
form = ContactForm(user=request.user, data=request.POST)
if form.is_valid():
new_contact = form.save()
return HttpResponseRedirect("/contacts")
else:
form = ContactForm(user=request.user)
return render_to_response("contacts/new.html", {
'form': form
}, RequestContext(request))
def create(request):
"""
Create Contact view - takes posts
"""
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
contact = form.save(commit=False)
contact.user = request.user
contact.save()
return redirect('index')
else:
return redirect('index')
def update(request, id):
contact = Contact.objects.get(id=id)
form = ContactForm(request.POST, instance=contact)
if form.is_valid():
form.save()
return redirect("/contacts?updated=true")
else:
err = form.errors
return render(request, 'contacts/edit.html', {
'contact': contact,
'errors': err
})
return render(request, 'contacts/edit.html', {'contact': contact})
def post(self, request, *args, **kwargs):
contact = get_object_or_404(Contact, pk=kwargs['contact_id'])
contact_form = ContactForm(request.POST, instance=contact)
if contact_form.is_valid():
contact_form.save()
return redirect(
reverse('contacts:contact_detail', args=(contact.id,))
)
else:
context = {'contact': contact}
return render(
request, 'contacts/contact_edit.html', context, status=422
)
def lead_edit(request, h_pk, pk):
lead = Lead.objects.filter(sponsorship__hackathon__pk=h_pk, contact__pk=pk)
lead = lead[0] if lead else None
if not lead:
return redirect(
reverse("contacts:edit", args=(pk, )) + "?next=" +
reverse("hackathons:leads:view", args=(
h_pk,
pk,
)))
if request.method == "POST":
lead_form = LeadForm(request.hackathon,
lead.sponsorship.company,
request.POST,
instance=lead,
prefix="lead")
if lead_form.is_valid():
lead = lead_form.save(commit=True)
lead.save()
ok = True
else:
ok = False
contact_form = ContactForm(request.POST,
instance=lead.contact,
prefix="contact")
if contact_form.is_valid():
contact = contact_form.save(commit=True)
contact.save()
ok = ok and True
else:
ok = False
if ok:
messages.success(request, f"Updated {lead.contact}")
if request.GET.get("next"):
return redirect(request.GET.get("next"))
return redirect("hackathons:leads:view",
h_pk=h_pk,
pk=lead.contact.pk)
else:
lead_form = LeadForm(request.hackathon,
lead.sponsorship.company,
instance=lead,
prefix="lead")
contact_form = ContactForm(instance=lead.contact, prefix="contact")
lead_form.fields['sponsorship'].widget = forms.HiddenInput()
lead_form.fields['contact'].widget = forms.HiddenInput()
return render(request, "lead_edit.html", {
"lead_form": lead_form,
"contact_form": contact_form
})
def edit_contact(request, pk):
contact = get_object_or_404(Contact, pk=pk)
if request.method == 'GET':
form = ContactForm(instance=contact)
else:
form = ContactForm(data=request.POST, instance=contact)
if form.is_valid():
form.save()
return redirect(to='list_contacts')
return render(request, "contacts/edit_contact.html", {
"form": form,
"contact": contact
})
def add_contact(request):
form = ContactForm()
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
contact = form.save(commit=False)
contact.full_name = '{0} {1}'.format(contact.first_name,
contact.last_name)
contact.save()
return HttpResponseRedirect(reverse('contacts:index'))
else:
print(form.errors)
context = {'form': form}
return render(request, 'contacts/add_contact.html', context)
def edit_contact(request, address_id):
message = None
contacttypes = ContactType.objects.all()
categories = Category.objects.all()
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
adr = Address(id=address_id,
adr_searchname=form.cleaned_data['searchname'],
adr_email=form.cleaned_data['email'])
adr.save()
# TODO: ct_type proof need to be implemented
for ct_type in contacttypes:
cd_id = ContactData.objects.filter(
cd_contacttype_id__id=ct_type.id,
cd_address_id__id=address_id)
if len(cd_id) > 0:
ctdata = ContactData(
id=cd_id,
cd_contacttype_id=ct_type,
cd_textfield=form.cleaned_data['{index}'.format(
index=ct_type.id)],
cd_address_id=adr)
else:
ctdata = ContactData(
cd_contacttype_id=ct_type,
cd_textfield=form.cleaned_data['{index}'.format(
index=ct_type.id)],
cd_address_id=adr)
print(ctdata, cd_id)
ctdata.save()
return redirect('all_contacts')
else:
adr = get_object_or_404(Address, pk=address_id)
datadict = {'searchname': adr.adr_searchname, 'email': adr.adr_email}
adr_data = ContactData.objects.filter(
cd_address_id=address_id).order_by('cd_contacttype_id__ct_sort_id')
for adr_element in adr_data:
datadict['{index}'.format(index=adr_element.cd_contacttype_id.id
)] = adr_element.cd_textfield
form = ContactForm(
initial=datadict
) # TODO: datadict index out of contacttype_id and catagory_id for Tab's
# or send filtered by category and ordered and give a list with the stop-point
return render(request, 'contacts/edit_contact.html', {
'address': adr,
'message': message,
'form': form,
'categories': categories
})
def landing(request):
name = 'Foo Bar'
context = RequestContext(request)
t = get_template('landing.html')
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
temp = form.save(commit=True)
return render_to_response('landing.html', context)
else:
if request.user.is_authenticated():
return HttpResponseRedirect('/accounts/articles')
else:
form = ContactForm()
return render_to_response('landing.html', {'form': form}, context)
def compte_dormant_add(request):
"""
Fonction Add new object
"""
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = Compte_dormantForm(request.POST)
# check whether it's valid:
if form.is_valid():
# process the data in form.cleaned_data as required
compte_dormant = form.save(commit=False)
compte_dormant.user = request.user
compte_dormant.save()
messages.success(request, "Compte dormant enregistrée!")
# redirect to a new URL:
return HttpResponseRedirect(
reverse('compte_dormant:compte_dormant_list'))
# if a GET (or any other method) we'll create a blank form
else:
form = Compte_dormantForm()
if request.method == 'POST':
if request.is_ajax():
formContact = ContactForm(request.POST)
if formContact.is_valid():
formContact.cleaned_data
formContact.user = request.user
formContact.save()
latest = Contact.objects.latest('id').id
contact_object = model_to_dict(Contact.objects.get(pk=latest))
return JsonResponse({'error': False, 'data': contact_object})
else:
print(formContact.errors)
return JsonResponse({
'error': True,
'data': formContact.errors
})
else:
error = {'message': 'Error, must be an Ajax call.'}
return JsonResponse(error, content_type="application/json")
else:
formContact = ContactForm()
context = {'form': form, 'formContact': formContact}
template_name = 'pages/compte_dormant/compte_dormant_add.html'
return render(request, template_name, context)
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_to_response('contact_form.html', {'form': form})
return render(request, "contact_form.html", context={'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('e-mail', '*****@*****.**'),
# ['*****@*****.**'],
# )
return HttpResponseRedirect('/contact/thanks/')
else:
form = ContactForm(
initial={'subject': 'I love your site!'}
)
return render_to_response('contact/contact_form.html', {'form': form})
def add(request):
if request.method == "GET":
form = ContactForm()
return render_to_response("contacts/New_contact.html", context_instance=RequestContext(request, {"form": form}))
else:
cnt = Contact()
form = ContactForm(request.POST, request.FILES, instance=cnt)
if form.is_valid():
form.save()
send_mail("new contact", "there is a new contact", settings.EMAIL_HOST_USER, ["*****@*****.**"])
return render_to_response(
"contacts/New_contact.html", context_instance=RequestContext(request, {"form": form, "status": "saved"})
)
else:
return render_to_response(
"contacts/New_contact.html", context_instance=RequestContext(request, {"form": form, "status": "error"})
)
def add_single(request, list_id):
lis = get_object_or_404(ContactList, pk=list_id, user=request.user)
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
if not Contact.objects.filter(email=form.cleaned_data['email'],
contact_list=lis):
Contact.objects.create(email=form.cleaned_data['email'],
name=form.cleaned_data['name'],
contact_list=lis)
messages.success(request, "Contact Added")
return redirect("contacts:get_all", list_id)
else:
form.add_error("email",
"Email Already exists in your contacts")
else:
form = ContactForm()
return render(request, "contacts/add_single.html", {'form': form})
def edit(request, contact_id):
contact = get_object_or_404(Contact, pk=contact_id)
if request.method == 'POST':
form = ContactForm(request.POST, request.FILES, instance=contact)
is_valid = form.is_valid()
if request.is_ajax():
if is_valid:
form.save()
# we need new form for ImageField to be displayed correctly
form = ContactForm(instance=contact)
return render(request, 'contacts/edit_form.html',
{'form': form, 'contact': contact})
if is_valid:
form.save()
return redirect(detail, contact_id=contact_id)
else:
form = ContactForm(instance=contact)
return render(request, 'contacts/edit.html',
{'form': form, 'contact': contact})
def test_unvalid_form(self):
data = {
"contact_first_name":
"",
"contact_last_name":
"",
"contact_company":
"",
"contact_job":
"CTO",
"contact_email":
"*****@*****.**",
"contact_phone":
"+33687120463",
"contact_notes":
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Morbi id porta felis. Vivamus felis urna, feugiat a erat nec, molestie viverra urna. Nam consequat nisl sem, et fringilla urna sagittis a."
}
form = ContactForm(data=data)
self.assertFalse(form.is_valid())
def add_or_update_contact_details(request, template_name, contact, context):
"""
Either create a new contact or update an existing contacts details.
request: the request object passed to the view
template_name: template to be rendered by this function
contact: instance of contact to whom the avatar will be linked - it must exist, even for
new contacts
context: "create" or "update" depending on how the "template_name" is going to be rendered
"""
contact_form = ContactForm(request.POST or None, instance=contact)
if contact_form.is_valid():
contact = contact_form.save()
return redirect('contacts:update_contact_avatar', contact_id=contact.id)
return render(request, template_name, {
'action': context,
'contact_form': contact_form
})
def new(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
try:
form = form.save(commit=False)
form.created_by = request.user
form.save()
return redirect('/contacts')
except:
pass
else:
err = form.errors
return render(request, 'contacts/index.html', {
'form': form,
'error': err
})
else:
form = ContactForm()
return render(request, 'contacts/index.html', {'form': form})
def post(self, request):
categories = Category.objects.all()
name = ''
email = ''
comment = ''
form = ContactForm(request.POST or None)
if form.is_valid():
name = form.cleaned_data.get("name")
email = form.cleaned_data.get("email")
comment = form.cleaned_data.get("comment")
subject = "Пользовательское обращение (Florus)"
comment = f"Пользователь {name} с e-mail адресом {email} отправил сообщение:\n\n {comment}"
send_mail(subject, comment, '*****@*****.**', [email])
messages.add_message(request, messages.INFO,
f'Благодарим за обращение! Оно будет рассмотрено в течение 2 часов')
return HttpResponseRedirect('/')
else:
context = {'form': form,
'cart': self.cart,
'categories': categories}
return render(request, 'contacts.html', context)
def contact(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
human = True
name = form.cleaned_data["name"]
email = form.cleaned_data["email"]
subject = form.cleaned_data["subject"]
message = form.cleaned_data["message"]
recipients = [settings.EMAIL_HOST_USER]
plaintext = get_template("contacts/email.txt")
d = Context({"name": name, "email": email, "subject": subject, "message": message})
subject, from_email, to = subject, email, recipients
text_content = plaintext.render(d)
headers = {"Reply-To": email}
msg = EmailMultiAlternatives(subject, text_content, from_email, to, headers=headers)
msg.send()
return HttpResponse("thanks")
else:
form = ContactForm()
return TemplateResponse(request, "contacts/contact.html", {"form": form})
