def handle_message(_, message): """Receive a message from nsq and send it as an email.""" body = json.loads(message.body) email = pyramid_mailer.message.Message(subject=body["subject"], recipients=body["recipients"], body=body["body"]) pyramid_mailer.get_mailer(request).send_immediately(email)
def handle_message(_, message): """Receive a message from nsq and send it as an email.""" body = json.loads(message.body) email = pyramid_mailer.message.Message( subject=body["subject"], recipients=body["recipients"], body=body["body"]) pyramid_mailer.get_mailer(request).send_immediately(email)
def update_(request): 'Update account' params = request.params if params.get('token') != request.session.get_csrf_token(): return dict(isOk=0, message='Invalid token') userID = authenticated_userid(request) # If the user is trying to update account information, send confirmation email if 'username' in params: return save_user_(request, dict(params), 'update', db.query(User).get(userID)) # Load smsAddressAction = params.get('smsAddressAction') # If the user is adding an SMS address, if 'add' == smsAddressAction: # Make sure it is a valid email address validateEmail = validators.Email().to_python try: smsAddressEmail = validateEmail(params.get('smsAddressEmail', '')) except Invalid, error: return dict(isOk=0, message=str(error)) # Check for duplicates smsAddress = db.query(SMSAddress).filter( (SMSAddress.email == smsAddressEmail) & (SMSAddress.user_id == userID)).first() if smsAddress: return dict(isOk=0, message='You already added this SMS address') # Add it to the database smsAddress = SMSAddress(email=smsAddressEmail, user_id=userID, code=make_random_string(CODE_LEN)) db.add(smsAddress) # Send confirmation code get_mailer(request).send_to_queue(Message( recipients=[smsAddress.email], body=smsAddress.code)) # Return smsAddresses return dict(isOk=1, content=render('users/smsAddresses.mak', update(request), request))
def test_valid(self): req = DummyRequest(post={ 'password': '******', 'password2': 'newpw', }) req.matchdict['token'] = self.token.token req.remote_addr = '127.0.0.1' resp = views.account.reset(req) self.assertIsInstance(resp, httpexceptions.HTTPMovedPermanently) self.assertTrue(resp.location.endswith('/account/login')) registry = self.config.registry mailer = get_mailer(registry) self.assertEqual(len(mailer.outbox), 1) # Should not be able to use a token > 1 time req = DummyRequest(post={ 'password': '******', 'password2': 'newpw', }) req.matchdict['token'] = self.token.token req.remote_addr = '127.0.0.1' resp = views.account.reset(req) self.assertIsInstance(resp, httpexceptions.HTTPMovedPermanently) self.assertTrue(resp.location.endswith('/account/forgot')) registry = self.config.registry mailer = get_mailer(registry) self.assertEqual(len(mailer.outbox), 1)
def send_confirmation_mail(user, email, request): url = request.route_url(service.name, token=make_token(user, email)) message = utils.render_mail(request=request, template='email_change', recipients=[email], subject=_('Confirm your email address'), data=dict(user=user, url=url, email=email)) get_mailer(request).send(message)
def send_confirmation_mail(user, request): url = request.route_url(service.name, _query=dict(token=make_token(user))) message = utils.render_mail(request=request, template='signup_confirmation', recipients=[user.email], subject=_(u'Please confirm your account'), data=dict(user=user, url=url)) get_mailer(request).send(message)
def send_password_reset_mail(user, request): url = request.route_url(service.name, token=make_token(user)) message = utils.render_mail(request=request, template='password_reset', recipients=[user.email], subject=_('Password reset'), data=dict(user=user, url=url)) get_mailer(request).send(message)
def cne_created(event): manage_url = event.request.route_url('defcne.e', traverse=(event.cne.dc, event.cne.id, 'manage')) text = __staff_eventcreated__.format(contest_name=event.cne.disp_name, contest_owner=event.request.user.user.disp_uname, event_manage_url=manage_url) staff_list = m.Group.find_group(u'staff').users staff_emails = [user.email for user in staff_list] message = Message(subject="DEFCnE Contest/Event Created", sender="*****@*****.**", recipients=staff_emails, body=text) get_mailer(event.request).send(message)
def test_send_passwords(self): preferences_link = 'http://localhost/preferences' backups_link = 'http://localhost/backups' user_id = self.db.users.insert({ 'first_name': 'John', 'last_name': 'Doe', 'email': '*****@*****.**', }, safe=True) user = self.db.users.find_one({'_id': user_id}) request = DummyRequest() request.db = self.db mailer = get_mailer(request) self.assertFalse(send_passwords(request, user, preferences_link, backups_link)) self.assertEqual(len(mailer.outbox), 0) # add some passwords self.db.passwords.insert({ 'owner': user_id, 'password': '******', }) self.db.passwords.insert({ 'owner': user_id, 'password': '******', }) request = DummyRequest() request.db = self.db request.date_service = FakeDateService(request) mailer = get_mailer(request) os.environ['YITH_FAKE_DATE'] = '2012-1-10' self.assertTrue(send_passwords(request, user, preferences_link, backups_link)) self.assertEqual(len(mailer.outbox), 1) message = mailer.outbox[0] self.assertEqual(message.subject, "Your Yith Library's passwords") self.assertEqual(message.recipients, ['*****@*****.**']) self.assertTrue(preferences_link in message.body) self.assertTrue(backups_link in message.body) self.assertEqual(len(message.attachments), 1) attachment = message.attachments[0] self.assertEqual(attachment.content_type, 'application/yith') self.assertEqual(attachment.filename, 'yith-library-backup-2012-01-10.yith') del os.environ['YITH_FAKE_DATE']
def sing_up(request): sign_up_form = forms.SignUpForm(csrf_context=request) successful_submission = False if request.method == 'POST': sign_up_form.process(request.POST) if sign_up_form.validate(): user = User( email=sign_up_form.email.data.lower(), phone=sign_up_form.phone.data, name=sign_up_form.user_name.data, company_name=( sign_up_form.company_name.data if sign_up_form.company_name.data else None ), timezone_tzname=str(request.registry['default_timezone']) ) user.set_password(sign_up_form.password.data) DBSession.add(user) template = request.registry['jinja2_environment'].get_template( 'sngconnect.accounts:templates/emails/account_activation.txt' ) activation_email = EmailMessage( subject=_("Activate your account at SNG Connect"), sender=request.registry['settings']['mail.sender'], recipients=[user.email], body=template.render( activation_url=request.route_url( 'sngconnect.accounts.activate', email=user.email, email_activation_code=user.email_activation_code ) ) ) get_mailer(request).send(activation_email) sms_service = SMSService(request.registry) sms_service.send_sms( [user.phone], _( "Your SNG:connect confirmation code is: ${code}", mapping={ 'code': user.phone_activation_code, } ) ) successful_submission = True return { 'sign_up_form': sign_up_form, 'successful_submission': successful_submission, }
def test_get_mailer_dummy(self): from pyramid_mailer import get_mailer from pyramid_mailer.testing import DummyMailer self.config.include('pyramid_mailer.testing') request = testing.DummyRequest() mailer = get_mailer(request) self.assertEqual(mailer.__class__, DummyMailer)
def password_reset(request): email = request.params.get('email') try: session = DBSession() user = DBSession.query(User).filter_by(email=email).one() ptoken = DBSession.query(PasswordResetToken).get(user.id) if not ptoken: ptoken = PasswordResetToken(user_id=user.id) token = str(uuid4()) ptoken.token = token session.add(ptoken) except NoResultFound: token = None if token: # settings = request.registry.settings mailer = get_mailer(request) headers = {"header": u'Password reset', "message": u'Please click on the link bellow to reset your penelope account\'s password.', "link": '%s/change_password?token=%s' % (request.application_url, token), "action": 'Reset password'} message = Message(subject=u"Password reset request", recipients=[email], body=u'Password reset', extra_headers={'X-MC-Template': 'general', 'X-MC-MergeVars': json.dumps(headers)}) mailer.send(message) return {'request': request, 'token': token}
def send_templated_mail(request, recipients, template, context, sender=None): """Send out templatized HTML and plain text emails. Each HTML email should have a plain text fallback. Premailer package is used to convert any CSS styles in HTML email messages to inline, so that email clients display them. The email is assembled from three different templates: * Read subject from a subject specific template $template.subject.txt * Generate HTML email from HTML template, $template.body.html * Generate plain text email from HTML template, $template.body.txt Make sure you have configured your template engine (Jinja 2) to read TXT templates beside HTML. :param request: HTTP request, passed to the template engine. Request configuration is used to get hold of the configured mailer. :param recipients: List of recipient emails :param template: Template filename base string for template tripled (subject, HTML body, plain text body). For example ``email/my_message`` would map to templates ``email/my_message.subject.txt``, ``email/my_message.body.txt``, ``email/my_message.body.html`` :param context: Template context variables as a dict :param sender: Override the sender email - if not specific use the default set in the config as ``mail.default_sender`` """ assert recipients assert len(recipients) > 0 assert type( recipients) != str, "Please give a list of recipients, not a string" for r in recipients: assert r, "Received empty recipient when sending out email {}".format( template) subject = render(template + ".subject.txt", context, request=request) subject = subject.strip() html_body = render(template + ".body.html", context, request=request) text_body = render(template + ".body.txt", context, request=request) if not sender: sender = request.registry.settings["mail.default_sender"] # Add enveloped From: sender_name = request.registry.settings.get("mail.default_sender_name") if sender_name: sender = formataddr((str(Header(sender_name, 'utf-8')), sender)) # Inline CSS styles html_body = premailer.transform(html_body) message = Message(subject=subject, sender=sender, recipients=recipients, body=text_body, html=html_body) mailer = get_mailer(request) mailer.send(message)
def confirmation(request): """ Generates confirmation page and confirmation emails to user and D2L site admin. """ if not logged_in(request): return HTTPFound(location=request.route_url("login")) form = SelectCoursesForm() csrf_token = request.session.get_csrf_token() submitter_email = request.session["uniqueName"] + "@" + request.registry.settings["EMAIL_DOMAIN"] name = request.session["firstName"] + " " + request.session["lastName"] sender = request.registry.settings["mail.username"] """remove for production""" submitter_email = "*****@*****.**" message = Message(subject="Course Combine Confirmation", sender=sender, recipients=[sender, submitter_email]) message.body = make_msg_text(name, submitter_email, request) message.html = make_msg_html(name, submitter_email, request) mailer = get_mailer(request) mailer.send_immediately(message, fail_silently=False) return { "csrf_token": csrf_token, "name": name, "form": form, "base_course": request.session["base_course"], "courses_to_combine": request.session["courses_to_combine"], }
def send_reset_password_mail(request, user, reset_password_link): """ Send an email with the instructions for resetting password """ mailer = get_mailer(request) site_name = request.registry.settings.get("site.name", "eduID") password_reset_timeout = int(request.registry.settings.get("password_reset_timeout", "120")) / 60 email = user.get_mail() context = { "email": email, "reset_password_link": reset_password_link, "password_reset_timeout": password_reset_timeout, "site_url": request.route_url("home"), "site_name": site_name, } message = Message( subject=_("Reset your {site_name} password").format( site_name=site_name), sender=request.registry.settings.get("mail.default_sender"), recipients=[email], body=render( "templates/reset-password-email.txt.jinja2", context, request, ), html=render( "templates/reset-password-email.html.jinja2", context, request, ), ) mailer.send(message)
def test_forgot_password(self): res = self.testapp.get('/users/forgot_password.html', status=200) # Submit form with invalid data form = res.forms['forgot-password-form'] form['email'] = 'test' res = form.submit('Submit') self.assertEqual(res.status_int, 200) self.assertIn('Please correct the specified errors.', res.pyquery('#flash-message').text()) # Submit form with invalid email form = res.forms['forgot-password-form'] form['email'] = '*****@*****.**' res = form.submit('Submit') self.assertEqual(res.status_int, 200) self.assertIn('Invalid email address.', res.pyquery('#flash-message').text()) # Submit form with valid data form = res.forms['forgot-password-form'] form['email'] = '*****@*****.**' res = form.submit('Submit') self.assertEqual(res.status_int, 200) self.assertIn('Password reset link has been emailed to you.', res.pyquery('#flash-message').text()) # Check the email registry = self.testapp.app.registry mailer = get_mailer(registry) self.assertEqual(len(mailer.outbox), 1) self.assertEqual(mailer.outbox[0].subject, 'Starter Password Reset') self.assertIn( 'Please follow the instructions at the following link ' + 'to reset your password:', mailer.outbox[0].body)
def send_email(subject, recipients, html, sender = None, plaintext = None, request = None, send_immediately = False, **kw): """ Send an email to users. This also checks the required settings and translates the subject. returns the message object sent, or None """ #FIXME: Docs if request is None: request = get_current_request() localizer = get_localizer(request) if isinstance(subject, TranslationString): subject = localizer.translate(subject) if isinstance(recipients, basestring): recipients = (recipients,) if plaintext is None: html2text = HTML2Text() html2text.ignore_links = True html2text.ignore_images = True html2text.body_width = 0 plaintext = html2text.handle(html).strip() if not plaintext: plaintext = None #In case it was an empty string #It seems okay to leave sender blank since it's part of the default configuration msg = Message(subject = subject, recipients = recipients, sender = sender, body = plaintext, html = html, **kw) mailer = get_mailer(request) #Note that messages are sent during the transaction process. See pyramid_mailer docs if send_immediately: mailer.send_immediately(msg) else: mailer.send(msg) return msg
def password_reminder(email, request): """ For an email address, find the corresponding team and send a password reset token. If no team is found send an email that no user was found for this address. """ mailer = get_mailer(request) team = DBSession.query(Team).filter(Team.email == email).first() if team: # send mail with reset token team.reset_token = random_token() html = render('mail_password_reset_valid.mako', {'team': team}, request=request) recipients = [team.email] else: # send mail with information that no team was found for that address. html = render('mail_password_reset_invalid.mako', {'email': email}, request=request) recipients = [email] competition = request.registry.settings['competition_title'] message = Message(subject="Password Reset for %s" % competition, recipients=recipients, html=html, ) mailer.send(message) return team
def email_change_notification(event): if ('old_address' not in event.activity_detail and 'new_address' not in event.activity_detail): return same_user = event.actor == event.user if event.actor.is_superuser and not same_user: return old = event.activity_detail['old_address'] new = event.activity_detail['new_address'] logger = getLogger('speak_friend.user_activity') logger.info('%s changed their email address' % event.user.username) path = 'speak_friend:templates/email/account_email_change_notification.pt' settings = event.request.registry.settings subject = '%s: Email changed' % settings['site_name'] mailer = get_mailer(event.request) response = render_to_response(path, {'profile': event.user, 'old_address': old, 'new_address': new, }, event.request) message = Message(subject=subject, sender=settings['site_from'], recipients=[old, new], html=response.unicode_body) mailer.send(message)
def notify_account_created(event): """Notify site admins when an account is created. """ logger = getLogger('speak_friend.user_activity') path = 'speak_friend:templates/email/account_creation_notification.pt' settings = event.request.registry.settings subject = '%s: New user created' % settings['site_name'] mailer = get_mailer(event.request) headers = {'Reply-To': event.user.full_email} response = render_to_response(path, {'profile': event.user}, event.request) # Obtain list of emails to notify from the control panel cp = ControlPanel(event.request) recipients = cp.get_value(email_notification_schema.name, 'user_creation', []) if not recipients: logger.info('No one to notify of account creation: %s.', event.user) return message = Message(subject=subject, sender=settings['site_from'], recipients=recipients, extra_headers=headers, html=response.unicode_body) mailer.send(message)
def email_profile_change_notification(event): if ('first_name' not in event.activity_detail and 'last_name' not in event.activity_detail): return same_user = event.actor == event.user if event.actor.is_superuser and not same_user: return first_name = event.activity_detail.get('first_name', '') last_name = event.activity_detail.get('last_name', '') logger = getLogger('speak_friend.user_activity') for key, value in event.activity_detail.items(): logger.info('%s changed their %s' % (event.user.username, key)) path = 'speak_friend:templates/email/account_change_notification.pt' settings = event.request.registry.settings subject = '%s: Account updated' % settings['site_name'] mailer = get_mailer(event.request) response = render_to_response(path, {'profile': event.user, 'first_name': first_name, 'last_name': last_name }, event.request) message = Message(subject=subject, sender=settings['site_from'], recipients=[event.user.full_email], html=response.unicode_body) mailer.send(message)
def send_auth_token_email(self, token: str, email: str) -> None: app_name = self.request.registry.settings["zam.app_name"] url = self.request.route_url("auth", _query={"token": token}) url_dossiers = self.request.resource_url(self.request.root["dossiers"]) mailer = get_mailer(self.request) message = MailMessage( subject=f"Se connecter à {app_name}", sender="*****@*****.**", recipients=[email], body=f""" Bonjour, Pour vous connecter à {app_name}, veuillez cliquer sur l’adresse suivante : {url} Notez que {app_name} ne fonctionne pas sous Internet Explorer, aussi il est conseillé de copier-coller cette adresse dans un navigateur moderne comme Firefox ou Chrome. Ce lien contient un code personnel à usage unique, valable 10 minutes, pour vous authentifier sur {app_name}. Une fois connecté·e, vous pourrez directement accéder aux dossiers : {url_dossiers} Bonne journée ! """.strip(), ) mailer.send(message)
def test_meeting_can_turn_off_notification(self): ai = self._fixture() ai.__parent__.set_field_value('mention_notification_setting', False) from voteit.core.models.proposal import Proposal ai['o'] = Proposal(text = "@admin") mailer = get_mailer(self.request) self.assertEqual(len(mailer.outbox), 0)
def test_send_thankyou_email(self): request = testing.DummyRequest() mailer = get_mailer(request) self.assertEqual(len(mailer.outbox), 0) donation = { 'amount': 10, 'firstname': 'John', 'lastname': 'Doe', 'city': 'Springfield', 'country': 'Exampleland', 'state': 'Example', 'street': 'Main Street 10', 'zip': '12345678', 'email': '*****@*****.**', 'creation': datetime.datetime.utcnow(), 'send_sticker': True, } send_thankyou_email(request, donation) self.assertEqual(len(mailer.outbox), 1) message = mailer.outbox[0] self.assertEqual(message.subject, 'Thanks for your contribution!') self.assertEqual(message.recipients, ['*****@*****.**'])
def send_change_password_email( request, profile, email=None): mailer = get_mailer(request) localizer = request.localizer data = dict( name=profile.name, assembl="Assembl", confirm_url=maybe_contextual_route( request, 'do_password_change', ticket=password_token(profile))) message = Message( subject=localizer.translate( _("Request for password change"), mapping=data), sender=config.get('assembl.admin_email'), recipients=["%s <%s>" % ( profile.name, email or profile.get_preferred_email())], body=localizer.translate(_(u"""Hello, ${name}! We have received a request to change the password on your ${assembl} account. To confirm your password change please click on the link below. <${confirm_url}> If you did not ask to reset your password please disregard this email. Best regards, The ${assembl} Team """), mapping=data), html=localizer.translate(_(u"""<p>Hello, ${name}!</p> <p>We have received a request to change the password on your ${assembl} account. Please <a href="${confirm_url}">click here to confirm your password change</a>.</p> <p>If you did not ask to reset your password please disregard this email.</p> <p>Best regards,<br />The ${assembl} Team</p> """), mapping=data)) # if deferred: # mailer.send_to_queue(message) # else: mailer.send(message)
def feedback(self): self.response['sent_status'] = 0 if 'feedback.message' in self.request.params: msg = Validate.sanatize_textsafe(self.request.params.get('feedback.message','')) msg = msg + "\n\n ---------- \n" msg = msg + "Player: " + self.request.params.get('feedback.player','error') + "\n" msg = msg + "Category: " + self.request.params.get('feedback.category','error') + "\n" msg = msg + "From: " + self.request.params.get('feedback.from','error') + "\n" try: # Send to emails = Properties.get('MAILER_FEEDBACK_ADDRESS').replace(' ','').split(',') message = Message(subject="Feedback - " + datetime.datetime.today().strftime("%Y-%m-%d %H:%M:%S"), sender=self.request.user.email, recipients=emails, body=msg ) mailer = get_mailer(self.request) mailer.send(message) # Receipt message_receipt = Message(subject="Feedback - Receipt", sender=Properties.get('MAILER_GLOBAL_FROM_ADDRESS'), recipients=[self.request.user.email], body="Thank you for submitting feedback. \n\n ---- \n" + Validate.sanatize_textsafe(self.request.params.get('feedback.message','')) ) mailer.send(message_receipt) self.response['sent_status'] = 2 except Exception as e: self.response['sent_status'] = 1 return self.response
def send(self, recipients, subject, body, html=None): """ Send an email. :param recipients: the list of email addresses to send the email to :type recipients: list of unicode strings :param subject: the subject of the email :type subject: unicode :param body: the body of the email :type body: unicode """ email = pyramid_mailer.message.Message(subject=subject, recipients=recipients, body=body, html=html) mailer = pyramid_mailer.get_mailer(celery.request) try: if celery.request.debug: log.info("emailing in debug mode: check the `mail/' directory") mailer.send_immediately(email) except smtplib.SMTPRecipientsRefused as exc: log.warning( "Recipient was refused when trying to send an email. Does the user have an invalid email address?", exc_info=exc, ) except smtplib.socket.error as exc: # Exponential backoff in case the SMTP service is having problems. countdown = self.default_retry_delay * 2**self.request.retries self.retry(exc=exc, countdown=countdown)
def create_activation(request, user): db = get_session(request) Activation = request.registry.getUtility(IActivationClass) activation = Activation() db.add(activation) user.activation = activation db.flush() # TODO Create a hook for the app to give us body and subject! # TODO We don't need pystache just for this! body = pystache.render( _("Please validate your email and activate your account by visiting:\n" "{{ link }}"), { 'link': request.route_url('activate', user_id=user.id, code=user.activation.code) } ) subject = _("Please activate your account!") message = Message(subject=subject, recipients=[user.email], body=body) mailer = get_mailer(request) mailer.send(message)
def test_proposal_added(self): ai = self._fixture() from voteit.core.models.proposal import Proposal obj = Proposal(text="@admin") ai['o'] = obj mailer = get_mailer(self.request) self.assertEqual(len(mailer.outbox), 1)
def create_user(request): user = request.validated['user'] username = user['username'] email = user['email'] token = user['token'] password = user['password'] activationToken = user['activationToken'] userID = uuid.uuid4() user_data = { 'username' : username, 'email' : email, 'token' : token, 'password' : password, 'activation_token' : activationToken, 'account_active' : False } request.db.users.insert({ '_id' : str(userID), 'profile' : user_data }) mailer = get_mailer(request) message = Message(subject="Welcome to DuD " + username, sender="*****@*****.**", recipients=["*****@*****.**"], body="hello " + username + "!<a href='" + base_url + "activate-account/" + activationToken +"'>" "Click here</a>" "to activate your account" ) mailer.send_immediately(message) return {'type' : 'true', 'response' : 'user successifully created', 'token' : token }
def success_check_email(request): """ This view just returns a note to go check mail """ #check if user has used form or 'guessed' this URL if ('appstruct' in request.session): # we do have valid info from the form in the session appstruct = request.session['appstruct'] from pyramid_mailer.message import Message mailer = get_mailer(request) # XXX TODO: check for locale, choose language for body text the_mail = Message( subject=_("C3S: confirm your email address and load your PDF"), sender="*****@*****.**", recipients=[appstruct['email']], body="""hello %s %s, please use this link to verify your email address and download your personal Declaration of Intent PDF: https://yes.c3s.cc/verify/%s/%s """ % (appstruct['firstname'], appstruct['lastname'], appstruct['email'], appstruct['email_confirm_code']) ) mailer.send(the_mail) return { 'firstname': appstruct['firstname'], 'lastname': appstruct['lastname'], } # 'else': send user to the form return HTTPFound(location=request.route_url('intent'))
def test_invitation(self): """ Test the invitation procedure for one single member at a time. Load this member from the DB, assure the email_invite_flag_bcgv17 and token are not set, prepare cookies, invite this member, assure the email_invite_flag_bcgv17 and token are now set, """ from c3smembership.invite_members import invite_member_bcgv member1 = C3sMember.get_by_id(1) self.assertEqual(member1.email_invite_flag_bcgv17, False) self.assertTrue(member1.email_invite_token_bcgv17 is None) req = testing.DummyRequest() # have some cookies req.cookies['on_page'] = 0 req.cookies['order'] = 'asc' req.cookies['orderby'] = 'id' # try with nonexistant id req.matchdict = {'m_id': 10000} res = invite_member_bcgv(req) self.assertEquals(302, res.status_code) req.matchdict = {'m_id': member1.id} res = invite_member_bcgv(req) self.assertEqual(member1.email_invite_flag_bcgv17, True) self.assertTrue(member1.email_invite_token_bcgv17 is not None) # now really send email self.config.registry.settings['testing.mail_to_console'] = 'false' mailer = get_mailer(req) res = invite_member_bcgv(req) self.assertEqual(len(mailer.outbox), 2) self.assertTrue(u'[C3S] Einladung zu Barcamp und Generalversammlung' in mailer.outbox[0].subject) self.assertTrue(u'[C3S] Einladung zu Barcamp und Generalversammlung' in mailer.outbox[1].subject) self.assertTrue(member1.firstname in mailer.outbox[1].body) self.assertTrue( member1.email_invite_token_bcgv17 in mailer.outbox[1].body) # now send invitation to english member member2 = C3sMember.get_by_id(2) self.assertEqual(member2.email_invite_flag_bcgv17, False) self.assertTrue(member2.email_invite_token_bcgv17 is None) req.matchdict = {'m_id': member2.id} res = invite_member_bcgv(req) self.assertEqual(member2.email_invite_flag_bcgv17, True) self.assertTrue(member2.email_invite_token_bcgv17 is not None) self.assertEqual(len(mailer.outbox), 3) self.assertTrue(u'[C3S] Invitation to Barcamp and General Assembly' in mailer.outbox[2].subject) self.assertTrue(member2.firstname in mailer.outbox[2].body) self.assertTrue( member2.email_invite_token_bcgv17 in mailer.outbox[2].body)
def test_success_check_email(self): """ test the success_check_email view """ from c3smembership.views import success_check_email self.config.add_route('join', '/') from pyramid_mailer import get_mailer request = testing.DummyRequest( params={'appstruct': { 'firstname': 'foo', 'lastname': 'bar', }}) request.session['appstruct'] = { 'person': { 'firstname': 'foo', 'lastname': 'bar', 'email': '*****@*****.**', }, 'email_confirm_code': '12345678', } mailer = get_mailer(request) result = success_check_email(request) print result self.assertTrue(result['lastname'] is 'bar') self.assertTrue(result['firstname'] is 'foo') self.assertEqual(len(mailer.outbox), 1) self.assertEqual(mailer.outbox[0].subject, 'C3S: confirm your email address and load your PDF') #self.assertEqual(mailer.outbox[0]., "hello world") verif_link = "https://pretest.c3s.cc/verify/[email protected]/12345678" self.assertTrue("hello foo bar !" in mailer.outbox[0].body) self.assertTrue(verif_link in mailer.outbox[0].body)
def setUp(self): # noqa self.app = TestApp(self.app) registry = self.app.app.registry self.mailer = get_mailer(registry) self.email_service = EmailService(self.mailer, settings) EmailService.instance = None self.config = testing.setUp() self.connection = self.engine.connect() # begin a non-ORM transaction self.trans = self.connection.begin() # DBSession is the scoped session manager used in the views, # reconfigure it to use this test's connection DBSession.configure(bind=self.connection) # create a session bound to the connection, this session is the one # used in the test code self.session = self.Session(bind=self.connection) self.queue_config = registry.queue_config reset_queue(self.queue_config) reset_cache_key()
def test_get_mailer_realthing(self): from pyramid_mailer import get_mailer from pyramid_mailer.mailer import Mailer self.config.include('pyramid_mailer') request = testing.DummyRequest() mailer = get_mailer(request) self.assertEqual(mailer.__class__, Mailer)
def test_mail_mtype_fixer_link_en(self): """ test the mail_mtype_fixer_link view """ from c3smembership.administration import mail_mtype_fixer_link self.config.add_route('join', '/') self.config.add_route('dashboard', '/') from pyramid_mailer import get_mailer request = testing.DummyRequest() request.matchdict = {'afmid': '2'} # locale: englisch request.cookies['on_page'] = 1 request.cookies['order'] = 'asc' request.cookies['orderby'] = 'id' mailer = get_mailer(request) result = mail_mtype_fixer_link(request) self.assertTrue(result.status_code == 302) # redirect self.assertEqual(len(mailer.outbox), 1) self.assertEqual( mailer.outbox[0].subject, u"[C3S] Help needed: Your Membership Status" ) self.assertTrue( u"Hello" in mailer.outbox[0].body) self.assertTrue( u"http://foo.com/mtype/" in mailer.outbox[0].body)
def notify(request): settings = request.registry.settings login = settings.get('sms.username') password = settings.get('sms.password') email = request.params.get('email') emails = request.params.get('emails') if emails: emails = json.loads(emails) else: emails = [] if email: emails.append(email) email_message = request.params.get('email_message') email_subject = request.params.get('email_subject', 'project notification') phone = request.params.get('phone') phone_message = request.params.get('phone_message') if not email_message and phone_message: return {'KO': 'No message provided.'} if not emails and phone: return {'KO': 'No recipients.'} if emails and email_message: mailer = get_mailer(request) mailing.send_emails.delay(mailer, email_message, email_subject, emails) if phone and phone_message: sms.send_sms.delay(login, password, phone_message, phone) return 'OK'
def test_send_email_to_admins(self): request = testing.DummyRequest() mailer = get_mailer(request) send_email_to_admins( request, 'yithlibraryserver.tests:templates/email_test', { 'name': 'John', 'email': '*****@*****.**' }, 'Testing message', ) self.assertEqual(len(mailer.outbox), 1) message = mailer.outbox[0] self.assertEqual(message.subject, 'Testing message') self.assertEqual( message.html, '<p>Hello John,</p>\n\n<p>this is your email address: [email protected]</p>' ) self.assertEqual( message.body, 'Hello John,\n\nthis is your email address: [email protected]\n') self.assertEqual(message.recipients, self.admin_emails) self.assertEqual(message.attachments, []) self.assertEqual(message.extra_headers, {})
def errmail_tween(request, subject=subject): try: return handler(request) except Exception, e: try: exc_info = sys.exc_info() mailer = get_mailer(request) exc_repr = repr(e)[:200] localtime = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) gmtime = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()) mapping = {'localtime':localtime, 'gmtime':gmtime, 'hostname':hostname, 'exception':exc_repr} def replace(match): whole, param1, param2 = match.groups() return mapping.get(param1 or param2, whole) subject = _interp_regex.sub(replace, subject) html = cgitb.html(exc_info) header = request.url html = '<html><h1>%s</h1>%s</html>' % (header, html) body = ''.join(traceback.format_exception(*exc_info)) body = '%s\n\n%s' % (header, body) message = Message(subject=subject, sender=sender, recipients=recipients, html=html, body=body) mailer.send_immediately(message, fail_silently=True) raise finally: del exc_info
def mailer_send(subject="!", sender=None, recipients=[], body=None, html=None, attachments=[]): try: request = get_current_request() if sender is None: sender = request.registry.settings['mail.default_sender'] mailer = get_mailer(request) message = Message(subject=subject, sender=sender, recipients=recipients, body=body, html=html) for attachment in attachments: attachment = Attachment(attachment.title, attachment.mimetype, attachment) message.attach(attachment) if transaction.get().status == Status.COMMITTED: mailer.send_immediately(message) else: mailer.send(message) except Exception: pass
def test_send_notification_to_admins(self): request = testing.DummyRequest() mailer = get_mailer(request) self.assertEqual(len(mailer.outbox), 0) donation = { 'amount': 10, 'firstname': 'John', 'lastname': 'Doe', 'city': 'Springfield', 'country': 'Exampleland', 'state': 'Example', 'street': 'Main Street 10', 'zip': '12345678', 'email': '*****@*****.**', 'creation': datetime.datetime.utcnow(), 'send_sticker': True, 'user': None, } send_notification_to_admins(request, donation) self.assertEqual(len(mailer.outbox), 1) message = mailer.outbox[0] self.assertEqual(message.subject, 'A new donation was received!') self.assertEqual(message.recipients, self.admin_emails)
def test_proposal(self): ai = self._fixture() from voteit.core.models.proposal import Proposal ai['o'] = obj = Proposal(title="@admin") self._fut(obj, None) mailer = get_mailer(self.request) self.assertEqual(len(mailer.outbox), 1)
def send_confirmation_email(request, email): mailer = get_mailer(request) localizer = get_localizer(request) confirm_what = _('email') if isinstance(email.profile, User) and not email.profile.verified: confirm_what = _('account') data = { 'name': email.profile.name, 'email': email.email, 'confirm_what': localizer.translate(confirm_what), 'confirm_url': request.route_url('user_confirm_email', ticket=email_token(email)) } message = Message( subject=localizer.translate(_('confirm_title', default="Please confirm your ${confirm_what} with Assembl", mapping=data)), sender=config.get('assembl.admin_email'), recipients=["%s <%s>" % (email.profile.name, email.email)], body=localizer.translate(_('confirm_email', default=u"""Hello, ${name}! Please confirm your ${confirm_what} <${email}> with Assembl by clicking on the link below. <${confirm_url}> """, mapping=data)), html=localizer.translate(_('confirm_email_html', default=u"""<p>Hello, ${name}!</p> <p>Please <a href="${confirm_url}">confirm your ${confirm_what}</a> <${email}> with Assembl.</p> """, mapping=data))) #if deferred: # mailer.send_to_queue(message) #else: mailer.send(message)
def send(self, recipients, subject, body, html=None): """ Send an email. :param recipients: the list of email addresses to send the email to :type recipients: list of unicode strings :param subject: the subject of the email :type subject: unicode :param body: the body of the email :type body: unicode """ email = pyramid_mailer.message.Message(subject=subject, recipients=recipients, body=body, html=html) mailer = pyramid_mailer.get_mailer(celery.request) try: if celery.request.debug: log.info("emailing in debug mode: check the `mail/' directory") mailer.send_immediately(email) except (smtplib.socket.error, smtplib.SMTPException) as exc: # Exponential backoff in case the SMTP service is having problems. countdown = self.default_retry_delay * 2 ** self.request.retries self.retry(exc=exc, countdown=countdown)
def forgot(request): _ = request.translate if request.method != 'POST' or 'username' not in request.POST: return {} u = DBSession.query(User) \ .filter_by(username=request.POST['username']) \ .first() if not u: request.messages.error(_('Unknown username.')) request.response.status_code = HTTPBadRequest.code return {} if not u.email: request.messages.error( _('No e-mail address associated with username.')) request.response.status_code = HTTPBadRequest.code return {} token = PasswordResetToken(u) DBSession.add(token) DBSession.flush() mailer = get_mailer(request) body = render('mail/password_reset.mako', { 'user': u, 'requested_by': request.remote_addr, 'url': request.route_url('account_reset', token=token.token) }, request=request) message = Message(subject=_('CCVPN: Password reset request'), recipients=[u.email], body=body) mailer.send(message) request.messages.info(_('We sent a reset link. Check your emails.')) return {}
def sendMail(request, msg, to, username='', confirm=''): from pyramid_mailer import get_mailer from pyramid_mailer.message import Message mailer = get_mailer(request) if msg == 'confirm': message = Message(sender="*****@*****.**", recipients=[to], subject="Welcome to BarterVegasTech!") message.body = "Hello " + username + ",\n\n" + \ "Thank you for checking out http://www.bartervegastech.com\n\n" + \ "To activate your account please go to:\nhttp://www.bartervegastech.com/message/" + \ "activate/" + username + "/" + confirm + "\n\nIf you do not wish to have an " + \ "account you may just ignore this email.\nThanks!\nBarterVegasTech.com" if request.registry.settings['testing'] != "true": mailer.send(message) elif msg == 'forgot': message = Message(sender="*****@*****.**", recipients=[to], subject="BarterVegasTech Password Recovery") message.body = "Hello " + username + ",\n\n" + \ "To reset your password please go to:\nhttp://www.bartervegastech.com/reset/" + \ username + "/" + confirm + "\n\n" + \ "If you did not request to have your password changed then " + \ "you may just ignore this email.\nThanks!\nBarterVegasTech.com" if request.registry.settings['testing'] != "true": mailer.send(message) elif msg == 'reply': message = Message(sender="*****@*****.**", recipients=[to], subject="BarterVegasTech Reply") message.body = "Hello!\n\n" + \ "You recieved a reply to your post: " + username + \ "\n\nVisit " + confirm + " to view it.\n\n" + \ "To change your email notification settings visit http://www.bartervegastech.com/account#profiletab" if request.registry.settings['testing'] != "true": mailer.send(message)
def _register(self, username, email, password): user = User(username=username, email=email, password=password) self.request.db.add(user) # Create a new activation for the user activation = Activation() self.request.db.add(activation) user.activation = activation # Flush the session to ensure that the user can be created and the # activation is successfully wired up self.request.db.flush() # Send the activation email message = activation_email(self.request, user) mailer = get_mailer(self.request) mailer.send(message) self.request.session.flash( jinja2.Markup( _('Thank you for creating an account! ' "We've sent you an email with an activation link, " 'before you can sign in <strong>please check your email and open ' 'the link to activate your account</strong>.')), 'success') self.request.registry.notify(RegistrationEvent(self.request, user))
def confirmation(request): ''' Generates confirmation page and confirmation emails to user and D2L site admin. ''' if not logged_in(request): return HTTPFound(location=request.route_url('login')) form = SelectCoursesForm() csrf_token = request.session.get_csrf_token() submitter_email = request.session['uniqueName'] + '@' + \ request.registry.settings['EMAIL_DOMAIN'] name = request.session['firstName'] + ' ' + request.session['lastName'] sender = request.registry.settings['mail.username'] '''remove for production''' submitter_email = '*****@*****.**' message = Message(subject="Course Combine Confirmation", sender=sender, recipients=[sender, submitter_email]) message.body = make_msg_text(name, submitter_email, request) message.html = make_msg_html(name, submitter_email, request) mailer = get_mailer(request) mailer.send_immediately(message, fail_silently=False) return{'csrf_token': csrf_token, 'name': name, 'form': form, 'base_course': request.session['base_course'], 'courses_to_combine': request.session['courses_to_combine'] }
def _send_existing_users_invitations(self, users: List[User]) -> int: # TODO: async? mailer = get_mailer(self.request) reply_to = formataddr((self.request.user.name, self.request.user.email)) app_name = self.request.registry.settings["zam.app_name"] subject = f"Invitation à participer à un dossier législatif sur {app_name}" url = self.request.resource_url(self.request.context) body = f""" Bonjour, Vous venez d’être invité·e par {self.request.user} à participer au dossier législatif suivant sur {app_name} : {self.dossier.titre} Vous pouvez y accéder via l’adresse suivante : {url} Bonne journée ! """ for user in users: message = MailMessage( subject=subject, sender="*****@*****.**", recipients=[user.email], body=body.strip(), extra_headers={"reply-to": reply_to}, ) mailer.send(message) return len(users)
def mail_password(self, password): #print "mail password: username=%s password=%s" % (self.__name__, password) root = self.find_root() # FIXME: make this stuff configurable... subject = "Your login info for %s" % root.title data = dict( site_title = root.title, login_url = self.request.resource_url(root, 'login'), username = self.__name__, password = password, remove_addr = self.request.environ['REMOTE_ADDR'], ) body = """Here's the information you'll need to log into %(site_title)s. The login url is: %(login_url)s Your username: %(username)s Your password: %(password)s Thanks, and have a nice day! ps. This request was made from %(remove_addr)s. """ % data mailer = get_mailer(self.request) message = Message(subject=subject, sender=self.email, recipients=[self.email], body=body) mailer.send_immediately(message, fail_silently=False)
def test_mail_mail_confirmation(self): """ test the mail_mail_confirmation view """ from c3smembership.administration import mail_mail_conf self.config.add_route('join', '/') self.config.add_route('dashboard', '/') from pyramid_mailer import get_mailer request = testing.DummyRequest() request.matchdict = {'memberid': '1'} request.cookies['on_page'] = 1 request.cookies['order'] = 'asc' request.cookies['orderby'] = 'id' mailer = get_mailer(request) result = mail_mail_conf(request) self.assertTrue(result.status_code == 302) # redirect self.assertEqual(len(mailer.outbox), 1) self.assertEqual( mailer.outbox[0].subject, u"[C3S] Please confirm your email address! " u"/ Bitte E-Mail-Adresse bestätigen!") # print mailer.outbox[0].body self.assertTrue(u"Hello" in mailer.outbox[0].body) self.assertTrue(u"Hallo" in mailer.outbox[0].body) _m = C3sMember.get_by_id(1) self.assertTrue(u'{} {}'.format(_m.firstname, _m.lastname) in mailer.outbox[0].body) self.assertTrue(u"http://foo.com/vae/" in mailer.outbox[0].body)
def test_discussion_post(self): ai = self._fixture() from voteit.core.models.discussion_post import DiscussionPost ai['o'] = obj = DiscussionPost(text="@admin") self._fut(obj, None) mailer = get_mailer(self.request) self.assertEqual(len(mailer.outbox), 1)
def confirmation_page(request): form = RequestForm() session = request.session csrf_token = session.get_csrf_token() if 'uc' not in request.session: request.session.flash('Please login to place request') return HTTPFound(location=request.route_url('login')) submitter_email = request.session['uniqueName'] + '@' + \ request.registry.settings['EMAIL_DOMAIN'] name = request.session['firstName'] + ' ' + request.session['lastName'] sender = request.registry.settings['mail.username'] message = Message(subject="Relay account setup", sender=sender, recipients=[sender, submitter_email]) message.body = make_msg_text(name, submitter_email, request.session['requestDetails'], form) message.html = make_msg_html(name, submitter_email, request.session['requestDetails'], form) mailer = get_mailer(request) mailer.send_immediately(message, fail_silently=False) return { 'csrf_token': csrf_token, 'name': name, 'form': form, 'requestDetails': request.session['requestDetails'] }
def send_notification(self, email, subject, message): """Sends email notification to admins. Sends email with the pyramid_mailer module. For configuration look at documentation http://pythonhosted.org//pyramid_mailer/ """ from pyramid_mailer import get_mailer mailer = get_mailer(self.request) sender = "noreply@%s" % (self.request.server_name) recipients = set() for user in self.collection.find({'group': Admin}): email = user.get('email') if email: recipients.add(email) if len(recipients) > 0: from pyramid_mailer.message import Message message = Message(subject=subject, sender=sender, recipients=recipients, body=message) try: mailer.send_immediately(message, fail_silently=True) except Exception: LOGGER.error("failed to send notification") else: LOGGER.warn( "Can't send notification. No admin emails are available.")
def test_reminder_signature(self): """ test the mail_signature_reminder view """ from c3smembership.accountants_views import mail_signature_reminder self.config.add_route('join', '/') self.config.add_route('dashboard', '/') from pyramid_mailer import get_mailer request = testing.DummyRequest() request.matchdict = {'memberid': '1'} request.cookies['on_page'] = 1 request.cookies['order'] = 'asc' request.cookies['orderby'] = 'id' mailer = get_mailer(request) result = mail_signature_reminder(request) self.assertTrue(result.status_code == 302) # redirect self.assertEqual(len(mailer.outbox), 1) self.assertEqual( mailer.outbox[0].subject, u"C3S: don't forget to send your form " u"/ Bitte Beitrittsformular einsenden" ) self.assertTrue( u"Dear SomeFirstnäme SomeLastnäme," in mailer.outbox[0].body) self.assertTrue( u"Liebe_r SomeFirstnäme SomeLastnäme," in mailer.outbox[0].body)