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