def process_email_form(request, content_type_id=None, object_id=None):
"""
submission processor for email form.
"""
if not (request.method=='POST' and request.is_ajax()):
return HttpResponse('Method Not Allowed', status=httplib.METHOD_NOT_ALLOWED, mimetype='text/plain')
if content_type_id is None:
content_type_id=request.POST.get('content_type')
try:
content_type=ContentType.objects.get(pk=int(content_type_id))
except (ObjectDoesNotExist, ValueError, TypeError):
return HttpResponseBadRequest("invalid content type", mimetype='text/plain')
if object_id is None:
object_id=request.POST.get('object_id')
try:
item=content_type.get_object_for_this_type(pk=int(object_id))
except (ObjectDoesNotExist, ValueError, TypeError):
return HttpResponseBadRequest("no such object id")
form=EmailEventForm(request.POST)
if not form.is_valid():
logging.debug("form is invalid. Errors are: %s", form.errors)
logging.debug("type of errors: %s", type(form.errors))
return render_to_json(clean_errors(form.errors), status=httplib.BAD_REQUEST)
cleaned=form.cleaned_data
message_template=loader.get_template('email_message.txt')
site=Site.objects.get_current()
user=request.user if request.user.is_authenticated() else None
message_context=Context(dict(
email_from=cleaned['email_from'],
subject=cleaned['subject'],
message=cleaned['message'],
site=site,
site_url='http://%s/' % site.domain,
url='http://%s%s' % (site.domain, item.get_absolute_url()),
item=item,
user=user,
))
message=message_template.render(message_context)
recipients=cleaned['email_to'].split(',')
from_address=cleaned['email_from']
send_mail(cleaned['subject'], message, from_address, recipients, fail_silently=False, priority='high')
#Update email_count
email_sent.send(sender=EmailEvent, instance=item)
event=form.save(commit=False)
event.remote_ip=request.META['REMOTE_ADDR']
event.content_type_id=content_type.pk
event.object_id=item.pk
event.mailed_by=user
event.save()
return render_to_response("email_success.txt")
def save(self, fail_silently=False):
"""
Builds and sends the email message.
"""
send_mail(priority="high", fail_silently=fail_silently, **self.get_message_dict())
def create_inactive_user(self, username, password, email,
send_email=True, profile_callback=None):
"""
Create a new, inactive ``User``, generates a
``RegistrationProfile`` and email its activation key to the
``User``, returning the new ``User``.
To disable the email, call with ``send_email=False``.
The activation email will make use of two templates:
``registration/activation_email_subject.txt``
This template will be used for the subject line of the
email. It receives one context variable, ``site``, which
is the currently-active
``django.contrib.sites.models.Site`` instance. Because it
is used as the subject line of an email, this template's
output **must** be only a single line of text; output
longer than one line will be forcibly joined into only a
single line.
``registration/activation_email.txt``
This template will be used for the body of the email. It
will receive three context variables: ``activation_key``
will be the user's activation key (for use in constructing
a URL to activate the account), ``expiration_days`` will
be the number of days for which the key will be valid and
``site`` will be the currently-active
``django.contrib.sites.models.Site`` instance.
To enable creation of a custom user profile along with the
``User`` (e.g., the model specified in the
``AUTH_PROFILE_MODULE`` setting), define a function which
knows how to create and save an instance of that model with
appropriate default values, and pass it as the keyword
argument ``profile_callback``. This function should accept one
keyword argument:
``user``
The ``User`` to relate the profile to.
"""
new_user = User.objects.create_user(username, email, password)
new_user.is_active = False
new_user.save()
registration_profile = self.create_profile(new_user)
if profile_callback is not None:
profile_callback(user=new_user)
if send_email:
from courant.core.mailer import send_mail
current_site = Site.objects.get_current()
subject = render_to_string('registration/activation_email_subject.txt',
{ 'site': current_site })
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
message = render_to_string('registration/activation_email.txt',
{ 'activation_key': registration_profile.activation_key,
'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS,
'site': current_site })
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [new_user.email])
return new_user
