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 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 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 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 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 new_contact(request):
data = {}
template = 'contacts/new_contact.html'
data['message'] = None
if request.method == "POST":
data['form'] = ContactForm(request.POST)
if data['form'].is_valid():
# each Address has a User ID # TODO: if email exists - solve this
passwd = User.objects.make_random_password()
user = User(username=data['form'].cleaned_data['searchname'],
email=data['form'].cleaned_data['email'],
password=passwd)
user.save()
adr = Address(
adr_searchname=data['form'].cleaned_data['searchname'],
adr_email=data['form'].cleaned_data['email'],
adr_user_id=user,
)
adr.save()
contacttypes = ContactType.objects.all()
for ct_type in contacttypes:
ctdata = ContactData(
cd_contacttype_id=ct_type,
cd_textfield=data['form'].cleaned_data['{index}'.format(
index=ct_type.id)],
cd_address_id=adr)
ctdata.save()
return redirect('proj_contacts')
else:
data['form'] = ContactForm()
print data
return render(request, template, data)
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 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 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 listing(request, listing_id):
listing = get_object_or_404(Listing, pk=listing_id)
if request.user.is_authenticated:
contact_form = ContactForm(initial={
'user_id': request.user.id,
'name': f'{request.user.first_name} {request.user.last_name}',
'email': request.user.email,
'listing_id': listing.id,
'listing_title': listing.title
})
else:
contact_form = ContactForm(initial={
'listing_id': listing.id,
'listing_title': listing.title
})
return render(request, 'listings/listing.html', {
'title': listing.title,
'sub_title': f'<i class="fas fa-map-marker"></i> {listing.city} {listing.state.code}, {listing.zipcode}',
'listing': listing,
'thumbs': listing.photo_set.all(),
'contact_form': contact_form,
'breadcrumbs': [
{
'title': 'Lisitings',
'url': reverse('listings:index'),
}
]
})
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 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 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_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_matching_email_is_valid(self):
form = ContactForm(
data={
'first_name': 'A',
'last_name': 'B',
'email': '*****@*****.**',
'confirm_email': '*****@*****.**',
})
self.assertTrue(form.is_valid())
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 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 test_email_confirm(self):
vals = {
'first_name': 'foo',
'last_name': 'bar',
'email': '*****@*****.**',
'confirm_email': '*****@*****.**'}
form = ContactForm(vals)
form.is_valid()
form.clean()
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 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 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 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 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 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 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 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 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 get(self, request, *args, **kwargs):
form = ContactForm(request.POST or None)
categories = Category.objects.all()
context = {'cart': self.cart,
'categories': categories,
'form': form}
return render(request, 'contacts.html', 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('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 listing(request, listing_slug):
listing = get_object_or_404(Listing, slug=listing_slug)
form = ContactForm(user=request.user, initial={'listing': listing.id})
return render(request, 'listings/listing.html', {
'listing': listing,
'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(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 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 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 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_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 lost_person_details(request, id):
lp_detail = get_object_or_404(Person, id=id)
related_lost_person = Person.objects.filter(body_color__icontains='white')[1:2]
# Contact Models ---------------------#
form = ContactForm(request.POST or None)
errors = None
if form.is_valid():
form.save()
messages.add_message(request, messages.SUCCESS,
'You message successfully send, please wait you will inform you')
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 = {
'lp_detail': lp_detail,
'form': form,
'errors': errors,
'related_lost_person': related_lost_person
}
return render(request, 'lost/lost-person-details.html', context)
def new_contact(request):
form = ContactForm(request.POST)
if request.method == 'POST':
class F(ContactForm):
pass
for name in request.POST.items():
if name[0] not in form._fields.keys() and name[0] != 'submit':
setattr(F, name[0], TextField(name[0],[validators.Required()]))
form = F(request.POST)
if form.validate():
d = dict(request.POST)
fs = request.fs
photo = request.POST['photo'].file
filename = request.POST['photo'].filename
b = fs.put(photo.read(), filename=filename)
d['photo'] = b
d.pop('submit')
request.db.contact.insert(d)
return HTTPFound(location=request.relative_url('list-contacts'))
return {'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 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 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 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 contact(request, listing_slug):
listing = get_object_or_404(Listing, slug=listing_slug)
contact = Contact(user=request.user, listing=listing)
form = ContactForm(request.POST, user=request.user, instance=contact)
if form.is_valid():
form.save()
# Send email
# send_mail(
# 'Property Listing Inquiry',
# 'There has been an inquiry for ' + listing + '. Sign into the admin panel for more info',
# '*****@*****.**',
# [listing.realtor.email, '*****@*****.**'],
# fail_silently=False
# )
messages.success(
request,
'Your request has been submitted, a realtor will get back to you soon'
)
return redirect('listing', listing_slug)
else:
return render(request, 'listings/listing.html', {
'listing': listing,
'form': form
})
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})
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})