mirror of https://github.com/morpheus65535/bazarr
1091 lines
37 KiB
Python
1091 lines
37 KiB
Python
# -*- coding: utf-8 -*-
|
|
# BSD 2-Clause License
|
|
#
|
|
# Apprise - Push Notification Library.
|
|
# Copyright (c) 2023, Chris Caron <lead2gold@gmail.com>
|
|
#
|
|
# Redistribution and use in source and binary forms, with or without
|
|
# modification, are permitted provided that the following conditions are met:
|
|
#
|
|
# 1. Redistributions of source code must retain the above copyright notice,
|
|
# this list of conditions and the following disclaimer.
|
|
#
|
|
# 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
# this list of conditions and the following disclaimer in the documentation
|
|
# and/or other materials provided with the distribution.
|
|
#
|
|
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
# POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
import dataclasses
|
|
import re
|
|
import smtplib
|
|
import typing as t
|
|
from email.mime.text import MIMEText
|
|
from email.mime.application import MIMEApplication
|
|
from email.mime.multipart import MIMEMultipart
|
|
from email.utils import formataddr, make_msgid
|
|
from email.header import Header
|
|
from email import charset
|
|
|
|
from socket import error as SocketError
|
|
from datetime import datetime
|
|
from datetime import timezone
|
|
|
|
from .NotifyBase import NotifyBase
|
|
from ..URLBase import PrivacyMode
|
|
from ..common import NotifyFormat, NotifyType
|
|
from ..conversion import convert_between
|
|
from ..utils import is_email, parse_emails
|
|
from ..AppriseLocale import gettext_lazy as _
|
|
from ..logger import logger
|
|
|
|
# Globally Default encoding mode set to Quoted Printable.
|
|
charset.add_charset('utf-8', charset.QP, charset.QP, 'utf-8')
|
|
|
|
|
|
class WebBaseLogin:
|
|
"""
|
|
This class is just used in conjunction of the default emailers
|
|
to best formulate a login to it using the data detected
|
|
"""
|
|
# User Login must be Email Based
|
|
EMAIL = 'Email'
|
|
|
|
# User Login must UserID Based
|
|
USERID = 'UserID'
|
|
|
|
|
|
# Secure Email Modes
|
|
class SecureMailMode:
|
|
INSECURE = "insecure"
|
|
SSL = "ssl"
|
|
STARTTLS = "starttls"
|
|
|
|
|
|
# Define all of the secure modes (used during validation)
|
|
SECURE_MODES = {
|
|
SecureMailMode.STARTTLS: {
|
|
'default_port': 587,
|
|
},
|
|
SecureMailMode.SSL: {
|
|
'default_port': 465,
|
|
},
|
|
SecureMailMode.INSECURE: {
|
|
'default_port': 25,
|
|
},
|
|
}
|
|
|
|
# To attempt to make this script stupid proof, if we detect an email address
|
|
# that is part of the this table, we can pre-use a lot more defaults if they
|
|
# aren't otherwise specified on the users input.
|
|
EMAIL_TEMPLATES = (
|
|
# Google GMail
|
|
(
|
|
'Google Mail',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>gmail\.com)$', re.I),
|
|
{
|
|
'port': 587,
|
|
'smtp_host': 'smtp.gmail.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.STARTTLS,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# Yandex
|
|
(
|
|
'Yandex',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>yandex\.(com|ru|ua|by|kz|uz|tr|fr))$', re.I),
|
|
{
|
|
'port': 465,
|
|
'smtp_host': 'smtp.yandex.ru',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.SSL,
|
|
'login_type': (WebBaseLogin.USERID, )
|
|
},
|
|
),
|
|
|
|
# Microsoft Hotmail
|
|
(
|
|
'Microsoft Hotmail',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>(hotmail|live)\.com(\.au)?)$', re.I),
|
|
{
|
|
'port': 587,
|
|
'smtp_host': 'smtp-mail.outlook.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.STARTTLS,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# Microsoft Outlook
|
|
(
|
|
'Microsoft Outlook',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>(smtp\.)?outlook\.com(\.au)?)$', re.I),
|
|
{
|
|
'port': 587,
|
|
'smtp_host': 'smtp.outlook.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.STARTTLS,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# Microsoft Office 365 (Email Server)
|
|
# You must specify an authenticated sender address in the from= settings
|
|
# and a valid email in the to= to deliver your emails to
|
|
(
|
|
'Microsoft Office 365',
|
|
re.compile(
|
|
r'^[^@]+@(?P<domain>(smtp\.)?office365\.com)$', re.I),
|
|
{
|
|
'port': 587,
|
|
'smtp_host': 'smtp.office365.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.STARTTLS,
|
|
},
|
|
),
|
|
|
|
# Yahoo Mail
|
|
(
|
|
'Yahoo Mail',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>yahoo\.(ca|com))$', re.I),
|
|
{
|
|
'port': 465,
|
|
'smtp_host': 'smtp.mail.yahoo.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.STARTTLS,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# Fast Mail (Series 1)
|
|
(
|
|
'Fast Mail',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>fastmail\.(com|cn|co\.uk|com\.au|de|es|fm|fr|im|'
|
|
r'in|jp|mx|net|nl|org|se|to|tw|uk|us))$', re.I),
|
|
{
|
|
'port': 465,
|
|
'smtp_host': 'smtp.fastmail.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.SSL,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# Fast Mail (Series 2)
|
|
(
|
|
'Fast Mail Extended Addresses',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>123mail\.org|airpost\.net|eml\.cc|fmail\.co\.uk|'
|
|
r'fmgirl\.com|fmguy\.com|mailbolt\.com|mailcan\.com|'
|
|
r'mailhaven\.com|mailmight\.com|ml1\.net|mm\.st|myfastmail\.com|'
|
|
r'proinbox\.com|promessage\.com|rushpost\.com|sent\.(as|at|com)|'
|
|
r'speedymail\.org|warpmail\.net|xsmail\.com|150mail\.com|'
|
|
r'150ml\.com|16mail\.com|2-mail\.com|4email\.net|50mail\.com|'
|
|
r'allmail\.net|bestmail\.us|cluemail\.com|elitemail\.org|'
|
|
r'emailcorner\.net|emailengine\.(net|org)|emailgroups\.net|'
|
|
r'emailplus\.org|emailuser\.net|f-m\.fm|fast-email\.com|'
|
|
r'fast-mail\.org|fastem\.com|fastemail\.us|fastemailer\.com|'
|
|
r'fastest\.cc|fastimap\.com|fastmailbox\.net|fastmessaging\.com|'
|
|
r'fea\.st|fmailbox\.com|ftml\.net|h-mail\.us|hailmail\.net|'
|
|
r'imap-mail\.com|imap\.cc|imapmail\.org|inoutbox\.com|'
|
|
r'internet-e-mail\.com|internet-mail\.org|internetemails\.net|'
|
|
r'internetmailing\.net|jetemail\.net|justemail\.net|'
|
|
r'letterboxes\.org|mail-central\.com|mail-page\.com|'
|
|
r'mailandftp\.com|mailas\.com|mailc\.net|mailforce\.net|'
|
|
r'mailftp\.com|mailingaddress\.org|mailite\.com|mailnew\.com|'
|
|
r'mailsent\.net|mailservice\.ms|mailup\.net|mailworks\.org|'
|
|
r'mymacmail\.com|nospammail\.net|ownmail\.net|petml\.com|'
|
|
r'postinbox\.com|postpro\.net|realemail\.net|reallyfast\.biz|'
|
|
r'reallyfast\.info|speedpost\.net|ssl-mail\.com|swift-mail\.com|'
|
|
r'the-fastest\.net|the-quickest\.com|theinternetemail\.com|'
|
|
r'veryfast\.biz|veryspeedy\.net|yepmail\.net)$', re.I),
|
|
{
|
|
'port': 465,
|
|
'smtp_host': 'smtp.fastmail.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.SSL,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# Zoho Mail (Free)
|
|
(
|
|
'Zoho Mail',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>zoho(mail)?\.com)$', re.I),
|
|
{
|
|
'port': 587,
|
|
'smtp_host': 'smtp.zoho.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.STARTTLS,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# SendGrid (Email Server)
|
|
# You must specify an authenticated sender address in the from= settings
|
|
# and a valid email in the to= to deliver your emails to
|
|
(
|
|
'SendGrid',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>(\.smtp)?sendgrid\.(com|net))$', re.I),
|
|
{
|
|
'port': 465,
|
|
'smtp_host': 'smtp.sendgrid.net',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.SSL,
|
|
'login_type': (WebBaseLogin.USERID, )
|
|
},
|
|
),
|
|
|
|
# 163.com
|
|
(
|
|
'163.com',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>163\.com)$', re.I),
|
|
{
|
|
'port': 465,
|
|
'smtp_host': 'smtp.163.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.SSL,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# Foxmail.com
|
|
(
|
|
'Foxmail.com',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>(foxmail|qq)\.com)$', re.I),
|
|
{
|
|
'port': 587,
|
|
'smtp_host': 'smtp.qq.com',
|
|
'secure': True,
|
|
'secure_mode': SecureMailMode.STARTTLS,
|
|
'login_type': (WebBaseLogin.EMAIL, )
|
|
},
|
|
),
|
|
|
|
# Catch All
|
|
(
|
|
'Custom',
|
|
re.compile(
|
|
r'^((?P<label>[^+]+)\+)?(?P<id>[^@]+)@'
|
|
r'(?P<domain>.+)$', re.I),
|
|
{
|
|
# Setting smtp_host to None is a way of
|
|
# auto-detecting it based on other parameters
|
|
# specified. There is no reason to ever modify
|
|
# this Catch All
|
|
'smtp_host': None,
|
|
},
|
|
),
|
|
)
|
|
|
|
|
|
@dataclasses.dataclass
|
|
class EmailMessage:
|
|
recipient: str
|
|
to_addrs: t.List[str]
|
|
body: str
|
|
|
|
|
|
class NotifyEmail(NotifyBase):
|
|
"""
|
|
A wrapper to Email Notifications
|
|
|
|
"""
|
|
|
|
# The default descriptive name associated with the Notification
|
|
service_name = 'E-Mail'
|
|
|
|
# The default simple (insecure) protocol
|
|
protocol = 'mailto'
|
|
|
|
# The default secure protocol
|
|
secure_protocol = 'mailtos'
|
|
|
|
# A URL that takes you to the setup/help of the specific protocol
|
|
setup_url = 'https://github.com/caronc/apprise/wiki/Notify_email'
|
|
|
|
# Support attachments
|
|
attachment_support = True
|
|
|
|
# Default Notify Format
|
|
notify_format = NotifyFormat.HTML
|
|
|
|
# Default SMTP Timeout (in seconds)
|
|
socket_connect_timeout = 15
|
|
|
|
# Define object templates
|
|
templates = (
|
|
'{schema}://{host}',
|
|
'{schema}://{host}:{port}',
|
|
'{schema}://{host}/{targets}',
|
|
'{schema}://{host}:{port}/{targets}',
|
|
'{schema}://{user}@{host}',
|
|
'{schema}://{user}@{host}:{port}',
|
|
'{schema}://{user}@{host}/{targets}',
|
|
'{schema}://{user}@{host}:{port}/{targets}',
|
|
'{schema}://{user}:{password}@{host}',
|
|
'{schema}://{user}:{password}@{host}:{port}',
|
|
'{schema}://{user}:{password}@{host}/{targets}',
|
|
'{schema}://{user}:{password}@{host}:{port}/{targets}',
|
|
)
|
|
|
|
# Define our template tokens
|
|
template_tokens = dict(NotifyBase.template_tokens, **{
|
|
'user': {
|
|
'name': _('User Name'),
|
|
'type': 'string',
|
|
},
|
|
'password': {
|
|
'name': _('Password'),
|
|
'type': 'string',
|
|
'private': True,
|
|
},
|
|
'host': {
|
|
'name': _('Domain'),
|
|
'type': 'string',
|
|
'required': True,
|
|
},
|
|
'port': {
|
|
'name': _('Port'),
|
|
'type': 'int',
|
|
'min': 1,
|
|
'max': 65535,
|
|
},
|
|
'target_email': {
|
|
'name': _('Target Email'),
|
|
'type': 'string',
|
|
'map_to': 'targets',
|
|
},
|
|
'targets': {
|
|
'name': _('Targets'),
|
|
'type': 'list:string',
|
|
},
|
|
})
|
|
|
|
template_args = dict(NotifyBase.template_args, **{
|
|
'to': {
|
|
'name': _('To Email'),
|
|
'type': 'string',
|
|
'map_to': 'targets',
|
|
},
|
|
'from': {
|
|
'name': _('From Email'),
|
|
'type': 'string',
|
|
'map_to': 'from_addr',
|
|
},
|
|
'name': {
|
|
'name': _('From Name'),
|
|
'type': 'string',
|
|
'map_to': 'from_addr',
|
|
},
|
|
'cc': {
|
|
'name': _('Carbon Copy'),
|
|
'type': 'list:string',
|
|
},
|
|
'bcc': {
|
|
'name': _('Blind Carbon Copy'),
|
|
'type': 'list:string',
|
|
},
|
|
'smtp': {
|
|
'name': _('SMTP Server'),
|
|
'type': 'string',
|
|
'map_to': 'smtp_host',
|
|
},
|
|
'mode': {
|
|
'name': _('Secure Mode'),
|
|
'type': 'choice:string',
|
|
'values': SECURE_MODES,
|
|
'default': SecureMailMode.STARTTLS,
|
|
'map_to': 'secure_mode',
|
|
},
|
|
'reply': {
|
|
'name': _('Reply To'),
|
|
'type': 'list:string',
|
|
'map_to': 'reply_to',
|
|
},
|
|
})
|
|
|
|
# Define any kwargs we're using
|
|
template_kwargs = {
|
|
'headers': {
|
|
'name': _('Email Header'),
|
|
'prefix': '+',
|
|
},
|
|
}
|
|
|
|
def __init__(self, smtp_host=None, from_addr=None, secure_mode=None,
|
|
targets=None, cc=None, bcc=None, reply_to=None, headers=None,
|
|
**kwargs):
|
|
"""
|
|
Initialize Email Object
|
|
|
|
The smtp_host and secure_mode can be automatically detected depending
|
|
on how the URL was built
|
|
"""
|
|
super().__init__(**kwargs)
|
|
|
|
# Acquire Email 'To'
|
|
self.targets = list()
|
|
|
|
# Acquire Carbon Copies
|
|
self.cc = set()
|
|
|
|
# Acquire Blind Carbon Copies
|
|
self.bcc = set()
|
|
|
|
# Acquire Reply To
|
|
self.reply_to = set()
|
|
|
|
# For tracking our email -> name lookups
|
|
self.names = {}
|
|
|
|
self.headers = {}
|
|
if headers:
|
|
# Store our extra headers
|
|
self.headers.update(headers)
|
|
|
|
# Now we want to construct the To and From email
|
|
# addresses from the URL provided
|
|
self.from_addr = [False, '']
|
|
|
|
if self.user and self.host:
|
|
# Prepare the bases of our email
|
|
self.from_addr = [self.app_id, '{}@{}'.format(
|
|
re.split(r'[\s@]+', self.user)[0],
|
|
self.host,
|
|
)]
|
|
|
|
if from_addr:
|
|
result = is_email(from_addr)
|
|
if result:
|
|
self.from_addr = (
|
|
result['name'] if result['name'] else False,
|
|
result['full_email'])
|
|
else:
|
|
self.from_addr[0] = from_addr
|
|
|
|
result = is_email(self.from_addr[1])
|
|
if not result:
|
|
# Parse Source domain based on from_addr
|
|
msg = 'Invalid ~From~ email specified: {}'.format(
|
|
'{} <{}>'.format(self.from_addr[0], self.from_addr[1])
|
|
if self.from_addr[0] else '{}'.format(self.from_addr[1]))
|
|
self.logger.warning(msg)
|
|
raise TypeError(msg)
|
|
|
|
# Store our lookup
|
|
self.names[self.from_addr[1]] = self.from_addr[0]
|
|
|
|
# Now detect the SMTP Server
|
|
self.smtp_host = \
|
|
smtp_host if isinstance(smtp_host, str) else ''
|
|
|
|
# Now detect secure mode
|
|
if secure_mode:
|
|
self.secure_mode = None \
|
|
if not isinstance(secure_mode, str) \
|
|
else secure_mode.lower()
|
|
else:
|
|
self.secure_mode = SecureMailMode.INSECURE \
|
|
if not self.secure else self.template_args['mode']['default']
|
|
|
|
if self.secure_mode not in SECURE_MODES:
|
|
msg = 'The secure mode specified ({}) is invalid.'\
|
|
.format(secure_mode)
|
|
self.logger.warning(msg)
|
|
raise TypeError(msg)
|
|
|
|
if targets:
|
|
# Validate recipients (to:) and drop bad ones:
|
|
for recipient in parse_emails(targets):
|
|
result = is_email(recipient)
|
|
if result:
|
|
self.targets.append(
|
|
(result['name'] if result['name'] else False,
|
|
result['full_email']))
|
|
continue
|
|
|
|
self.logger.warning(
|
|
'Dropped invalid To email '
|
|
'({}) specified.'.format(recipient),
|
|
)
|
|
|
|
else:
|
|
# If our target email list is empty we want to add ourselves to it
|
|
self.targets.append((False, self.from_addr[1]))
|
|
|
|
# Validate recipients (cc:) and drop bad ones:
|
|
for recipient in parse_emails(cc):
|
|
email = is_email(recipient)
|
|
if email:
|
|
self.cc.add(email['full_email'])
|
|
|
|
# Index our name (if one exists)
|
|
self.names[email['full_email']] = \
|
|
email['name'] if email['name'] else False
|
|
continue
|
|
|
|
self.logger.warning(
|
|
'Dropped invalid Carbon Copy email '
|
|
'({}) specified.'.format(recipient),
|
|
)
|
|
|
|
# Validate recipients (bcc:) and drop bad ones:
|
|
for recipient in parse_emails(bcc):
|
|
email = is_email(recipient)
|
|
if email:
|
|
self.bcc.add(email['full_email'])
|
|
|
|
# Index our name (if one exists)
|
|
self.names[email['full_email']] = \
|
|
email['name'] if email['name'] else False
|
|
continue
|
|
|
|
self.logger.warning(
|
|
'Dropped invalid Blind Carbon Copy email '
|
|
'({}) specified.'.format(recipient),
|
|
)
|
|
|
|
# Validate recipients (reply-to:) and drop bad ones:
|
|
for recipient in parse_emails(reply_to):
|
|
email = is_email(recipient)
|
|
if email:
|
|
self.reply_to.add(email['full_email'])
|
|
|
|
# Index our name (if one exists)
|
|
self.names[email['full_email']] = \
|
|
email['name'] if email['name'] else False
|
|
continue
|
|
|
|
self.logger.warning(
|
|
'Dropped invalid Reply To email '
|
|
'({}) specified.'.format(recipient),
|
|
)
|
|
|
|
# Apply any defaults based on certain known configurations
|
|
self.NotifyEmailDefaults(secure_mode=secure_mode, **kwargs)
|
|
|
|
if not self.secure and self.secure_mode != SecureMailMode.INSECURE:
|
|
# Enable Secure mode if not otherwise set
|
|
self.secure = True
|
|
|
|
if not self.port:
|
|
# Assign our port based on our secure_mode if not otherwise
|
|
# detected
|
|
self.port = SECURE_MODES[self.secure_mode]['default_port']
|
|
|
|
# if there is still no smtp_host then we fall back to the hostname
|
|
if not self.smtp_host:
|
|
self.smtp_host = self.host
|
|
|
|
return
|
|
|
|
def NotifyEmailDefaults(self, secure_mode=None, port=None, **kwargs):
|
|
"""
|
|
A function that prefills defaults based on the email
|
|
it was provided.
|
|
"""
|
|
|
|
if self.smtp_host or not self.user:
|
|
# SMTP Server was explicitly specified, therefore it is assumed
|
|
# the caller knows what he's doing and is intentionally
|
|
# over-riding any smarts to be applied. We also can not apply
|
|
# any default if there was no user specified.
|
|
return
|
|
|
|
# detect our email address using our user/host combo
|
|
from_addr = '{}@{}'.format(
|
|
re.split(r'[\s@]+', self.user)[0],
|
|
self.host,
|
|
)
|
|
|
|
for i in range(len(EMAIL_TEMPLATES)): # pragma: no branch
|
|
self.logger.trace('Scanning %s against %s' % (
|
|
from_addr, EMAIL_TEMPLATES[i][0]
|
|
))
|
|
match = EMAIL_TEMPLATES[i][1].match(from_addr)
|
|
if match:
|
|
self.logger.info(
|
|
'Applying %s Defaults' %
|
|
EMAIL_TEMPLATES[i][0],
|
|
)
|
|
# the secure flag can not be altered if defined in the template
|
|
self.secure = EMAIL_TEMPLATES[i][2]\
|
|
.get('secure', self.secure)
|
|
|
|
# The SMTP Host check is already done above; if it was
|
|
# specified we wouldn't even reach this part of the code.
|
|
self.smtp_host = EMAIL_TEMPLATES[i][2]\
|
|
.get('smtp_host', self.smtp_host)
|
|
|
|
# The following can be over-ridden if defined manually in the
|
|
# Apprise URL. Otherwise they take on the template value
|
|
if not port:
|
|
self.port = EMAIL_TEMPLATES[i][2]\
|
|
.get('port', self.port)
|
|
if not secure_mode:
|
|
self.secure_mode = EMAIL_TEMPLATES[i][2]\
|
|
.get('secure_mode', self.secure_mode)
|
|
|
|
# Adjust email login based on the defined usertype. If no entry
|
|
# was specified, then we default to having them all set (which
|
|
# basically implies that there are no restrictions and use use
|
|
# whatever was specified)
|
|
login_type = EMAIL_TEMPLATES[i][2]\
|
|
.get('login_type', [])
|
|
|
|
if login_type:
|
|
# only apply additional logic to our user if a login_type
|
|
# was specified.
|
|
if is_email(self.user):
|
|
if WebBaseLogin.EMAIL not in login_type:
|
|
# Email specified but login type
|
|
# not supported; switch it to user id
|
|
self.user = match.group('id')
|
|
|
|
elif WebBaseLogin.USERID not in login_type:
|
|
# user specified but login type
|
|
# not supported; switch it to email
|
|
self.user = '{}@{}'.format(self.user, self.host)
|
|
|
|
break
|
|
|
|
def _get_charset(self, input_string):
|
|
"""
|
|
Get utf-8 charset if non ascii string only
|
|
|
|
Encode an ascii string to utf-8 is bad for email deliverability
|
|
because some anti-spam gives a bad score for that
|
|
like SUBJ_EXCESS_QP flag on Rspamd
|
|
"""
|
|
if not input_string:
|
|
return None
|
|
return 'utf-8' if not all(ord(c) < 128 for c in input_string) else None
|
|
|
|
def send(self, body, title='', notify_type=NotifyType.INFO, attach=None,
|
|
**kwargs):
|
|
"""
|
|
Perform Email Notification
|
|
"""
|
|
|
|
if not self.targets:
|
|
# There is no one to email; we're done
|
|
self.logger.warning(
|
|
'There are no Email recipients to notify')
|
|
return False
|
|
|
|
messages: t.List[EmailMessage] = []
|
|
|
|
# Create a copy of the targets list
|
|
emails = list(self.targets)
|
|
while len(emails):
|
|
# Get our email to notify
|
|
to_name, to_addr = emails.pop(0)
|
|
|
|
# Strip target out of cc list if in To or Bcc
|
|
cc = (self.cc - self.bcc - set([to_addr]))
|
|
|
|
# Strip target out of bcc list if in To
|
|
bcc = (self.bcc - set([to_addr]))
|
|
|
|
# Strip target out of reply_to list if in To
|
|
reply_to = (self.reply_to - set([to_addr]))
|
|
|
|
# Format our cc addresses to support the Name field
|
|
cc = [formataddr(
|
|
(self.names.get(addr, False), addr), charset='utf-8')
|
|
for addr in cc]
|
|
|
|
# Format our bcc addresses to support the Name field
|
|
bcc = [formataddr(
|
|
(self.names.get(addr, False), addr), charset='utf-8')
|
|
for addr in bcc]
|
|
|
|
if reply_to:
|
|
# Format our reply-to addresses to support the Name field
|
|
reply_to = [formataddr(
|
|
(self.names.get(addr, False), addr), charset='utf-8')
|
|
for addr in reply_to]
|
|
|
|
self.logger.debug(
|
|
'Email From: {}'.format(
|
|
formataddr(self.from_addr, charset='utf-8')))
|
|
|
|
self.logger.debug('Email To: {}'.format(to_addr))
|
|
if cc:
|
|
self.logger.debug('Email Cc: {}'.format(', '.join(cc)))
|
|
if bcc:
|
|
self.logger.debug('Email Bcc: {}'.format(', '.join(bcc)))
|
|
if reply_to:
|
|
self.logger.debug(
|
|
'Email Reply-To: {}'.format(', '.join(reply_to))
|
|
)
|
|
self.logger.debug('Login ID: {}'.format(self.user))
|
|
self.logger.debug(
|
|
'Delivery: {}:{}'.format(self.smtp_host, self.port))
|
|
|
|
# Prepare Email Message
|
|
if self.notify_format == NotifyFormat.HTML:
|
|
base = MIMEMultipart("alternative")
|
|
base.attach(MIMEText(
|
|
convert_between(
|
|
NotifyFormat.HTML, NotifyFormat.TEXT, body),
|
|
'plain', 'utf-8')
|
|
)
|
|
base.attach(MIMEText(body, 'html', 'utf-8'))
|
|
else:
|
|
base = MIMEText(body, 'plain', 'utf-8')
|
|
|
|
if attach and self.attachment_support:
|
|
mixed = MIMEMultipart("mixed")
|
|
mixed.attach(base)
|
|
# Now store our attachments
|
|
for attachment in attach:
|
|
if not attachment:
|
|
# We could not load the attachment; take an early
|
|
# exit since this isn't what the end user wanted
|
|
|
|
# We could not access the attachment
|
|
self.logger.error(
|
|
'Could not access attachment {}.'.format(
|
|
attachment.url(privacy=True)))
|
|
|
|
return False
|
|
|
|
self.logger.debug(
|
|
'Preparing Email attachment {}'.format(
|
|
attachment.url(privacy=True)))
|
|
|
|
with open(attachment.path, "rb") as abody:
|
|
app = MIMEApplication(abody.read())
|
|
app.set_type(attachment.mimetype)
|
|
|
|
app.add_header(
|
|
'Content-Disposition',
|
|
'attachment; filename="{}"'.format(
|
|
Header(attachment.name, 'utf-8')),
|
|
)
|
|
mixed.attach(app)
|
|
base = mixed
|
|
|
|
# Apply any provided custom headers
|
|
for k, v in self.headers.items():
|
|
base[k] = Header(v, self._get_charset(v))
|
|
|
|
base['Subject'] = Header(title, self._get_charset(title))
|
|
base['From'] = formataddr(self.from_addr, charset='utf-8')
|
|
base['To'] = formataddr((to_name, to_addr), charset='utf-8')
|
|
base['Message-ID'] = make_msgid(domain=self.smtp_host)
|
|
base['Date'] = \
|
|
datetime.now(timezone.utc)\
|
|
.strftime("%a, %d %b %Y %H:%M:%S +0000")
|
|
base['X-Application'] = self.app_id
|
|
|
|
if cc:
|
|
base['Cc'] = ','.join(cc)
|
|
|
|
if reply_to:
|
|
base['Reply-To'] = ','.join(reply_to)
|
|
|
|
message = EmailMessage(
|
|
recipient=to_addr,
|
|
to_addrs=[to_addr] + list(cc) + list(bcc),
|
|
body=base.as_string())
|
|
messages.append(message)
|
|
|
|
return self.submit(messages)
|
|
|
|
def submit(self, messages: t.List[EmailMessage]):
|
|
|
|
# error tracking (used for function return)
|
|
has_error = False
|
|
|
|
# bind the socket variable to the current namespace
|
|
socket = None
|
|
|
|
# Always call throttle before any remote server i/o is made
|
|
self.throttle()
|
|
|
|
try:
|
|
self.logger.debug('Connecting to remote SMTP server...')
|
|
socket_func = smtplib.SMTP
|
|
if self.secure_mode == SecureMailMode.SSL:
|
|
self.logger.debug('Securing connection with SSL...')
|
|
socket_func = smtplib.SMTP_SSL
|
|
|
|
socket = socket_func(
|
|
self.smtp_host,
|
|
self.port,
|
|
None,
|
|
timeout=self.socket_connect_timeout,
|
|
)
|
|
|
|
if self.secure_mode == SecureMailMode.STARTTLS:
|
|
# Handle Secure Connections
|
|
self.logger.debug('Securing connection with STARTTLS...')
|
|
socket.starttls()
|
|
|
|
if self.user and self.password:
|
|
# Apply Login credetials
|
|
self.logger.debug('Applying user credentials...')
|
|
socket.login(self.user, self.password)
|
|
|
|
# Send the emails
|
|
for message in messages:
|
|
try:
|
|
socket.sendmail(
|
|
self.from_addr[1],
|
|
message.to_addrs,
|
|
message.body)
|
|
|
|
self.logger.info(
|
|
f'Sent Email notification to "{message.recipient}".')
|
|
except (SocketError, smtplib.SMTPException, RuntimeError) as e:
|
|
self.logger.warning(
|
|
f'Sending email to "{message.recipient}" failed. '
|
|
f'Reason: {e}')
|
|
|
|
# Mark as failure
|
|
has_error = True
|
|
|
|
except (SocketError, smtplib.SMTPException, RuntimeError) as e:
|
|
self.logger.warning(
|
|
f'Connection error while submitting email to {self.smtp_host}.'
|
|
f' Reason: {e}')
|
|
|
|
# Mark as failure
|
|
has_error = True
|
|
|
|
finally:
|
|
# Gracefully terminate the connection with the server
|
|
if socket is not None: # pragma: no branch
|
|
socket.quit()
|
|
|
|
return not has_error
|
|
|
|
def url(self, privacy=False, *args, **kwargs):
|
|
"""
|
|
Returns the URL built dynamically based on specified arguments.
|
|
"""
|
|
|
|
# Define an URL parameters
|
|
params = {}
|
|
|
|
# Append our headers into our parameters
|
|
params.update({'+{}'.format(k): v for k, v in self.headers.items()})
|
|
|
|
# Extend our parameters
|
|
params.update(self.url_parameters(privacy=privacy, *args, **kwargs))
|
|
|
|
from_addr = None
|
|
if len(self.targets) == 1 and self.targets[0][1] != self.from_addr[1]:
|
|
# A custom email was provided
|
|
from_addr = self.from_addr[1]
|
|
|
|
if self.smtp_host != self.host:
|
|
# Apply our SMTP Host only if it differs from the provided hostname
|
|
params['smtp'] = self.smtp_host
|
|
|
|
if self.secure:
|
|
# Mode is only requried if we're dealing with a secure connection
|
|
params['mode'] = self.secure_mode
|
|
|
|
if self.from_addr[0] and self.from_addr[0] != self.app_id:
|
|
# A custom name was provided
|
|
params['from'] = self.from_addr[0] if not from_addr else \
|
|
formataddr((self.from_addr[0], from_addr), charset='utf-8')
|
|
|
|
elif from_addr:
|
|
params['from'] = formataddr((False, from_addr), charset='utf-8')
|
|
|
|
elif not self.user:
|
|
params['from'] = \
|
|
formataddr((False, self.from_addr[1]), charset='utf-8')
|
|
|
|
if len(self.cc) > 0:
|
|
# Handle our Carbon Copy Addresses
|
|
params['cc'] = ','.join([
|
|
formataddr(
|
|
(self.names[e] if e in self.names else False, e),
|
|
# Swap comma for it's escaped url code (if detected) since
|
|
# we're using that as a delimiter
|
|
charset='utf-8').replace(',', '%2C')
|
|
for e in self.cc])
|
|
|
|
if len(self.bcc) > 0:
|
|
# Handle our Blind Carbon Copy Addresses
|
|
params['bcc'] = ','.join([
|
|
formataddr(
|
|
(self.names[e] if e in self.names else False, e),
|
|
# Swap comma for it's escaped url code (if detected) since
|
|
# we're using that as a delimiter
|
|
charset='utf-8').replace(',', '%2C')
|
|
for e in self.bcc])
|
|
|
|
if self.reply_to:
|
|
# Handle our Reply-To Addresses
|
|
params['reply'] = ','.join([
|
|
formataddr(
|
|
(self.names[e] if e in self.names else False, e),
|
|
# Swap comma for it's escaped url code (if detected) since
|
|
# we're using that as a delimiter
|
|
charset='utf-8').replace(',', '%2C')
|
|
for e in self.reply_to])
|
|
|
|
# pull email suffix from username (if present)
|
|
user = None if not self.user else self.user.split('@')[0]
|
|
|
|
# Determine Authentication
|
|
auth = ''
|
|
if self.user and self.password:
|
|
auth = '{user}:{password}@'.format(
|
|
user=NotifyEmail.quote(user, safe=''),
|
|
password=self.pprint(
|
|
self.password, privacy, mode=PrivacyMode.Secret, safe=''),
|
|
)
|
|
elif user:
|
|
# user url
|
|
auth = '{user}@'.format(
|
|
user=NotifyEmail.quote(user, safe=''),
|
|
)
|
|
|
|
# Default Port setup
|
|
default_port = SECURE_MODES[self.secure_mode]['default_port']
|
|
|
|
# a simple boolean check as to whether we display our target emails
|
|
# or not
|
|
has_targets = \
|
|
not (len(self.targets) == 1
|
|
and self.targets[0][1] == self.from_addr[1])
|
|
|
|
return '{schema}://{auth}{hostname}{port}/{targets}?{params}'.format(
|
|
schema=self.secure_protocol if self.secure else self.protocol,
|
|
auth=auth,
|
|
# never encode hostname since we're expecting it to be a valid one
|
|
hostname=self.host,
|
|
port='' if self.port is None or self.port == default_port
|
|
else ':{}'.format(self.port),
|
|
targets='' if not has_targets else '/'.join(
|
|
[NotifyEmail.quote('{}{}'.format(
|
|
'' if not e[0] else '{}:'.format(e[0]), e[1]),
|
|
safe='') for e in self.targets]),
|
|
params=NotifyEmail.urlencode(params),
|
|
)
|
|
|
|
def __len__(self):
|
|
"""
|
|
Returns the number of targets associated with this notification
|
|
"""
|
|
targets = len(self.targets)
|
|
return targets if targets > 0 else 1
|
|
|
|
@staticmethod
|
|
def parse_url(url):
|
|
"""
|
|
Parses the URL and returns enough arguments that can allow
|
|
us to re-instantiate this object.
|
|
|
|
"""
|
|
results = NotifyBase.parse_url(url)
|
|
if not results:
|
|
# We're done early as we couldn't load the results
|
|
return results
|
|
|
|
# The From address is a must; either through the use of templates
|
|
# from= entry and/or merging the user and hostname together, this
|
|
# must be calculated or parse_url will fail.
|
|
from_addr = ''
|
|
|
|
# The server we connect to to send our mail to
|
|
smtp_host = ''
|
|
|
|
# Get our potential email targets; if none our found we'll just
|
|
# add one to ourselves
|
|
results['targets'] = NotifyEmail.split_path(results['fullpath'])
|
|
|
|
# Attempt to detect 'to' email address
|
|
if 'to' in results['qsd'] and len(results['qsd']['to']):
|
|
results['targets'].append(results['qsd']['to'])
|
|
|
|
# Attempt to detect 'from' email address
|
|
if 'from' in results['qsd'] and len(results['qsd']['from']):
|
|
from_addr = NotifyEmail.unquote(results['qsd']['from'])
|
|
|
|
if 'name' in results['qsd'] and len(results['qsd']['name']):
|
|
# Depricate use of both `from=` and `name=` in the same url as
|
|
# they will be synomomus of one another in the future.
|
|
from_addr = formataddr(
|
|
(NotifyEmail.unquote(results['qsd']['name']), from_addr),
|
|
charset='utf-8')
|
|
logger.warning(
|
|
'Email name= and from= are synonymous; '
|
|
'use one or the other.')
|
|
|
|
elif 'name' in results['qsd'] and len(results['qsd']['name']):
|
|
# Extract from name to associate with from address
|
|
from_addr = NotifyEmail.unquote(results['qsd']['name'])
|
|
|
|
# Store SMTP Host if specified
|
|
if 'smtp' in results['qsd'] and len(results['qsd']['smtp']):
|
|
# Extract the smtp server
|
|
smtp_host = NotifyEmail.unquote(results['qsd']['smtp'])
|
|
|
|
if 'mode' in results['qsd'] and len(results['qsd']['mode']):
|
|
# Extract the secure mode to over-ride the default
|
|
results['secure_mode'] = results['qsd']['mode'].lower()
|
|
|
|
# Handle Carbon Copy Addresses
|
|
if 'cc' in results['qsd'] and len(results['qsd']['cc']):
|
|
results['cc'] = results['qsd']['cc']
|
|
|
|
# Handle Blind Carbon Copy Addresses
|
|
if 'bcc' in results['qsd'] and len(results['qsd']['bcc']):
|
|
results['bcc'] = results['qsd']['bcc']
|
|
|
|
# Handle Reply To Addresses
|
|
if 'reply' in results['qsd'] and len(results['qsd']['reply']):
|
|
results['reply_to'] = results['qsd']['reply']
|
|
|
|
results['from_addr'] = from_addr
|
|
results['smtp_host'] = smtp_host
|
|
|
|
# Add our Meta Headers that the user can provide with their outbound
|
|
# emails
|
|
results['headers'] = {NotifyBase.unquote(x): NotifyBase.unquote(y)
|
|
for x, y in results['qsd+'].items()}
|
|
|
|
return results
|