def approve_user(request, user_id):
""" Approves an inactive, registration pending user and sends out an email to let them know """
error = _check_user_approval_permissions(request, user_id)
if error:
return error
try:
user = USER_MODEL.objects.get(id=user_id)
except USER_MODEL.DoesNotExist:
messages.error(request, _('The user account you were looking for does not exist! Their registration was probably already denied.'))
return redirect(reverse('cosinnus:user-list'))
if user.is_active:
messages.success(request, _('The user account was already approved, but thank you anyway!'))
return redirect(reverse('cosinnus:user-list'))
user.is_active = True
user.save()
# message user for accepeted request
data = get_common_mail_context(request)
data.update({
'user': user,
})
template = 'cosinnus/mail/user_registration_approved.html'
subj_user = render_to_string('cosinnus/mail/user_registration_approved_subj.txt', data)
send_mail_or_fail_threaded(user.email, subj_user, template, data)
_send_user_welcome_email_if_enabled(user)
messages.success(request, _('Thank you for approving user %(username)s (%(email)s)! An introduction-email was sent out to them and they can now log in to the site.') \
% {'username':full_name_force(user), 'email': user.email})
return redirect(reverse('cosinnus:profile-detail', kwargs={'username': user.username}) + '?force_show=1')
def set_user_email_to_verify(user, new_email, request=None, user_has_just_registered=True):
""" Sets the profile variables for a user to confirm a pending email,
and sends out an email with a verification URL to the user.
@param user_has_just_registered: If this True, a welcome email will be sent.
If False, an email change email will be sent. """
# the verification param for the URL consists of <user-id>-<uuid>, where the uuid is saved to the user's profile
a_uuid = uuid1()
verification_url_param = '%d-%s' % (user.id, a_uuid)
user.cosinnus_profile.settings[PROFILE_SETTING_EMAIL_TO_VERIFY] = new_email
user.cosinnus_profile.settings[PROFILE_SETTING_EMAIL_VERFICIATION_TOKEN] = a_uuid
user.cosinnus_profile.save()
# message user for email verification
if request:
data = get_common_mail_context(request)
data.update({
'user':user,
'user_email':new_email,
'verification_url_param':verification_url_param,
'next': redirect_with_next('', request),
})
template = 'cosinnus/mail/user_email_verification%s.html' % ('_onchange' if not user_has_just_registered else '')
data.update({
'content': render_to_string(template, data),
})
subj_user = render_to_string('cosinnus/mail/user_email_verification%s_subj.txt' % ('_onchange' if not user_has_just_registered else ''), data)
send_mail_or_fail_threaded(new_email, subj_user, None, data)
def deny_user(request, user_id):
""" Deny a registration pending user. Sends out an email letting them know, then deletes the pending user account.
Cannot be done for users that are active. """
error = _check_user_approval_permissions(request, user_id)
if error:
return error
try:
user = USER_MODEL.objects.get(id=user_id)
except USER_MODEL.DoesNotExist:
messages.error(request, _('The user account you were looking for does not exist! Their registration was probably already denied.'))
return redirect(reverse('cosinnus:user-list'))
if user.is_active:
messages.warning(request, _('The user account %(username)s (%(email)s) was already approved, so you cannot deny the registration! If this is a problem, you may want to deactivate the user manually from the admin interface.') \
% {'username':full_name_force(user), 'email': user.email})
return redirect(reverse('cosinnus:user-list'))
# message user for denied request
admins = get_user_model().objects.filter(id__in=CosinnusPortal.get_current().admins)
data = get_common_mail_context(request)
data.update({
'user': user,
'admins': admins,
})
subj_user = render_to_string('cosinnus/mail/user_registration_denied_subj.txt', data)
send_mail_or_fail_threaded(user.email, subj_user, 'cosinnus/mail/user_registration_denied.html', data)
messages.success(request, _('You have denied the join request of %(username)s (%(email)s)! An email was sent to let them know.') \
% {'username':full_name_force(user), 'email': user.email})
user.delete()
return redirect(reverse('cosinnus:user-list'))
def send_mail(self, subject_template_name, email_template_name,
context, from_email, to_email, html_email_template_name=None):
"""
Sends the email using the Cosinnus mailer instead of the default django one.
"""
template = email_template_name
is_html = False
if html_email_template_name:
is_html = True
template = html_email_template_name
# Email subject *must not* contain newlines
subject = loader.render_to_string(subject_template_name, context)
subject = ''.join(subject.splitlines())
send_mail_or_fail_threaded(to_email, subject, template, context, from_email=from_email, is_html=is_html)
def send_testmail(request):
if request and not request.user.is_superuser:
return HttpResponseForbidden('Not authenticated')
mode = request.GET.get('mode', None)
if mode not in ['or_fail', 'direct', 'direct_html', 'threaded', 'override']:
mode = 'or_fail'
subject = mode + ': Testmail from Housekeeping at %s' % str(now())
template = 'cosinnus/common/internet_explorer_not_supported.html'
retmsg = '\n\n<br><br> Use ?mode=[or_fail, direct, direct_html, threaded, override]\n\nThe Answer was: '
if mode == 'or_fail':
retmsg += force_text(send_mail_or_fail(request.user.email, subject, template, {}))
return HttpResponse('Sent mail using or_fail mode. ' + retmsg)
if mode == 'direct':
retmsg += force_text(send_mail(request.user.email, subject, template, {}))
return HttpResponse('Sent mail using direct mode. ' + retmsg)
if mode == 'direct_html':
template = 'cosinnus/housekeeping/test_html_mail.html'
retmsg += force_text(send_mail(request.user.email, subject, template, {}, is_html=True))
return HttpResponse('Sent mail using direct HTML mode. ' + retmsg)
if mode == 'threaded':
retmsg += force_text(send_mail_or_fail_threaded(request.user.email, subject, template, {}))
return HttpResponse('Sent mail using threaded mode. ' + retmsg)
if mode == 'override':
retmsg += force_text(EmailMessage(subject, 'No content', 'Testing <%s>' % settings.COSINNUS_DEFAULT_FROM_EMAIL, [request.user.email]).send())
return HttpResponse('Sent mail using override mode. ' + retmsg)
return HttpResponse('Did not send any mail. ' + retmsg)
def send_notification_item_html_threaded(to_user, subject, context, template='cosinnus/html_mail/summary_item.html'):
"""
Send notification item mail using context given
"""
notification_item_html = render_to_string(template, context)
data = get_html_mail_data(to_user, subject, notification_item_html, use_notification_item_html=True)
mail_template = '/cosinnus/html_mail/notification.html'
return send_mail_or_fail_threaded(to_user.email, subject, mail_template, data, is_html=True)
def approve_user(request, user_id):
""" Approves an inactive, registration pending user and sends out an email to let them know """
error = _check_user_approval_permissions(request, user_id)
if error:
return error
try:
user = USER_MODEL.objects.get(id=user_id)
except USER_MODEL.DoesNotExist:
messages.error(request, _('The user account you were looking for does not exist! Their registration was probably already denied.'))
return redirect(reverse('cosinnus:user-list'))
if user.is_active:
messages.success(request, _('The user account was already approved, but thank you anyway!'))
return redirect(reverse('cosinnus:user-list'))
user.is_active = True
user.save()
# message user for accepeted request
data = get_common_mail_context(request)
data.update({
'user': user,
})
template = 'cosinnus/mail/user_registration_approved.html'
# if a welcome email text is set in the portal in admin, send that text instead of the default template
portal = CosinnusPortal.get_current()
welcome_text = getattr(portal, 'welcome_email_text', None) or ''
welcome_text = force_text(welcome_text).strip()
if welcome_text:
template = None
data.update({
'content': portal.welcome_email_text,
})
subj_user = render_to_string('cosinnus/mail/user_registration_approved_subj.txt', data)
send_mail_or_fail_threaded(user.email, subj_user, template, data)
messages.success(request, _('Thank you for approving user %(username)s (%(email)s)! An introduction-email was sent out to them and they can now log in to the site.') \
% {'username':full_name_force(user), 'email': user.email})
return redirect(reverse('cosinnus:user-list'))
def save(self, *args, **kwargs):
created = bool(self.pk is None)
# sanity check for missing media_tag:
if not self.media_tag:
from cosinnus.models.tagged import get_tag_object_model
media_tag = get_tag_object_model()._default_manager.create()
self.media_tag = media_tag
try:
existing = self._meta.model._default_manager.get(user=self.user)
# workaround for http://goo.gl/4I8Ok
self.id = existing.id # force update instead of insert
except ObjectDoesNotExist:
pass
super(BaseUserProfile, self).save(*args, **kwargs)
if created:
# send creation signal
signals.userprofile_created.send(sender=self, profile=self)
# send a copy of the ToS to the User via email?
if settings.COSINNUS_SEND_TOS_AFTER_USER_REGISTRATION and self.user and self.user.email:
if self.settings.get(
'tos_accepted',
False) and not self._settings.get('tos_accepted', False):
tos_content = mark_safe(
strip_tags(
render_to_string('nutzungsbedingungen_content.html')))
data = {
'user': self.user,
'site_name': _(settings.COSINNUS_BASE_PAGE_TITLE_TRANS),
'domain_url': CosinnusPortal.get_current().get_domain(),
'tos_content': tos_content,
}
subj_user = '******' % (_('Terms of Service'),
data['site_name'])
send_mail_or_fail_threaded(
get_newly_registered_user_email(self.user), subj_user,
'cosinnus/mail/user_terms_of_services.html', data)
self._settings = copy.deepcopy(self.settings)
self._dynamic_fields = copy.deepcopy(self.dynamic_fields)
def email(subject_template, message_template, recipient_list, object, action,
site):
"""Compose and send an email."""
ctx_dict = {'site': site, 'object': object, 'action': action}
subject = render_to_string(subject_template, ctx_dict)
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
# check if we have a connected mailbox for direct replies, and if so, set the sender to a specified email, so that users
# can directly reply to them
hash_vars = {
'portal_name': force_text(_(settings.COSINNUS_BASE_PAGE_TITLE_TRANS)),
'default_from': settings.DEFAULT_FROM_EMAIL,
}
if CosinnusPortal.get_current().mailboxes.filter(active=True).count() > 0:
hash_vars.update({
'domain': settings.DEFAULT_FROM_EMAIL.split('@')[1],
'portal_id': CosinnusPortal.get_current().id,
'hash': object.direct_reply_hash,
})
sender = '%(portal_name)s <directreply@%(domain)s>' % hash_vars
hash_code = 'directreply+%(portal_id)d+%(hash)s+%(domain)s' % hash_vars
ctx_dict.update({
'direct_reply_enabled': True,
'hash_code': hash_code,
})
else:
sender = '%(portal_name)s <%(default_from)s>' % hash_vars
#message = render_to_string(message_template, ctx_dict)
# during the development phase, consider using the setting: EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
#send_mail(subject, message, sender, recipient_list, fail_silently=True)
# now sending through our system
send_mail_or_fail_threaded(recipient_list[0],
subject,
message_template,
ctx_dict,
sender,
is_html=False)
def send_direct_reply_error_mail(recipient_email, text, reason):
subject = _('Your direct reply failed!')
template = 'cosinnus_message/email_direct_reply_failed.txt'
logger.warning('Sending out a direct-reply error mail', extra={'recipient': recipient_email, 'reason': reason, 'text': text})
send_mail_or_fail_threaded(recipient_email, subject, template, {'reason': reason, 'text': text})
def form_valid(self, form):
ret = super(UserCreateView, self).form_valid(form)
user = self.object
# sanity check, retrieve the user's profile (will create it if it doesnt exist)
profile = user.cosinnus_profile or get_user_profile_model()._default_manager.get_for_user(user)
# set current django language during signup as user's profile language
lang = get_language()
if not profile.language == lang:
profile.language = lang
profile.save(update_fields=['language'])
# set user inactive if this portal needs user approval and send an email to portal admins
if CosinnusPortal.get_current().users_need_activation:
user.is_active = False
user.save()
data = get_common_mail_context(self.request)
data.update({
'user': user,
})
# message portal admins of request
subject = render_to_string('cosinnus/mail/user_register_notification_subj.txt', data)
email_portal_admins(subject, 'cosinnus/mail/user_register_notification.html', data)
# message user for pending request
subj_user = render_to_string('cosinnus/mail/user_registration_pending_subj.txt', data)
send_mail_or_fail_threaded(user.email, subj_user, 'cosinnus/mail/user_registration_pending.html', data)
messages.success(self.request, self.message_success_inactive % {'user': user.email, 'email': user.email})
# scramble this users email so he cannot log in until he verifies his email, if the portal has this enabled
if CosinnusPortal.get_current().email_needs_verification:
with transaction.atomic():
# scramble actual email so the user cant log in but can be found in the admin
original_user_email = user.email # don't show the scrambled emai later on
user.email = '__unverified__%s__%s' % (str(uuid1())[:8], original_user_email)
user.save()
set_user_email_to_verify(user, original_user_email, self.request)
messages.success(self.request, self.message_success_email_verification % {'user': original_user_email, 'email': original_user_email})
if not CosinnusPortal.get_current().users_need_activation and not CosinnusPortal.get_current().email_needs_verification:
messages.success(self.request, self.message_success % {'user': user.email})
user.backend = 'cosinnus.backends.EmailAuthBackend'
login(self.request, user)
# send user registration signal
signals.user_registered.send(sender=self, user=user)
# check if there was a token group invite associated with the signup
invite_token = self.request.POST.get('invite_token', None)
if invite_token:
invite = get_object_or_None(CosinnusGroupInviteToken, token__iexact=invite_token, portal=CosinnusPortal.get_current())
if not invite:
messages.warning(self.request, _('The invite token you have used does not exist!'))
elif not invite.is_active:
messages.warning(self.request, _('Sorry, but the invite token you have used is not active yet or not active anymore!'))
else:
success = apply_group_invite_token_for_user(invite, user)
if success:
messages.success(self.request, _('Token invitations applied. You are now a member of the associated projects/groups!'))
else:
messages.error(self.request, _('There was an error while processing your invites. Some of your invites may not have been applied.'))
if getattr(settings, 'COSINNUS_SHOW_WELCOME_SETTINGS_PAGE', True):
# add redirect to the welcome-settings page, with priority so that it is shown as first one
profile.add_redirect_on_next_page(redirect_with_next(reverse('cosinnus:welcome-settings'), self.request), message=None, priority=True)
return ret
