def test_sendmail_transactional(self):
"Test sendmail_transactional"
message = Mock()
datamanager = Mock()
sendmail_transactional("*****@*****.**", "*****@*****.**", message, datamanager=datamanager)
datamanager.put.assert_called_once_with("*****@*****.**", "*****@*****.**", message)
def send_email(self, datamanager=None):
pool = Pool()
Configuration = pool.get('ir.configuration')
Lang = pool.get('ir.lang')
from_ = self.level.email_from or config.get('email', 'from')
to = []
if self.party.email:
name = str(Header(self.party.rec_name))
to.append(formataddr((name, self.party.email)))
cc = []
bcc = []
languages = set()
if self.party.lang:
languages.add(self.party.lang)
else:
lang, = Lang.search([
('code', '=', Configuration.get_language()),
], limit=1)
languages.add(lang)
msg = self._email(from_, to, cc, bcc, languages)
to_addrs = [e for _, e in getaddresses(to + cc + bcc)]
if to_addrs:
if not pool.test:
sendmail_transactional(
from_, to_addrs, msg, datamanager=datamanager)
return self._email_log(msg)
def request_subscribe(self, email, from_=None):
pool = Pool()
Email = pool.get('marketing.email')
# Randomize processing time to prevent guessing whether the email
# address is already subscribed to the list or not.
Transaction().atexit(time.sleep, random.random())
email = email.lower()
with Transaction().set_context(active_test=False):
records = Email.search([
('email', '=', email),
('list_', '=', self.id),
])
if not records:
record = Email(email=email, list_=self.id, active=False)
record.save()
else:
record, = records
if not record.active:
from_cfg = (config.get('marketing', 'email_from')
or config.get('email', 'from'))
msg, title = record.get_email_subscribe()
set_from_header(msg, from_cfg, from_ or from_cfg)
msg['To'] = record.email
msg['Subject'] = Header(title, 'utf-8')
sendmail_transactional(from_cfg, [record.email], msg)
def _send_email(from_, users, email_func):
from_cfg = config.get('email', 'from')
for user in users:
msg, title = email_func(user)
set_from_header(msg, from_cfg, from_ or from_cfg)
msg['To'] = user.email
msg['Subject'] = Header(title, 'utf-8')
sendmail_transactional(from_cfg, [user.email], msg)
def send_email(self, records, trigger):
pool = Pool()
Log = pool.get('notification.email.log')
datamanager = SMTPDataManager()
Transaction().join(datamanager)
from_ = self.from_ or config.get('email', 'from')
logs = []
for record in records:
languagues = set()
to = []
if self.recipients:
recipients = getattr(record, self.recipients.name, None)
if recipients:
languagues.update(self._get_languages(recipients))
to = self._get_addresses(recipients)
if not to and self.fallback_recipients:
languagues.update(self._get_languages(
self.fallback_recipients))
to = self._get_addresses(self.fallback_recipients)
cc = []
if self.recipients_secondary:
recipients_secondary = getattr(record,
self.recipients_secondary.name,
None)
if recipients_secondary:
languagues.update(
self._get_languages(recipients_secondary))
cc = self._get_addresses(recipients_secondary)
if not cc and self.fallback_recipients_secondary:
languagues.update(
self._get_languages(self.fallback_recipients_secondary))
cc = self._get_addresses(self.fallback_recipients_secondary)
bcc = []
if self.recipients_hidden:
recipients_hidden = getattr(record,
self.recipients_hidden.name, None)
if recipients_hidden:
languagues.update(self._get_languages(recipients_hidden))
bcc = self._get_addresses(recipients_hidden)
if not bcc and self.fallback_recipients_hidden:
languagues.update(
self._get_languages(self.fallback_recipients_hidden))
bcc = self._get_addresses(self.fallback_recipients_hidden)
msg = self.get_email(record, from_, to, cc, bcc, languagues)
to_addrs = [e for _, e in getaddresses(to + cc + bcc)]
if to_addrs:
sendmail_transactional(from_,
to_addrs,
msg,
datamanager=datamanager)
logs.append(
self.get_log(record, trigger, msg, bcc=', '.join(bcc)))
if logs:
Log.create(logs)
def _send_email(from_, users, email_func):
if from_ is None:
from_ = config.get('email', 'from')
for user in users:
msg, title = email_func(user)
msg['From'] = from_
msg['To'] = user.email
msg['Subject'] = Header(title, 'utf-8')
sendmail_transactional(from_, [user.email], msg)
def test_sendmail_transactional(self):
'Test sendmail_transactional'
message = Mock()
datamanager = Mock()
sendmail_transactional(
'*****@*****.**', '*****@*****.**', message,
datamanager=datamanager)
datamanager.put.assert_called_once_with(
'*****@*****.**', '*****@*****.**', message)
def _send_email(from_, users, email_func):
from_cfg = config.get('email', 'from')
for user in users:
if not user.email:
logger.info("Missing address for '%s' to send email", user.login)
continue
msg, title = email_func(user)
set_from_header(msg, from_cfg, from_ or from_cfg)
msg['To'] = user.email
msg['Subject'] = Header(title, 'utf-8')
sendmail_transactional(from_cfg, [user.email], msg)
def send_msg(self, from_addr, to_addrs, msg, type):
'''
Send message and return the list of email addresses sent
'''
User = Pool().get('res.user')
if not to_addrs:
return to_addrs
to_addrs = list(set(to_addrs))
users = User.search([
('email', 'in', to_addrs),
])
for user in users:
if not getattr(user, 'calendar_email_notification_' + type):
to_addrs.remove(user.email)
sendmail_transactional(from_addr, to_addrs, msg)
return to_addrs
def send_email(self, datamanager=None):
pool = Pool()
Configuration = pool.get('ir.configuration')
AccountConfig = pool.get('account.configuration')
Lang = pool.get('ir.lang')
account_config = AccountConfig(1)
from_ = self.level.email_from or config.get('email', 'from')
to = []
contact = self.party.contact_mechanism_get(
'email', usage=self.level.email_contact_mechanism)
if contact and contact.email:
name = str(Header(contact.name or self.party.rec_name))
to.append(formataddr((name, contact.email)))
elif account_config.dunning_email_fallback:
user = account_config.dunning_email_fallback
to.append(formataddr((self.party.rec_name, user.email)))
cc = []
bcc = []
languages = set()
if self.party.lang:
languages.add(self.party.lang)
else:
lang, = Lang.search([
('code', '=', Configuration.get_language()),
],
limit=1)
languages.add(lang)
msg = self._email(from_, to, cc, bcc, languages)
to_addrs = [e for _, e in getaddresses(to + cc + bcc)]
if to_addrs:
if not pool.test:
sendmail_transactional(from_,
to_addrs,
msg,
datamanager=datamanager)
return self._email_log(msg)
def send_email(self, records, trigger):
pool = Pool()
Log = pool.get('notification.email.log')
datamanager = SMTPDataManager()
Transaction().join(datamanager)
from_ = (config.get('notification_email', 'from')
or config.get('email', 'from'))
logs = []
for record in records:
to, to_languages = self._get_to(record)
cc, cc_languages = self._get_cc(record)
bcc, bcc_languages = self._get_bcc(record)
languagues = to_languages | cc_languages | bcc_languages
to_addrs = [e for _, e in getaddresses(to + cc + bcc)]
if to_addrs:
msg = self.get_email(record, from_, to, cc, bcc, languagues)
sendmail_transactional(from_,
to_addrs,
msg,
datamanager=datamanager)
logs.append(
self.get_log(record, trigger, msg, bcc=', '.join(bcc)))
if logs:
Log.create(logs)
def send(cls,
to='',
cc='',
bcc='',
subject='',
body='',
files=None,
record=None,
reports=None,
attachments=None):
pool = Pool()
User = pool.get('res.user')
ActionReport = pool.get('ir.action.report')
Attachment = pool.get('ir.attachment')
transaction = Transaction()
user = User(transaction.user)
Model = pool.get(record[0])
record = Model(record[1])
body_html = HTML_EMAIL % {
'subject': subject,
'body': body,
'signature': user.signature or '',
}
content = MIMEMultipart('alternative')
if html2text:
body_text = HTML_EMAIL % {
'subject': subject,
'body': body,
'signature': '',
}
converter = html2text.HTML2Text()
body_text = converter.handle(body_text)
if user.signature:
body_text += '\n-- \n' + converter.handle(user.signature)
part = MIMEText(body_text, 'plain', _charset='utf-8')
content.attach(part)
part = MIMEText(body_html, 'html', _charset='utf-8')
content.attach(part)
if files or reports or attachments:
msg = MIMEMultipart('mixed')
msg.attach(content)
if files is None:
files = []
else:
files = list(files)
for report_id in (reports or []):
report = ActionReport(report_id)
Report = pool.get(report.report_name, type='report')
ext, content, _, title = Report.execute([record.id], {
'action_id': report.id,
})
name = '%s.%s' % (title, ext)
if isinstance(content, str):
content = content.encode('utf-8')
files.append((name, content))
if attachments:
files += [(a.name, a.data)
for a in Attachment.browse(attachments)]
for name, data in files:
mimetype, _ = mimetypes.guess_type(name)
if mimetype:
attachment = MIMENonMultipart(*mimetype.split('/'))
attachment.set_payload(data)
encode_base64(attachment)
else:
attachment = MIMEApplication(data)
attachment.add_header('Content-Disposition',
'attachment',
filename=('utf-8', '', name))
msg.attach(attachment)
else:
msg = content
from_ = config.get('email', 'from')
set_from_header(msg, from_, user.email or from_)
msg['To'] = ', '.join(formataddr(a) for a in getaddresses([to]))
msg['Cc'] = ', '.join(formataddr(a) for a in getaddresses([cc]))
msg['Subject'] = Header(subject, 'utf-8')
to_addrs = list(
filter(
None,
map(str.strip,
_get_emails(to) + _get_emails(cc) + _get_emails(bcc))))
sendmail_transactional(from_,
to_addrs,
msg,
datamanager=SMTPDataManager(strict=True))
email = cls(recipients=to,
recipients_secondary=cc,
recipients_hidden=bcc,
addresses=[{
'address': a
} for a in to_addrs],
subject=subject,
body=body,
resource=record)
email.save()
with Transaction().set_context(_check_access=False):
attachments_ = []
for name, data in files:
attachments_.append(
Attachment(resource=email, name=name, data=data))
Attachment.save(attachments_)
return email
def send_msg(self, from_addr, to_addr, msg):
'''
Send message and return True if the mail has been sent
'''
sendmail_transactional(from_addr, to_addr, msg)
return True
def process(cls, messages=None, emails=None, smtpd_datamanager=None):
pool = Pool()
WebShortener = pool.get('web.shortened_url')
spy_pixel = config.getboolean('marketing',
'email_spy_pixel',
default=False)
@lru_cache(None)
def short(url, record):
url = WebShortener(record=record, redirect_url=url)
url.save()
return url.shortened_url
def convert_href(message):
def filter_(stream):
for kind, data, pos in stream:
if kind is START:
tag, attrs = data
if tag == 'a':
href = attrs.get('href')
attrs -= 'href'
href = short(href, str(message))
attrs |= [(QName('href'), href)]
data = tag, attrs
elif kind is END and data == 'body' and spy_pixel:
yield START, (QName('img'),
Attrs([
(QName('src'),
short(URL_OPEN, str(message))),
(QName('height'), '1'),
(QName('width'), '1'),
])), pos
yield END, QName('img'), pos
yield kind, data, pos
return filter_
if not smtpd_datamanager:
smtpd_datamanager = SMTPDataManager()
if messages is None:
messages = cls.search([
('state', '=', 'sending'),
])
for message in messages:
template = MarkupTemplate(message.content)
for email in (emails or message.list_.emails):
content = (template.generate(email=email).filter(
convert_href(message)).render())
name = email.party.rec_name if email.party else ''
from_cfg = (config.get('marketing', 'email_from')
or config.get('email', 'from'))
to = _formataddr(name, email.email)
msg = MIMEMultipart('alternative')
set_from_header(msg, from_cfg, message.from_ or from_cfg)
msg['To'] = to
msg['Subject'] = Header(message.title, 'utf-8')
if html2text:
converter = html2text.HTML2Text()
part = MIMEText(converter.handle(content),
'plain',
_charset='utf-8')
msg.attach(part)
part = MIMEText(content, 'html', _charset='utf-8')
msg.attach(part)
sendmail_transactional(from_cfg,
getaddresses([to]),
msg,
datamanager=smtpd_datamanager)
if not emails:
cls.sent(messages)
