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