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 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 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 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 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 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_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 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 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 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, 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 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, 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 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 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 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(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 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 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 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_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 test_matching_email_is_valid(self):
form = ContactForm(
data={
'first_name': 'A',
'last_name': 'B',
'email': '*****@*****.**',
'confirm_email': '*****@*****.**',
})
self.assertTrue(form.is_valid())
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 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 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 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})
