def send_email(email_to: str, subject_template="", html_template="", environment=None) -> Union[SMTPResponse, bool]: if environment is None: environment = {} assert config.EMAILS_ENABLED, "no provided configuration for email variables" message = emails.Message( subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(config.EMAILS_FROM_NAME, config.EMAILS_FROM_EMAIL), ) smtp_options = {"host": config.SMTP_HOST, "port": config.SMTP_PORT} if config.SMTP_TLS: smtp_options["tls"] = True if config.SMTP_USER: smtp_options["user"] = config.SMTP_USER if config.SMTP_PASSWORD: smtp_options["password"] = config.SMTP_PASSWORD try: response = message.send(to=email_to, render=environment, smtp=smtp_options) assert response.status_code == 250 logging.info(f"Send email result: {response}") except SMTPException as error: logging.error(f"Error while trying to send email: {error}") return False except AssertionError: logging.error(f"Failed to send email, send email result: {response}") return False return response
def send_email(email_to: str, subject_template="", html_template="", environment={}): if not settings.EMAILS_ENABLED: if settings.EMAIL_TESTING: logging.info("\nMessage: " + subject_template + "\nSent to: " + email_to) return raise HTTPException(status_code=HTTP_403_FORBIDDEN, detail="Emails not enabled.") message = emails.Message( subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(settings.EMAILS_FROM_NAME, settings.EMAILS_FROM_EMAIL), ) smtp_options = {"host": settings.SMTP_HOST, "port": settings.SMTP_PORT} if settings.SMTP_TLS: smtp_options["tls"] = True if settings.SMTP_USER: smtp_options["user"] = settings.SMTP_USER if settings.SMTP_PASSWORD: smtp_options["password"] = settings.SMTP_PASSWORD response = message.send(to=email_to, render=environment, smtp=smtp_options) logging.info(f"send email result: {response}")
def send_email( email_to: str, subject_template: str = "", html_template: str = "", environment: Dict[str, Any] = {}, ) -> None: assert current_app.config[ "EMAILS_ENABLED"], "no provided configuration for email variables" message = emails.Message( subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(current_app.config["EMAILS_FROM_NAME"], current_app.config["EMAILS_FROM_EMAIL"]), ) smtp_options = { "host": current_app.config["MAIL_SERVER"], "port": current_app.config["MAIL_PORT"] } if current_app.config["MAIL_USE_TLS"]: smtp_options["tls"] = True if current_app.config["MAIL_USERNAME"]: smtp_options["user"] = current_app.config["MAIL_USERNAME"] if current_app.config["MAIL_PASSWORD"]: smtp_options["password"] = current_app.config["MAIL_PASSWORD"] response = message.send(to=email_to, render=environment, smtp=smtp_options) logging.info(f"send email result: {response}")
def send_email( email_to: str, subject_template: str = "", html_template: str = "", environment: Dict[str, Any] = {}, ) -> None: assert settings.EMAILS_ENABLED, "no provided configuration for email variables" message = emails.Message( subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(settings.EMAILS_FROM_NAME, settings.EMAILS_FROM_EMAIL), ) smtp_options = {"host": settings.SMTP_HOST, "port": settings.SMTP_PORT} if settings.SMTP_TLS: smtp_options["tls"] = True if settings.SMTP_SSL: smtp_options["ssl"] = True if settings.SMTP_USER: smtp_options["user"] = settings.SMTP_USER if settings.SMTP_PASSWORD: smtp_options["password"] = settings.SMTP_PASSWORD response = message.send(to=email_to, render=environment, smtp=smtp_options) print(response) logging.info(f"send email result: {response}")
def send_email(email_to: str, subject_template: str = "", html_template: str = "", environment: Dict[str, Any] = {}) -> None: message = emails.Message(subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(None, None)) smtp_options = {"host": config.SMTP_HOST, "port": config.SMTP_PORT} response = message.send(to=email_to, render=environment, smtp=smtp_options) logging.info(f"send email result: {response}")
def send_email(email_to: str, subject_template='', html_template='', context: dict = {}): assert settings.EMAILS_ENABLED, 'please configure email backend to send emails' message = emails.Message(subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(settings.EMAIL_FROM_NAME, settings.EMAIL_FROM_EMAIL)) smtp_options = {'host': settings.SMTP_HOST, 'port': settings.SMTP_PORT, 'user': settings.EMAIL_HOST_USER, 'password': settings.EMAIL_HOST_PASSWORD} if settings.SMTP_TLS: smtp_options['tls'] = True message.send(email_to, render=context, smtp=smtp_options)
def render_email_template(results): """Return populated text that can be sent as an email summary of the item/location results. Inputs: results (dict) -- Two-dimensional dictionary containing search keywords (keys) and location search results (key, value pairs). Returns: str -- Summary of results in HTML format. """ with open( 'ebay_multilocation_item_notifier/templates/notification-email.html' ) as fp: template = JinjaTemplate(fp.read()) return template.render(results=results)
def send_email(email_to: str, subject_template="", html_template="", environment={}): assert config.EMAILS_ENABLED, "no provided configuration for email variables" message = emails.Message( subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(config.EMAILS_FROM_NAME, config.EMAILS_FROM_EMAIL), ) smtp_options = {"host": config.SMTP_HOST, "port": config.SMTP_PORT} if config.SMTP_TLS: smtp_options["tls"] = True if config.SMTP_USER: smtp_options["user"] = config.SMTP_USER if config.SMTP_PASSWORD: smtp_options["password"] = config.SMTP_PASSWORD response = message.send(to=email_to, render=environment, smtp=smtp_options) logging.info(f"send email result: {response}")
def test_render_message_with_template(): TEMPLATE = JinjaTemplate('Hello, {{name}}!') V = dict(name='world') RESULT = TEMPLATE.render(**V) assert RESULT == 'Hello, world!' msg = emails.html(subject=TEMPLATE) msg.render(**V) assert msg.subject == RESULT msg = emails.html(html=TEMPLATE) msg.render(**V) assert msg.html_body == RESULT msg = emails.html(text=TEMPLATE) msg.render(**V) assert msg.text_body == RESULT
def _build_message() -> Message: with _EMAIL_TEMPLATE.open("r") as _: template = _.read() return emails.html( subject=params.email.subject, mail_from=str(params.email.sender), html=JinjaTemplate(template), )
def send_email(email_to: str, subject_template: str = "", html_template: str = "", environment: Dict[str, Any] = {}) -> None: assert settings.EMAIL_ENABLED, "no provided configuration for email variables" message = emails.Message(subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(settings.EMAIL_FROM_NAME, settings.EMAIL_FROM_ADDRESS)) smtp_options = {"host": settings.SMTP_HOST, "port": settings.SMTP_PORT} if settings.SMTP_TLS: smtp_options["tls"] = True if settings.SMTP_USER: smtp_options["user"] = settings.SMTP_USER if settings.SMTP_PASSWORD: smtp_options["password"] = settings.SMTP_PASSWORD message.send(to=email_to, render=environment, smtp=smtp_options)
async def send_mail(self, to: str, subject: str = "", template: str = "", environment: Any = {}) -> None: """ [Send] Метод, отвечающий за отправку сообщения по почте. Только и всего. """ message = emails.Message( subject=JinjaTemplate(subject), html=JinjaTemplate(template), mail_from=("Untername0", email_config.DEFAULT_FROM_EMAIL)) settings = { "host": email_config.EMAIL_HOST, "port": email_config.EMAIL_PORT, "user": email_config.EMAIL_HOST_USER, "password": email_config.EMAIL_HOST_PASSWORD, "tls": email_config.EMAIL_USE_TLS} response = message.send(to=to, render=environment, smtp=settings) assert response.status_code == 250
def send_email( email_to: str, subject_template: str = "", html_template: str = "", text_template: str = "", environment: Dict[str, Any] = {}, ) -> None: message = emails.Message( subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), text=JinjaTemplate(text_template), mail_from=(settings.EMAILS_FROM_NAME, settings.EMAILS_FROM_EMAIL), ) smtp_options = {"host": settings.SMTP_HOST, "port": settings.SMTP_PORT} if settings.SMTP_TLS: smtp_options["tls"] = True if settings.SMTP_USER: smtp_options["user"] = settings.SMTP_USER if settings.SMTP_PASSWORD: smtp_options["password"] = settings.SMTP_PASSWORD response = message.send(to=email_to, render=environment, smtp=smtp_options) logging.info(f"send email result: {response}")
def test_templates_commons(): JINJA_TEMPLATE = "Hello, {{name}}!" STRING_TEMPLATE = "Hello, $name!" MAKO_TEMPLATE = "Hello, ${name}!" RESULT = "Hello, world!" values = {'name': 'world'} assert JinjaTemplate(JINJA_TEMPLATE).render(**values) == RESULT assert StringTemplate(STRING_TEMPLATE).render(**values) == RESULT assert MakoTemplate(MAKO_TEMPLATE).render(**values) == RESULT
def send_email( email_to: str, subject_template: str = "", html_template: str = "", environment: Dict[str, Any] = {}, ): # print(">>> send_email > settings : ...") # pp.pprint(settings.dict()) assert settings.EMAILS_ENABLED, "no provided configuration for email variables" with open(Path(f'{cwd}{settings.EMAIL_TEMPLATES_DIR}') / html_template) as f: template_str = f.read() subject = JinjaTemplate(subject_template) template = JinjaTemplate(template_str) # print(">>> send_email > template : ...", template) # print("send_email > email_to : ", email_to) # print("send_email > subject : ", subject) # print("send_email > settings.EMAILS_FROM_EMAIL : ", settings.EMAILS_FROM_EMAIL) # print("send_email > environment : ", environment) # print("send_email > subject_template : ", subject_template) # print("send_email > html_template : ", html_template) message = emails.Message( subject=subject, html=template, # mail_from=(settings.EMAILS_FROM_NAME, settings.EMAILS_FROM_EMAIL), mail_from=(settings.EMAILS_FROM_EMAIL), ) print("send_email > message : ", message) response = message.send(to=email_to, render=environment, smtp=smtp_options) print("send_email > response : ", response) logging.info(f"send email > result: {response}")
def send_email(email_to: str, subject_template: str = "", html_template: str = "", environment: tp.Mapping = {}) -> None: """Sends an email with the given parameters. Parameters ---------- email_to : str The email address to send the email to. subject_template : str, optional The subject line template string to use. html_template : str, optional The email body template string to use. environment : Mapping, optional The environment variables to use in rendering the message. """ if not config.EMAILS_ENABLED: logging.warn("Emails are not enabled") return message = emails.Message(subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(config.EMAILS_FROM_NAME, config.EMAILS_FROM_EMAIL)) smtp_options = dict(host=config.SMTP_HOST, port=config.SMTP_PORT) if config.SMTP_TLS: smtp_options["tls"] = True if config.SMTP_USER: smtp_options["user"] = config.SMTP_USER if config.SMTP_PASSWORD: smtp_options["password"] = config.SMTP_PASSWORD response = message.send(to=email_to, render=environment, smtp=smtp_options) logging.info(f"Email send result: {response}") return
def send_email(template, subject, data_map, recipient): template_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "email_templates", template) smtp_config = { 'host': CONFIG.smtp_host, 'port': CONFIG.smtp_port, 'user': CONFIG.smtp_user, 'password': CONFIG.smtp_pass, 'ssl': True } message = emails.Message(html=JinjaTemplate(open(template_path).read()), subject=subject, mail_from=("VulnFeed Agent", "*****@*****.**")) if CONFIG.has_dkim: message.dkim(key=open(CONFIG.dkim_privkey), domain=CONFIG.dkim_domain, selector=CONFIG.dkim_selector) response = message.send(render=data_map, to=recipient, smtp=smtp_config) return response
subject_template = "" elif isinstance(subject_template, Path): with open(subject_template, 'r') as fin: subject_template = fin.read() if html_template is None: html_template = "" elif isinstance(html_template, Path): with open(html_template, 'r') as fin: html_template = fin.read() environment = environment or {} if isinstance((attachments := attachments or {}), Path): attachments = {attachments.name: attachments} # - Construct message message = emails.Message( subject=JinjaTemplate(subject_template), html=JinjaTemplate(html_template), mail_from=(settings.EMAILS_FROM_NAME, settings.EMAILS_FROM_EMAIL), ) for name, file in attachments.items(): with open(file) as fin: message.attach(data=fin, filename=name) smtp_opts = { "host": settings.SMTP_HOST, "port": settings.SMTP_PORT, } if settings.SMTP_TLS: smtp_opts["tls"] = True if settings.SMTP_USER: smtp_opts["user"] = settings.SMTP_USER
def process_user(self, user_email): # Get object u = User(user_email) days_to_run = u.get_days() last_day = u.last_run current_time = datetime.utcnow() current_day = int(current_time.strftime("%w")) + 1 day_diff = 2 if last_day > 0: if last_day > current_day: current_day += 7 day_diff = current_day - last_day # Get reports between the time requested plus some buffer time query_time = current_time - timedelta(hours=(day_diff*24)+4) reports = get_feed_reports(query_time) rules = u.get_rules() filled_rules = fill_rules(rules) report_map = {} for report in reports: self.check_report(report_map, report, filled_rules) high_reports = [] medium_reports = [] low_reports = [] report_count = 0 for report_id in report_map: score = report_map[report_id]['score'] report = report_map[report_id]['report'] report_count += 1 if score == 0: low_reports.append(report) else: high_reports.append(report) render_map = { "vulncount": report_count, "high_importance_reports": high_reports, "medium_importance_reports": medium_reports, "low_importance_reports": low_reports } template_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "templates", 'email_template.html') smtp_config = { 'host': CONFIG.smtp_host, 'port': CONFIG.smtp_port, 'user': CONFIG.smtp_user, 'password': CONFIG.smtp_pass, 'ssl': True } m = emails.Message(html=JinjaTemplate(open(template_path).read()), text="hi there", subject="VulnFeed Test", mail_from=("VulnFeed Agent", "*****@*****.**")) response = m.send(render=render_map, to=user_email, smtp={smtp_config) print(response) def run(self): for user_email in self.user_chunk: self.process_user(user_email) sm = SenderMaster() sm.start_senders()
def process_user(self, user_email): # Get object u = User(user_email) days_to_run = u.get_days() last_day = u.last_run current_time = datetime.utcnow() current_day = int(current_time.strftime("%w")) + 1 if current_day not in days_to_run: return day_diff = 2 if last_day > 0: if last_day > current_day: current_day += 7 day_diff = current_day - last_day # Get reports between the time requested plus some buffer time query_time = current_time - timedelta(hours=(day_diff * 24) + 4) reports = get_feed_reports(query_time) rules = u.get_rules() filled_rules = fill_rules(rules) report_map = {} for report in reports: self.check_report(report_map, report, filled_rules) sorted_reports = sorted(report_map, key=lambda item: report_map[item]['score'], reverse=True) scored_reports = [] unscored_reports = [] for item in sorted_reports: if report_map[item]['score'] > 0: scored_reports.append(report_map[item]['report']) else: unscored_reports.append(report_map[item]['report']) for item in sorted_reports: print(report_map[item]['score']) print(report_map[item]['report']['contents']) report_count = len(sorted_reports) render_map = { "vulncount": report_count, "scored_reports": scored_reports, "unscored_reports": unscored_reports } template_path = os.path.join( os.path.dirname(os.path.abspath(__file__)), "templates", 'email_template.html') smtp_config = { 'host': CONFIG.smtp_host, 'port': CONFIG.smtp_port, 'user': CONFIG.smtp_user, 'password': CONFIG.smtp_pass, 'ssl': True } m = emails.Message(html=JinjaTemplate(open(template_path).read()), subject="VulnFeed Report for " + time.strftime("%m/%d/%Y"), mail_from=("VulnFeed Agent", "*****@*****.**")) response = m.send(render=render_map, to=user_email, smtp=smtp_config) print(response)