def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
contact = form.instance
mandir_staff = getattr(settings, "MANDIR_STAFF", None)
## Send Thank you email
message = "Dear " + contact.name + "\n"
message += "Thank you for your message. We will get back to you soon!"
send_mail("Thank you from Ved Mandir!", message, '*****@*****.**', [contact.email])
## Notify Ved mandir staff
message = "New Contact message received from: " + contact.name + "\n"
message += "Subject: " + contact.subject + "\n"
message += "Message: \n"
message += contact.message + "\n"
message += "-----------------------------------------------------\n"
send_mail("New Contact Message", message, '*****@*****.**', mandir_staff)
return render(request, 'ved/contact.html', {} )
else:
return render(request, 'ved/contact.html', {'form':form} )
else:
form = ContactForm()
return render(request, 'ved/contact.html', {'form':form} )
def index(request):
if request.POST:
form=ContactForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('send_contact_complete'))
else:
form=ContactForm()
return direct_to_template(request,'contacts/contact.html',{'form':form})
def contact(request):
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return render(request,
'contato.html',
{'sucess':
"Seus dados foram inseridos com sucesso ^ ^."})
else:
return render(request, 'contato.html', {'error':"Ocorreu um erro ao tentar enviar seu contato."})
def send_mail(request):
form = ContactForm(request.POST)
if form.is_valid():
form.save()
msg = _('Your message has been successfully sent')
messages.add_message(request, messages.SUCCESS, msg)
url = reverse('section_view', args=('contato',))
return HttpResponseRedirect(url)
else:
return section_view(request, slug='contato')
def contact_view(request):
if request.method == 'POST':
form = ContactForm(request.user, data=request.POST)
if form.is_valid():
form.save()
messages.success(request, 'Ваше сообщение отправлено.')
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
else:
form = ContactForm(request.user)
return render(request, 'contact.html', {'form': form})
def contact(request):
"""Default contact view"""
if not request.POST:
form = ContactForm()
else:
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("contact_success"))
return render_to_response("contact/contact.html", {"form": form}, context_instance=RequestContext(request))
def ajax(request,):
"""Ajax contact view"""
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return HttpResponse(simplejson.dumps({"success": True}), "application/json")
else:
return HttpResponse(simplejson.dumps({"success": False, "errors": form.errors}), "application/json")
else:
raise Http404
def contact(request):
if not request.POST:
form = ContactForm()
else:
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('contact_success'))
return render_to_response('contact/contact.html',
{'form': form},
context_instance=RequestContext(request))
def edit(request, id=None):
obj = get_object_or_404(Contact, pk=id)
form = ContactForm(request.POST or None, instance=obj)
if request.method == 'POST':
if form.is_valid():
form.save()
return HttpResponseRedirect('/contacts')
args = {}
args.update(csrf(request))
args['form'] = form
t = loader.get_template('contacts/contact_form.html')
c = RequestContext(request, args)
return HttpResponse(t.render(c))
def edit_contact(request):
contact = get_object_or_404(Contact, pk=1)
if request.method == 'POST':
form_person = PersonForm(
request.POST,
request.FILES,
prefix='person',
instance=contact.person
)
form_contact = ContactForm(
request.POST,
request.FILES,
prefix='contact',
instance=contact
)
is_ajax_request = form_person.data.get('person-is_ajax_request',0)
if form_person.is_valid() and form_contact.is_valid():
# Process the data in form.cleaned_data
form_person.save()
form_contact.save()
response = json.dumps({
'success': True,
'html': 'Data is succesfully updated.'
})
else:
html = form_person.errors.as_ul() + form_contact.errors.as_ul()
response = json.dumps({'success': False, 'html': html})
if is_ajax_request:
return HttpResponse(response, content_type="application/javascript")
else:
if form_person.is_valid() and form_contact.is_valid():
return HttpResponseRedirect(reverse('index')) # Redirect after POST
else:
form_contact = ContactForm(
prefix="contact", instance=contact
)
form_person = PersonForm(
prefix="person", instance=contact.person
)
return render_to_response('edit_contact.html', {
'contact': contact,
'form_contact': form_contact,
'form_person': form_person,
},
context_instance=RequestContext(request)
)
def contact(request, template_name="about/contactus.html"):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
from datetime import datetime
name = form.cleaned_data['name']
email = form.cleaned_data['email']
phone = form.cleaned_data['phone']
message = form.cleaned_data['message']
subject = "Contact Us message from " + name
if request.user.is_authenticated():
form.submitter = request.user
form.submitteddate = datetime.now()
contact = form.save()
message = 'Email: %s\nPhone: %s\n\n' % (email, phone) + message
recipients = settings.CONTACT_EMAIL.split(';')
from django.core.mail import send_mail
try:
send_mail(subject, message, settings.CONTACT_EMAIL, recipients)
except:
pass
request.user.message_set.create(message="Contact Us message has been successfully submitted")
return HttpResponseRedirect(reverse('contactus')) # Redirect after POST
else:
if request.user.is_authenticated():
profile = request.user.get_profile()
kwargs = { "email": request.user.email, "name": profile.name, }
form = ContactForm(initial=kwargs)
else:
form = ContactForm()
return render_to_response(template_name, {
"form": form,
}, context_instance=RequestContext(request))
def contact_edit(request, contact_id, response_format='html'):
"Contact edit"
contact = get_object_or_404(Contact, pk=contact_id)
if not request.user.profile.has_permission(contact, mode='w'):
return user_denied(request, message="You don't have write access to this Contact")
if request.POST:
if 'cancel' not in request.POST:
form = ContactForm(request.user.profile, contact.contact_type, request.POST,
files=request.FILES, instance=contact)
if form.is_valid():
contact = form.save(request)
return HttpResponseRedirect(reverse('identities_contact_view', args=[contact.id]))
else:
return HttpResponseRedirect(reverse('identities_contact_view', args=[contact.id]))
else:
form = ContactForm(
request.user.profile, contact.contact_type, instance=contact)
types = Object.filter_by_request(
request, ContactType.objects.order_by('name'))
return render_to_response('identities/contact_edit',
{'contact': contact,
'types': types,
'form': form},
context_instance=RequestContext(request), response_format=response_format)
def create_contact(request):
if request.user.is_authenticated():
user = request.user
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
obj = form.save(commit=False)
obj.user = user
obj.save()
return HttpResponseRedirect('/contacts/mycontacts/')
else:
form = ContactForm(initial={'user' : User})
args = {}
args.update(csrf(request))
args['form'] = form
return render_to_response('contacts/create_contact.html', args)
else:
c = {}
c.update(csrf(request))
return render_to_response('registration/login.html', c)
def main_list(request):
peer_list = Peer.objects.all()
if request.method == 'POST':
c_form = ContactForm(request.POST)
if c_form.is_valid():
peer = c_form.save(commit=False)
peer.user = request.user
peer.save()
else:
c_form = ContactForm()
if 'q' in request.GET and request.GET['q']:
q = request.GET['q']
people = Peer.objects.filter(name__icontains=q)
return render(request, 'peer-search-block.html', {
'peer_list': peer_list,
'c_form': c_form,
'people': people,
'query': q
})
return render(request, 'peer-list-block.html', {
'peer_list': peer_list,
'c_form': c_form,
})
def contact_add_typed(request, type_id, response_format='html'):
"Contact add with preselected type"
contact_type = get_object_or_404(ContactType, pk=type_id)
if not request.user.profile.has_permission(contact_type, mode='x'):
return user_denied(request,
message="You don't have access to create " +
unicode(contact_type))
if request.POST:
if 'cancel' not in request.POST:
form = ContactForm(request.user.profile,
contact_type,
request.POST,
files=request.FILES)
if form.is_valid():
contact = form.save(request, contact_type)
contact.set_user_from_request(request)
return HttpResponseRedirect(
reverse('identities_contact_view', args=[contact.id]))
else:
return HttpResponseRedirect(reverse('identities_index'))
else:
form = ContactForm(request.user.profile, contact_type)
types = Object.filter_by_request(request,
ContactType.objects.order_by('name'))
return render_to_response('identities/contact_add_typed', {
'type': contact_type,
'types': types,
'form': form
},
context_instance=RequestContext(request),
response_format=response_format)
def _create_or_edit_contact(request, contact_id=None):
# assme user has contacts.add_contact and contacts.change_contact
if not contact_id is None:
# we're editing an existing contact
contact = Contact.objects.get(pk=contact_id)
template = 'contacts/edit_contact.html'
else:
# we're creating a new contact
contact = None # the default for ContactForm(instance=)
template = 'contacts/create_contact.html'
if request.method == 'POST':
form = ContactForm(request.POST, instance=contact)
if form.is_valid():
contact = form.save()
return redirect('contact_detail', contact.pk)
else:
form = ContactForm(instance=contact)
media = form.media
context = {
'contact': contact,
'form': form,
'media': media,
}
return render_to_response(
template,
context,
context_instance= RequestContext(request),
)
def create(request):
if request.POST:
form = ContactForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/contacts')
else:
form = ContactForm()
args = {}
args.update(csrf(request))
args['form'] = form
t = loader.get_template('contacts/contact_form.html')
c = RequestContext(request, args)
return HttpResponse(t.render(c))
def contact_add_typed(request, type_id, response_format='html'):
"Contact add with preselected type"
contact_type = get_object_or_404(ContactType, pk=type_id)
if not request.user.profile.has_permission(contact_type, mode='x'):
return user_denied(request, message="You don't have access to create " + unicode(contact_type))
if request.POST:
if 'cancel' not in request.POST:
form = ContactForm(
request.user.profile, contact_type, request.POST, files=request.FILES)
if form.is_valid():
contact = form.save(request, contact_type)
contact.set_user_from_request(request)
return HttpResponseRedirect(reverse('identities_contact_view', args=[contact.id]))
else:
return HttpResponseRedirect(reverse('identities_index'))
else:
form = ContactForm(request.user.profile, contact_type)
types = Object.filter_by_request(
request, ContactType.objects.order_by('name'))
return render_to_response('identities/contact_add_typed',
{'type': contact_type,
'types': types, 'form': form},
context_instance=RequestContext(request), response_format=response_format)
def contact(request):
contactform = ContactForm()
if request.method == "POST":
contactform = ContactForm(request.POST)
if contactform.is_valid():
message = contactform.save(commit=False)
message.save()
email_subject = "Message From {0} {1}".format(message.first_name, message.last_name)
email_message = "{0} \n\n {1} \n {2}".format(message.message, message.email, message.phone_number)
email_sender = settings.EMAIL_HOST_USER
email = EmailMessage(
email_subject,
email_message,
email_sender,
[email_sender,],
)
email.send()
return HttpResponseRedirect(reverse("contact"))
else:
print(contactform.errors)
return render(request,"contact_form/contact.html",{"contactform":contactform})
def contact(request):
contactform = ContactForm()
if request.method == "POST":
contactform = ContactForm(request.POST)
if contactform.is_valid():
message = contactform.save(commit=False)
message.save()
email_subject = "Message From {0} {1}".format(
message.first_name, message.last_name)
email_message = "{0} \n\n {1} \n {2}".format(
message.message, message.email, message.phone_number)
email_sender = settings.EMAIL_HOST_USER
email = EmailMessage(
email_subject,
email_message,
email_sender,
[
email_sender,
],
)
email.send()
return HttpResponseRedirect(reverse("contact"))
else:
print(contactform.errors)
return render(request, "contact_form/contact.html",
{"contactform": contactform})
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
try:
form.save()
messages.success(request, 'Thank you for your email. We will get back to you soon.')
form = ContactForm()
except:
messages.error(request, 'We are sorry, but there was a problem with the email server. '\
+ 'Please try again later.')
else:
form = ContactForm()
if not request.user.is_anonymous() or request.user.id == -1:
form.fields['sender'].initial = request.user.email
return render_to_response('server/contact.html', {'form': form},
context_instance=RequestContext(request))
def contact(request):
if request.method == 'POST': # If the form has been submitted...
form = ContactForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
form.save();
return render_to_response('contact/contact_sent.html', {
'script_name':request.META['SCRIPT_NAME']});
else:
form = ContactForm(); # An unbound form
if request.user.is_authenticated():
form = ContactForm(initial={'name':request.user.username,'email':request.user.email}); # An unbound form
return render_to_response('contact/contact.html',
{
'script_name':request.META['SCRIPT_NAME'],
'form':form
},
context_instance=RequestContext(request));
def save_contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
form.save()
messages.success(request, u'Your message were successfully sended.')
return HttpResponseRedirect('/contact/view_contact')
else:
form = ContactForm()
args = {}
args.update(csrf(request))
args['form'] = form
return render_to_response('contact.html',args, context_instance=RequestContext(request))
def new_contact_from_share(request):
if request.method == 'POST':
contact_form = ContactForm(request.POST, instance=Contact())
if contact_form.is_valid():
contact_form.save()
return HttpResponseRedirect(reverse('manage_contact'))
else:
project_pk = request.session.get('viewing_project', None)
if project_pk is None:
return HttpResponseRedirect(reverse('no_project'))
contact_form = ContactForm(instance=Contact(), initial={'project': project_pk})
context = {
'contact_form': contact_form,
'project_name': Project.objects.get(pk=project_pk).name
}
context.update(csrf(request))
return render_to_response('viewer/contact/new_contact_from_share.html', context,
context_instance=RequestContext(request))
def new_contact_from_share(request):
if request.method == 'POST':
contact_form = ContactForm(request.POST, instance=Contact())
if contact_form.is_valid():
contact_form.save()
return HttpResponseRedirect(reverse('manage_contact'))
else:
project_pk = request.session.get('viewing_project', None)
if project_pk is None:
return HttpResponseRedirect(reverse('no_project'))
contact_form = ContactForm(instance=Contact(), initial={'project': project_pk})
context = {
'contact_form': contact_form,
'project_name': Project.objects.get(pk=project_pk).name
}
context.update(csrf(request))
return render_to_response('viewer/contact/new_contact_from_share.html', context,
context_instance=RequestContext(request))
def edit_contact(request, contact_id):
contact = Contact.objects.get(pk=contact_id)
if request.method == 'POST':
contact_form = ContactForm(request.POST, instance = contact)
if contact_form.is_valid():
contact_form.save()
return HttpResponseRedirect('/contacts/mycontacts/', { 'contacts' : contact } )
else:
contact_form = ContactForm(instance=contact)
args = {}
args.update(csrf(request))
args['contact_form'] = contact_form
return render_to_response('contacts/edit_contact.html', args)
def edit(request):
contact = Contact.objects.get(pk=1)
form = ContactForm(request.POST or None, request.FILES or None, instance=contact)
if form.is_valid():
form.save()
if request.is_ajax():
return render(request, 'hello/form_edit.html', {
'form': form,
'contact': contact,
'notification': 'Changes have been saved'
})
else:
return HttpResponseRedirect(reverse('edit'))
if request.is_ajax():
return render(request, 'hello/form_edit.html', {'form': form, 'contact': contact})
else:
return render(request, 'hello/edit.html', {'form': form, 'contact': contact})
def create_contact(request):
""" Create a new contact. """
contact_form = ContactForm()
if request.method == "POST":
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
contact = contact_form.save(commit=False)
contact.owner = request.user
contact.save()
messages.success(request, "%s added" % contact.name)
return redirect("view_contact", contact.id)
return render(request, "contacts/create.html", {"form": contact_form})
def edit_contact(request, contact_id):
if request.method == 'POST':
contact = Contact.objects.get(pk=contact_id)
updated_form = ContactForm(request.POST, instance=contact)
if updated_form.is_valid():
updated_form.save()
return HttpResponseRedirect(reverse('manage_contact'))
else:
project_pk = request.session.get('viewing_project', None)
if project_pk is None:
return HttpResponseRedirect(reverse('no_project'))
contact = Contact.objects.get(pk=contact_id)
contact_form = ContactForm(instance=contact)
context = {
'contact_form': contact_form,
'name': contact.full_name,
'pk': contact.pk,
'project_name': Project.objects.get(pk=project_pk).name
}
context.update(csrf(request))
return render_to_response('viewer/contact/edit_contact.html', context,
context_instance=RequestContext(request))
def contact(request):
if request.method == 'POST': # If the form has been submitted...
form = ContactForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
form.save()
return render_to_response(
'contact/contact_sent.html',
{'script_name': request.META['SCRIPT_NAME']})
else:
form = ContactForm()
# An unbound form
if request.user.is_authenticated():
form = ContactForm(initial={
'name': request.user.username,
'email': request.user.email
})
# An unbound form
return render_to_response('contact/contact.html', {
'script_name': request.META['SCRIPT_NAME'],
'form': form
},
context_instance=RequestContext(request))
def edit_contact(request, contact_id):
if request.method == 'POST':
contact = Contact.objects.get(pk=contact_id)
updated_form = ContactForm(request.POST, instance=contact)
if updated_form.is_valid():
updated_form.save()
return HttpResponseRedirect(reverse('manage_contact'))
else:
project_pk = request.session.get('viewing_project', None)
if project_pk is None:
return HttpResponseRedirect(reverse('no_project'))
contact = Contact.objects.get(pk=contact_id)
contact_form = ContactForm(instance=contact)
context = {
'contact_form': contact_form,
'name': contact.full_name,
'pk': contact.pk,
'project_name': Project.objects.get(pk=project_pk).name
}
context.update(csrf(request))
return render_to_response('viewer/contact/edit_contact.html', context,
context_instance=RequestContext(request))
def edit_contact(request, pk):
""" Edit a contact. """
contact = get_object_or_404(Contact, pk=pk, owner=request.user)
contact_form = ContactForm(instance=contact)
if request.method == "POST":
contact_form = ContactForm(request.POST, instance=contact)
if contact_form.is_valid():
contact = contact_form.save()
messages.success(request, "%s updated" % contact.name)
return redirect("view_contact", contact.id)
return render(request, "contacts/edit.html", {
"contact": contact,
"form": contact_form
})
def contact_edit(request):
contact = Contact.objects.get(pk=1)
if request.method == 'POST':
form = ContactForm(request.POST, request.FILES, instance=contact)
if form.is_valid():
if request.is_ajax():
contact = form.save()
try:
photo = contact.photo.url
except ValueError:
photo = None
data = {
'is_error': 0,
'photo': photo,
}
return HttpResponse(json.dumps(data))
else:
form.save()
return HttpResponseRedirect(reverse('index'))
else:
if request.is_ajax():
data = {
'is_error': 1,
'errors': form.errors,
}
return HttpResponse(json.dumps(data))
else:
data = {
'form': form,
}
return render(request, 'core/contact_edit.html', data)
else:
form = ContactForm(instance=contact)
data = {
'form': form,
}
return render(request, 'core/contact_edit.html', data)
def contact_page(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
contact = form.save(commit=False)
contact.published_date = timezone.now()
contact.save()
email = form.cleaned_data['email']
message = form.cleaned_data['message']
subject, from_email, to = 'Message from katastrofffe.com', '*****@*****.**', config.CONTACT_EMAIL
html_content = render_to_string('contact/mail_template.html', {
'message': message,
'email': email
})
text_content = strip_tags(html_content)
msg = EmailMultiAlternatives(subject, text_content, from_email,
[to])
msg.attach_alternative(html_content, "text/html")
try:
msg.send()
status = 'OK'
system_message = 'Thank you! Your message has been sent.'
return render(
request, 'contact/contact.html', {
'form': form,
'status': status,
'system_message': system_message
})
except SMTPException:
status = 'ERROR'
system_message = "Sorry! Something went wrong, your message hasn't been sent."
return render(
request, 'contact/contact.html', {
'form': form,
'status': status,
'system_message': system_message
})
else:
form = ContactForm()
return render(request, 'contact/contact.html', {'form': form})
def contact_view(request):
"""
Record a contact request from the website.
"""
context = {'current': 'contact'}
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
contact = form.save()
return HttpResponseRedirect(reverse('contact_message_sent_view'))
else:
context['form']=form
else:
context['form']=ContactForm()
context['unread'] = Contact.objects.filter(is_read=False).count()
return render_response(request, 'contact/contact_view.html', context)
def edit_form_contact(request, id):
contacts = Contact.objects.get(pk=id)
if request.POST and request.is_ajax():
form = ContactForm(request.POST, request.FILES, instance=contacts)
if form.is_valid():
contact = form.save(commit=False)
contact.save()
return HttpResponse('OK')
else:
errors_dict = {}
for e in form.errors:
error = form.errors[e]
errors_dict[e] = unicode(error)
return HttpResponseBadRequest(json.dumps(errors_dict))
else:
form = ContactForm(instance=contacts)
return render(request, 'edit_form.html', {'form': form})
def new_form(request, template_name = 'tnycnt/tnycnt_edit.html'):
"""
Create new user created contact form
"""
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
contactform = form.save(commit=False)
contactform.user = request.user
contactform.save()
return HttpResponseRedirect(reverse("tnycnt_list"))
else:
form = ContactForm()
status = _("Create")
return render_to_response(template_name, {
'form': form, 'status': status,
},
context_instance=RequestContext(request)
)
def post(self, request, **kwargs):
form = ContactForm(request.POST)
context = {"form": form}
if form.is_valid():
msg = form.save()
subject = "Contact Form Submission"
toAddr = "*****@*****.**" if settings.DEBUG else "*****@*****.**"
email = EmailMessage(
subject,
msg.message,
'*****@*****.**',
[toAddr],
reply_to=[msg.email],
)
try:
email.send()
except Exception as e:
raise
return HttpResponseRedirect('/thank-you/')
return render(request, self.template_name, context)
def post(self, request):
if request.method == 'POST':
contact_form = ContactForm(request.POST)
if contact_form.is_valid():
new_contact = contact_form.save()
# send_mail(
# 'Feedback Submitted',
# 'Thanks for submitting your suggestion.',
# settings.DEFAULT_FROM_EMAIL,
# [new_contact.contact_email],
# )
return render_to_response('contact_added.html',
{'contact': new_contact},
RequestContext(request))
else:
error_fields = contact_form.errors.keys()
for each_field in error_fields:
contact_form.fields[each_field].widget.attrs['class'] = 'textbox_error'
else:
contact_form = ContactForm()
return render_to_response(self.template_name, locals(), context_instance = RequestContext( request ))
def edit_form(request,form_id, template_name = 'tnycnt/tnycnt_edit.html'):
"""
Edit user created contact form
"""
userform = get_object_or_404(Contact, id=form_id)
if userform.user != request.user:
return HttpResponseRedirect('/404/')
if request.method == "POST":
form = ContactForm(request.POST, instance=userform)
if form.is_valid():
contactform = form.save(commit=False)
contactform.user = request.user
contactform.save()
return HttpResponseRedirect(reverse("tnycnt_list"))
else:
form = ContactForm(instance=userform)
status = _("Edit")
return render_to_response(template_name, {
'form': form, 'status': status,
},
context_instance=RequestContext(request)
)
def index(request):
if request.method == 'POST':
form = ContactForm(request.REQUEST)
if form.is_valid():
ctc = form.save(commit=False)
ctc.vm = True
ctc.save()
# Make the call
d = {
'Caller' : settings.CALLER_ID,
'Called' : ctc.phone,
'Url' : '%s/call/%s' % (settings.BASE_URL, ctc.pk),
#'IfMachine' : 'Continue',
}
response = account.request('/%s/Accounts/%s/Calls' %(settings.API_VERSION, settings.ACCOUNT_SID), 'POST', d)
updateContact(response, ctc)
return HttpResponseRedirect(reverse('status', args=[ctc.pk]))
else:
form = ContactForm()
return render_to_response('index.html', {'form':form})
def contact_edit(request, contact_id, response_format='html'):
"Contact edit"
contact = get_object_or_404(Contact, pk=contact_id)
if not request.user.profile.has_permission(contact, mode='w'):
return user_denied(
request, message="You don't have write access to this Contact")
if request.POST:
if 'cancel' not in request.POST:
form = ContactForm(request.user.profile,
contact.contact_type,
request.POST,
files=request.FILES,
instance=contact)
if form.is_valid():
contact = form.save(request)
return HttpResponseRedirect(
reverse('identities_contact_view', args=[contact.id]))
else:
return HttpResponseRedirect(
reverse('identities_contact_view', args=[contact.id]))
else:
form = ContactForm(request.user.profile,
contact.contact_type,
instance=contact)
types = Object.filter_by_request(request,
ContactType.objects.order_by('name'))
return render_to_response('identities/contact_edit', {
'contact': contact,
'types': types,
'form': form
},
context_instance=RequestContext(request),
response_format=response_format)
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
from datetime import datetime
name = form.cleaned_data['name']
email = form.cleaned_data['email']
phone = form.cleaned_data['phone']
message = form.cleaned_data['message']
subject = "Contact Us message from " + form.cleaned_data['name']
if request.user.is_authenticated():
form.submitter = request.user
form.submitteddate = datetime.now()
contact = form.save()
message = 'Email: %s\nPhone: %s\n\n' % (email, phone) + message
recipients = settings.CONTACT_EMAIL.split(';');
from django.core.mail import send_mail
send_mail(subject, message, settings.CONTACT_EMAIL, recipients)
return HttpResponseRedirect('/contacttks.html') # Redirect after POST
else:
form = ContactForm()
return direct_to_template(request, 'content/contactus.html', { 'form': form, })
