def form_valid(self, form):
email_outbox_message, task = super(EmailMessageSendView, self).form_valid(form)
if is_ajax(self.request):
return HttpResponse(anyjson.dumps({'task_id': task.id}), content_type='application/json')
else:
return HttpResponseRedirect(self.get_success_url())
def delete(self, request, *args, **kwargs):
"""
Overloading super().delete to remove the related models and the instance itself.
"""
self.object = self.get_object()
# Check this contact isn't linked to a user in an admin group.
if has_user_in_group(self.object, 'account_admin'):
raise Http404()
self.object.email_addresses.remove()
self.object.addresses.remove()
self.object.phone_numbers.remove()
self.object.tags.remove()
functions = Function.objects.filter(contact=self.object)
functions.delete()
# Show delete message
messages.success(self.request, _('%s (Contact) has been deleted.') % self.object.full_name())
self.object.delete()
redirect_url = self.get_success_url()
if is_ajax(request):
response = anyjson.serialize({
'error': False,
'redirect_url': redirect_url
})
return HttpResponse(response, content_type='application/json')
return redirect(redirect_url)
def get_form(self, form_class):
"""
Instantiate formsets for non-ajax requests.
"""
form = super(ModelFormSetViewMixin, self).get_form(form_class)
if not is_ajax(self.request):
for context_name, formset_class in self.formset_classes.items():
model = self.formset_data[context_name]['model']
prefix = self.formset_data[context_name]['prefix']
queryset = model._default_manager.none()
if hasattr(self, 'get_%s_queryset' % prefix) and callable(getattr(self, 'get_%s_queryset' % prefix)):
queryset = getattr(self, 'get_%s_queryset' % prefix)(form.instance)
else:
try:
queryset = getattr(form.instance, self.formset_data[context_name]['related_name']).all()
except:
pass
formset_instance = formset_class(self.request.POST or None, queryset=queryset, prefix=prefix)
self.add_formset_instance(context_name, formset_instance)
return super(ModelFormSetViewMixin, self).get_form(form_class)
def dispatch(self, request, *args, **kwargs):
# Change form and template for ajax calls
if is_ajax(request):
self.form_class = CreateUpdateCaseForm
self.template_name = 'cases/case_unarchive_form.html'
return super(UpdateAndUnarchiveCaseView, self).dispatch(request, *args, **kwargs)
def form_valid(self, form):
email_outbox_message = super(EmailMessageReplyOrForwardView, self).form_valid(form)
task = self.send_message(email_outbox_message)
success_url = self.get_success_url()
# Send and archive was pressed.
if task and form.data.get('archive', False) == 'true':
# An email message is archived by removing the inbox label and the provided label of the current inbox.
current_inbox = form.data.get('current_inbox', '')
# Filter out labels an user should not manipulate.
remove_labels = []
if current_inbox and current_inbox not in settings.GMAIL_LABELS_DONT_MANIPULATE:
remove_labels.append(current_inbox)
# Archiving email should always remove the inbox label.
if settings.GMAIL_LABEL_INBOX not in remove_labels:
remove_labels.append(settings.GMAIL_LABEL_INBOX)
email_message = EmailMessage.objects.get(pk=self.object.id)
email_message._is_archived = True
labels_to_remove = EmailLabel.objects.filter(label_id__in=remove_labels,
account=self.object.account)
email_message.labels.remove(*labels_to_remove)
reindex_email_message(email_message)
add_and_remove_labels_for_message.delay(self.object.id, remove_labels=remove_labels)
if is_ajax(self.request):
return HttpResponse(anyjson.dumps({'task_id': task.id}), content_type='application/json')
else:
return HttpResponseRedirect(success_url)
def dispatch(self, request, *args, **kwargs):
# Change form and template for ajax calls
if is_ajax(request):
self.form_class = CreateUpdateDealForm
self.template_name = 'deals/deal_unarchive_form.html'
return super(UpdateAndUnarchiveDealView, self).dispatch(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
"""
Overloading super().delete to check if the user who tries to delete this entry is also the
author.
"""
self.object = self.get_object()
# Check if this blog entry account is written by request.user
if self.object.author != get_current_user():
raise Http404()
# Show delete message
messages.success(self.request, _('Post deleted.'))
self.object.delete()
if is_ajax(request):
do_redirect = True
url = request.META.get('HTTP_REFERER', reverse('dashboard'))
# Return response
return HttpResponse(anyjson.serialize({
'error': False,
'redirect_url': url
}), content_type='application/json')
return redirect(request.META.get('HTTP_REFERER', reverse('dashboard')))
def delete(self, request, *args, **kwargs):
"""
Overloading super().delete to remove the related models and the instance itself.
"""
self.object = self.get_object()
# Prevents deleting an account with users and checks if the account has a user that's linked to an admin group
if self.object.user.exists() or has_user_in_group(self.object, 'account_admin'):
raise Http404()
self.object.email_addresses.remove()
self.object.addresses.remove()
self.object.phone_numbers.remove()
self.object.tags.remove()
functions = Function.objects.filter(account=self.object)
functions.delete()
# Show delete message
messages.success(self.request, _('%s (Account) has been deleted.') % self.object.name)
self.object.delete()
# TODO: check for contacts and websites ..
redirect_url = self.get_success_url()
if is_ajax(request):
response = anyjson.serialize({
'error': False,
'redirect_url': redirect_url
})
return HttpResponse(response, content_type='application/json')
return redirect(redirect_url)
def formset_valid(self, formset):
"""
This function is called when the formset is deemed valid.
An email is sent to all email fields which are filled in.
If the request is done via ajax give json back with a success message, otherwise
redirect to the success url.
"""
protocol = self.request.is_secure() and 'https' or 'http'
date_string = date.today().strftime('%d%m%Y')
# Get the current site or empty string
try:
current_site = Site.objects.get_current()
except Site.DoesNotExist:
current_site = ''
for form in formset:
if form in formset.deleted_forms:
continue
first_name = form.cleaned_data.get('first_name')
email = form.cleaned_data.get('email')
tenant_id = self.request.user.tenant_id
hash = sha256('%s-%s-%s-%s' % (
tenant_id,
email,
date_string,
settings.SECRET_KEY
)).hexdigest()
invite_link = '%s://%s%s' % (protocol, current_site, reverse_lazy('invitation_accept', kwargs={
'tenant_id': tenant_id,
'first_name': first_name,
'email': email,
'date': date_string,
'hash': hash,
}))
# Email to the user
send_templated_mail(
template_name='invitation',
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[form.cleaned_data['email']],
context={
'current_site': current_site,
'full_name': self.request.user.full_name,
'name': first_name,
'invite_link': invite_link,
}
)
post_intercom_event(event_name='invite-sent', user_id=self.request.user.id)
if is_ajax(self.request):
return HttpResponse(anyjson.serialize({
'error': False,
'html': _('The invitations were sent successfully'),
}), content_type='application/json')
return HttpResponseRedirect(self.get_success_url())
def dispatch(self, request, *args, **kwargs):
"""
For AJAX calls, use a different form and template.
"""
if is_ajax(request):
self.template_name_suffix = '_form_ajax'
return super(UpdateNoteView, self).dispatch(request, *args, **kwargs)
def dispatch(self, request, *args, **kwargs):
"""
This is a copy from HistoryListViewMixin.
"""
if is_ajax(request):
self.template_name = 'utils/historylist.html'
return super(DetailAccountView, self).dispatch(request, *args, **kwargs)
def dispatch(self, request, *args, **kwargs):
"""
For AJAX calls, use a different form and template.
"""
if is_ajax(request):
self.template_name_suffix = '_form_ajax'
return super(UpdateNoteView, self).dispatch(request, *args, **kwargs)
def formset_valid(self, formset):
"""
This function is called when the formset is deemed valid.
An email is sent to all email fields which are filled in.
If the request is done via ajax give json back with a success message, otherwise
redirect to the success url.
"""
protocol = self.request.is_secure() and 'https' or 'http'
date_string = date.today().strftime('%d%m%Y')
# Get the current site or empty string
try:
current_site = Site.objects.get_current()
except Site.DoesNotExist:
current_site = ''
for form in formset:
if form in formset.deleted_forms:
continue
first_name = form.cleaned_data.get('first_name')
email = form.cleaned_data.get('email')
tenant_id = self.request.user.tenant_id
hash = sha256('%s-%s-%s-%s' % (tenant_id, email, date_string,
settings.SECRET_KEY)).hexdigest()
invite_link = '%s://%s%s' % (protocol, current_site,
reverse_lazy(
'invitation_accept',
kwargs={
'tenant_id': tenant_id,
'first_name': first_name,
'email': email,
'date': date_string,
'hash': hash,
}))
# E-mail to the user
send_templated_mail(template_name='invitation',
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[form.cleaned_data['email']],
context={
'current_site': current_site,
'full_name':
self.request.user.get_full_name(),
'name': first_name,
'invite_link': invite_link,
})
if is_ajax(self.request):
return HttpResponse(anyjson.serialize({
'error':
False,
'html':
_('The invitations were sent successfully'),
}),
content_type='application/json')
return HttpResponseRedirect(self.get_success_url())
def dispatch(self, request, *args, **kwargs):
"""
For AJAX calls, use a different form and template.
"""
if is_ajax(request):
self.template_name_suffix = '_form_ajax'
self.form_class = CreateCaseQuickbuttonForm
return super(CreateCaseView, self).dispatch(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
if not is_ajax(request):
if request.POST.get('submit-delete', None):
pass # TODO: get delete url
if request.POST.get('submit-back', None):
success_url = self.get_success_url() # TODO: ask if the user is sure to cancel when the form has been changed
return redirect(success_url) if isinstance(success_url, basestring) else success_url
# continue for other options (add or save)
return super(DeleteBackAddSaveFormViewMixin, self).post(request, *args, **kwargs)
def delete(self, request, *args, **kwargs):
response = super(EmailTemplateDeleteView, self).delete(request, *args, **kwargs)
messages.success(self.request, _('%s (Email template) has been deleted.' % self.object.name))
if is_ajax(self.request):
return HttpResponse(anyjson.serialize({
'error': False,
'redirect_url': self.get_success_url()
}), content_type='application/json')
return response
def current_site(request):
if is_ajax(request):
return {}
protocol = 'https' if request.is_secure() else 'http'
domain = Site.objects.get_current().domain
return {
'SITE': '%s://%s' % (protocol, domain)
}
def form_valid(self, form):
email_outbox_message, task = super(EmailMessageSendView,
self).form_valid(form)
if is_ajax(self.request):
return HttpResponse(anyjson.dumps({'task_id': task.id}),
content_type='application/json')
else:
return HttpResponseRedirect(self.get_success_url())
def dispatch(self, request, *args, **kwargs):
"""
For AJAX calls, use a different form and template.
"""
if is_ajax(request):
self.template_name_suffix = '_form_ajax'
self.form_class = CreateCaseQuickbuttonForm
return super(CreateCaseView, self).dispatch(request, *args, **kwargs)
def form_invalid(self, form):
response = self.render_to_response(self.get_context_data(form=form))
if is_ajax(self.request):
response = anyjson.serialize({
'error': True,
'html': response.rendered_content
})
return HttpResponse(response, content_type='application/json')
return response
def form_invalid(self, form):
response = self.render_to_response(self.get_context_data(form=form))
if is_ajax(self.request):
response = anyjson.serialize({
'error': True,
'html': response.rendered_content
})
return HttpResponse(response, content_type='application/json')
return response
def email(request):
"""
Add extra context variables for email.
"""
extra_context = {}
if not is_ajax(request) and not request.user.is_anonymous():
extra_context.update({'email_auth_update': email_auth_update(request.user)})
# TODO: slow queries, temporary disable unread_emails
# extra_context.update({'unread_emails': unread_emails(request.user)})
return extra_context
def form_invalid(self, form):
response = super(UpdateNoteView, self).form_invalid(form)
if is_ajax(self.request):
response = anyjson.serialize({
'error': True,
'html': response.rendered_content
})
return HttpResponse(response, content_type='application/json')
return response
def form_invalid(self, form):
response = super(UpdateNoteView, self).form_invalid(form)
if is_ajax(self.request):
response = anyjson.serialize({
'error': True,
'html': response.rendered_content
})
return HttpResponse(response, content_type='application/json')
return response
def formset_valid(self, formset):
"""
This function is called when the formset is deemed valid.
An email is sent to all email fields which are filled in.
If the request is done via ajax give json back with a success message, otherwise
redirect to the success url.
"""
self.protocol = self.request.is_secure() and 'https' or 'http'
self.account = self.request.user.account
self.b36accountpk = int_to_base36(self.account.pk)
self.date = date.today().strftime('%d%m%Y')
# Get the current site or empty string
try:
self.current_site = Site.objects.get_current()
except Site.DoesNotExist:
self.current_site = ''
for form in formset:
if form in formset.deleted_forms:
continue
first_name = form.cleaned_data.get('first_name')
email = form.cleaned_data.get('email')
if email: # check that the email is not empty
self.hash = sha256('%s-%s-%s-%s' % (self.account.name, email, self.date, settings.SECRET_KEY)).hexdigest()
self.invite_link = '%s://%s%s' % (self.protocol, self.current_site, reverse_lazy('invitation_accept', kwargs={
'account_name': self.account.name,
'first_name': first_name,
'email': email,
'date': self.date,
'aidb36': self.b36accountpk,
'hash': self.hash,
}))
# E-mail to the user
send_templated_mail(
template_name='invitation',
from_email=settings.DEFAULT_FROM_EMAIL,
recipient_list=[form.cleaned_data['email']],
context={
'current_site': self.current_site,
'full_name': self.request.user.contact.full_name(),
'name': first_name,
'invite_link': self.invite_link,
'company_name': self.account.name,
}
)
if is_ajax(self.request):
return HttpResponse(anyjson.serialize({
'error': False,
'html': _('The invitations were sent successfully'),
}), content_type='application/json')
return HttpResponseRedirect(self.get_success_url())
def get_context_data(self, **kwargs):
"""
Provide an url to go back to.
"""
kwargs = super(EmailAccountUpdateView, self).get_context_data(**kwargs)
if not is_ajax(self.request):
kwargs.update({
'back_url': self.get_success_url(),
})
return kwargs
def get_context_data(self, **kwargs):
"""
Provide an url to go back to.
"""
kwargs = super(CreateUpdateAccountMixin, self).get_context_data(**kwargs)
if not is_ajax(self.request):
kwargs.update({
'back_url': self.get_success_url(),
})
return kwargs
def get_context_data(self, **kwargs):
"""
Provide an url to go back to.
"""
kwargs = super(CreateUpdateCaseMixin, self).get_context_data(**kwargs)
if not is_ajax(self.request):
kwargs.update({
'back_url': self.get_success_url(),
})
return kwargs
def form_invalid(self, form):
"""
Overloading super().form_invalid to return a different response to ajax requests.
"""
if is_ajax(self.request):
context = RequestContext(self.request, self.get_context_data(form=form))
return HttpResponse(anyjson.serialize({
'error': True,
'html': render_to_string(self.template_name, context_instance=context)
}), content_type='application/json')
return super(AddAccountView, self).form_invalid(form)
def form_valid(self, form):
email_message = super(EmailMessageDraftView, self).form_valid(form)
if form.data.get('send_draft', False) == 'true':
task = self.send_message(email_message)
else:
task = self.draft_message(email_message)
if is_ajax(self.request):
return HttpResponse(anyjson.dumps({'task_id': task.id}), content_type='application/json')
else:
return HttpResponseRedirect(self.get_success_url())
def dispatch(self, request, *args, **kwargs):
"""
Overloading super().dispatch to change the template to be rendered for ajax requests.
"""
# Change form and template for ajax calls or create formset instances for the normal form
self.is_ajax = False
if is_ajax(request):
self.is_ajax = True
self.form_class = AddAccountQuickbuttonForm
self.template_name = 'accounts/account_form_ajax.html'
return super(AddAccountView, self).dispatch(request, *args, **kwargs)
def formset_invalid(self, formset):
"""
This function is called when the formset didn't pass validation.
If the request is done via ajax, send back a json object with the error set to true and
the form rendered into a string.
"""
if is_ajax(self.request):
context = RequestContext(self.request, self.get_context_data(formset=formset))
return HttpResponse(anyjson.serialize({
'error': True,
'html': render_to_string(self.form_template_name, context)
}), content_type='application/json')
return self.render_to_response(self.get_context_data(formset=formset))
def form_valid(self, form):
email_message = super(EmailMessageDraftView, self).form_valid(form)
if form.data.get('send_draft', False) == 'true':
task = self.send_message(email_message)
else:
task = self.draft_message(email_message)
if is_ajax(self.request):
return HttpResponse(anyjson.dumps({'task_id': task.id}),
content_type='application/json')
else:
return HttpResponseRedirect(self.get_success_url())
def form_valid(self, form):
email_outbox_message = super(EmailMessageReplyOrForwardView, self).form_valid(form)
task = self.send_message(email_outbox_message)
# Send and archive was pressed, so start an archive task
if task and form.data.get('archive', False) == 'true':
archive_email_message.apply_async(args=(self.object.id,))
if is_ajax(self.request):
return HttpResponse(anyjson.dumps({'task_id': task.id}), content_type='application/json')
else:
return HttpResponseRedirect(self.get_success_url())
def dispatch(self, request, *args, **kwargs):
"""
Overloading super().dispatch to change the template to be rendered for ajax requests.
"""
# Change form and template for ajax calls or create formset instances for the normal form
self.reply_to = None
if kwargs.get('pk'):
self.reply_to = get_object_or_404(BlogEntry, pk=kwargs.get('pk'))
if is_ajax(request):
self.template_name_suffix = '_form_ajax'
return super(AddBlogEntryView, self).dispatch(request, *args, **kwargs)
def get_context_data(self, **kwargs):
"""
Pass all formsets to the context.
"""
kwargs = super(ModelFormSetViewMixin, self).get_context_data(**kwargs)
if not is_ajax(self.request): # filter formsets from ajax requests
if not 'formsets' in kwargs:
kwargs['formsets'] = SortedDict()
for context_name, instance in self.formsets.items():
kwargs['formsets'][context_name] = {'instance': instance, 'label': self.formset_data[context_name]['label'], 'template': self.formset_data[context_name]['template']}
return kwargs
def dispatch(self, request, *args, **kwargs):
"""
# Check if it is an DataTables AJAX call and redirect request.
"""
self.request = request
self.args = args
self.kwargs = kwargs
# Get app_name from url.
self._app_name = resolve(request.path).app_name
if is_ajax(request) and request.GET.get('sEcho', False):
return self.get_ajax(request)
return super(DataTablesListView, self).dispatch(request, *args, **kwargs)
def form_valid(self, form):
email_outbox_message = super(EmailMessageReplyOrForwardView,
self).form_valid(form)
task = self.send_message(email_outbox_message)
# Send and archive was pressed, so start an archive task
if task and form.data.get('archive', False) == 'true':
archive_email_message.apply_async(args=(self.object.id, ))
if is_ajax(self.request):
return HttpResponse(anyjson.dumps({'task_id': task.id}),
content_type='application/json')
else:
return HttpResponseRedirect(self.get_success_url())
def delete(self, request, *args, **kwargs):
response = super(EmailTemplateDeleteView,
self).delete(request, *args, **kwargs)
messages.success(
self.request,
_('%s (Email template) has been deleted.' % self.object.name))
if is_ajax(self.request):
return HttpResponse(anyjson.serialize({
'error':
False,
'redirect_url':
self.get_success_url()
}),
content_type='application/json')
return response
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
self.object.delete()
# Show delete message
message = _('The note was successfully deleted.')
messages.success(self.request, message)
if is_ajax(self.request):
response = anyjson.serialize({
'error': False,
'redirect_url': self.get_success_url()
})
return HttpResponse(response, content_type='application/json')
return HttpResponseRedirect(self.get_success_url())
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
self.object.delete()
# Show delete message
message = _('The note was successfully deleted.')
messages.success(self.request, message)
if is_ajax(self.request):
response = anyjson.serialize({
'error': False,
'redirect_url': self.get_success_url()
})
return HttpResponse(response, content_type='application/json')
return HttpResponseRedirect(self.get_success_url())
def form_valid(self, form):
# Saves the instance
response = super(UpdateNoteView, self).form_valid(form)
# Show save message
message = _('Note has been updated.')
messages.success(self.request, message)
if is_ajax(self.request):
response = anyjson.serialize({
'error': False,
'redirect_url': self.get_success_url()
})
return HttpResponse(response, content_type='application/json')
return response
def form_valid(self, form):
# Saves the instance
response = super(UpdateNoteView, self).form_valid(form)
# Show save message
message = _('Note has been updated.')
messages.success(self.request, message)
if is_ajax(self.request):
response = anyjson.serialize({
'error': False,
'redirect_url': self.get_success_url()
})
return HttpResponse(response, content_type='application/json')
return response
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
self.object.delete()
# Show delete message
messages.success(self.request, _('%s (Case) has been deleted.') % self.object.subject)
redirect_url = self.get_success_url()
if is_ajax(request):
response = anyjson.serialize({
'error': False,
'redirect_url': redirect_url
})
return HttpResponse(response, content_type='application/json')
return HttpResponseRedirect(redirect_url)
def formset_invalid(self, formset):
"""
This function is called when the formset didn't pass validation.
If the request is done via ajax, send back a json object with the error set to true and
the form rendered into a string.
"""
if is_ajax(self.request):
context = RequestContext(self.request,
self.get_context_data(formset=formset))
return HttpResponse(anyjson.serialize({
'error':
True,
'html':
render_to_string(self.form_template_name, context)
}),
content_type='application/json')
return self.render_to_response(self.get_context_data(formset=formset))
def form_valid(self, form):
# Saves the instance
response = super(CreateDealView, self).form_valid(form)
# Show save message
message = _('%s (Deal) has been created.') % self.object.name
messages.success(self.request, message)
if is_ajax(self.request):
# Reload when user is in the deal list
response = anyjson.serialize({
'error': False,
'redirect_url': self.get_success_url()^M
})
return HttpResponse(response, content_type='application/json')
return response
def form_valid(self, form):
# Saves the instance
response = super(CreateCaseView, self).form_valid(form)
# Show save message
message = _('%s (Case) has been created.') % self.object.subject
messages.success(self.request, message)
if is_ajax(self.request):
# Reload when user is in the case list
redirect_url = None
parse_result = urlparse(self.request.META['HTTP_REFERER'])
if parse_result.path == reverse('case_list'):
redirect_url = '%s?order_by=7&sort_order=desc' % reverse('case_list')
response = anyjson.serialize({
'error': False,
'redirect_url': redirect_url
})
return HttpResponse(response, content_type='application/json')
return response
def form_valid(self, form):
"""
When adding a blogentry, try to automatically save the author and object being replied to.
"""
blogentry = form.save(commit=False)
blogentry.author = self.request.user
if self.reply_to:
blogentry.reply_to = self.reply_to
blogentry.save()
# Show success message
messages.success(self.request, _('Post successful.'))
if is_ajax(self.request):
response = anyjson.serialize({
'error': False,
'redirect_url': reverse('dashboard')
})
return HttpResponse(response, content_type='application/json')
return super(AddBlogEntryView, self).form_valid(form)
def form_valid(self, form):
email_outbox_message = super(EmailMessageReplyOrForwardView,
self).form_valid(form)
task = self.send_message(email_outbox_message)
success_url = self.get_success_url()
# Send and archive was pressed.
if task and form.data.get('archive', False) == 'true':
# An email message is archived by removing the inbox label and the provided label of the current inbox.
current_inbox = form.data.get('current_inbox', '')
# Filter out labels an user should not manipulate.
remove_labels = []
if current_inbox and current_inbox not in settings.GMAIL_LABELS_DONT_MANIPULATE:
remove_labels.append(current_inbox)
# Archiving email should always remove the inbox label.
if settings.GMAIL_LABEL_INBOX not in remove_labels:
remove_labels.append(settings.GMAIL_LABEL_INBOX)
email_message = EmailMessage.objects.get(pk=self.object.id)
email_message._is_archived = True
labels_to_remove = EmailLabel.objects.filter(
label_id__in=remove_labels, account=self.object.account)
email_message.labels.remove(*labels_to_remove)
reindex_email_message(email_message)
add_and_remove_labels_for_message.delay(
self.object.id, remove_labels=remove_labels)
if is_ajax(self.request):
return HttpResponse(anyjson.dumps({'task_id': task.id}),
content_type='application/json')
else:
return HttpResponseRedirect(success_url)
def get(self, request, *args, **kwargs):
if not is_ajax(request):
self.template_name = 'form.html'
return super(EmailAccountUpdateView, self).get(request, *args,
**kwargs)
