275 lines
10 KiB
Python
275 lines
10 KiB
Python
# Copyright 2016 Tecnativa - Antonio Espinosa
|
|
# Copyright 2017 Tecnativa - David Vidal
|
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
|
|
|
|
import hashlib
|
|
import hmac
|
|
import logging
|
|
from datetime import datetime
|
|
|
|
import requests
|
|
|
|
from odoo import _, api, fields, models
|
|
from odoo.exceptions import UserError, ValidationError
|
|
from odoo.tools import email_split
|
|
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class MailTrackingEmail(models.Model):
|
|
_inherit = "mail.tracking.email"
|
|
|
|
def _country_search(self, country_code):
|
|
country = False
|
|
if country_code:
|
|
country = self.env["res.country"].search(
|
|
[("code", "=", country_code.upper())]
|
|
)
|
|
if country:
|
|
return country.id
|
|
return False
|
|
|
|
@property
|
|
def _mailgun_mandatory_fields(self):
|
|
return (
|
|
"event",
|
|
"timestamp",
|
|
"token",
|
|
"signature",
|
|
"tracking_email_id",
|
|
"odoo_db",
|
|
)
|
|
|
|
@property
|
|
def _mailgun_event_type_mapping(self):
|
|
return {
|
|
# Mailgun event type: tracking event type
|
|
"delivered": "delivered",
|
|
"opened": "open",
|
|
"clicked": "click",
|
|
"unsubscribed": "unsub",
|
|
"complained": "spam",
|
|
"bounced": "hard_bounce",
|
|
"dropped": "reject",
|
|
"accepted": "sent",
|
|
"failed": "error",
|
|
"rejected": "error",
|
|
}
|
|
|
|
def _mailgun_event_type_verify(self, event):
|
|
event = event or {}
|
|
mailgun_event_type = event.get("event")
|
|
if mailgun_event_type not in self._mailgun_event_type_mapping:
|
|
_logger.error("Mailgun: event type '%s' not supported", mailgun_event_type)
|
|
return False
|
|
# OK, event type is valid
|
|
return True
|
|
|
|
def _mailgun_signature(self, api_key, timestamp, token):
|
|
return hmac.new(
|
|
key=bytes(api_key, "utf-8"),
|
|
msg=bytes("{}{}".format(str(timestamp), str(token)), "utf-8"),
|
|
digestmod=hashlib.sha256,
|
|
).hexdigest()
|
|
|
|
def _mailgun_values(self):
|
|
icp = self.env["ir.config_parameter"].sudo()
|
|
api_key = icp.get_param("mailgun.apikey")
|
|
if not api_key:
|
|
raise ValidationError(_("There is no Mailgun API key!"))
|
|
api_url = icp.get_param("mailgun.api_url", "https://api.mailgun.net/v3")
|
|
catchall_domain = icp.get_param("mail.catchall.domain")
|
|
domain = icp.get_param("mailgun.domain", catchall_domain)
|
|
if not domain:
|
|
raise ValidationError(_("A Mailgun domain value is needed!"))
|
|
validation_key = icp.get_param("mailgun.validation_key")
|
|
return api_key, api_url, domain, validation_key
|
|
|
|
def _mailgun_signature_verify(self, event):
|
|
event = event or {}
|
|
icp = self.env["ir.config_parameter"].sudo()
|
|
api_key = icp.get_param("mailgun.apikey")
|
|
if not api_key:
|
|
_logger.warning(
|
|
"No Mailgun api key configured. "
|
|
"Please add 'mailgun.apikey' to System parameters "
|
|
"to enable Mailgun authentication webhoook "
|
|
"requests. More info at: "
|
|
"https://documentation.mailgun.com/"
|
|
"user_manual.html#webhooks"
|
|
)
|
|
else:
|
|
timestamp = event.get("timestamp")
|
|
token = event.get("token")
|
|
signature = event.get("signature")
|
|
event_digest = self._mailgun_signature(api_key, timestamp, token)
|
|
if signature != event_digest:
|
|
_logger.error(
|
|
"Mailgun: Invalid signature '%s' != '%s'", signature, event_digest
|
|
)
|
|
return False
|
|
# OK, signature is valid
|
|
return True
|
|
|
|
def _db_verify(self, event):
|
|
event = event or {}
|
|
odoo_db = event.get("odoo_db")
|
|
current_db = self.env.cr.dbname
|
|
if odoo_db != current_db:
|
|
_logger.error("Mailgun: Database '%s' is not the current database", odoo_db)
|
|
return False
|
|
# OK, DB is current
|
|
return True
|
|
|
|
def _mailgun_metadata(self, mailgun_event_type, event, metadata):
|
|
# Get Mailgun timestamp when found
|
|
ts = event.get("timestamp", False)
|
|
try:
|
|
ts = float(ts)
|
|
except Exception:
|
|
ts = False
|
|
if ts:
|
|
dt = datetime.utcfromtimestamp(ts)
|
|
metadata.update(
|
|
{
|
|
"timestamp": ts,
|
|
"time": fields.Datetime.to_string(dt),
|
|
"date": fields.Date.to_string(dt),
|
|
"mailgun_id": event.get("id", False),
|
|
}
|
|
)
|
|
# Common field mapping
|
|
mapping = {
|
|
"recipient": "recipient",
|
|
"ip": "ip",
|
|
"user_agent": "user-agent",
|
|
"os_family": "client-os",
|
|
"ua_family": "client-name",
|
|
"ua_type": "client-type",
|
|
"url": "url",
|
|
}
|
|
for k, v in mapping.items():
|
|
if event.get(v, False):
|
|
metadata[k] = event[v]
|
|
# Special field mapping
|
|
metadata.update(
|
|
{
|
|
"mobile": event.get("device-type") in {"mobile", "tablet"},
|
|
"user_country_id": self._country_search(event.get("country", False)),
|
|
}
|
|
)
|
|
# Mapping for special events
|
|
if mailgun_event_type == "bounced":
|
|
metadata.update(
|
|
{
|
|
"error_type": event.get("code", False),
|
|
"error_description": event.get("error", False),
|
|
"error_details": event.get("notification", False),
|
|
}
|
|
)
|
|
elif mailgun_event_type == "dropped":
|
|
metadata.update(
|
|
{
|
|
"error_type": event.get("reason", False),
|
|
"error_description": event.get("code", False),
|
|
"error_details": event.get("description", False),
|
|
}
|
|
)
|
|
elif mailgun_event_type == "complained":
|
|
metadata.update(
|
|
{
|
|
"error_type": "spam",
|
|
"error_description": "Recipient '%s' mark this email as spam"
|
|
% event.get("recipient", False),
|
|
}
|
|
)
|
|
return metadata
|
|
|
|
def _mailgun_tracking_get(self, event):
|
|
tracking = False
|
|
tracking_email_id = event.get("tracking_email_id", False)
|
|
if tracking_email_id and tracking_email_id.isdigit():
|
|
tracking = self.search([("id", "=", tracking_email_id)], limit=1)
|
|
return tracking
|
|
|
|
def _event_is_from_mailgun(self, event):
|
|
event = event or {}
|
|
return all([k in event for k in self._mailgun_mandatory_fields])
|
|
|
|
@api.model
|
|
def event_process(self, request, post, metadata, event_type=None):
|
|
res = super(MailTrackingEmail, self).event_process(
|
|
request, post, metadata, event_type=event_type
|
|
)
|
|
if res == "NONE" and self._event_is_from_mailgun(post):
|
|
if not self._mailgun_signature_verify(post):
|
|
res = "ERROR: Signature"
|
|
elif not self._mailgun_event_type_verify(post):
|
|
res = "ERROR: Event type not supported"
|
|
elif not self._db_verify(post):
|
|
res = "ERROR: Invalid DB"
|
|
else:
|
|
res = "OK"
|
|
if res == "OK":
|
|
mailgun_event_type = post.get("event")
|
|
mapped_event_type = (
|
|
self._mailgun_event_type_mapping.get(mailgun_event_type) or event_type
|
|
)
|
|
if not mapped_event_type: # pragma: no cover
|
|
res = "ERROR: Bad event"
|
|
tracking = self._mailgun_tracking_get(post)
|
|
if not tracking:
|
|
res = "ERROR: Tracking not found"
|
|
if res == "OK":
|
|
# Complete metadata with mailgun event info
|
|
metadata = self._mailgun_metadata(mailgun_event_type, post, metadata)
|
|
# Create event
|
|
tracking.event_create(mapped_event_type, metadata)
|
|
if res != "NONE":
|
|
if event_type:
|
|
_logger.info("Mailgun: event '%s' process '%s'", event_type, res)
|
|
else:
|
|
_logger.info("Mailgun: event process '%s'", res)
|
|
return res
|
|
|
|
@api.multi
|
|
def action_manual_check_mailgun(self):
|
|
"""
|
|
Manual check against Mailgun API
|
|
API Documentation:
|
|
https://documentation.mailgun.com/en/latest/api-events.html
|
|
"""
|
|
api_key, api_url, domain, validation_key = self._mailgun_values()
|
|
for tracking in self:
|
|
if not tracking.mail_message_id:
|
|
raise UserError(_("There is no tracked message!"))
|
|
message_id = tracking.mail_message_id.message_id.replace("<", "").replace(
|
|
">", ""
|
|
)
|
|
res = requests.get(
|
|
"{}/{}/events".format(api_url, domain),
|
|
auth=("api", api_key),
|
|
params={
|
|
"begin": tracking.timestamp,
|
|
"ascending": "yes",
|
|
"message-id": message_id,
|
|
},
|
|
)
|
|
if not res or res.status_code != 200:
|
|
raise ValidationError(_("Couldn't retrieve Mailgun information"))
|
|
content = res.json()
|
|
if "items" not in content:
|
|
raise ValidationError(_("Event information not longer stored"))
|
|
for item in content["items"]:
|
|
# mailgun event hasn't been synced and recipient is the same as
|
|
# in the evaluated tracking. We use email_split since tracking
|
|
# recipient could come in format: "example" <to@dest.com>
|
|
if not self.env["mail.tracking.event"].search(
|
|
[("mailgun_id", "=", item["id"])]
|
|
) and (item.get("recipient", "") == email_split(tracking.recipient)[0]):
|
|
mapped_event_type = self._mailgun_event_type_mapping.get(
|
|
item["event"], item["event"]
|
|
)
|
|
metadata = self._mailgun_metadata(mapped_event_type, item, {})
|
|
tracking.event_create(mapped_event_type, metadata)
|