def send_message_email(sender, instance, created, **kwargs):
"""
Sends an email to a user when they are sent a message
"""
if not created:
return
# build email
message = render_to_string('messages/email.html', {'message': instance})
ctx = {'body': message,
'title': "myEWB message",
'topic_id': None,
'event': None,
'attachments': None
}
sender = 'myEWB <*****@*****.**>'
user = instance.recipient
if user.get_profile().messages_as_emails and not user.nomail:
send_mail(subject="myEWB private message",
txtMessage=None,
htmlMessage=message,
fromemail=sender,
recipients=[user.email],
context=ctx,
content_object=instance)
def contact():
# validate the form successfully posts data from the user
if request.method == 'POST':
contact_data = request.form.to_dict()
table_name = 'query'
# Database table creation and storage of data
create_contact_table(db, table_name)
# Query the checkbox name copy
for response in request.form.getlist('copy'):
if response == 'yes':
contact_data['copy'] = 'yes'
send_mail(contact_data['email'], contact_data['message'])
update_contact_table(db, table_name, contact_data)
return redirect('/success.html')
# Updates database if copy is unchecked
contact_data['copy'] = 'no'
update_contact_table(db, table_name, contact_data)
return redirect('/success.html')
else:
# Redirects on failed execution
return "Something went wrong"
def notify_topic_subscribers(post):
topic = post.topic
if post != topic.head:
for user in topic.subscribers.all():
if user != post.user:
try:
email_validator.clean(user.email)
except:
#invalid email
continue
old_lang = translation.get_language()
lang = user.get_profile().language or settings.LANGUAGE_CODE
translation.activate(lang)
delete_url = reverse('pybb:delete_subscription', args=[post.topic.id])
current_site = Site.objects.get_current()
subject = render_to_string('pybb/mail_templates/subscription_email_subject.html',
{ 'site': current_site,
'post': post
})
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
message = render_to_string('pybb/mail_templates/subscription_email_body.html',
{ 'site': current_site,
'post': post,
'delete_url': delete_url,
})
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [user.email], fail_silently=True)
translation.activate(old_lang)
def test_blacklisted_emails(self):
with self.settings(MAILER_EMAIL_BACKEND=
"django.core.mail.backends.locmem.EmailBackend"):
now = datetime_now()
obj = DontSendEntry.objects.create(to_address="*****@*****.**",
when_added=now)
self.assertTrue(obj.to_address, "*****@*****.**")
mailer.send_mail("Subject", "GoBody", "*****@*****.**",
["*****@*****.**"])
mailer.send_mail("Subject", "NoGoBody", "*****@*****.**",
["*****@*****.**"])
self.assertEqual(Message.objects.count(), 2)
self.assertEqual(Message.objects.deferred().count(), 0)
engine.send_all()
# All messages are processed
self.assertEqual(Message.objects.count(), 0)
self.assertEqual(Message.objects.deferred().count(), 0)
# but only one should get sent
self.assertEqual(len(mail.outbox), 1)
sent = mail.outbox[0]
# Default "plain text"
self.assertEqual(sent.body, "GoBody")
self.assertEqual(sent.to, ["*****@*****.**"])
def send_activation(email, is_secure):
# import pdb; pdb.set_trace()
this_site = Site.objects.get_current()
# first try to use our views fuction to construct the activation path (deterministic)
# if views didn't reverse to a path, then use named url (less deterministic as it is user configurable)
try:
p = reverse("emailargs.view.email_activate", args=[email.identifier])
except NoReverseMatch:
p = reverse('emailmgr_email_activate',
kwargs={'identifier': email.identifier})
proto = getattr(settings, "DEFAULT_HTTP_PROTOCOL", "")
if not proto:
if is_secure:
proto = "https"
else:
proto = "http"
url = u"%s://%s%s" % (proto, unicode(this_site.domain), p)
context = {
"user": email.user,
"activate_url": url,
"this_site": this_site,
"identifier": email.identifier,
}
subject = "".join(
render_to_string(get_template("emailmgr_activation_subject.txt"),
context).splitlines())
message = render_to_string(get_template("emailmgr_activation_message.txt"),
context)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [email.email])
def test_purge_old_entries(self):
# Send one successfully
with self.settings(MAILER_EMAIL_BACKEND=
"django.core.mail.backends.locmem.EmailBackend"):
mailer.send_mail("Subject", "Body", "*****@*****.**",
["*****@*****.**"])
engine.send_all()
# And one failure
with self.settings(
MAILER_EMAIL_BACKEND="mailer.tests.FailingMailerEmailBackend"):
mailer.send_mail("Subject", "Body", "*****@*****.**",
["*****@*****.**"])
engine.send_all()
Message.objects.retry_deferred()
engine.send_all()
with patch.object(mailer.models, 'datetime_now') as datetime_now_patch:
datetime_now_patch.return_value = datetime_now(
) + datetime.timedelta(days=2)
call_command('purge_mail_log', '1')
self.assertNotEqual(
MessageLog.objects.filter(result=RESULT_FAILURE).count(), 0)
self.assertEqual(
MessageLog.objects.filter(result=RESULT_SUCCESS).count(), 0)
def notify(trap_id, host):
s, e = connect_db()
trap = s.query(Port).filter(Port.id == trap_id).first()
if trap.is_last(s):
# the trap is last in sequence from this host
# so we notify about all the traps in the sequence
traps_raw = trap.getcircuit(s)
traps_for_notification = []
for trap in traps_raw:
if trap.ifName is not None:
# ignore subinterfaces
if '.' not in trap.ifName:
if not trap.is_blocked(s):
traps_for_notification.append(trap)
for trap in traps_raw:
if not trap.is_blocked(s) and trap.is_flapping(s):
trap.block(s)
for trap in traps_raw:
trap.del_from_queue(s)
text_main = for_html_trap_list(traps_for_notification, s)
text_title = for_html_title(traps_for_notification, s)
send_mail(text_title, MAIL_TO, text_main)
logging.info(text_title)
s.close()
def new_message_email(
sender,
instance,
signal,
subject_prefix=_(u"New Message: %(subject)s"),
template_name="django_messages/new_message.html",
default_protocol=None,
*args,
**kwargs
):
"""
This function sends an email and is called via Django's signal framework.
Optional arguments:
``template_name``: the template to use
``subject_prefix``: prefix for the email subject.
``default_protocol``: default protocol in site URL passed to template
"""
if default_protocol is None:
default_protocol = getattr(settings, "DEFAULT_HTTP_PROTOCOL", "http")
if "created" in kwargs and kwargs["created"]:
try:
current_domain = Site.objects.get_current().domain
subject = subject_prefix % {"subject": instance.subject}
message = render_to_string(
template_name, {"site_url": "%s://%s" % (default_protocol, current_domain), "message": instance}
)
from_email = instance.sender.email or settings.DEFAULT_FROM_EMAIL
if instance.recipient.email != "":
send_mail(subject, message, from_email, [instance.recipient.email])
except Exception, e:
# print e
pass # fail silently
def test_retry_deferred(self):
with self.settings(MAILER_EMAIL_BACKEND="mailer.tests.FailingMailerEmailBackend"):
mailer.send_mail("Subject", "Body", "*****@*****.**", ["*****@*****.**"])
engine.send_all()
self.assertEqual(Message.objects.count(), 1)
self.assertEqual(Message.objects.deferred().count(), 1)
self.assertEqual(MessageLog.objects.count(), 1)
with patch.object(mailer.models, 'datetime_now') as datetime_now_patch:
datetime_now_patch.side_effect = lambda: datetime_now() + datetime.timedelta(days=2)
self.assertEquals(MessageLog.objects.purge_old_entries(1), 0)
call_command('purge_mail_log', '1')
self.assertEqual(MessageLog.objects.count(), 1)
with self.settings(MAILER_EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend"):
engine.send_all()
self.assertEqual(len(mail.outbox), 0)
# Should not have sent the deferred ones
self.assertEqual(Message.objects.count(), 1)
self.assertEqual(Message.objects.deferred().count(), 1)
# Now mark them for retrying
Message.objects.retry_deferred()
engine.send_all()
self.assertEqual(len(mail.outbox), 1)
self.assertEqual(Message.objects.count(), 0)
def save(self, domain_override=None, email_template_name='registration/password_reset_email.html',
use_https=False, token_generator=default_token_generator):
"""
Generates a one-use only link for resetting password and sends
it in an email.
"""
for user in self.users_cache:
if not domain_override:
current_site = Site.objects.get_current()
site_name = current_site.name
domain = current_site.domain
else:
site_name = domain = domain_override
c = {
'DEFAULT_EMAIL_FROM': DEFAULT_EMAIL_FROM,
'SITE_URL': domain,
'email': user.email,
'email_to': user.email,
'domain': domain,
'site_name': site_name,
'uid': int_to_base36(user.id),
'user': user,
'token': token_generator.make_token(user),
'protocol': use_https and 'https' or 'http',
}
t = loader.get_template(email_template_name)
text_content = t.render(Context(c))
send_mail(_("Password reset on %s") % site_name, text_content, settings.DEFAULT_EMAIL_FROM, [user.email])
def _handle(self, *args, **kwargs):
stdout_backup = None
if COMMAND_LOG_ROOT and self.OUTPUT_LOG:
pass # redirect output to file, not implemented yet
lock = None
if COMMAND_LOCK_ROOT and (COMMAND_USE_LOCK or self.USE_LOCK):
lock = FileLock(os.path.join(COMMAND_LOCK_ROOT, self.COMMAND_NAME))
try:
lock.acquire(0)
except:
print("Command `%s` already running" % self.COMMAND_NAME)
return
print("\n======\nRunning `%s` command at %s\n======\n" % (self.COMMAND_NAME, str(datetime.now())))
try:
# This call should call handle(...) method in the inherited class, that was renamed to _handle by BaseCommandMeta
self._handle(*args, **kwargs)
except Exception as e:
if COMMAND_HANDLE_EXCEPTIONS or self.HANDLE_EXCEPTIONS:
print("Unexpected crash:")
print(traceback.format_exc())
if (COMMAND_EMAIL_EXCEPTIONS or self.EMAIL_EXCEPTIONS) and not settings.DEBUG:
mailer.send_mail("Command %s crash" % self.COMMAND_NAME, traceback.format_exc(), settings.DEFAULT_FROM_EMAIL, [email for name, email in settings.ADMINS ])
print("Emails were sent to admins of the website about this crash")
else:
raise e
finally:
if lock is not None:
lock.release()
def send_invitations(self, slug):
# TODO: Move to manager
from django.core.urlresolvers import reverse
if "mailer" in settings.INSTALLED_APPS:
from mailer import send_mail
else:
from django.core.mail import send_mail
current_site = Site.objects.get_current()
for email in self.cleaned_data['emails']:
invitation = EmailInvitation.objects.create(user=self.user,
group=self.group,
email=email)
# TODO: Move templates to config class.
url = reverse('usergroups_validate_email_invitation',
args=(slug, self.group.pk, invitation.secret_key))
full_url = 'http://%s%s' % (current_site.domain, url)
subject = render_to_string('usergroups/invitation_subject.txt', {
'user': self.user,
'site': current_site
}).replace('\n', ' ')
message = render_to_string('usergroups/invitation_body.txt', {
'activation_key': invitation.secret_key,
'user': self.user,
'site': current_site,
'group': self.group,
'url': full_url,
})
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [email])
def send(request):
"""
Send the email to the current in-cache query, and redirect out
"""
if request.method == 'POST':
form = EmailForm(request.POST)
if form.is_valid(): # should always be true..!!!
sender = '"%s" <%s>' % (form.cleaned_data['sendername'],
form.cleaned_data['senderemail'])
terms = request.session.get('profilequery', [])
recipients = build_profile_query(terms)
emails = []
for r in recipients:
emails.append(r.user.email)
send_mail(subject=form.cleaned_data['subject'],
txtMessage=None,
htmlMessage=form.cleaned_data['body'],
fromemail=sender,
recipients=emails,
use_template=False)
request.user.message_set.create(message='Email sent')
return HttpResponseRedirect(reverse('profile_query'))
else:
return Http404()
def test_message_log(self):
with self.settings(MAILER_EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend"):
mailer.send_mail("Subject Log", "Body", "*****@*****.**", ["*****@*****.**"])
self.assertEqual(Message.objects.count(), 1)
self.assertEqual(Message.objects.deferred().count(), 0)
self.assertEqual(MessageLog.objects.count(), 0)
engine.send_all()
self.assertEqual(Message.objects.count(), 0)
self.assertEqual(Message.objects.deferred().count(), 0)
self.assertEqual(MessageLog.objects.count(), 1)
log = MessageLog.objects.all()[0]
self.assertEqual(log.email.from_email, "*****@*****.**")
self.assertEqual(log.to_addresses, ["*****@*****.**"])
self.assertEqual(log.subject, "Subject Log")
# Fake a log entry without email
log.message_data = ""
self.assertEqual(log.to_addresses, [])
self.assertEqual(log.subject, "")
def notify_matching_askers(sender, instance, **kwargs):
# TODO: make a nicer HTML email template
ASKER_NOTIFICATION_EMAIL_STRING = """
Bidders have met your asking price for {url}.
If you fix the issue, you may claim the payout by visiting the issue url:
{url}
"""
unnotified_asks = Bid.objects.filter(
url=instance.url,
ask_match_sent=None
).exclude(
ask__lte=0,
)
for bid in unnotified_asks:
if bid.ask_met():
send_mail(
"[codesy] Your ask for %(ask)d for %(url)s has been met" %
(
{'ask': bid.ask, 'url': bid.url}
),
ASKER_NOTIFICATION_EMAIL_STRING.format(url=bid.url),
settings.DEFAULT_FROM_EMAIL,
[bid.user.email]
)
# use .update to avoid recursive signal processing
Bid.objects.filter(id=bid.id).update(ask_match_sent=datetime.now())
def put(self, request, picture_id, *args, **kwargs):
picture = MultiuploaderImage.objects.get(id=picture_id)
picture.is_inappropriate = True
picture.save()
#email to admin
user = request.user
email_body = render_to_string(
'emails/picture_report_email.html', {
'user': user,
'title': 'Picture report',
'site_name': settings.SITE_NAME,
'domain': request.build_absolute_uri(reverse('index')),
'picture_id': picture_id
})
manager_emails = [t[1] for t in settings.MANAGERS]
if "mailer" in settings.INSTALLED_APPS:
send_html_mail("Picture report", email_body, email_body,
settings.DEFAULT_FROM_EMAIL, manager_emails)
else:
send_mail("Picture report", email_body,
settings.DEFAULT_FROM_EMAIL, manager_emails)
return Response({}, status=status.HTTP_200_OK)
def test_message(self):
with self.settings(MAILER_EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend"):
mailer.send_mail("Subject Msg", "Body", "*****@*****.**", ["*****@*****.**"])
self.assertEqual(Message.objects.count(), 1)
self.assertEqual(Message.objects.deferred().count(), 0)
self.assertEqual(MessageLog.objects.count(), 0)
msg = Message.objects.all()[0]
self.assertEqual(msg.email.from_email, "*****@*****.**")
self.assertEqual(msg.to_addresses, ["*****@*****.**"])
self.assertEqual(msg.subject, "Subject Msg")
# Fake a msg stored in DB with invalid data
msg.message_data = ""
self.assertEqual(msg.to_addresses, [])
self.assertEqual(msg.subject, "")
msg.save()
engine.send_all()
self.assertEqual(Message.objects.count(), 0)
self.assertEqual(Message.objects.deferred().count(), 0)
# Delivery should discard broken messages
self.assertEqual(MessageLog.objects.count(), 0)
def register_view(request, template_name='registration.html'):
"""
Form that send registration email to user
"""
context = {}
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
registration = form.save()
context['registration'] = registration
context['email_to'] = registration.email
text_content = render_string(request,
'email/registration.txt',
context)
send_mail('Your Registration is done',
text_content,
DEFAULT_EMAIL_FROM,
[registration.email, ])
return HttpResponseRedirect(reverse('registration_sent'))
else:
# form is invalid
context['register_form'] = form
else:
# no post, user just arrived
context['register_form'] = RegisterForm()
return render_response(request, template_name, context)
def send_confirmation(self, email_address):
salt = sha_constructor(str(random())).hexdigest()[:5]
confirmation_key = sha_constructor(salt + email_address.email).hexdigest()
current_site = Site.objects.get_current()
# check for the url with the dotted view path
try:
path = reverse("emailconfirmation.views.confirm_email",
args=[confirmation_key])
except NoReverseMatch:
# or get path with named urlconf instead
path = reverse(
"emailconfirmation_confirm_email", args=[confirmation_key])
activate_url = u"http://%s%s" % (unicode(current_site.domain), path)
context = {
"user": email_address.user,
"activate_url": activate_url,
"current_site": current_site,
"confirmation_key": confirmation_key,
}
subject = render_to_string(
"emailconfirmation/email_confirmation_subject.txt", context)
# remove superfluous line breaks
subject = "".join(subject.splitlines())
message = render_to_string(
"emailconfirmation/email_confirmation_message.txt", context)
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[email_address.email], priority="high")
return self.create(
email_address=email_address,
sent=datetime.now(),
confirmation_key=confirmation_key)
def notify_topic_subscribers(post):
topic = post.topic
if post != topic.head:
for user in topic.subscribers.all():
if user != post.user:
try:
email_validator.clean(user.email)
except:
#invalid email
continue
old_lang = translation.get_language()
lang = util.get_pybb_profile(
user).language or settings.LANGUAGE_CODE
translation.activate(lang)
delete_url = reverse('pybb:delete_subscription',
args=[post.topic.id])
current_site = Site.objects.get_current()
subject = render_to_string(
'pybb/mail_templates/subscription_email_subject.html', {
'site': current_site,
'post': post
})
# Email subject *must not* contain newlines
subject = ''.join(subject.splitlines())
message = render_to_string(
'pybb/mail_templates/subscription_email_body.html', {
'site': current_site,
'post': post,
'delete_url': delete_url,
})
send_mail(subject,
message,
settings.DEFAULT_FROM_EMAIL, [user.email],
fail_silently=True)
translation.activate(old_lang)
def message_email_notification( message,
template_name="django_messages/new_message.html",
default_protocol=None,
subject_prefix="New message from %s on %s: %s",
*args, **kwargs):
"""
This function sends an email and is called via Django's signal framework.
Optional arguments:
``template_name``: the template to use
``subject_prefix``: prefix for the email subject.
``default_protocol``: default protocol in site URL passed to template
"""
if default_protocol is None:
default_protocol = getattr(settings, 'DEFAULT_HTTP_PROTOCOL', 'http')
try:
thread = message.thread.all()[0]
current_domain = Site.objects.get_current().domain
subject = subject_prefix % (message.sender.username, current_domain, thread.subject)
email_message = render_to_string(template_name, {
'site_url': '%s://%s' % (default_protocol, current_domain),
'site_name': current_domain,
'message': message,
})
recipients = []
for p in thread.participants.exclude(user=message.sender):
if p.user.email:
recipients.append(p.user.email)
if recipients:
send_mail(subject, email_message, settings.DEFAULT_FROM_EMAIL, recipients)
except Exception, e:
# print e
pass #fail silently
def notify_matching_offerers(sender, instance, created, **kwargs):
# Only notify when the claim is first created
if not created:
return True
email_template = get_template('../templates/email/claim_notify.html')
current_site = Site.objects.get_current()
self_Q = models.Q(user=instance.user)
offered0_Q = models.Q(offer=0)
others_bids = Bid.objects.filter(
issue=instance.issue
).exclude(
self_Q | offered0_Q
)
for bid in others_bids:
email_context = ({
'user': instance.user,
'url': instance.issue.url,
'offer': bid.offer,
'site': current_site,
'claim_link': instance.get_absolute_url(),
})
message = email_template.render(email_context)
send_mail(
"[codesy] A claim needs your vote!",
message,
settings.DEFAULT_FROM_EMAIL,
[bid.user.email]
)
def notify_matching_offerers(sender, instance, created, **kwargs):
# Only notify when the claim is first created
if not created:
return True
email_template = get_template('../templates/email/claim_notify.html')
current_site = Site.objects.get_current()
self_Q = models.Q(user=instance.user)
offered0_Q = models.Q(offer=0)
others_bids = Bid.objects.filter(
issue=instance.issue).exclude(self_Q | offered0_Q)
for bid in others_bids:
email_context = ({
'user': instance.user,
'url': instance.issue.url,
'offer': bid.offer,
'site': current_site,
'claim_link': instance.get_absolute_url(),
})
message = email_template.render(email_context)
send_mail("[codesy] A claim needs your vote!", message,
settings.DEFAULT_FROM_EMAIL, [bid.user.email])
def new_message_email(sender, instance, signal,
subject_prefix=_(u'New Message: %(subject)s'),
template_name="django_messages/new_message.html",
default_protocol=None,
*args, **kwargs):
"""
This function sends an email and is called via Django's signal framework.
Optional arguments:
``template_name``: the template to use
``subject_prefix``: prefix for the email subject.
``default_protocol``: default protocol in site URL passed to template
"""
if default_protocol is None:
default_protocol = getattr(settings, 'DEFAULT_HTTP_PROTOCOL', 'http')
if 'created' in kwargs and kwargs['created']:
try:
current_domain = Site.objects.get_current().domain
subject = subject_prefix % {'subject': instance.subject}
message = render_to_string(template_name, {
'site_url': '%s://%s' % (default_protocol, current_domain),
'message': instance,
})
if instance.recipient.email != "":
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[instance.recipient.email,])
except Exception as e:
#print e
pass #fail silently
def notify_approved_claim(sender, instance, created, **kwargs):
claim = instance.claim
votes_needed = claim.offers.count()
if claim.num_rejections == votes_needed:
email_template = get_template('../templates/email/claim_reject.html')
current_site = Site.objects.get_current()
email_context = ({
'url': claim.issue.url,
'site': current_site,
})
message = email_template.render(email_context)
send_mail("[codesy] Your claim has been rejected", message,
settings.DEFAULT_FROM_EMAIL, [claim.user.email])
if votes_needed == claim.num_approvals:
email_template = get_template('../templates/email/claim_approved.html')
current_site = Site.objects.get_current()
email_context = ({
'url': claim.issue.url,
'site': current_site,
})
message = email_template.render(email_context)
send_mail("[codesy] Your claim has been approved", message,
settings.DEFAULT_FROM_EMAIL, [claim.user.email])
def new_message_email(sender, instance, signal,
subject_prefix=_(u'New Message: %(subject)s'),
template_name="django_messages/new_message.html",
default_protocol=None,
*args, **kwargs):
"""
This function sends an email and is called via Django's signal framework.
Optional arguments:
``template_name``: the template to use
``subject_prefix``: prefix for the email subject.
``default_protocol``: default protocol in site URL passed to template
"""
if default_protocol is None:
default_protocol = getattr(settings, 'DEFAULT_HTTP_PROTOCOL', 'http')
if 'created' in kwargs and kwargs['created']:
try:
current_domain = Site.objects.get_current().domain
subject = subject_prefix % {'subject': instance.subject}
message = render_to_string(template_name, {
'site_url': '%s://%s' % (default_protocol, current_domain),
'message': instance,
})
if instance.recipient.email != "":
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL,
[instance.recipient.email,])
except Exception as e:
#print e
pass #fail silently
def feedback(request):
if request.method == "GET":
c = {}
update_context(request, c)
return my_render(request, 'help/feedback.html', c)
elif request.method == "POST":
content = request.POST.get("content", "")
if not content:
request.session["error_message"] = u"피드백 내용을 입력 해 주세요."
return redirect('/help/feedback')
profile = get_profile(request)
if profile:
content = u'"%s (%s)" 님의 피드백.' % (profile.name, profile.email) \
+ "\n\n" + content
# send mail
send_mail(u"코딩도장 피드백이 도착했습니다.",
content,
settings.DEFAULT_FROM_EMAIL,
[settings.ADMINS[0][1]])
request.session["ok_message"] = u"감사합니다. 피드백이 전송되었습니다."
return redirect('/help/feedback')
def ticket_post_save(sender, instance, **kwargs):
print "SIGNAL ticket_post_save:", sender, instance, kwargs
if not kwargs.get('created', False):
return
print "signal new ticket %s" %(instance.pk)
template = loader.get_template('irontickets/email/ticket_new.txt')
subjecttemplate = loader.get_template('irontickets/email/ticket_new_subject.txt')
current_site = Site.objects.get_current()
context = Context({
'ticket': instance,
'site': current_site,
'proto': settings.IT_USE_PROTO,
})
subject = subjecttemplate.render(context)
message = template.render(context)
recipients = instance.recipient_list()
#BUG: fail_silently should be True in production
send_mail(subject, message, '*****@*****.**' %(instance.pk), recipients, fail_silently=False)
def buy_save(request):
book_id = request.POST.get("book_id")
book = Book.objects.get(id=book_id)
if not book.is_sell() or book.price() == 0:
return redirect("/book/%s" % book.id)
form = BuyForm(request.POST)
if not form.is_valid():
request.session["error"] = form
return redirect("/buy/%s" % book_id)
buyer = request.POST.get("buyer")
email = request.POST.get("email")
telno = request.POST.get("telno")
buy = Buy(book=book, buyer=buyer, email=email, telno=telno)
buy.save()
context = {"buy": buy, "book": buy.book}
info = render(request, 'book/buy_info.html', context)
mail_body = info.content
# send to buyer
send_mail(u"%s 님, %s 구매신청이 완료되었습니다" % (buyer, book.subject), mail_body,
settings.DEFAULT_FROM_EMAIL, [buy.email, settings.ADMINS[0][1]])
# # send to admin
# send_mail(u"책 구매 발생: %s" % buy.buyer,
# str(book)+":"+str(buy),
# settings.DEFAULT_FROM_EMAIL,
# [settings.ADMINS[0][1]])
return render(request, 'book/buy_save.html', context)
def test_message(self):
with self.settings(MAILER_EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend"):
mailer.send_mail("Subject Msg", "Body", "*****@*****.**", ["*****@*****.**"])
self.assertEqual(Message.objects.count(), 1)
self.assertEqual(Message.objects.deferred().count(), 0)
self.assertEqual(MessageLog.objects.count(), 0)
msg = Message.objects.all()[0]
self.assertEqual(msg.email.from_email, "*****@*****.**")
self.assertEqual(msg.to_addresses, ["*****@*****.**"])
self.assertEqual(msg.subject, "Subject Msg")
# Fake a msg stored in DB with invalid data
msg.message_data = ""
self.assertEqual(msg.to_addresses, [])
self.assertEqual(msg.subject, "")
msg.save()
with patch("logging.warning") as w:
engine.send_all()
w.assert_called_once()
arg = w.call_args[0][0]
self.assertIn("message discarded due to failure in converting from DB", arg)
self.assertEqual(Message.objects.count(), 0)
self.assertEqual(Message.objects.deferred().count(), 0)
# Delivery should discard broken messages
self.assertEqual(MessageLog.objects.count(), 0)
def feedback(request):
page_id = request.POST.get("page_id")
print "page_id:%s" % page_id
email = request.POST.get("email")
page = Page.objects.get(id=page_id)
content = u"""%(email)s 님이 전송한 피드백입니다.
----------------------------------------------------------------
책제목 : %(book_subject)s
페이지 : %(page_subject)s
%(feedback)s
----------------------------------------------------------------
※ 이 메일은 발신전용 메일입니다. 답장은 %(email)s 님에게 남겨주세요.
""" % {
"feedback": request.POST.get("feedback"),
"email": email,
"book_subject": page.book.subject,
"page_subject": page.subject,
}
author_emails = []
for user in page.book.user.all():
author_emails.append(user.email)
# send to buyer
send_mail(u"위키독스 피드백이 도착했습니다 : [%s]" % page.subject, content,
settings.DEFAULT_FROM_EMAIL, author_emails)
return HttpResponse("ok")
def adm_send_mail(to_email, subject, message, force=False, priority='medium'):
if settings.EMAIL_SENDER == '':
sender = admin_email()
else:
sender = settings.EMAIL_SENDER
send_real_email = True
try:
if settings.FAKE_SENDING_EMAIL:
send_real_email = False
except:
pass
if send_real_email:
send_mail(subject,
message,
sender, [to_email],
fail_silently=True,
priority=priority)
else:
print 'Does not send email'
print 'Message:'
print message
def alert_user():
# Users Needing Alerts.
ualert = Alert.objects.filter(
need_to_alert=True).values('user_id').distinct()
for user in ualert:
user_alerts = Alert.objects.filter(user_id=user['user_id'],
need_to_alert=True)
msg = "New Fire Detected \n"
if user_alerts.count() > 1:
msg = f"{user_alerts.count()} New Fires Detected \n"
i = 1
for fire in user_alerts:
source = "GOES Satellite"
url_info = ""
if fire.cal_fire_incident_id is not None:
cal_fire_obj = CAfire.objects.filter(
incident_id=fire.cal_fire_incident_id)
source = "Cal Fire"
url_info = cal_fire_obj[0].incident_url
msg = msg + f"Fire #{i} is {int(fire.dist_to_fire)} miles from {fire.closest_saved_location} \n" \
f"Source: {source} \n\n"
i += 1
# SEND EMAIL FOR THIS USER HERE
print("Sending Email...")
mailer.send_mail(None, msg)
# PUT: "CURRENT WINDS, HUMIDITY, FIRE_SPREAD_RATE" AT SOURCE
user_alerts.update(need_to_alert=False)
print("Email Sent!")
return
def feedback(request):
if request.method == 'POST':
username = request.POST.get('feedback-username', None)
visiblename = request.POST.get('feedback-visiblename', None)
systememail = request.POST.get('feedback-email-h', None)
email = request.POST.get('feedback-email', None)
text = request.POST.get('feedback-text', None)
category = request.POST.get('feedback-category', None)
pagename = request.POST.get('feedback-path', None)
body = """myEWB 1.5 feedback received!
Category: %s
From: %s
Page: http://my.ewb.ca%s
Feeback:
%s
""" % (category, email, pagename, text)
send_mail(subject="myEWB feedback (%s)" % category,
txtMessage=body,
htmlMessage=None,
fromemail=email,
recipients=["*****@*****.**"],
use_template=False)
return HttpResponse("thanks")
def iauction_post_bid(request):
if request.method == "POST":
try:
product_id = request.POST["product_id"]
amount = int(request.POST["amount"])
anonymous = (request.POST["anonymous"] == "true")
product = AuctionProduct.objects.get(pk=product_id)
if amount > request.user.egghead.bidding_credits():
return HttpResponse("1") # Error code 1: Not enough credit
elif amount <= product.current_price():
return HttpResponse(
"2") # Error code 2: Bid less than current price
time_stamp = datetime.now()
if not product.status == "A" or time_stamp > product.end_time:
product.expire()
return HttpResponse(
"3") # Error code 3: Bid later than expiration time
# All previous bids must be cleared first
for fca in AuctionFreezeCredit.objects.filter(bid__product=product,
ftype="F",
app="A",
ttype="BI",
cleared=False):
fca.unfreeze()
if not fca.bid.bidder == request.user:
recipients = (fca.bid.bidder, )
current_site = Site.objects.get_current()
# subject = "[ " + current_site.name + " ] " + "You got outbid"
subject = u"[ %s ] %s" % (current_site.name,
_("You got outbid"))
t = loader.get_template("iauction/email_outbid.txt")
c = Context({
"bid": fca.bid,
"leading": amount,
"current_site": current_site,
})
send_mail(subject, t.render(c),
settings.DEFAULT_FROM_EMAIL,
verified_emails(recipients))
bid = AuctionBid(product=product,
bidder=request.user,
amount=amount,
time_stamp=time_stamp,
anonymous=anonymous,
win=False)
bid.save()
fca = AuctionFreezeCredit(time_stamp=time_stamp,
fuser=request.user,
ftype="F",
app="A",
ttype="BI",
amount=amount,
cleared=False,
bid=bid)
fca.save()
return HttpResponse("0")
except Exception, e:
alogger.warning(e)
def send_invitation(request):
if request.method == 'POST':
invitation_form = InvitationForm(request.POST)
if invitation_form.is_valid():
data = invitation_form.cleaned_data
invitation = ConferenceInvitation(
sender=ConferenceProfile.objects.get(member_profile__user=invitation_form.sender),
receiver=ConferenceProfile.objects.get(member_profile__user=invitation_form.recipient),
)
invitation.save()
body = data['body']
matches = URL_RE.findall(body)
for m in matches:
url = m.split('?') # split on querystring
# apologies for the cryptic list comprehension below. it basically splits
# the qs on &'s and then removes any blank values from trailing &'s or a
# trailing ? on the url with no other qs components.
qs = len(url) > 1 and [p for p in url[1].split('&') if p] or [] # split up the querystring into its parts
qs.append('i=%s' % invitation.code) # add the invitation to the qs
url = '%s?%s' % (url[0], '&'.join(qs)) # remake the url
body = body.replace(m, url) # make the replacement in the body
send_mail(subject=data['subject'],
txtMessage=body,
htmlMessage=None,
fromemail=invitation_form.sender_email,
recipients=[invitation_form.recipient.email,],
use_template=False
)
return HttpResponse('Invitation sent to %s.' % invitation_form.recipient.get_profile().name)
else:
return HttpResponseBadRequest('Sending mail failed: %s' % " ".join(["%s: %s." % (k, v) for k, v in invitation_form.errors.items()]))
else:
return HttpResponseBadRequest('Sending email requires a POST method')
def send_invitation(self, from_user, to_email, message=None):
contact, _ = Contact.objects.get_or_create(email=to_email, owner=from_user)
contact.type = "I"
contact.save()
salt = sha_constructor(str(random())).hexdigest()[:5]
confirmation_key = sha_constructor(salt + to_email).hexdigest()
accept_url = u"http://%s%s" % (
unicode(Site.objects.get_current()),
reverse("friends_accept_join", args=(confirmation_key,)),
)
ctx = {
"SITE_NAME": unicode(Site.objects.get_current()),
"CONTACT_EMAIL": settings.CONTACT_EMAIL,
"contact": contact,
"user": from_user,
"message": message,
"accept_url": accept_url,
}
subject = render_to_string("friends/join_invite_subject.txt", ctx)
email_message = render_to_string("friends/join_invite_message.txt", ctx)
send_mail(subject, email_message, settings.DEFAULT_FROM_EMAIL, [to_email])
return self.create(
from_user=from_user, contact=contact, message=message, status="2", confirmation_key=confirmation_key
)
def post(self, request):
email = request.POST.get('email')
context = {'values': request.POST}
if not validate_email(email):
messages.error(request, 'Please supply a valid email')
return render(request, 'mail/reset_password.html', context)
current_site = get_current_site(request)
user = User.objects.filter(email=email)
if user.exists():
email_subject = '[Reset your Password]'
message = render_to_string(
'mail/reset_mail.html', {
'domain': current_site.domain,
'uid': urlsafe_base64_encode(force_bytes(user[0].pk)),
'token': PasswordResetTokenGenerator().make_token(user[0])
})
send_mail(subject=email_subject,
message='',
from_email=DEFAULT_FROM_EMAIL,
recipient_list=[email],
html_message=message)
messages.success(
request, 'We have sent you an email to reset your password')
return render(request, 'mail/reset_password.html')
def demultiplex_stats(investigator_dict, demultiplex_dir, bcldir):
conf = read_config()
my_env = os.environ.copy()
dmx_stats = conf["demultiplex"]["dmx_stats"]
samplesheet_path = f"{bcldir}/SampleSheet.csv"
dmx_stats_results = f"{demultiplex_dir}/{os.path.basename(demultiplex_dir)}_demultiplex_stats.tsv"
if not os.path.isfile(dmx_stats_results):
dmx_stats_args = [dmx_stats, samplesheet_path, demultiplex_dir]
subprocess.call(dmx_stats_args, shell=False, env=my_env)
email_list = []
for key in investigator_dict:
email_list.append(investigator_dict[key].email)
attachment = dmx_stats_results
mailsubject = f"Demultiplex report: {os.path.basename(demultiplex_dir)}"
mailbody = f"""
Demultiplexing of {os.path.basename(demultiplex_dir)} is complete. The report is attached in this mail.
If you have any question you can reach us at:
[email protected]
Or reply to this email.
Kind regards,
/Clinical Genomics Göteborg\n\n
"""
send_mail(mailsubject, mailbody, attachment, email_list)
def start():
if 'email' not in request.form:
return abort(400)
email = request.form['email']
if not validate_email(email):
return abort(422)
email = email.lower()
user = User.query.filter_by(email=email).first()
if user:
template = 'mail/login.html'
else:
user = User(email)
db.session.add(user)
db.session.commit()
template = 'mail/start.html'
link = url_for('ui.login', login_token=user.login_token, _external=True)
send_mail(
sender_domain = current_app.config['SERVER_NAME'],
sender_name = 'Varmail Login',
sender_account = 'login',
recipient = email,
subject = 'Get started with varmail',
html=render_template(template, link=link)
)
return render_template('web/start.html')
def adm_send_mail(to_email, subject, message, force=False):
if settings.EMAIL_SENDER=='':
sender = admin_email()
else:
sender = settings.EMAIL_SENDER
send_real_email = True
try:
if settings.FAKE_SENDING_EMAIL:
send_real_email = False
except:
pass
if send_real_email:
send_mail(subject,
message,
sender,
[ to_email ],
fail_silently=True)
else:
print 'Does not send email'
print 'Message:'
print message
def send_message_email(sender, instance, created, **kwargs):
"""
Sends an email to a user when they are sent a message
"""
if not created:
return
# build email
message = render_to_string('messages/email.html', {'message': instance})
ctx = {'body': message,
'title': "myEWB message",
'topic_id': None,
'event': None,
'attachments': None
}
sender = 'myEWB <*****@*****.**>'
user = instance.recipient
if user.get_profile().messages_as_emails and not user.nomail:
send_mail(subject="myEWB private message",
txtMessage=None,
htmlMessage=message,
fromemail=sender,
recipients=[user.email],
context=ctx)
def send_confirmation(self, email_address):
salt = sha_constructor(str(random())).hexdigest()[:5]
confirmation_key = sha_constructor(salt +
email_address.email).hexdigest()
current_site = Site.objects.get_current()
# check for the url with the dotted view path
try:
path = reverse("emailconfirmation.views.confirm_email",
args=[confirmation_key])
except NoReverseMatch:
# or get path with named urlconf instead
path = reverse("emailconfirmation_confirm_email",
args=[confirmation_key])
activate_url = u"http://%s%s" % (unicode(current_site.domain), path)
context = {
"user": email_address.user,
"activate_url": activate_url,
"current_site": current_site,
"confirmation_key": confirmation_key,
}
subject = render_to_string(
"emailconfirmation/email_confirmation_subject.txt", context)
# remove superfluous line breaks
subject = "".join(subject.splitlines())
message = render_to_string(
"emailconfirmation/email_confirmation_message.txt", context)
send_mail(subject,
message,
settings.DEFAULT_FROM_EMAIL, [email_address.email],
priority="high")
return self.create(email_address=email_address,
sent=datetime.now(),
confirmation_key=confirmation_key)
def confirm_email(request, confirmation_key):
confirmation_key = confirmation_key.lower()
email_address = EmailConfirmation.objects.confirm_email(confirmation_key)
# this only runs if it's a new user confirming their first email address
if email_address and email_address.user.email == email_address.email:
email_address.user.message_set.create(message='Your email address has been confirmed!')
email_address.user.backend = "django.contrib.auth.backends.ModelBackend"
auth_login(request, email_address.user)
c = Context({})
htmlmessage = loader.get_template("emailconfirmation/welcome.html")
htmlbody = htmlmessage.render(c)
txtmessage = loader.get_template("emailconfirmation/welcome.txt")
txtbody = txtmessage.render(c)
send_mail(subject='Welcome to myEWB!',
txtMessage=txtbody,
htmlMessage=htmlbody,
fromemail='Francis Kung <*****@*****.**>',
recipients=[email_address.email],
use_template=False)
return HttpResponseRedirect(reverse('home'))
return render_to_response("emailconfirmation/confirm_email.html", {
"email_address": email_address,
}, context_instance=RequestContext(request))
def send_invitations(self, slug):
# TODO: Move to manager
from django.core.urlresolvers import reverse
if "mailer" in settings.INSTALLED_APPS:
from mailer import send_mail
else:
from django.core.mail import send_mail
current_site = Site.objects.get_current()
for email in self.cleaned_data['emails']:
invitation = EmailInvitation.objects.create(user=self.user,
group=self.group,
email=email)
# TODO: Move templates to config class.
url = reverse('usergroups_validate_email_invitation',
args=(slug, self.group.pk, invitation.secret_key))
full_url = 'http://%s%s' % (current_site.domain, url)
subject = render_to_string('usergroups/invitation_subject.txt', {
'user': self.user,
'site': current_site
}).replace('\n', ' ')
message = render_to_string(
'usergroups/invitation_body.txt', {
'activation_key': invitation.secret_key,
'user': self.user,
'site': current_site,
'group': self.group,
'url': full_url,
})
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [email])
def contactView(request):
if request.method == 'GET':
form = ContactForm()
return render(request, "contact_form.html", {'form': form})
else:
if request.user.is_authenticated:
post = request.POST.copy()
post['from_email'] = request.user.email
else:
post = request.POST.copy()
form = ContactForm(post)
if form.is_valid():
from_email = form.cleaned_data['from_email']
message = form.cleaned_data['message']
# subject = f"{[from_email]} { form.cleaned_data['subject']}"
subject = form.cleaned_data['subject']
try:
send_mail(subject,
message,
from_email, [DEFAULT_FROM_MAIL],
fail_silently=False)
messages.success(request,
'Success! Thank you for your message.')
except BadHeaderError:
return HttpResponse('Invalid header found.')
return redirect('contact')
def test_message(self):
with self.settings(MAILER_EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend"):
mailer.send_mail("Subject Msg", "Body", "*****@*****.**", ["*****@*****.**"])
self.assertEqual(Message.objects.count(), 1)
self.assertEqual(Message.objects.deferred().count(), 0)
self.assertEqual(MessageLog.objects.count(), 0)
msg = Message.objects.all()[0]
self.assertEqual(msg.email.from_email, "*****@*****.**")
self.assertEqual(msg.to_addresses, ["*****@*****.**"])
self.assertEqual(msg.subject, "Subject Msg")
# Fake a msg stored in DB with invalid data
msg.message_data = ""
self.assertEqual(msg.to_addresses, [])
self.assertEqual(msg.subject, "")
msg.save()
with patch("logging.warning") as w:
engine.send_all()
w.assert_called_once()
arg = w.call_args[0][0]
self.assertIn("message discarded due to failure in converting from DB", arg)
self.assertEqual(Message.objects.count(), 0)
self.assertEqual(Message.objects.deferred().count(), 0)
# Delivery should discard broken messages
self.assertEqual(MessageLog.objects.count(), 0)
def send(request):
"""
Send the email to the current in-cache query, and redirect out
"""
if request.method == 'POST':
form = EmailForm(request.POST)
if form.is_valid(): # should always be true..!!!
sender = '"%s" <%s>' % (form.cleaned_data['sendername'],
form.cleaned_data['senderemail'])
terms = request.session.get('profilequery', [])
recipients = build_profile_query(terms)
emails = []
for r in recipients:
emails.append(r.user.email)
send_mail(subject=form.cleaned_data['subject'],
txtMessage=None,
htmlMessage=form.cleaned_data['body'],
fromemail=sender,
recipients=emails,
use_template=False)
request.user.message_set.create(message='Email sent')
return HttpResponseRedirect(reverse('profile_query'))
else:
return Http404()
def letters_form(request):
success = False
if request.method == 'POST':
form = LetterForm(request.POST, request.FILES)
if form.is_valid():
letter = form.save()
success = True
if letter.email:
send_mail(
subject=u'%s%s' % (settings.EMAIL_SUBJECT_PREFIX,
u'Обращения граждан'),
message=render_to_string('letter_notify_success.txt',
{'letter': letter}),
recipient_list=[letter.email],
from_email=settings.DEFAULT_FROM_EMAIL,
)
else:
form = LetterForm(initial={
'region': get_region().id,
'reply_by_email': True
})
return render(request, 'letters_form.html', {
'form': form,
'success': success
})
def submit_contact_form(request):
if request.method == "POST":
post = request.POST
user = request.user
name = ""
email = ""
subject_f = post['subject']
message = post['message']
if user.is_authenticated():
name = user.get_full_name()
email = user.email
else:
name = post['name']
email = post['email']
subject = "Dr.Derma - Contato de usuario (%s - %s)" % (name, subject_f)
body = """Dr.Derma - Contato de usuario (%s)\n
Usuario: %s\n
Email: %s\n
Assunto: %s\n
Mensagem: %s""" % (subject_f, name, email, subject_f, message)
sender = "%s" % email
to = [settings.CONTACT_CENTER]
send_mail(subject, body, sender, to)
success = _(u"Seu contato foi feito com sucesso. Tentaremos retornar o contato o mais breve possivel. Obrigado!")
return render_to_response("message.html", {"success": success}, context_instance=RequestContext(request))
else:
error = _(u"Método de acesso inválido.")
return render_to_response("message.html", {"error": error}, context_instance=RequestContext(request))
def form(request):
if request.method == "POST":
form = ContactForm(request.POST)
if form.is_valid():
new_data = form.cleaned_data
t = loader.get_template('shop/email/contact_us.txt')
c = Context({
'request_type': new_data['inquiry'],
'name': new_data['name'],
'email': new_data['sender'],
'request_text': new_data['contents'] })
subject = new_data['subject']
shop_config = Config.objects.get_current()
shop_email = shop_config.store_email
if not shop_email:
log.warn('No email address configured for the shop. Using admin settings.')
shop_email = settings.ADMINS[0][1]
try:
body = t.render(c)
send_mail(subject, body, shop_email,
[shop_email], fail_silently=False)
except SocketError, e:
if settings.DEBUG:
log.error('Error sending mail: %s' % e)
log.warn('Ignoring email error, since you are running in DEBUG mode. Email was:\nTo:%s\nSubject: %s\n---\n%s', shop_email, subject, body)
else:
log.fatal('Error sending mail: %s' % e)
raise IOError('Could not send email. Please make sure your email settings are correct and that you are not being blocked by your ISP.')
url = urlresolvers.reverse('satchmo_contact_thanks')
return http.HttpResponseRedirect(url)
def test_message_log(self):
with self.settings(MAILER_EMAIL_BACKEND=
"django.core.mail.backends.locmem.EmailBackend"):
mailer.send_mail("Subject Log", "Body", "*****@*****.**",
["*****@*****.**"])
self.assertEqual(Message.objects.count(), 1)
self.assertEqual(Message.objects.deferred().count(), 0)
self.assertEqual(MessageLog.objects.count(), 0)
engine.send_all()
self.assertEqual(Message.objects.count(), 0)
self.assertEqual(Message.objects.deferred().count(), 0)
self.assertEqual(MessageLog.objects.count(), 1)
log = MessageLog.objects.all()[0]
self.assertEqual(log.email.from_email, "*****@*****.**")
self.assertEqual(log.to_addresses, ["*****@*****.**"])
self.assertEqual(log.subject, "Subject Log")
# Fake a log entry without email
log.message_data = ""
self.assertEqual(log.to_addresses, [])
self.assertEqual(log.subject, "")
def notify_topic_subscribers(post):
from djangobb_forum.models import Post
topic = post.topic
post_body_text = strip_tags(post.body_html)
if post != topic.head:
for user in topic.subscribers.all():
if user != post.user:
subject = u'RE: %s' % topic.name
to_email = user.email
text_content = TOPIC_SUBSCRIPTION_TEXT_TEMPLATE % {
'username':
post.user.username,
'message':
post_body_text,
'post_url':
absolute_url(post.get_absolute_url()),
'unsubscribe_url':
absolute_url(
reverse('djangobb:forum_delete_subscription',
args=[post.topic.id])),
}
#html_content = html_version(post)
send_mail(subject, text_content, settings.DEFAULT_FROM_EMAIL,
[to_email])
def new_message_email(sender,
instance,
signal,
subject_prefix=_(u'New Message: %(subject)s'),
template_name="messages/new_message.html",
*args,
**kwargs):
"""
This function sends an email and is called via Django's signal framework.
Optional arguments:
``template_name``: the template to use
``subject_prefix``: prefix for the email subject.
"""
if 'created' in kwargs and kwargs['created']:
try:
current_domain = Site.objects.get_current().domain
subject = subject_prefix % {'subject': instance.subject}
message = render_to_string(template_name, {
'site_url': 'http://%s' % current_domain,
'message': instance,
})
if instance.recipient.email != "":
send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [
instance.recipient.email,
])
except Exception, e:
#print e
pass #fail silently
def send_mail_to_members(self, subject, htmlBody,
fail_silently=False, sender=None,
context=None):
"""
Creates and sends an email to all members of a network using Django's
EmailMessage.
Takes in a a subject and a message and an optional fail_silently flag.
Automatically sets:
from_email: the sender param, or group_name <*****@*****.**>
(note, NO validation is done on "sender" - it is assumed clean!!)
to: [email protected]
bcc: list of member emails
"""
if sender == None:
sender = '%s <*****@*****.**>' % (self.name, self.slug)
lang = 'en'
try:
# is there a cleaner way to do this???!!!
if self.network.chapter_info.francophone:
lang = 'fr'
except:
pass
send_mail(subject=subject,
txtMessage=None,
htmlMessage=htmlBody,
fromemail=sender,
recipients=self.get_member_emails(),
context=context,
shortname=self.slug,
lang=lang)
def send_invitation(self, from_user, to_email, message):
contact, created = Contact.objects.get_or_create(email=to_email,
user=from_user)
salt = sha_constructor(str(random())).hexdigest()[:5]
confirmation_key = sha_constructor(salt + to_email).hexdigest()
accept_url = u"http://%s%s" % (
unicode(Site.objects.get_current()),
reverse("friends_accept_join", args=(confirmation_key, )),
)
ctx = {
"SITE_NAME": settings.SITE_NAME,
"CONTACT_EMAIL": settings.CONTACT_EMAIL,
"user": from_user,
"message": message,
"accept_url": accept_url,
}
subject = render_to_string("friends/join_invite_subject.txt", ctx)
email_message = render_to_string("friends/join_invite_message.txt",
ctx)
send_mail(subject, email_message, settings.DEFAULT_FROM_EMAIL,
[to_email])
return self.create(from_user=from_user,
contact=contact,
message=message,
status="2",
confirmation_key=confirmation_key)
def test_blacklisted_emails(self):
with self.settings(MAILER_EMAIL_BACKEND="django.core.mail.backends.locmem.EmailBackend"):
now = datetime_now()
obj = DontSendEntry.objects.create(to_address="*****@*****.**", when_added=now)
self.assertTrue(obj.to_address, "*****@*****.**")
mailer.send_mail("Subject", "GoBody", "*****@*****.**", ["*****@*****.**"])
mailer.send_mail("Subject", "NoGoBody", "*****@*****.**", ["*****@*****.**"])
self.assertEqual(Message.objects.count(), 2)
self.assertEqual(Message.objects.deferred().count(), 0)
engine.send_all()
# All messages are processed
self.assertEqual(Message.objects.count(), 0)
self.assertEqual(Message.objects.deferred().count(), 0)
# but only one should get sent
self.assertEqual(len(mail.outbox), 1)
sent = mail.outbox[0]
# Default "plain text"
self.assertEqual(sent.body, "GoBody")
self.assertEqual(sent.to, ["*****@*****.**"])
def comment_post_save(sender, instance, **kwargs):
return #BUG: Unfinished
print "SIGNAL comment_post_save:", sender, instance, kwargs
# if not kwargs.get('created', False):
# return
print "signal new comment %s" %(instance.pk)
template = loader.get_template('irontickets/email/ticket_comment_new.txt')
subjecttemplate = loader.get_template('irontickets/email/ticket_comment_new_subject.txt')
current_site = Site.objects.get_current()
#BUG: Docs say this should return the ticket object, but it returns None.
ticket = instance.content_object
context = Context({
'comment': instance,
'ticket': ticket,
'site': current_site,
'proto': settings.IT_USE_PROTO,
})
subject = subjecttemplate.render(context)
message = template.render(context)
recipients = instance.recipient_list()
#BUG: fail_silently should be True in production
send_mail(subject, message, '*****@*****.**' %(instance.pk), recipients, fail_silently=False)
def send_email():
user_name = twitter.token["screen_name"]
id = request.form["id"]
udhaar = get_udhaar(id)[0]
user = get_user_mail_and_name(user_name)[0]
send_mail(udhaar["name"],udhaar["email"],udhaar["amount"],user["email"],user["name"])
return "Okay"
