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 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 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 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)
