def bug_report(self, couch_user, error_id):
error = PillowError.objects.get(id=error_id)
context = {
'error': error,
'url': "{}{}?error={}".format(get_url_base(), reverse(EditPillowError.urlname), error_id)
}
message = render_to_string('hqpillow_retry/fb.txt', context)
subject = 'PillowTop error: {} - {}'.format(error.pillow, error.error_type)
reply_to = u'"{}" <{}>'.format(couch_user.full_name, couch_user.get_email())
email = EmailMessage(
subject=subject,
body=message,
to=settings.BUG_REPORT_RECIPIENTS,
headers={'Reply-To': reply_to}
)
# only fake the from email if it's an @dimagi.com account
if re.search('@dimagi\.com$', couch_user.username):
email.from_email = couch_user.username
else:
email.from_email = settings.CCHQ_BUG_REPORT_EMAIL
email.send(fail_silently=False)
def emit(self, record):
import traceback
if not settings.ADMINS:
return
try:
# Hack to try to get request from context
request = record.exc_info[2].tb_frame.f_locals['context']['request']
request_repr = repr(request)
request_path = request.path
except Exception:
request_repr = "Request unavailable"
request_path = 'Unknown URL'
if record.exc_info:
stack_trace = '\n'.join(traceback.format_exception(*record.exc_info))
else:
stack_trace = 'No stack trace available'
message = "%s\n\n%s" % (stack_trace, request_repr)
msg = EmailMessage(
'[sorl-thumbnail] %s: %s' % (record.levelname, request_path),
message,
settings.SERVER_EMAIL,
[a[1] for a in settings.ADMINS],
connection=None
)
msg.send(fail_silently=True)
def contact(request):
if request.method == 'POST':
form = ContactForm(request.POST,
initial={
'captcha': request.META['REMOTE_ADDR']})
if form.is_valid():
if form.cleaned_data['sender']:
headers = {
'Reply-To': form.cleaned_data['sender']}
else:
headers = {}
email = EmailMessage(
subject=form.cleaned_data['subject'],
body="%s\n\nfrom: %s" % (form.cleaned_data['message'],
form.cleaned_data['sender']),
from_email='*****@*****.**',
to=('*****@*****.**', '*****@*****.**'),
headers=headers,
)
email.send()
# Redirect after POST
return HttpResponseRedirect(reverse('contact_sent'))
else:
form = ContactForm() # An unbound form
# request context required for CSRF
return render_to_response('dnd/contacts/contact.html',
{
'request': request,
'form': form, }, context_instance=RequestContext(request), )
def notify(self):
base_url = "http://%s" % Site.objects.get_current().domain
text = render_to_string("harvester/notification.html",
dict(base_url=base_url, job=self))
message = EmailMessage(u"Harvesting job is complete", text, settings.DEFAULT_FROM_EMAIL, [self.email])
message.content_subtype = "html"
message.send()
def home(request):
if request.method == 'POST':
form = ContactForm(request.POST, request.FILES)
if form.is_valid():
contact = form.save()
message = render_to_string("email.html", {'contact': contact})
msg = EmailMessage('Info verzoek van anverhuizen.be',
message,
contact.email,
['*****@*****.**'])
msg.content_subtype = "html"
if 'attachment' in request.FILES:
request.FILES['attachment'].seek(0)
msg.attach(request.FILES['attachment'].name,
request.FILES['attachment'].read(),
request.FILES['attachment'].content_type)
msg.send(fail_silently=False)
messages.success(request, _("Ik heb jouw bericht ontvangen en zal zo snel mogelijk contact opnemen."))
return HttpResponseRedirect(reverse('home'))
else:
form = ContactForm()
return render_to_response('home.html',
{'form': form},
RequestContext(request))
def send_simple_order_notification(sender, order, request, **kwargs):
"""
:param order: Order
:type order: shuup.core.models.Order
"""
if order.log_entries.filter(identifier=NOTIFICATION_SUCCESS_LOG_IDENTIFIER).exists():
return
try:
engine = engines["jinja2"]
except InvalidTemplateEngineError:
return # Dont send notifications because we cannot parse files :(
with translation.override(order.language):
# Local import to make sure the environment is initialized
env = {"order": order}
subject = engine.from_string(MESSAGE_SUBJECT_TEMPLATE).render(env)
body = engine.from_string(MESSAGE_BODY_TEMPLATE).render(env)
message = EmailMessage(subject, body, to=[order.email])
try:
message.send()
except Exception as exc:
LOG.exception("Failed to send order notification to %s" % message.to)
order.add_log_entry(
"Order Notification Email failed: %s" % exc,
identifier=NOTIFICATION_ERROR_LOG_IDENTIFIER,
kind=LogEntryKind.ERROR)
else:
LOG.info("Order notification sent to %s" % message.to)
order.add_log_entry(
"Order Notification Email sent",
identifier=NOTIFICATION_SUCCESS_LOG_IDENTIFIER,
kind=LogEntryKind.ERROR)
def newsite(req):
import base.models as M, random, string
form = None
auth_user = UR.getUserInfo(req)
ensemble_form = None
user_form = None
if auth_user is not None:
return HttpResponseRedirect("/admin")
if req.method == 'POST':
user = M.User(confkey="".join([choice(string.ascii_letters+string.digits) for i in xrange(0,32)]))
ensemble = M.Ensemble()
user_form = forms.UserForm(req.POST, instance=user)
ensemble_form = forms.EnsembleForm(req.POST, instance=ensemble)
if user_form.is_valid() and ensemble_form.is_valid():
user_form.save()
ensemble.invitekey = "".join([ random.choice(string.ascii_letters+string.digits) for i in xrange(0,50)])
ensemble_form.save()
m = M.Membership(user=user, ensemble=ensemble, admin=True)
m.save()
p = {"tutorial_url": settings.GUEST_TUTORIAL_URL, "conf_url": "http://%s?ckey=%s" %(settings.NB_SERVERNAME, user.confkey), "firstname": user.firstname, "email": user.email, "password": user.password }
email = EmailMessage(
"Welcome to NB, %s" % (user.firstname),
render_to_string("email/confirm_newsite", p),
settings.EMAIL_FROM,
(user.email, ),
(settings.EMAIL_BCC, ))
email.send()
return HttpResponseRedirect('/newsite_thanks')
else:
user_form = forms.UserForm()
ensemble_form = forms.EnsembleForm()
return render_to_response("web/newsite.html", {"user_form": user_form, "ensemble_form": ensemble_form})
def payment_notification(sender, **kwargs):
ipn_obj = sender
if ipn_obj.payment_status == ST_PP_COMPLETED:
# payment was successful
order = get_object_or_404(Order, id=ipn_obj.invoice)
# mark the order as paid
order.paid = True
order.save()
# create invoice e-mail
subject = 'My Shop - Invoice no. {}'.format(order.id)
message = 'Please, find attached the invoice for your recent purchase.'
email = EmailMessage(subject, message, '*****@*****.**', [order.email])
# generate PDF
html = render_to_string('orders/order/pdf.html', {'order': order})
out = BytesIO()
css_path = os.path.join(settings.STATICFILES_DIRS[0], 'css/pdf.css')
weasyprint.HTML(string=html).write_pdf(out, stylesheets=[weasyprint.CSS(css_path)])
# attach PDF file
email.attach('order_{}.pdf'.format(order.id), out.getvalue(), 'application/pdf')
# send e-mail
email.send()
def send_mail(subject, template_name, to, **kwargs):
kwargs['settings'] = settings
body = render_to_string(template_name, kwargs)
if to:
msg = EmailMessage(subject, body, None, to=to)
msg.content_subtype = "html"
msg.send()
def send_confirmation(self):
url = reverse("users:reset_password", kwargs=dict(key=self.key))
url = "http://%s%s" % (Site.objects.get_current().domain, url)
body = render_to_string("users/emails/reset-password-confirmation.html", dict(url=url, user=self.user))
message = EmailMessage(u"Reset your OER Commons password", body, to=[self.user.email])
message.content_subtype = "html"
message.send()
def send_csv(self, emails=[]):
filename, csv_file = self.create_csv()
message = EmailMessage(subject='{} LEVEL ASSORTMENT REPORT'.format(self.level.upper()),
from_email=EMAIL_HOST_USER, to=emails)
message.attach(filename, csv_file.getvalue(), 'text/csv')
print message.send()
def remind_account_about_events_with_email(account, single_events):
featured_events = Event.featured_events_for_region(account.native_region)
similar_events = find_similar_events(
Event.future_events.filter(id__in=single_events.values_list("event_id", flat=True))
)
subject = "Upcoming events from cityfusion"
message = render_to_string(
"accounts/emails/reminder_email.html",
{
"featured_events": featured_events,
"events": single_events,
"similar_events": similar_events,
"STATIC_URL": "/static/",
"advertising_region": account.advertising_region,
"site": "http://%s" % Site.objects.get_current().domain,
},
)
msg = EmailMessage(subject, message, "*****@*****.**", [account.reminder_email])
msg.content_subtype = "html"
msg.send()
return message
def register_company_view(request):
"""Registro de compañias"""
if request.method == 'POST':
form = RegistrerCompaniesForm(request.POST)
if form.is_valid():
cleaned_data = form.cleaned_data
username = cleaned_data.get('email')
company = cleaned_data.get('company')
password = cleaned_data.get('password')
email = cleaned_data.get('email')
# instanciamos un objeto User, con el username y password
user_model = User.objects.create_user(username=username,
password=password,
first_name=company)
user_model.email = email
user_model.save()
company_user = CompanyUser()
company_user.company = user_model
company_user.save()
asunto = 'Servifeng'
mens = 'Se a realizado su registro correctamente su usuario es: ' + username
mens = mens + r' ingrese a http://127.0.0.1:8000/admin/'
mail = EmailMessage(asunto, mens, to=[email, '*****@*****.**'])
mail.send()
return redirect(reverse('accounts.gracias', kwargs={'username': username}))
else:
form = RegistrerCompaniesForm()
context ={
'form': form
}
return render(request, 'companies/registro.html', context)
def local_red_alert(message):
'''
Sends out an SMS message, email, and initiates a conference call.
'''
message = message.replace('/', ' slash ').replace('.py', ' dot pie.') #To assist the text-to-speech
sms_recipients = []
phone_recipients = []
email_recipients = []
for contact in PRODUCTION_EMERGENCY:
if contact[1]:
phone_recipients.append(contact[1])
if contact[2]:
email_recipients.append(contact[2])
if contact[3]:
sms_recipients.append(contact[3])
place_red_alert_phone_call(phone_recipients, message)
subject = ""
body = message
sender = '*****@*****.**'
sms_msg = EmailMessage(subject, body, sender, sms_recipients)
sms_msg.send()
email_msg = EmailMessage(subject, body, sender, email_recipients)
email_msg.send()
return True
def activate(request, token):
aux1=YoungInvestigator.objects.filter(token=token)
aux2=PrincipalInvestigator.objects.filter(token=token)
aux=[]
if len(aux1)==1:
aux=aux1
if len(aux2)==1:
aux=aux2
if len(aux)==1:
reg1=aux[0]
user1=User.objects.filter(id=reg1.user.id)[0]
user1.is_active=1
user1.save()
reg1.activation_key="ALREADY_ACTIVATED"
reg1.save()
##correo para informar de la activacion
contenido="Thanks for trust in ScienceWeb.\n You can access with your account.\n\nUsername: "******"\n http://www.peerland.org/"
correo = EmailMessage("ScienceWeb: Your Account is already activated", contenido, to=[user1.email])
correo.send()
return render_to_response('users/activation_complete.html',context_instance = RequestContext(request))
else:
return render_to_response('users/activate.html')
def inform_account_about_events_with_tag_with_email(account, events, tags_in_venues):
featured_events = Event.featured_events_for_region(account.native_region)[:4]
similar_events = find_similar_events(events)
subject = "New Events in cityfusion"
message = render_to_string(
"accounts/emails/in_the_loop_email.html",
{
"featured_events": featured_events,
"events": events,
"similar_events": similar_events,
"STATIC_URL": "/static/",
"site": "http://%s" % Site.objects.get_current().domain,
"tags_in_venues": tags_in_venues,
"advertising_region": account.advertising_region,
},
)
msg = EmailMessage(subject, message, "*****@*****.**", [account.in_the_loop_email])
msg.content_subtype = "html"
msg.send()
return message
def wyslij_email(request, pk):
if request.is_ajax():
response_message = "success"
wiadomosc = Wiadomosc.objects.get(id=pk)
subject = 'Hotel Messiah'
try:
message = request.GET['message']
message_html = '<h3>' + _('Twoje pytanie') + ': </h3><p>' + wiadomosc.tresc + \
'</p><h3>' + _('Nasza odpowiedz') + ': </h3><p>' + request.GET['message'] + "</p>"
from_email = '*****@*****.**'
to_email = request.GET['email_address']
if subject and message and from_email:
try:
# send_mail(subject, message, from_email, [to_email])
msg = EmailMessage(subject, message_html, from_email, [to_email])
msg.content_subtype = "html"
msg.send()
except KeyError:
response_message = "site_error"
else:
response_message = "empty_field"
if response_message == "success":
wiadomosc.wyslano_odpowiedz = True
wiadomosc.odpowiedz = message
wiadomosc.save()
except KeyError:
raise Http404
return HttpResponse(response_message)
else:
raise Http404
def send(self, fail_silently=False):
recipient_list = []
recipient_bcc_list = []
headers = {}
if self.recipient:
recipient_list = self.recipient.split(',')
recipient_list = [recipient.strip() for recipient in recipient_list \
if recipient.strip() <> '']
if self.recipient_cc:
recipient_cc_list = self.recipient_cc.split(',')
recipient_cc_list = [recipient_cc.strip() for recipient_cc in recipient_cc_list if \
recipient_cc.strip() <> '']
recipient_list += recipient_cc_list
if self.recipient_bcc:
recipient_bcc_list = self.recipient_bcc.split(',')
recipient_bcc_list = [recipient_bcc.strip() for recipient_bcc in recipient_bcc_list if \
recipient_bcc.strip() <> '']
if self.reply_to:
headers['Reply-To'] = self.reply_to
if self.sender_display:
headers['From'] = '%s<%s>' % (self.sender_display, self.sender)
if recipient_list or recipient_bcc_list:
msg = EmailMessage(self.subject,
self.body,
self.sender,
recipient_list,
recipient_bcc_list,
headers=headers )
if self.content_type == 'html' or self.content_type == 'text/html':
msg.content_subtype = 'html'
msg.send(fail_silently=fail_silently)
def send_mail(self, request, newsletter_id):
object = Newsletter.objects.get(id=newsletter_id)
subscribers = Subscription.objects.filter(subscribed=True)
site = Site.objects.get_current()
template = render_to_string(object.template, locals(), RequestContext(request))
if request.method == 'POST':
object.sent_date = datetime.now()
object.save()
email = EmailMessage(subject = '%s - %s' % (object.title, site),
body = template,
from_email = settings.NEWSLETTER_FROM_EMAIL,
bcc = [e.email for e in subscribers],
headers = {'Reply-To': settings.NEWSLETTER_REPLYTO_EMAIL}
)
email.content_subtype = "html" # Main content is now text/html
email.send()
self.message_user(request, _(u"Newsletter sent successfully"))
return HttpResponseRedirect(reverse('admin:newsletters_newsletter_changelist'))
opts = Newsletter._meta
app_label = opts.app_label
return render_to_response('admin/newsletters/send_mail.html',
locals(),
RequestContext(request))
def send_pdf_to_user(self, user):
report = self.report.get_path_to_pdf(user, self.view_args)
title = self.report.email_subject(user, self.view_args)
email = EmailMessage(title, 'See attachment',
settings.EMAIL_LOGIN, [user.email])
email.attach_file(report)
email.send(fail_silently=False)
def wyslij_biuletyn(request):
if request.is_ajax():
subscribers = Newsletter.objects.all()
response_message = "success"
from_email = '*****@*****.**'
connection = mail.get_connection()
connection.open()
subject = 'Hotel Messiah Newsletter!'
for subscriber in subscribers:
try:
message_html = request.GET['message']+"<a href='"+request.build_absolute_uri(reverse('hotel:newsletter_anuluj', args=[subscriber.news_kod]))+"'>"+"Anuluj newsletter"+"</a>"
to_email = subscriber.news_email
#to_email_bcc = Newsletter.objects.values_list('news_email', flat=True)
if subject and message_html and from_email:
try:
msg = EmailMessage(subject, message_html, from_email, [to_email])
msg.content_subtype = "html"
msg.send()
except KeyError:
response_message = "site_error"
else:
response_message = "empty_field"
except KeyError:
raise Http404
connection.close()
return HttpResponse(response_message)
else:
raise Http404
def save_user(form, client):
list_mail = dict()
name = form.cleaned_data['name']
email = form.cleaned_data['email']
user = form.cleaned_data['user'].upper()
groups = form.cleaned_data['groups']
user_ldap = form.cleaned_data[
'ldap_user'] if form.cleaned_data['is_ldap'] else None
list_mail['nome'] = name
list_mail['user'] = user
password = make_random_password()
list_mail['pass'] = password
new_user = client.create_usuario().inserir(
user, password, name, email, user_ldap)
for group in groups:
client.create_usuario_grupo().inserir(
new_user.get('usuario')['id'], group)
if user_ldap is None:
connection = EmailBackend(
username=EMAIL_HOST_USER, password=EMAIL_HOST_PASSWORD)
send_email = EmailMessage('Novo Usuário CadVlan-Globo.com', loader.render_to_string(
MAIL_NEW_USER, list_mail), EMAIL_FROM, [email], connection=connection)
send_email.content_subtype = "html"
send_email.send()
def send_html_message(subject, html_content, from_email, to_list):
# with open( "output.html" , "w") as debug_file:
# debug_file.write(html_content)
msg = EmailMessage(string_to_email_subject(subject), html_content, from_email, to_list)
msg.content_subtype = "html" # Main content is now text/html
msg.send()
def remind_account_about_events_with_email(account, single_events):
if account.reminder_email:
featured_events = Event.featured_events_for_region(account.native_region)[0:4]
similar_events = find_similar_events(
Event.future_events.filter(id__in=single_events.values_list("event_id", flat=True))
)
subject = "Upcoming events from cityfusion"
message = render_to_string('accounts/emails/reminder_email.html', {
"featured_events": featured_events,
"events": single_events,
"similar_events": similar_events,
"STATIC_URL": "/static/",
"advertising_region": account.advertising_region,
"site": "http://%s" % Site.objects.get_current().domain
})
try:
msg = EmailMessage(subject,
message,
"*****@*****.**",
[account.reminder_email])
msg.content_subtype = 'html'
msg.send()
except:
logger.error("Invalid email %s" % account.reminder_email)
return message
else:
return ""
def send_email_feedback(self, feedback_pk, sender, recipents):
try:
feedback = Feedback.objects.get(pk=feedback_pk)
except Feedback.DoesNotExist as exc:
logger.error('Failed processing_crash_dump',
exc_info=True,
extra=dict(crash_pk=feedback_pk))
raise self.retry(exc=exc, countdown=2 ** send_email_feedback.request.retries)
recipients = [x.strip() for x in recipents.split(',')]
body = email_body_tmpl % (
feedback.description, feedback.page_url, feedback.email,
feedback.ip, feedback.feedback_data,
)
email = EmailMessage("Feedback # %s" % feedback_pk, body, sender, recipients)
attachments = [
feedback.screenshot,
feedback.blackbox,
feedback.system_logs,
feedback.attached_file
]
for attach in attachments:
if attach:
email.attach(os.path.basename(attach.name), attach.read())
email.send()
def _log_to_email(email_to, email_from, output, req_string):
em = EmailMessage('Slow Request Watchdog: %s' %
req_string.encode('utf-8'),
output,
email_from,
(email_to,))
em.send(fail_silently=True)
def remind_account_about_deleted_events_with_email(account, single_events):
if account.reminder_email:
featured_events = Event.featured_events_for_region(account.native_region)[:4]
subject = 'Deleted events from cityfusion'
message = render_to_string('accounts/emails/reminder_deleted_event_email.html', {
"featured_events": featured_events,
"events": single_events,
"STATIC_URL": "/static/",
"advertising_region": account.advertising_region,
"site": "http://%s" % Site.objects.get_current().domain
})
try:
msg = EmailMessage(subject,
message,
"*****@*****.**",
[account.reminder_email])
msg.content_subtype = 'html'
msg.send()
except:
logger.error("Invalid email %s" % account.reminder_email)
return message
else:
return ""
def send_activation_mail(user):
key = SecretKey.objects.get_or_create(user=user).secretkey
context = {'username': user.username, 'security_key': key}
html_content = render_to_string('massage.html', context)
msg = EmailMessage('submit registration', html_content, '*****@*****.**', [user.email])
msg.content_subtype = "html"
msg.send()
def sender(request):
if request.method == 'POST':
doc_id = request.POST.get('doc_id')
comment = request.POST.get('comment')
name_email = request.POST.get('name_email')
document = Document.objects.get(id=doc_id)
personals = document.personal.all()
send_to = []
for per in personals:
send_to.append(per.email)
# Build message
email = EmailMessage(subject=name_email, body=comment, from_email='*****@*****.**',to=send_to, headers = {'Reply-To': '*****@*****.**'})
# Open file
attachment = open(u''+document.docfile.name, 'rb')
# Attach file
email.attach("attach_file.pdf", attachment.read(),'application/pdf')
# Send message with built-in send() method
email.send()
msg_ok = "Send message success"
print('Send message success')
return render_to_response('group1/send.html', {'document': document, 'msg_ok': msg_ok} ,
context_instance=RequestContext(request))
def email(request, template_name="email.html"):
ctx = dict()
if request.method == "POST":
email_address = request.POST.get("email", "your mom")
trips = Trip.objects.filter(user=request.user)
csv_data = "\n".join(["%s, %s, %s %s, %s" % (trip.date,
trip.odometer_start,
trip.odometer_end,
trip.distance(),
trip.reason)
for trip in trips])
email = EmailMessage('MileTracker Data',
'Your data is attached',
'*****@*****.**',
['*****@*****.**', email_address])
email.attach('miletracker_report.csv', csv_data, 'text/csv')
email.send()
messages.info(request, "We've sent an email report to: %s" % email_address)
return HttpResponseRedirect(reverse("log"))
return render_to_response(
template_name, RequestContext(request, ctx))
def user_details_force_sync(auth_entry, strategy, details, user=None, *args, **kwargs):
"""
Update normally protected user details using data from provider.
This step in the pipeline is akin to `social_core.pipeline.user.user_details`, which updates
the user details but has an unconfigurable protection over updating the username & email, and
is unable to update information such as the user's full name which isn't on the user model, but
rather on the user profile model.
Additionally, because the email field is normally used to log in, if the email is changed by this
forced synchronization, we send an email to both the old and new emails, letting the user know.
This step is controlled by the `sync_learner_profile_data` flag on the provider's configuration.
"""
current_provider = provider.Registry.get_from_pipeline({'backend': strategy.request.backend.name, 'kwargs': kwargs})
if user and current_provider.sync_learner_profile_data:
# Keep track of which incoming values get applied.
changed = {}
# Map each incoming field from the provider to the name on the user model (by default, they always match).
field_mapping = {field: (user, field) for field in details.keys() if hasattr(user, field)}
# This is a special case where the field mapping should go to the user profile object and not the user object,
# in some cases with differing field names (i.e. 'fullname' vs. 'name').
field_mapping.update({
'fullname': (user.profile, 'name'),
'country': (user.profile, 'country'),
})
# Remove username from list of fields for update
field_mapping.pop('username', None)
# Track any fields that would raise an integrity error if there was a conflict.
integrity_conflict_fields = {'email': user.email, 'username': user.username}
for provider_field, (model, field) in field_mapping.items():
provider_value = details.get(provider_field)
current_value = getattr(model, field)
if provider_value is not None and current_value != provider_value:
if field in integrity_conflict_fields and User.objects.filter(**{field: provider_value}).exists():
logger.warning(u'[THIRD_PARTY_AUTH] Profile data synchronization conflict. '
u'UserId: {user_id}, Provider: {provider}, ConflictField: {conflict_field}, '
u'ConflictValue: {conflict_value}'.format(
user_id=user.id,
provider=current_provider.name,
conflict_field=field,
conflict_value=provider_value))
continue
changed[provider_field] = current_value
setattr(model, field, provider_value)
if changed:
logger.info(
u'[THIRD_PARTY_AUTH] User performed SSO and data was synchronized. '
u'Username: {username}, Provider: {provider}, UpdatedKeys: {updated_keys}'.format(
username=user.username,
provider=current_provider.name,
updated_keys=list(changed.keys())
)
)
# Save changes to user and user.profile models.
strategy.storage.user.changed(user)
user.profile.save()
# Send an email to the old and new email to alert the user that their login email changed.
if changed.get('email'):
old_email = changed['email']
new_email = user.email
email_context = {'old_email': old_email, 'new_email': new_email}
# Subjects shouldn't have new lines.
subject = ''.join(render_to_string(
'emails/sync_learner_profile_data_email_change_subject.txt',
email_context
).splitlines())
body = render_to_string('emails/sync_learner_profile_data_email_change_body.txt', email_context)
from_email = configuration_helpers.get_value('email_from_address', settings.DEFAULT_FROM_EMAIL)
email = EmailMessage(subject=subject, body=body, from_email=from_email, to=[old_email, new_email])
email.content_subtype = "html"
try:
email.send()
except SMTPException:
logger.exception('[THIRD_PARTY_AUTH] Error sending IdP learner data sync-initiated email change '
u'notification email. Username: {username}'.format(username=user.username))
def send_mail_async(self, subject, message, from_email, recipient_list, messaging_event_id=None):
""" Call with send_mail_async.delay(*args, **kwargs)
- sends emails in the main celery queue
- if sending fails, retry in 15 min
- retry a maximum of 10 times
"""
from corehq.util.soft_assert import soft_assert
soft_assert('{}@dimagi.com'.format('skelly'))(
all(recipient for recipient in recipient_list),
'Blank email addresses',
{
'subject': subject,
'message': message,
'recipients': recipient_list
}
)
recipient_list = [_f for _f in recipient_list if _f]
# todo deal with recipients marked as bounced
from dimagi.utils.django.email import get_valid_recipients, mark_subevent_bounced
filtered_recipient_list = get_valid_recipients(recipient_list)
bounced_recipients = list(set(recipient_list) - set(filtered_recipient_list))
if bounced_recipients and messaging_event_id:
mark_subevent_bounced(bounced_recipients, messaging_event_id)
if not filtered_recipient_list:
return
headers = {}
if messaging_event_id is not None:
headers[COMMCARE_MESSAGE_ID_HEADER] = messaging_event_id
if settings.SES_CONFIGURATION_SET is not None:
headers[SES_CONFIGURATION_SET_HEADER] = settings.SES_CONFIGURATION_SET
try:
message = EmailMessage(
subject=subject,
body=message,
from_email=from_email,
to=filtered_recipient_list,
headers=headers,
)
return message.send()
except SMTPDataError as e:
# If the SES configuration has not been properly set up, resend the message
if (
"Configuration Set does not exist" in e.smtp_error
and SES_CONFIGURATION_SET_HEADER in message.extra_headers
):
del message.extra_headers[SES_CONFIGURATION_SET_HEADER]
message.send()
notify_exception(None, message="SES Configuration Set missing", details={'error': e})
else:
raise
except Exception as e:
notify_exception(
None,
message="Encountered error while sending email",
details={
'subject': subject,
'recipients': ', '.join(filtered_recipient_list),
'error': e,
'messaging_event_id': messaging_event_id,
}
)
if messaging_event_id is not None:
mark_subevent_gateway_error(messaging_event_id, e, retrying=True)
try:
self.retry(exc=e)
except MaxRetriesExceededError:
if messaging_event_id is not None:
mark_subevent_gateway_error(messaging_event_id, e, retrying=False)
def handle(self, *args, **options):
from tendenci.apps.site_settings.utils import get_setting
pass_update_tendenci = False
pass_update_tendenci_site = False
pass_restart_server = False
is_uwsgi = False
gunicorn_error_msg = None
uwsgi_error_msg = None
errors_list = []
pypi = xmlrpclib.ServerProxy('http://pypi.python.org/pypi')
latest_version = pypi.package_releases('tendenci')[0]
error_message = ""
email_context = {'site_url':get_setting('site', 'global', 'siteurl'),
'version':latest_version, 'error_message':error_message}
email_sender = get_setting('site', 'global', 'siteemailnoreplyaddress') or settings.DEFAULT_FROM_EMAIL
email_recipient = ""
user_id = options['user']
if User.objects.filter(pk=user_id).exists():
user = User.objects.get(pk=user_id)
if user.email:
email_recipient = user.email
try:
print("Updating tendenci")
subprocess.check_output("%s -m pip install tendenci --upgrade" % python_executable(), stderr=subprocess.STDOUT, shell=True)
pass_update_tendenci = True
except subprocess.CalledProcessError as e:
errors_list.append(e.output)
# run python deploy.py iff update_tendenci is successful
if pass_update_tendenci:
try:
print("Updating tendenci site")
subprocess.check_output("%s deploy.py" % python_executable(), stderr=subprocess.STDOUT, shell=True)
pass_update_tendenci_site = True
except subprocess.CalledProcessError as e:
errors_list.append(e.output)
# run reload if update is done
if pass_update_tendenci_site:
try:
print("Restarting Server")
subprocess.check_output("sudo reload %s" % os.path.basename(settings.PROJECT_ROOT),
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
gunicorn_error_msg = e.output
if "reload: Unknown job:" in e.output:
is_uwsgi = True
# run usgi command iff it was proven that the site is using uwsgi instead
if is_uwsgi:
try:
print("Restarting Server")
subprocess.check_output("sudo touch /etc/uwsgi/vassals/%s.ini" % os.path.basename(settings.PROJECT_ROOT),
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
uwsgi_error_msg = e.output
if gunicorn_error_msg and uwsgi_error_msg:
errors_list.append(uwsgi_error_msg)
errors_list.append(gunicorn_error_msg)
try:
print("Clearing cache")
call_command('clear_cache')
except CommandError as e:
errors_list.append(e.output)
email_context['errors_list'] = errors_list
if email_recipient:
subject = render_to_string('notification/update_tendenci_notice/short.txt', email_context)
subject = subject.strip('\n').strip('\r')
body = render_to_string('notification/update_tendenci_notice/full.html', email_context)
email = EmailMessage()
email.subject = subject
email.body = body
email.from_email = email_sender
email.to = [email_recipient]
email.content_subtype = 'html'
email.send()
def post(self, req, *args, **kwargs):
report = dict([(key, req.POST.get(key, '')) for key in (
'subject',
'username',
'domain',
'url',
'message',
'app_id',
'cc',
'email',
'500traceback',
'sentry_id',
)])
try:
couch_user = req.couch_user
full_name = couch_user.full_name
if couch_user.is_commcare_user():
email = report['email']
else:
email = couch_user.get_email()
except Exception:
full_name = None
email = report['email']
report['full_name'] = full_name
report['email'] = email or report['username']
if report['domain']:
domain = report['domain']
elif len(couch_user.domains) == 1:
# This isn't a domain page, but the user has only one domain, so let's use that
domain = couch_user.domains[0]
else:
domain = "<no domain>"
message = (
"username: {username}\n"
"full name: {full_name}\n"
"domain: {domain}\n"
"url: {url}\n"
).format(**report)
domain_object = Domain.get_by_name(domain) if report['domain'] else None
debug_context = {
'datetime': datetime.utcnow(),
'self_started': '<unknown>',
'scale_backend': '<unknown>',
'has_handoff_info': '<unknown>',
'project_description': '<unknown>',
'sentry_error': '{}{}'.format(getattr(settings, 'SENTRY_QUERY_URL'), report['sentry_id'])
}
if domain_object:
current_project_description = domain_object.project_description if domain_object else None
new_project_description = req.POST.get('project_description')
if (domain_object and
req.couch_user.is_domain_admin(domain=domain) and
new_project_description and current_project_description != new_project_description):
domain_object.project_description = new_project_description
domain_object.save()
message += ((
"software plan: {software_plan}\n"
).format(
software_plan=Subscription.get_subscribed_plan_by_domain(domain),
))
debug_context.update({
'self_started': domain_object.internal.self_started,
'scale_backend': should_use_sql_backend(domain),
'has_handoff_info': bool(domain_object.internal.partner_contact),
'project_description': domain_object.project_description,
})
subject = '{subject} ({domain})'.format(subject=report['subject'], domain=domain)
cc = [el for el in report['cc'].strip().split(",") if el]
if full_name and not any([c in full_name for c in '<>"']):
reply_to = '"{full_name}" <{email}>'.format(**report)
else:
reply_to = report['email']
# if the person looks like a commcare user, fogbugz can't reply
# to their email, so just use the default
if settings.HQ_ACCOUNT_ROOT in reply_to:
reply_to = settings.SERVER_EMAIL
message += "Message:\n\n{message}\n".format(message=report['message'])
if req.POST.get('five-hundred-report'):
extra_message = ("This message was reported from a 500 error page! "
"Please fix this ASAP (as if you wouldn't anyway)...")
extra_debug_info = (
"datetime: {datetime}\n"
"Is self start: {self_started}\n"
"Is scale backend: {scale_backend}\n"
"Has Support Hand-off Info: {has_handoff_info}\n"
"Project description: {project_description}\n"
"Sentry Error: {sentry_error}\n"
).format(**debug_context)
traceback_info = cache.cache.get(report['500traceback']) or 'No traceback info available'
cache.cache.delete(report['500traceback'])
message = "\n\n".join([message, extra_debug_info, extra_message, traceback_info])
email = EmailMessage(
subject=subject,
body=message,
to=self.recipients,
headers={'Reply-To': reply_to},
cc=cc
)
uploaded_file = req.FILES.get('report_issue')
if uploaded_file:
filename = uploaded_file.name
content = uploaded_file.read()
email.attach(filename=filename, content=content)
# only fake the from email if it's an @dimagi.com account
is_icds_env = settings.SERVER_ENVIRONMENT in settings.ICDS_ENVS
if re.search(r'@dimagi\.com$', report['username']) and not is_icds_env:
email.from_email = report['username']
else:
email.from_email = settings.CCHQ_BUG_REPORT_EMAIL
email.send(fail_silently=False)
if req.POST.get('five-hundred-report'):
messages.success(
req,
"Your CommCare HQ Issue Report has been sent. We are working quickly to resolve this problem."
)
return HttpResponseRedirect(reverse('homepage'))
return HttpResponse()
def bug_report(req):
report = dict([(key, req.POST.get(key, ''))
for key in ('subject', 'username', 'domain', 'url',
'message', 'app_id', 'cc')])
report['user_agent'] = req.META['HTTP_USER_AGENT']
report['datetime'] = datetime.utcnow()
if report['app_id']:
app = import_app(report['app_id'], BUG_REPORTS_DOMAIN)
report['copy_url'] = "%s%s" % (
get_url_base(),
reverse('view_app', args=[BUG_REPORTS_DOMAIN, app.id]))
else:
report['copy_url'] = None
try:
couch_user = CouchUser.get_by_username(report['username'])
full_name = couch_user.full_name
email = couch_user.get_email()
except Exception:
full_name = None
email = None
report['full_name'] = full_name
report['email'] = email or report['username']
matching_subscriptions = Subscription.objects.filter(
is_active=True,
subscriber__domain=report['domain'],
)
if len(matching_subscriptions) >= 1:
report['software_plan'] = matching_subscriptions[0].plan_version
else:
report['software_plan'] = u'domain has no active subscription'
subject = u'{subject} ({domain})'.format(**report)
message = (u"username: {username}\n"
u"full name: {full_name}\n"
u"domain: {domain}\n"
u"software plan: {software_plan}\n"
u"url: {url}\n"
u"copy url: {copy_url}\n"
u"datetime: {datetime}\n"
u"User Agent: {user_agent}\n"
u"Message:\n\n"
u"{message}\n").format(**report)
cc = report['cc'].strip().split(",")
cc = filter(None, cc)
if full_name and not any([c in full_name for c in '<>"']):
reply_to = u'"{full_name}" <{email}>'.format(**report)
else:
reply_to = report['email']
# if the person looks like a commcare user, fogbugz can't reply
# to their email, so just use the default
if settings.HQ_ACCOUNT_ROOT in reply_to:
reply_to = settings.SERVER_EMAIL
if req.POST.get('five-hundred-report'):
message = "%s \n\n This messge was reported from a 500 error page! Please fix this ASAP (as if you wouldn't anyway)..." % message
email = EmailMessage(subject=subject,
body=message,
to=settings.BUG_REPORT_RECIPIENTS,
headers={'Reply-To': reply_to},
cc=cc)
uploaded_file = req.FILES.get('report_issue')
if uploaded_file:
filename = uploaded_file.name
content = uploaded_file.read()
email.attach(filename=filename, content=content)
# only fake the from email if it's an @dimagi.com account
if re.search('@dimagi\.com$', report['username']):
email.from_email = report['username']
else:
email.from_email = settings.CCHQ_BUG_REPORT_EMAIL
email.send(fail_silently=False)
if req.POST.get('five-hundred-report'):
messages.success(
req,
"Your CommCare HQ Issue Report has been sent. We are working quickly to resolve this problem."
)
return HttpResponseRedirect(reverse('homepage'))
return HttpResponse()
def send_message(subject_user, user_context_html, from_email, to_email):
message_user = EmailMessage(subject_user, user_context_html, from_email,
[to_email])
message_user.content_subtype = "html"
message_user.send(fail_silently=True)
def bug_report(req):
report = dict([(key, req.POST.get(key, '')) for key in (
'subject',
'username',
'domain',
'url',
'message',
'app_id',
'cc',
'email',
'500traceback',
)])
domain_object = Domain.get_by_name(report['domain'])
current_project_description = domain_object.project_description if domain_object else None
new_project_description = req.POST.get('project_description')
if (domain_object
and req.couch_user.is_domain_admin(domain=report['domain'])
and new_project_description
and current_project_description != new_project_description):
domain_object.project_description = new_project_description
domain_object.save()
report['user_agent'] = req.META['HTTP_USER_AGENT']
report['datetime'] = datetime.utcnow()
report['feature_flags'] = toggles.toggles_dict(
username=report['username'], domain=report['domain']).keys()
report['feature_previews'] = feature_previews.previews_dict(
report['domain']).keys()
report['scale_backend'] = should_use_sql_backend(
report['domain']) if report['domain'] else False
report[
'project_description'] = domain_object.project_description if domain_object else '(Not applicable)'
try:
couch_user = req.couch_user
full_name = couch_user.full_name
if couch_user.is_commcare_user():
email = report['email']
else:
email = couch_user.get_email()
except Exception:
full_name = None
email = report['email']
report['full_name'] = full_name
report['email'] = email or report['username']
matching_subscriptions = Subscription.objects.filter(
is_active=True,
subscriber__domain=report['domain'],
)
if len(matching_subscriptions) >= 1:
report['software_plan'] = matching_subscriptions[0].plan_version
else:
report['software_plan'] = u'domain has no active subscription'
subject = u'{subject} ({domain})'.format(**report)
message = (u"username: {username}\n"
u"full name: {full_name}\n"
u"domain: {domain}\n"
u"software plan: {software_plan}\n"
u"url: {url}\n"
u"datetime: {datetime}\n"
u"User Agent: {user_agent}\n"
u"Feature Flags: {feature_flags}\n"
u"Feature Previews: {feature_previews}\n"
u"Is scale backend: {scale_backend}\n"
u"Project description: {project_description}\n"
u"Message:\n\n"
u"{message}\n").format(**report)
cc = report['cc'].strip().split(",")
cc = filter(None, cc)
if full_name and not any([c in full_name for c in '<>"']):
reply_to = u'"{full_name}" <{email}>'.format(**report)
else:
reply_to = report['email']
# if the person looks like a commcare user, fogbugz can't reply
# to their email, so just use the default
if settings.HQ_ACCOUNT_ROOT in reply_to:
reply_to = settings.SERVER_EMAIL
if req.POST.get('five-hundred-report'):
extra_message = ("This messge was reported from a 500 error page! "
"Please fix this ASAP (as if you wouldn't anyway)...")
traceback_info = cache.cache.get(report['500traceback'])
cache.cache.delete(report['500traceback'])
traceback_info = "Traceback of this 500: \n%s" % traceback_info
message = "%s \n\n %s \n\n %s" % (message, extra_message,
traceback_info)
email = EmailMessage(subject=subject,
body=message,
to=settings.BUG_REPORT_RECIPIENTS,
headers={'Reply-To': reply_to},
cc=cc)
uploaded_file = req.FILES.get('report_issue')
if uploaded_file:
filename = uploaded_file.name
content = uploaded_file.read()
email.attach(filename=filename, content=content)
# only fake the from email if it's an @dimagi.com account
if re.search('@dimagi\.com$', report['username']):
email.from_email = report['username']
else:
email.from_email = settings.CCHQ_BUG_REPORT_EMAIL
email.send(fail_silently=False)
if req.POST.get('five-hundred-report'):
messages.success(
req,
"Your CommCare HQ Issue Report has been sent. We are working quickly to resolve this problem."
)
return HttpResponseRedirect(reverse('homepage'))
return HttpResponse()
def _generate_notification_for_seqr_match(submission, results):
"""
Generate a notifcation to say that a match happened initiated from a seqr user.
"""
matches = []
hpo_terms_by_id, genes_by_id, _ = get_mme_genes_phenotypes_for_results(
results)
for result in results:
patient = result['patient']
gene_message = ''
if patient.get('genomicFeatures'):
gene_symbols = set()
for gene in patient['genomicFeatures']:
gene_symbol = gene['gene']['id']
if gene_symbol.startswith('ENSG'):
gene_symbol = genes_by_id.get(gene_symbol, {}).get(
'geneSymbol', gene_symbol)
gene_symbols.add(gene_symbol)
gene_message = ' with genes {}'.format(' '.join(
sorted(gene_symbols)))
phenotypes_message = ''
if patient.get('features'):
phenotypes_message = ' with phenotypes {}'.format(' '.join([
'{} ({})'.format(feature['id'],
hpo_terms_by_id.get(feature['id']))
for feature in patient['features']
]))
matches.append(
' - From {contact} at institution {institution}{gene_message}{phenotypes_message}.'
.format(
contact=patient['contact'].get('name', '(none given)'),
institution=patient['contact'].get('institution',
'(none given)'),
gene_message=gene_message,
phenotypes_message=phenotypes_message,
))
individual = submission.individual
project = individual.family.project
message = u"""
A search from a seqr user from project {project} individual {individual_id} had the following new match(es):
{matches}
{host}project/{project_guid}/family_page/{family_guid}/matchmaker_exchange
""".format(
project=project.name,
individual_id=individual.individual_id,
matches='\n\n'.join(matches),
host=BASE_URL,
project_guid=project.guid,
family_guid=submission.individual.family.guid,
)
post_to_slack(MME_SLACK_SEQR_MATCH_NOTIFICATION_CHANNEL, message)
emails = map(lambda s: s.strip().split('mailto:')[-1],
submission.contact_href.split(','))
email_message = EmailMessage(
subject=u'New matches found for MME submission {} (project: {})'.
format(individual.individual_id, project.name),
body=message,
to=[email for email in emails if email != MME_DEFAULT_CONTACT_EMAIL],
from_email=MME_DEFAULT_CONTACT_EMAIL,
)
email_message.send()
def run(self):
msg = EmailMessage(self.subject, self.html_content, EMAIL_HOST_USER,
self.recipient_list)
msg.content_subtype = "html"
msg.send()
def post(self, req, *args, **kwargs):
report = dict([(key, req.POST.get(key, '')) for key in (
'subject',
'username',
'domain',
'url',
'message',
'app_id',
'cc',
'email',
'500traceback',
'sentry_id',
)])
report['user_agent'] = req.META['HTTP_USER_AGENT']
report['datetime'] = datetime.utcnow()
try:
couch_user = req.couch_user
full_name = couch_user.full_name
if couch_user.is_commcare_user():
email = report['email']
else:
email = couch_user.get_email()
except Exception:
full_name = None
email = report['email']
report['full_name'] = full_name
report['email'] = email or report['username']
if report['domain']:
domain = report['domain']
elif len(couch_user.domains) == 1:
# This isn't a domain page, but the user has only one domain, so let's use that
domain = couch_user.domains[0]
else:
domain = "<no domain>"
message = (
u"username: {username}\n"
u"full name: {full_name}\n"
u"domain: {domain}\n"
u"url: {url}\n"
u"datetime: {datetime}\n"
u"User Agent: {user_agent}\n"
).format(**report)
domain_object = Domain.get_by_name(domain) if report['domain'] else None
if domain_object:
current_project_description = domain_object.project_description if domain_object else None
new_project_description = req.POST.get('project_description')
if (domain_object and
req.couch_user.is_domain_admin(domain=domain) and
new_project_description and current_project_description != new_project_description):
domain_object.project_description = new_project_description
domain_object.save()
matching_subscriptions = Subscription.visible_objects.filter(
is_active=True,
subscriber__domain=domain,
)
if len(matching_subscriptions) >= 1:
software_plan = matching_subscriptions[0].plan_version
else:
software_plan = u'domain has no active subscription'
message += ((
u"software plan: {software_plan}\n"
u"Is self start: {self_started}\n"
u"Feature Flags: {feature_flags}\n"
u"Feature Previews: {feature_previews}\n"
u"Is scale backend: {scale_backend}\n"
u"Has Support Hand-off Info: {has_handoff_info}\n"
u"Internal Project Information: {internal_info_link}\n"
u"Project description: {project_description}\n"
u"Sentry Error: {sentry_error}\n"
).format(
software_plan=software_plan,
self_started=domain_object.internal.self_started,
feature_flags=list(toggles.toggles_dict(username=report['username'], domain=domain)),
feature_previews=list(feature_previews.previews_dict(domain)),
scale_backend=should_use_sql_backend(domain),
has_handoff_info=bool(domain_object.internal.partner_contact),
internal_info_link=reverse('domain_internal_settings', args=[domain], absolute=True),
project_description=domain_object.project_description,
sentry_error='{}{}'.format(getattr(settings, 'SENTRY_QUERY_URL'), report['sentry_id'])
))
subject = u'{subject} ({domain})'.format(subject=report['subject'], domain=domain)
cc = [el for el in report['cc'].strip().split(",") if el]
if full_name and not any([c in full_name for c in '<>"']):
reply_to = u'"{full_name}" <{email}>'.format(**report)
else:
reply_to = report['email']
# if the person looks like a commcare user, fogbugz can't reply
# to their email, so just use the default
if settings.HQ_ACCOUNT_ROOT in reply_to:
reply_to = settings.SERVER_EMAIL
message += u"Message:\n\n{message}\n".format(message=report['message'])
if req.POST.get('five-hundred-report'):
extra_message = ("This messge was reported from a 500 error page! "
"Please fix this ASAP (as if you wouldn't anyway)...")
traceback_info = cache.cache.get(report['500traceback'])
cache.cache.delete(report['500traceback'])
message = "%s \n\n %s \n\n %s" % (message, extra_message, traceback_info)
email = EmailMessage(
subject=subject,
body=message,
to=self.recipients,
headers={'Reply-To': reply_to},
cc=cc
)
uploaded_file = req.FILES.get('report_issue')
if uploaded_file:
filename = uploaded_file.name
content = uploaded_file.read()
email.attach(filename=filename, content=content)
# only fake the from email if it's an @dimagi.com account
if re.search('@dimagi\.com$', report['username']):
email.from_email = report['username']
else:
email.from_email = settings.CCHQ_BUG_REPORT_EMAIL
email.send(fail_silently=False)
if req.POST.get('five-hundred-report'):
messages.success(
req,
"Your CommCare HQ Issue Report has been sent. We are working quickly to resolve this problem."
)
return HttpResponseRedirect(reverse('homepage'))
return HttpResponse()
def subscribe_with_key(req):
key = req.GET.get("key", "")
if not key:
return HttpResponse(UR.prepare_response({}, 1, "NOT ALLOWED"))
e = M.Ensemble.objects.get(invitekey=key)
if not e.use_invitekey:
return HttpResponse(UR.prepare_response({}, 1, "NOT ALLOWED"))
auth_user = UR.getUserInfo(req)
if req.method == 'GET':
if auth_user is None: # Guest retrieving the subscribe page
remote_form = RemoteForm(forms.UserForm())
return HttpResponse(
UR.prepare_response({
"new_user": True,
"class_settings": UR.model2dict(e),
"form": remote_form.as_dict()
}))
else: # Logged in user retrieving the subscribe page
user = auth_user
remote_form = RemoteForm(forms.UserForm(instance=user))
m = M.Membership.objects.filter(user=user, ensemble=e)
if m.count() == 0:
m = M.Membership(user=user, ensemble=e)
m.save()
return HttpResponse(
UR.prepare_response({
"new_user": False,
"user": UR.model2dict(user),
"class_settings": UR.model2dict(e),
"form": remote_form.as_dict()
}))
else: # POST requests
if auth_user is None: # Guest subscribing to a class
user = M.User(confkey="".join([
choice(string.ascii_letters + string.digits)
for i in xrange(0, 32)
]))
req.POST = dict(req.POST.iteritems()
) # Convert immutable object to mutable object
user_form = forms.UserForm(req.POST, instance=user)
if user_form.is_valid():
user_form.save()
m = M.Membership(user=user, ensemble=e)
m.save(
) # membership exists but user is still invalid until has confirmed their email
p = {
"tutorial_url":
settings.GUEST_TUTORIAL_URL,
"conf_url":
"%s://%s/?ckey=%s" %
(settings.PROTOCOL, settings.NB_SERVERNAME, user.confkey),
"firstname":
user.firstname,
"email":
user.email
}
email = EmailMessage(
"Welcome to NB, %s" % (user.firstname, ),
render_to_string("email/confirm_subscribe",
p), settings.EMAIL_FROM, (user.email, ),
(settings.EMAIL_BCC, ))
email.send()
return HttpResponse(
UR.prepare_response({
"new_user": True,
"class_settings": UR.model2dict(e),
"next": "/subscribe_thanks"
}))
else: # Invalid form - return form with error messages
__clean_form(
user_form
) # Ensure user-generated data gets cleaned before sending back the form
remote_form = RemoteForm(user_form)
return HttpResponse(
UR.prepare_response({
"new_user": True,
"user": UR.model2dict(user),
"class_settings": UR.model2dict(e),
"form": remote_form.as_dict()
}))
else: # Logged in user subscribing to a class
user = auth_user
m = M.Membership.objects.filter(user=user, ensemble=e)
if m.count() == 0:
m = M.Membership(user=user, ensemble=e)
m.save()
return HttpResponse(
UR.prepare_response({
"new_user": False,
"class_settings": UR.model2dict(e),
"next": "/"
}))
def email_sender(self, body, to_email):
title = "email verification!"
email = EmailMessage(title, body, to=[to_email])
email.send()
def handle(self, *args, **options):
from tendenci.apps.site_settings.utils import get_setting
from tendenci import __version__ as version
from tendenci.apps.base.utils import get_latest_version
verbosity = int(options['verbosity'])
user_id = options['user_id']
if user_id:
[request_user] = User.objects.filter(pk=user_id)[:1] or [None]
else:
request_user = None
site_url = get_setting('site', 'global', 'siteurl')
# check what tendenci version we're on
major_bit = int(version.split('.')[0])
if major_bit < 7:
if verbosity >1:
print("No update for this version {}.".format(version))
print("Please consider to upgrade https://tendenci.readthedocs.org/en/latest/")
return
project_root = settings.PROJECT_ROOT
err_list = []
# check the latest version
latest_version = get_latest_version()
if int(latest_version.split('.')[0]) < 7 or version == latest_version:
# STOP - NO UPDATE
return
if verbosity >1:
print("Latest version: {}".format(latest_version))
print("Your version: {}".format(version))
print("Start updating...")
# update some files - deploy.py, requirements/tendenci.txt
files_to_update = {'deploy.py': 'https://raw.githubusercontent.com/tendenci/tendenci-project-template/master/deploy.py',
'requirements/tendenci.txt': 'https://raw.githubusercontent.com/tendenci/tendenci-project-template/master/requirements/tendenci.txt'
}
for key, value in files_to_update.items():
try:
subprocess.check_output('curl {0} > {1}/{2}'.format(value, project_root, key),
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
err_list.append(e.output)
# update tendenci
if not err_list:
try:
if verbosity >1:
print("Updating tendenci...")
update_cmd = '{0} -m pip install -r {1}/{2} --upgrade'.format(python_executable(), project_root, 'requirements/tendenci.txt')
subprocess.check_output('cd {}; {}'.format(project_root, update_cmd),
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
err_list.append(e.output)
if not err_list:
# run migrate, collectstatic, etc via deploy.py
try:
subprocess.check_output("cd {0}; {1} manage.py migrate".format(latest_version, python_executable()),
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
known_error = "BadMigrationError: Migrated app 'djcelery' contains South migrations"
known_error2 = 'relation "djcelery_crontabschedule" already exists'
if known_error in e.output or known_error2 in e.output:
try:
subprocess.check_output("cd {0}; {1} manage.py migrate djcelery 0001 --fake".format(latest_version, python_executable()),
stderr=subprocess.STDOUT, shell=True)
subprocess.check_output("cd {0}; {1} manage.py migrate".format(latest_version, python_executable()),
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
err_list.append(e.output)
if not err_list:
# run deploy.py
try:
subprocess.check_output("cd {0}; {1} deploy.py".format(latest_version, python_executable()),
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
err_list.append(e.output)
if not err_list:
if verbosity >1:
print('Reloading the site...')
# reload the site.
# it's a guessing game here - because we don't know what wsgi server the site is behind
# and how exactly the site was set up
try:
subprocess.check_output("sudo reload %s" % os.path.basename(settings.PROJECT_ROOT),
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
try:
subprocess.check_output("sudo sv kill tendenci_site && sv start tendenci_site",
stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as e:
err_list.append(e.output)
if verbosity >1:
if err_list:
print('Sorry, updating tendenci is not complete due to the following error(s):\n\n')
print('\n\n'.join(err_list))
else:
print("Update is done.")
if request_user and request_user.email:
# notify update is done
if err_list:
subject = 'Error on updating tendenci %s' % site_url
body = 'Error(s) encountered on updating tendenci:\n\n'
body += '\n\n'.join(err_list)
else:
subject = 'Update ams365 is done %s' % site_url
body = 'Successfully updated tendenci for %s.\n\n' % site_url
body += 'AMS365 version: %s\n\n' % latest_version
body += "Thanks!\n%s\n\n" % get_setting('site', 'global', 'sitedisplayname')
msg = EmailMessage(subject, body, settings.DEFAULT_FROM_EMAIL, [request_user.email])
msg.send()
def newsite_form(req):
import base.models as M, random, string
auth_user = UR.getUserInfo(req)
if auth_user is not None:
return HttpResponse(UR.prepare_response({"redirect": "/"}))
if req.method == 'GET':
remote_user_form = RemoteForm(forms.UserForm())
remote_class_form = RemoteForm(forms.EnsembleForm())
return HttpResponse(
UR.prepare_response({
"user_form": remote_user_form.as_dict(),
"class_form": remote_class_form.as_dict()
}))
else:
user = M.User(confkey="".join([
choice(string.ascii_letters + string.digits)
for i in xrange(0, 32)
]))
ensemble = M.Ensemble()
req.POST = dict(
req.POST.iteritems()) # Convert immutable object to mutable object
user_form = forms.UserForm(req.POST, instance=user)
ensemble_form = forms.EnsembleForm(req.POST, instance=ensemble)
if user_form.is_valid() and ensemble_form.is_valid():
user_form.save()
ensemble.invitekey = "".join([
random.choice(string.ascii_letters + string.digits)
for i in xrange(0, 50)
])
ensemble_form.save()
m = M.Membership(user=user, ensemble=ensemble, admin=True)
m.save()
p = {
"tutorial_url":
settings.GUEST_TUTORIAL_URL,
"conf_url":
"http://%s?ckey=%s" % (settings.NB_SERVERNAME, user.confkey),
"firstname":
user.firstname,
"email":
user.email
}
email = EmailMessage("Welcome to NB, %s" % (user.firstname),
render_to_string("email/confirm_newsite",
p), settings.EMAIL_FROM,
(user.email, ), (settings.EMAIL_BCC, ))
email.send()
return HttpResponse(
UR.prepare_response({"redirect": "/newsite_thanks"}))
else: # Invalid form - return form with error messages
__clean_form(
user_form
) # Ensure user-generated data gets cleaned before sending back the form
__clean_form(
ensemble_form
) # Ensure user-generated data gets cleaned before sending back the form
remote_user_form = RemoteForm(user_form)
remote_class_form = RemoteForm(ensemble_form)
return HttpResponse(
UR.prepare_response({
"user_form": remote_user_form.as_dict(),
"class_form": remote_class_form.as_dict()
}))
def send_email_to_staff_on_student_enrollment(sender,
event=None,
user=None,
**kwargs): # pylint: disable=unused-argument
"""
Sends an e-mail to staff after a new enrollment.
This feature can be enabled by setting the e-mail of the staff in ENROLLMENT_NOTIFICATION_EMAIL in lms.env.json,
or by using a SiteConfiguration variable of the same name (which will override the env one).
Disabled by default.
"""
if event == EnrollStatusChange.enroll:
to_email = configuration_helpers.get_value(
'ENROLLMENT_NOTIFICATION_EMAIL',
settings.ENROLLMENT_NOTIFICATION_EMAIL)
if not to_email:
# feature disabled
return
course_id = kwargs['course_id']
site_protocol = 'https' if settings.HTTPS == 'on' else 'http'
site_domain = configuration_helpers.get_value('site_domain',
settings.SITE_NAME)
context = {
'user':
user,
# This full_name is dependent on edx-platform's profile implementation
'user_full_name':
user.profile.name if hasattr(user, 'profile') else None,
'course_url':
urlunsplit((site_protocol, site_domain,
reverse('about_course',
args=[course_id.to_deprecated_string()]), None,
None)),
'user_admin_url':
urlunsplit((
site_protocol,
site_domain,
reverse('admin:auth_user_change', args=[user.id]),
None,
None,
)),
}
subject = ''.join(
render_to_string('emails/new_enrollment_email_subject.txt',
context).splitlines())
message = render_to_string('emails/new_enrollment_email_body.txt',
context)
email = EmailMessage(subject=subject,
body=message,
from_email=settings.DEFAULT_FROM_EMAIL,
to=[to_email])
try:
email.send()
except SMTPException as exception:
LOGGER.error("Failed sending e-mail about new enrollment to %s",
to_email)
LOGGER.exception(exception)
def send(self, fail_silently=False, **kwargs):
recipient_list = []
recipient_bcc_list = []
headers = kwargs.get('headers', {})
attachments = kwargs.get('attachments', [])
if isinstance(self.recipient, basestring):
recipient_list = self.recipient.split(',')
recipient_list = [recipient.strip() for recipient in recipient_list \
if recipient.strip() <> '']
else:
recipient_list = list(self.recipient)
if isinstance(self.recipient_cc, basestring):
recipient_cc_list = self.recipient_cc.split(',')
recipient_cc_list = [recipient_cc.strip() for recipient_cc in recipient_cc_list if \
recipient_cc.strip() <> '']
recipient_list += recipient_cc_list
else:
recipient_list += list(self.recipient_cc)
if isinstance(self.recipient_bcc, basestring):
recipient_bcc_list = self.recipient_bcc.split(',')
recipient_bcc_list = [recipient_bcc.strip() for recipient_bcc in recipient_bcc_list if \
recipient_bcc.strip() <> '']
else:
recipient_bcc_list = list(self.recipient_bcc)
if self.reply_to:
headers['Reply-To'] = self.reply_to
if not self.sender:
self.sender = get_setting('site', 'global', 'siteemailnoreplyaddress') or settings.DEFAULT_FROM_EMAIL
if self.sender_display:
# Add quotes around display name to prevent errors on sending
# When display name contains comma or other control characters,
headers['From'] = '"%s"<%s>' % (self.sender_display, self.sender)
if self.priority and self.priority == 1:
headers['X-Priority'] = '1'
headers['X-MSMail-Priority'] = 'High'
# remove blocked from recipient_list and recipient_bcc_list
temp_recipient_list = copy.copy(recipient_list)
for e in temp_recipient_list:
if self.is_blocked(e):
recipient_list.remove(e)
temp_recipient_bcc_list = copy.copy(recipient_bcc_list)
for e in temp_recipient_bcc_list:
if self.is_blocked(e):
recipient_bcc_list.remove(e)
if recipient_list or recipient_bcc_list:
msg = EmailMessage(self.subject,
self.body,
self.sender,
recipient_list,
recipient_bcc_list,
headers=headers,
connection=kwargs.get('connection', None))
if self.content_type == 'html' or self.content_type == self.CONTENT_TYPE_HTML:
msg.content_subtype = 'html'
if attachments:
msg.attachments = attachments
msg.send(fail_silently=fail_silently)
def _generate_notification_for_incoming_match(results, incoming_query,
incoming_request_node,
incoming_patient):
"""
Generate a SLACK notifcation to say that a VALID match request came in and the following
results were sent back. If Slack is not supported, a message is not sent, but details persisted.
Args:
response_from_matchbox (python requests object): contains the response from matchbox
incoming_request (Django request object): The request that came into the view
incoming_patient (JSON): The query patient JSON structure from outside MME node that was matched with
"""
incoming_patient_id = incoming_patient['patient']['id']
logger.info('{} MME matches found for patient {} from {}'.format(
len(results), incoming_patient_id, incoming_request_node))
institution = incoming_patient['patient']['contact'].get(
'institution', incoming_request_node)
contact_href = incoming_patient['patient']['contact'].get(
'href', '(sorry I was not able to read the information given for URL)')
if not results:
message_template = """A match request for {patient_id} came in from {institution} today.
The contact information given was: {contact}.
We didn't find any individuals in matchbox that matched that query well, *so no results were sent back*."""
post_to_slack(
MME_SLACK_MATCH_NOTIFICATION_CHANNEL,
message_template.format(institution=institution,
patient_id=incoming_patient_id,
contact=contact_href))
return
new_matched_results = MatchmakerResult.objects.filter(
originating_query=incoming_query).prefetch_related('submission')
if not new_matched_results:
message_template = """A match request for {patient_id} came in from {institution} today.
The contact information given was: {contact}.
We found {existing_results} existing matching individuals but no new ones, *so no results were sent back*."""
post_to_slack(
MME_SLACK_MATCH_NOTIFICATION_CHANNEL,
message_template.format(institution=institution,
patient_id=incoming_patient_id,
contact=contact_href,
existing_results=len(results)))
return
hpo_terms_by_id, genes_by_id, _ = get_mme_genes_phenotypes_for_results(
[incoming_patient])
match_results = []
all_emails = set()
for result in new_matched_results:
submission = result.submission
individual = submission.individual
project = individual.family.project
result_text = """seqr ID {individual_id} from project {project_name} in family {family_id} inserted into
matchbox on {insertion_date}, with seqr link
{host}project/{project_guid}/family_page/{family_guid}/matchmaker_exchange""".replace(
'\n', ' ').format(
individual_id=individual.individual_id,
project_guid=project.guid,
project_name=project.name,
family_guid=individual.family.guid,
family_id=individual.family.family_id,
insertion_date=submission.created_date.strftime('%b %d, %Y'),
host=BASE_URL)
emails = [
email.strip() for email in submission.contact_href.replace(
'mailto:', '').split(',')
if email.strip() != MME_DEFAULT_CONTACT_EMAIL
]
all_emails.update(emails)
match_results.append((result_text, emails))
match_results = sorted(match_results,
key=lambda result_tuple: result_tuple[0])
base_message = """Dear collaborators,
matchbox found a match between a patient from {query_institution} and the following {number_of_results} case(s)
in matchbox. The following information was included with the query,
genes: {incoming_query_genes}
phenotypes: {incoming_query_phenotypes}
contact: {incoming_query_contact_name}
email: {incoming_query_contact_url}
We sent back the following:
""".format(
query_institution=institution,
number_of_results=len(results),
incoming_query_genes=', '.join(
sorted([gene['geneSymbol'] for gene in genes_by_id.values()])),
incoming_query_phenotypes=', '.join([
'{} ({})'.format(hpo_id, term)
for hpo_id, term in hpo_terms_by_id.items()
]),
incoming_query_contact_url=contact_href,
incoming_query_contact_name=incoming_patient['patient']['contact'].get(
'name',
'(sorry I was not able to read the information given for name'),
)
message_template = """{base_message}{match_results}
We sent this email alert to: {email_addresses_alert_sent_to}\n{footer}."""
post_to_slack(
MME_SLACK_MATCH_NOTIFICATION_CHANNEL,
message_template.format(
base_message=base_message,
match_results='\n'.join([text for text, _ in match_results]),
email_addresses_alert_sent_to=', '.join(sorted(all_emails)),
footer=MME_EMAIL_FOOTER))
for result_text, emails in match_results:
email_message = EmailMessage(
subject='Received new MME match',
body=message_template.format(
base_message=base_message,
match_results=result_text,
email_addresses_alert_sent_to=', '.join(emails),
footer=MME_EMAIL_FOOTER),
to=emails,
from_email=MME_DEFAULT_CONTACT_EMAIL,
)
email_message.send()
def pmp_indicator_report():
base_url = 'https://etools.unicef.org'
countries = Country.objects.exclude(schema_name__in=['public', 'uat', 'frg'])
fieldnames = [
'Country',
'Partner Name',
'Partner Type',
'PD / SSFA ref',
'PD / SSFA status',
'PD / SSFA start date',
'PD / SSFA creation date',
'PD / SSFA end date',
'UNICEF US$ Cash contribution',
'UNICEF US$ Supply contribution',
'Total Budget',
'UNICEF Budget',
'Currency',
'Partner Contribution',
'Unicef Cash',
'In kind Amount',
'Total',
'FR numbers against PD / SSFA',
'FR currencies',
'Sum of all FR planned amount',
'Core value attached',
'Partner Link',
'Intervention Link',
]
csvfile = StringIO()
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
writer.writeheader()
for country in countries:
connection.set_tenant(Country.objects.get(name=country.name))
logger.info(u'Running on %s' % country.name)
for partner in PartnerOrganization.objects.filter():
for intervention in Intervention.objects.filter(
agreement__partner=partner).select_related('planned_budget'):
planned_budget = getattr(intervention, 'planned_budget', None)
fr_currencies = intervention.frs.all().values_list('currency', flat=True).distinct()
writer.writerow({
'Country': country,
'Partner Name': str(partner),
'Partner Type': partner.cso_type,
'PD / SSFA ref': intervention.number.replace(',', '-'),
'PD / SSFA status': intervention.get_status_display(),
'PD / SSFA start date': intervention.start,
'PD / SSFA creation date': intervention.created,
'PD / SSFA end date': intervention.end,
'UNICEF US$ Cash contribution': intervention.total_unicef_cash,
'UNICEF US$ Supply contribution': intervention.total_in_kind_amount,
'Total Budget': intervention.total_budget,
'UNICEF Budget': intervention.total_unicef_budget,
'Currency': intervention.planned_budget.currency if planned_budget else '-',
'Partner Contribution': intervention.planned_budget.partner_contribution if planned_budget else '-',
'Unicef Cash': intervention.planned_budget.unicef_cash if planned_budget else '-',
'In kind Amount': intervention.planned_budget.in_kind_amount if planned_budget else '-',
'Total': intervention.planned_budget.total if planned_budget else '-',
'FR numbers against PD / SSFA': u' - '.join([fh.fr_number for fh in intervention.frs.all()]),
'FR currencies': ', '.join(fr for fr in fr_currencies),
'Sum of all FR planned amount': intervention.frs.aggregate(
total=Coalesce(Sum('intervention_amt'), 0))['total'] if fr_currencies.count() <= 1 else '-',
'Core value attached': True if partner.core_values_assessment else False,
'Partner Link': '{}/pmp/partners/{}/details'.format(base_url, partner.pk),
'Intervention Link': '{}/pmp/interventions/{}/details'.format(base_url, intervention.pk),
})
mail = EmailMessage('PMP Indicator Report', 'Report generated',
'*****@*****.**', settings.REPORT_EMAILS)
mail.attach('pmp_indicators.csv', csvfile.getvalue().encode('utf-8'), 'text/csv')
mail.send()
def handle(self, *args, **options):
outputfile = options.get('file')
output_text = []
output_text.append('@@@@@'.join([
smart_str(u"ID"),
smart_str(u"User"),
smart_str(u"Date"),
smart_str(u"Date Updated"),
smart_str(u"Name (as stated on disclaimer)"),
smart_str(u"DOB"),
smart_str(u"Address"),
smart_str(u"Postcode"),
smart_str(u"Home Phone"),
smart_str(u"Mobile Phone"),
smart_str(u"Emergency Contact 1: Name"),
smart_str(u"Emergency Contact 1: Relationship"),
smart_str(u"Emergency Contact 1: Phone"),
smart_str(u"Emergency Contact 2: Name"),
smart_str(u"Emergency Contact 2: Relationship"),
smart_str(u"Emergency Contact 2: Phone"),
smart_str(u"Medical Conditions"),
smart_str(u"Medical Conditions Details"),
smart_str(u"Joint Problems"),
smart_str(u"Joint Problems Details"),
smart_str(u"Allergies"),
smart_str(u"Allergies Details"),
smart_str(u"Medical Treatment Terms"),
smart_str(u"Medical Treatment Accepted"),
smart_str(u"Disclaimer Terms"),
smart_str(u"Disclaimer Terms Accepted"),
smart_str(u"Over 18 Statement"),
smart_str(u"Over 18 Confirmed")
]))
for obj in OnlineDisclaimer.objects.all():
output_text.append('@@@@@'.join([
smart_str(obj.pk),
smart_str(obj.user),
smart_str(obj.date.strftime('%Y-%m-%d %H:%M:%S:%f %z')),
smart_str(
obj.date_updated.strftime('%Y-%m-%d %H:%M:%S:%f %z'
) if obj.date_updated else ''),
smart_str(obj.name),
smart_str(obj.dob.strftime('%Y-%m-%d')),
smart_str(obj.address),
smart_str(obj.postcode),
smart_str(obj.home_phone),
smart_str(obj.mobile_phone),
smart_str(obj.emergency_contact1_name),
smart_str(obj.emergency_contact1_relationship),
smart_str(obj.emergency_contact1_phone),
smart_str(obj.emergency_contact2_name),
smart_str(obj.emergency_contact2_relationship),
smart_str(obj.emergency_contact2_phone),
smart_str('Yes' if obj.medical_conditions else 'No'),
smart_str(obj.medical_conditions_details),
smart_str('Yes' if obj.joint_problems else 'No'),
smart_str(obj.joint_problems_details),
smart_str('Yes' if obj.allergies else 'No'),
smart_str(obj.allergies_details),
smart_str(obj.medical_treatment_terms),
smart_str('Yes' if obj.medical_treatment_permission else 'No'),
smart_str(obj.disclaimer_terms),
smart_str('Yes' if obj.terms_accepted else 'No'),
smart_str(obj.over_18_statement),
smart_str('Yes' if obj.age_over_18_confirmed else 'No'),
]))
output_str = '&&&&&'.join(output_text)
with open(outputfile, 'wb') as out:
out.write(encrypt(PASSWORD, output_str))
with open(outputfile, 'rb') as file:
filename = os.path.split(outputfile)[1]
try:
msg = EmailMessage(
'{} disclaimer backup'.format(
settings.ACCOUNT_EMAIL_SUBJECT_PREFIX),
'Encrypted disclaimer back up file attached. '
'{} records.'.format(OnlineDisclaimer.objects.count()),
settings.DEFAULT_FROM_EMAIL,
to=[settings.SUPPORT_EMAIL],
attachments=[(filename, file.read(), 'bytes/bytes')])
msg.send(fail_silently=False)
except:
pass
self.stdout.write(
'{} disclaimer records encrypted and written to {}'.format(
OnlineDisclaimer.objects.count(), outputfile))
logger.info('{} disclaimer records encrypted and backed up'.format(
OnlineDisclaimer.objects.count()))
ActivityLog.objects.create(
log='{} disclaimer records encrypted and backed up'.format(
OnlineDisclaimer.objects.count()))
def upload(req):
r = HttpResponse()
f = req.FILES["file"]
id_ensemble = req.GET["id_ensemble"]
id_source = req.GET["id_source"]
id_folder = req.GET.get("id_folder", None)
uid = UR.getUserId(req)
logging.info("upload uid=%s, id_source=%s, id_ensemble=%s, id_folder=%s" %
(uid, id_source, id_ensemble, id_folder))
url = "http://%s:%s/%s?id_ensemble=%s" % ("localhost", "8080", f.name,
id_ensemble)
payload = {"url": url, "id_source": id_source, "id_folder": id_folder}
if auth.canInsertFile(uid, id_ensemble, id_folder):
#the followong data will be deleted in utils_pdf if an PDF error happens later...
annotations.createSource(uid, payload)
ownership = annotations.addOwnership(id_source, id_ensemble, id_folder)
source = ownership.source
REPOSITORY_DIR = "%s/%s" % (settings.HTTPD_MEDIA, "/pdf/repository")
f2 = open("%s/%s" % (
REPOSITORY_DIR,
id_source,
), "wb")
f2.write(f.read())
f2.close()
if insert_pdf_metadata(id_source, REPOSITORY_DIR):
V = {
"reply_to": settings.SMTP_REPLY_TO,
"email": source.submittedby.email,
"title": source.title,
"submitted": ownership.published,
"protocol": settings.PROTOCOL,
"hostname": settings.HOSTNAME,
"id_source": id_source,
"firstname": source.submittedby.firstname
}
msg = render_to_string("email/msg_pdfdone", V)
email = EmailMessage(
"The PDF file that you've submitted is now ready on NB.", msg,
settings.EMAIL_FROM, (V["email"], settings.SMTP_CC_USER),
(settings.EMAIL_BCC, ))
email.send()
else:
#send email that stg didn't work and remove that document.
V = {
"reply_to": settings.SMTP_REPLY_TO,
"email": source.submittedby.email,
"source_id": id_source,
"title": source.title,
"submitted": ownership.published,
"support": settings.SUPPORT_LINK,
"contact_email": settings.NBTEAM_EMAIL,
"firstname": source.submittedby.firstname
}
ownership.delete()
source.delete()
msg = render_to_string("email/msg_pdferror", V)
email = EmailMessage(
"NB was unable to read a PDF file that you've submitted", msg,
settings.EMAIL_FROM, (V["email"], settings.SMTP_CC_PDFERROR),
(settings.EMAIL_BCC, ))
email.send()
r.content = UR.prepare_response({})
else:
r.content = UR.prepare_response(
{}, 1, "NOT ALLOWED to insert a file to this group")
return r
def send_mail_task(subject, message, from_email, recipient_list):
message = EmailMessage("Discover Special Value - {0}".format(subject), message, from_email, recipient_list)
message.send()
def playstay_request_booking_email(booked_id):
email_path = EMAIL_TEMPLATE_PATH + "playstay_request.html"
booked = BookedPackageTour.objects.get(pk=booked_id)
booked_data = BookedPackageTourSerializer(booked).data
package_tour = PackageTour.objects.filter(
id=booked_data['package_tour']).first()
with open(email_path, encoding="utf-8") as f:
data = f.read()
if CURRENT_ENV == 'prod':
bcc_email = ['*****@*****.**']
else:
bcc_email = []
total_cost = int(booked_data['total_cost'])
data = data.replace('{customer_name}', booked_data['customer_name'])
data = data.replace('{booked_id}', booked_data['reservation_code'])
data = data.replace('{customer_phone}', booked_data['customer_phone'])
data = data.replace('{customer_email}', booked_data['customer_email'])
data = data.replace('{total_cost}', "{:,}".format(total_cost))
data = data.replace('{checkin_date}',
booked_data['checkin_date'].strftime('%b %d, %Y'))
data = data.replace('{checkout_date}',
booked_data['checkout_date'].strftime('%b %d, %Y'))
data = data.replace('{note}', booked_data['note'])
data = data.replace('{no_nights}', str(booked_data['quantity']))
if len(booked_data['golfcourses']) > 1:
no_rounds = len(booked_data['golfcourses'])
else:
no_rounds = booked_data['golfcourses'][0]['no_round']
no_rooms = 0
total_stay = 0
template_hotel = """
<tr align="center">
<td align="left" valign="top" width="60%">
<span style="margin: 0; font-size: 15px; line-height: 21px; font-family: 'Helvetica', Arial, sans-serif; color: #333333;">
<span id="ctl13_lblRoomName">{hotel_name} - {room_name}</span></span>
</td>
<td align="right" valign="top" width="40%">
<span style="margin: 0; font-size: 15px; line-height: 21px; font-family: 'Helvetica', Arial, sans-serif; color: #333333;">
<span id="ctl13_lblRoomPrice">{hotel_no_rooms} Room{scale}</span>
</span>
</td>
</tr>
"""
template_golfcourse = """
<tr align="center">
<td align="left" valign="top" width="60%">
<span style="margin: 0; font-size: 15px; line-height: 21px; font-family: 'Helvetica', Arial, sans-serif; color: #333333;">
<span id="ctl13_lblRoomName">{golfcourse_name}</span></span>
</td>
<td align="right" valign="top" width="40%">
<span style="margin: 0; font-size: 15px; line-height: 21px; font-family: 'Helvetica', Arial, sans-serif; color: #333333;">
<span id="ctl13_lblRoomPrice">{golfcourse_no_round} Round{scale}</span>
</span>
</td>
</tr>
"""
package_hotel = ""
for hotel in booked_data['hotels']:
no_rooms += hotel['quantity']
total_stay += int(hotel['price'])
td = {
'room_name': hotel['info']['room_info']['name'],
'hotel_no_rooms': hotel['quantity'],
'hotel_name': hotel['name'],
'scale': 's' if hotel['quantity'] > 1 else ''
}
package_hotel += template_hotel.format(**td)
total_play = 0
package_golfcourse = ""
golfcourse_no_round = 1 if len(booked_data['golfcourses']) > 1 else 0
for golfcourse in booked_data['golfcourses']:
total_play += int(golfcourse['price'])
gc_round = golfcourse_no_round or golfcourse['no_round']
td = {
'golfcourse_name':
golfcourse['info']['golfcourse_info']['name'],
'golfcourse_no_round': gc_round,
'scale': 's' if (gc_round > 1) else ''
}
package_golfcourse += template_golfcourse.format(**td)
total_stay *= booked_data['quantity']
#total_play *= 1 if len(booked_data['golfcourses']) > 1 else booked_data['quantity']
no_golfer = booked_data['golfcourses'][0]['quantity']
data = data.replace('{no_rooms}', str(no_rooms))
data = data.replace('{no_golfer}', str(no_golfer))
data = data.replace('{total_stay}', "{:,}".format(total_stay))
data = data.replace('{total_play}', "{:,}".format(total_play))
data = data.replace('{package_hotel}', package_hotel)
data = data.replace('{package_golfcourse}', package_golfcourse)
scale_nogolfer = 's' if no_golfer > 1 else ''
data = data.replace('{scale_nogolfer}', scale_nogolfer)
total_sum = total_play + total_stay
data = data.replace('{total_sum}', "{:,}".format(total_sum))
template_discount = """
<tr align="center">
<td align="left" style="border-top: 1px dotted #dedede;">
<strong style="margin: 0; font-size: 15px; line-height: 21px; font-family: 'Helvetica', Arial, sans-serif; color: #333333;">
<span id="ctl13_lblTxtTotalPrice">Discount (-{0}%)</span>
</strong>
</td>
<td align="right" valign="top" width="40%" style="border-top: 1px dotted #dedede;">
<strong style="margin: 0; font-size: 15px; line-height: 21px; font-family: 'Helvetica', Arial, sans-serif; color: #333333;">
<span id="ctl13_lblTotalPrice">VND -{1:,}</span>
</strong>
</td>
</tr>
"""
if booked_data['discount']:
td = template_discount.format(package_tour.discount,
total_play + total_stay - total_cost)
data = data.replace('{discount_amount}', td)
else:
data = data.replace('{discount_amount}', '')
hotel_id = int(booked_data['hotels'][0]['info']['room_info']['hotel'])
hotel = Hotel.objects.get(pk=hotel_id)
data = data.replace('{hotel_name}', hotel.name.upper())
data = data.replace('{hotel_address}', (hotel.address or ''))
data = data.replace(
'{hotel_image}',
hotel.hotel_images.all()[0].url
if hotel.hotel_images.all().count() > 0 else '')
package_tour = PackageTour.objects.get(pk=booked_data['package_tour'])
package_name = "{0} | {1} round{2} {3} night{4}".format(
package_tour.title, no_rounds, 's' if no_rounds > 1 else '',
booked_data['quantity'],
's' if booked_data['quantity'] > 1 else '')
data = data.replace('{package_name}', package_name)
template_currency = """
<tr align="center">
<td align="left" align="right" valign="top" width="40%">
<strong style="margin: 0; font-size: 20px; line-height: 21px; font-family: 'Helvetica', Arial, sans-serif; color: #333333;">
<span id="ctl13_lblTxtTotalPrice"></span>
</strong>
</td>
<td align="right" valign="top" width="40%">
<strong style="margin: 0; font-size: 20px; line-height: 21px; font-family: 'Helvetica', Arial, sans-serif; color: #333333;">
<span id="ctl13_lblTotalPrice">{currencyCode} {currencyValue}*</span>
</strong>
</td>
</tr>
"""
#round(a,2)
if booked_data['currencyCode'] and booked_data['currencyCode'] != 'VND':
temp_currency = {
'currencyCode': booked_data['currencyCode'],
'currencyValue': round(booked_data['currencyValue'], 2)
}
currency = template_currency.format(**temp_currency)
data = data.replace('{currency}', currency)
else:
data = data.replace('{currency}', '')
email = [booked_data['customer_email']]
ctx = {'email': booked_data['customer_email']}
text = 'Thanks you for your booking with GolfConnect24'
template_data = Template(data)
message = template_data.render(Context(ctx))
msg = EmailMessage(
'GOLFCONNECT24 BOOKING REQUEST #{}'.format(
booked_data['reservation_code']),
message,
from_email='GolfConnect24 <*****@*****.**>',
to=email,
bcc=bcc_email)
msg.content_subtype = "html"
msg.send()
return
def send_test_report():
from django.core.mail import EmailMessage
email = EmailMessage('Subject',
'Body',
to=['*****@*****.**'])
email.send()
def send_email(request):
msg = EmailMessage('Request Callback',
'Here is the message.', to=['*****@*****.**'])
msg.send()
return HttpResponseRedirect('/')
def download_payment_file_post(request):
download_file = request.POST.get('download_payment_file', None)
send_file = request.POST.get('send_payment_file', None)
send_sales_report = request.POST.get('send_sales_report', None)
if download_file:
dl_url = get_today_payments()
if not dl_url:
return HttpResponseBadRequest('no url found')
return HttpResponseRedirect(redirect_to=dl_url)
if send_file:
dl_url = payment_summary_today()
msg = "Email sent to " + ', '.join(
['*****@*****.**', '*****@*****.**', '*****@*****.**', '*****@*****.**',
'*****@*****.**', '*****@*****.**', '*****@*****.**'])
messages.error(request, "Mail sent successfully")
return HttpResponseRedirect(redirect_to=dl_url)
if send_sales_report:
mb = ManualBooking.objects.filter(
created_on__date=datetime.now().date() - timedelta(days=1)
).exclude(
booking_status='cancelled'
).order_by(
'-shipment_date'
)
if mb:
data = []
for booking in mb:
try:
data.append([
booking.booking_id,
'\n'.join(booking.lr_numbers.values_list('lr_number', flat=True)),
booking.from_city,
booking.to_city,
booking.party_rate,
booking.charged_weight,
booking.total_amount_to_company,
booking.supplier_rate,
booking.supplier_charged_weight,
booking.total_amount_to_owner,
booking.total_amount_to_company - booking.total_amount_to_owner,
"{0:.2f}".format(((
booking.total_amount_to_company - booking.total_amount_to_owner) / booking.total_amount_to_owner) * 100)
])
except ZeroDivisionError:
data.append([
booking.booking_id,
'\n'.join(booking.lr_numbers.values_list('lr_number', flat=True)),
booking.from_city,
booking.to_city,
booking.party_rate,
booking.charged_weight,
booking.total_amount_to_company,
booking.supplier_rate,
booking.supplier_charged_weight,
booking.total_amount_to_owner,
booking.total_amount_to_company - booking.total_amount_to_owner,
'Amount to owner is zero'
])
df = pd.DataFrame(data=data,
columns=['Booking ID', 'LR Number(s)', 'From City', 'To City', 'Party Rate',
'Party Weight',
'Party Amount', 'Supplier Rate', 'Supplier Weight', 'Supplier Amount', 'Profit',
'% Profit'])
bytes_io = BytesIO()
df.to_csv(bytes_io, index=False)
bytes_io.seek(0)
content = bytes_io.getvalue() or '\n'
filename = datetime.now().strftime('%d%b%Y%I%M') + '.csv'
s3_upload = save_to_s3_daily_sales_report(filename, content)
s3_url = s3_upload.public_url()
subject = '[Aaho] Daily Sales Report for ' + (datetime.now().date() - timedelta(days=1)).strftime(
'%d-%b-%Y')
body = get_template('team/emails/last-day-bookings.html').render(context={'mb': mb, 's3_url': s3_url})
email = EmailMessage(subject, body,
to=['*****@*****.**', '*****@*****.**', '*****@*****.**', '*****@*****.**'])
email.content_subtype = 'html'
email.send()
return HttpResponseRedirect('/team/download-payment-file/')
def send_confirmation_emails(self, pdf_file, site_name):
"""
send confirmation e-mail
"""
recipient_list = [(self.user.username, self.user.email, 'user')] # pylint: disable=no-member
subject = _("Order Payment Confirmation")
dashboard_url = '{base_url}{dashboard}'.format(
base_url=site_name, dashboard=reverse('dashboard'))
try:
from_address = configuration_helpers.get_value(
'email_from_address', settings.PAYMENT_SUPPORT_EMAIL)
# Send a unique email for each recipient. Don't put all email
# addresses in a single email.
for recipient in recipient_list:
message = render_to_string(
'micro_masters/emails/order_confirmation_email.txt', {
'order':
self,
'recipient_name':
recipient[0],
'recipient_type':
recipient[2],
'site_name':
site_name,
'dashboard_url':
dashboard_url,
'currency_symbol':
settings.PAID_COURSE_REGISTRATION_CURRENCY[1],
'order_placed_by':
'{username} ({email})'.format(
username=self.user.username,
email=self.user.email),
'has_billing_info':
settings.FEATURES['STORE_BILLING_INFO'],
'platform_name':
configuration_helpers.get_value(
'platform_name', settings.PLATFORM_NAME),
'payment_support_email':
configuration_helpers.get_value(
'payment_support_email',
settings.PAYMENT_SUPPORT_EMAIL,
),
'payment_email_signature':
configuration_helpers.get_value(
'payment_email_signature'),
})
email = EmailMessage(subject=subject,
body=message,
from_email=from_address,
to=[recipient[1]])
if pdf_file is not None:
email.attach(u'Receipt.pdf', pdf_file.getvalue(),
'application/pdf')
else:
file_buffer = StringIO.StringIO(
_('pdf download unavailable right now, please contact support.'
))
email.attach(u'pdf_not_available.txt',
file_buffer.getvalue(), 'text/plain')
email.send()
# sadly need to handle diff. mail backends individually
except (smtplib.SMTPException, BotoServerError):
log.error('Failed sending confirmation e-mail for order %d',
self.id)
def registro_de_usuarios(request):
captcha = generar_captchat()
if request.POST:
c = request.POST['captcha'].upper()
c1 = request.POST['captcha1']
print c, captcha
if c1 == c and validar_cedula(request.POST['cedula']):
try:
user = User.objects.create_user(
username=request.POST['email'],
email=request.POST['email'],
password=request.POST['password'],
first_name=request.POST['nombres'],
last_name=request.POST['apellidos'])
user.is_staff = False
user.is_active = False
user.save()
try:
print request.POST['fecha_nacimiento']
Estudiantes(
usuario=user,
cedula=request.POST['cedula'],
fecha_nacimiento=request.POST['fecha_nacimiento'],
cert_votacion=request.POST['certificado_votacion'],
nombre_colegio=request.POST['nombre_colegio'],
lugar_nacimiento=request.POST['lugar_nacimiento'],
nacionalidad=request.POST['nacionalidad'],
telefono=request.POST['telefono'],
tipo_sangre=request.POST['tipo_sangre'],
anio_graduacion=request.POST['anio_graduacion'],
direccion=request.POST['direccion'],
sexo=request.POST['sexo']).save()
host = str(lectura_host())
email = EmailMessage(
"- SINDICATO CANTONAL DE CHOFERES PROFESIONALES DE PASAJE -",
"\n\n\nTe damos la Bienvenida, y te agradecemos por registrarte en nuestro sistema, aqui tienes un enlace para activar tú cuenta: http://"
+ host + "/activar_usuario/" + str(user.id),
to=[request.POST['email']])
email.send()
except Exception as error:
print error
pass
return render_to_response(
"public/Registro.html", {
"mensaje":
"Su cuenta fué creada exitosamente, LOS DATOS DE LA ACTIVACIÓN LLEGARÁN A SU CORREO ELECTRÓNICO..!!",
"captcha": captcha
})
except:
return render_to_response(
"public/Registro.html", {
"mensaje":
"Se ha presentado un error desconocido, por favor intente más tarde..!!"
})
else:
return render_to_response(
"public/Registro.html", {
"mensaje":
"No ha pasado la validación o su cédula no es correcta, Reintente..!!"
})
else:
return render_to_response("public/Registro.html", {"captcha": captcha})
def email(name, subject, mailid, file_path):
email = EmailMessage("Respected, {}!!".format(name), subject, to=[mailid])
email.attach_file(file_path)
email.send()
print("Email Sent")
def execute(self, context):
"""
:param context: Script Context.
:type context: shuup.notify.script.Context
"""
recipient = get_email_list(self.get_value(context, "recipient"))
if not recipient:
context.log(logging.INFO,
"Info! %s: Not sending mail, no recipient.",
self.identifier)
return
send_identifier = self.get_value(context, "send_identifier")
if send_identifier and context.log_entry_queryset.filter(
identifier=send_identifier).exists():
context.log(
logging.INFO,
"Info! %s: Not sending mail, it was already sent (%r).",
self.identifier, send_identifier)
return
languages = [
language for language in [
self.get_value(context, "language"),
self.get_value(context, "fallback_language"),
] if language and language in dict(settings.LANGUAGES).keys()
]
if not languages:
languages = [settings.PARLER_DEFAULT_LANGUAGE_CODE]
strings = self.get_template_values(context, languages)
subject = unescape(strings.get("subject"))
body = unescape(strings.get("body"))
email_template_id = strings.get("email_template")
if email_template_id:
email_template = EmailTemplate.objects.filter(
pk=email_template_id).first()
if email_template and "%html_body%" in email_template.template:
body = email_template.template.replace("%html_body%", body)
content_type = strings.get("content_type")
if not (subject and body):
context.log(
logging.INFO,
"Info! %s: Not sending mail to %s, either subject or body empty.",
self.identifier,
recipient,
)
return
reply_to = get_email_list(self.get_value(context, "reply_to_address"))
from_email = self.get_value(context, "from_email")
bcc = get_email_list(self.get_value(context, "bcc"))
cc = get_email_list(self.get_value(context, "cc"))
subject = " ".join(
subject.splitlines()) # Email headers may not contain newlines
message = EmailMessage(subject=subject,
body=body,
to=recipient,
reply_to=reply_to,
from_email=from_email,
bcc=bcc,
cc=cc)
message.content_subtype = content_type
notification_email_before_send.send(sender=type(self),
action=self,
message=message,
context=context)
message.send()
context.log(logging.INFO, "Info! %s: Mail sent to %s.",
self.identifier, recipient)
notification_email_sent.send(sender=type(self),
message=message,
context=context)
if send_identifier:
context.add_log_entry_on_log_target(
"Info! Email sent to %s: %s" % (recipient, subject),
send_identifier)
def enviar_email(asunto, mensaje, mensaje_html, destinos):
msg = EmailMessage(asunto, mensaje_html, settings.EMAIL_HOST_USER, destinos)
msg.content_subtype = "html"
msg.send()
