size
int64 0
304k
| ext
stringclasses 1
value | lang
stringclasses 1
value | branch
stringclasses 1
value | content
stringlengths 0
304k
| avg_line_length
float64 0
238
| max_line_length
int64 0
304k
|
---|---|---|---|---|---|---|
1,155 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Pedro M. Baeza <[email protected]>
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from . import base
class MailMailStatisticsCase(base.BaseCase):
def test_link_partner(self):
partner = self.create_partner({"name": "Test partner"})
stat = self.env["mailing.trace"].create(
{"model": "res.partner", "res_id": partner.id}
)
self.assertEqual(partner.id, stat.partner_id.id)
def test_link_mail_contact(self):
partner = self.create_partner(
{"name": "Test partner", "email": "[email protected]"}
)
contact_vals = {
"partner_id": partner.id,
"list_ids": [[6, 0, [self.mailing_list.id]]],
}
contact = self.create_mailing_contact(contact_vals)
stat = self.env["mailing.trace"].create(
{"model": "mailing.contact", "res_id": contact.id}
)
self.assertEqual(partner.id, stat.partner_id.id)
| 38.5 | 1,155 |
2,637 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Tecnativa - Pedro M. Baeza
# Copyright 2015 Tecnativa - Antonio Espinosa
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# Copyright 2021 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.exceptions import ValidationError
from . import base
class ResPartnerCase(base.BaseCase):
def test_count_mass_mailing_contacts(self):
self.create_mailing_contact(
{"email": "[email protected]", "list_ids": [[6, 0, [self.mailing_list.id]]]}
)
self.create_mailing_contact(
{"email": "[email protected]", "list_ids": [[6, 0, [self.mailing_list2.id]]]}
)
self.assertEqual(self.partner.mass_mailing_contacts_count, 2)
def test_write_res_partner(self):
contact = self.create_mailing_contact(
{"email": "[email protected]", "list_ids": [[6, 0, [self.mailing_list.id]]]}
)
self.assertEqual(self.partner, contact.partner_id)
title_doctor = self.env.ref("base.res_partner_title_doctor")
country_cu = self.env.ref("base.cu")
category_8 = self.env.ref("base.res_partner_category_8")
category_11 = self.env.ref("base.res_partner_category_11")
self.partner.write(
{
"name": "Changed",
"email": "[email protected]",
"title": title_doctor.id,
"company_id": self.main_company.id,
"country_id": country_cu.id,
"category_id": [(6, 0, (category_8 | category_11).ids)],
}
)
self.check_mailing_contact_partner(contact)
with self.assertRaises(ValidationError):
self.partner.write({"email": False})
def test_write_res_partner_multi(self):
self.assertEqual(len(self.partner.category_id.ids), 2)
partner2 = self.partner.copy({"name": "Partner test 2"})
self.partner.write({"category_id": [(4, self.category_3.id)]})
self.assertEqual(len(self.partner.category_id.ids), 3)
self.assertEqual(len(partner2.category_id.ids), 2)
for partner in [self.partner, partner2]:
self.create_mailing_contact(
{"partner_id": partner.id, "list_ids": [[6, 0, [self.mailing_list.id]]]}
)
self.env["res.partner"].search(
[("id", "in", (self.partner.id, partner2.id))]
).write({"category_id": [(4, self.category_3.id)]})
self.assertEqual(len(self.partner.category_id.ids), 3)
self.assertEqual(len(partner2.category_id.ids), 3)
| 43.196721 | 2,635 |
1,488 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Ernesto tejeda
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.exceptions import ValidationError
from . import base
class MailMassMailingListCase(base.BaseCase):
def test_create_mass_mailing_list(self):
contact_test_1 = self.create_mailing_contact(
{"name": "Contact test 1", "partner_id": self.partner.id}
)
contact_test_2 = self.create_mailing_contact(
{"name": "Contact test 2", "partner_id": self.partner.id}
)
with self.assertRaises(ValidationError):
self.create_mailing_list(
{
"name": "List test Create Mailing List",
"contact_ids": [(6, 0, (contact_test_1 | contact_test_2).ids)],
}
)
def test_create_mass_mailing_list_with_subscription(self):
contact_test_1 = self.create_mailing_contact(
{"name": "Contact test 1", "partner_id": self.partner.id}
)
contact_test_2 = self.create_mailing_contact(
{"name": "Contact test 2", "partner_id": self.partner.id}
)
with self.assertRaises(ValidationError):
self.create_mailing_list(
{
"name": "List test Creat List With Subscription",
"contact_ids": [(4, contact_test_1.id), (4, contact_test_2.id)],
}
)
| 38.153846 | 1,488 |
1,737 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Pedro M. Baeza <[email protected]>
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.exceptions import UserError
from . import base
class PartnerMailListWizardCase(base.BaseCase):
def test_add_to_mail_list(self):
wizard = self.env["partner.mail.list.wizard"].create(
{"mail_list_id": self.mailing_list.id}
)
wizard.partner_ids = [self.partner.id]
wizard.add_to_mail_list()
contacts = self.env["mailing.contact"].search(
[("partner_id", "=", self.partner.id)]
)
cont = contacts.filtered(lambda r: wizard.mail_list_id in r.list_ids)
self.assertEqual(len(cont), 1)
self.check_mailing_contact_partner(cont)
# This line does not create a new contact
wizard.add_to_mail_list()
self.assertEqual(len(self.partner.mass_mailing_contact_ids), 1)
self.assertEqual(
self.partner.mass_mailing_contact_ids.list_ids, self.mailing_list
)
list_2 = self.create_mailing_list({"name": "Test Add to List"})
wizard.mail_list_id = list_2
wizard.add_to_mail_list()
self.assertEqual(len(self.partner.mass_mailing_contact_ids), 1)
self.assertEqual(
self.partner.mass_mailing_contact_ids.list_ids, self.mailing_list | list_2
)
partner = self.env["res.partner"].create({"name": "No email partner"})
wizard.partner_ids = [partner.id]
with self.assertRaises(UserError):
wizard.add_to_mail_list()
| 40.395349 | 1,737 |
2,769 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Pedro M. Baeza <[email protected]>
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import TransactionCase
class BaseCase(TransactionCase):
def setUp(self):
super(BaseCase, self).setUp()
self.main_company = self.env.ref("base.main_company")
self.country_es = self.env.ref("base.es")
self.category_0 = self.env.ref("base.res_partner_category_0")
self.category_2 = self.env.ref("base.res_partner_category_2")
self.title_mister = self.env.ref("base.res_partner_title_mister")
self.partner = self.create_partner(
{
"name": "Partner test",
"email": "[email protected]",
"title": self.title_mister.id,
"company_id": self.main_company.id,
"country_id": self.country_es.id,
"category_id": [(6, 0, (self.category_0 | self.category_2).ids)],
}
)
self.category_3 = self.env.ref("base.res_partner_category_3")
self.mailing_list = self.create_mailing_list({"name": "List test"})
self.mailing_list2 = self.create_mailing_list(
{
"name": "List test 2",
"partner_mandatory": True,
"partner_category": self.category_3.id,
}
)
def create_partner(self, vals):
m_partner = self.env["res.partner"]
return m_partner.create(vals)
def create_mailing_contact(self, vals):
m_mailing_contact = self.env["mailing.contact"]
return m_mailing_contact.create(vals)
def create_mailing_list(self, vals):
m_mailing_list = self.env["mailing.list"]
return m_mailing_list.create(vals)
def check_mailing_contact_partner(self, mailing_contact):
if mailing_contact.partner_id:
self.assertEqual(mailing_contact.partner_id.email, mailing_contact.email)
self.assertEqual(mailing_contact.partner_id.name, mailing_contact.name)
self.assertEqual(mailing_contact.partner_id.title, mailing_contact.title_id)
if mailing_contact.partner_id.company_id:
self.assertEqual(
mailing_contact.partner_id.company_id.name,
mailing_contact.company_name,
)
self.assertEqual(
mailing_contact.partner_id.country_id, mailing_contact.country_id
)
self.assertEqual(
mailing_contact.partner_id.category_id, mailing_contact.tag_ids
)
| 41.328358 | 2,769 |
1,733 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Pedro M. Baeza <[email protected]>
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, fields, models
from odoo.exceptions import UserError
class PartnerMailListWizard(models.TransientModel):
_name = "partner.mail.list.wizard"
_description = "Create contact mailing list"
mail_list_id = fields.Many2one(comodel_name="mailing.list", string="Mailing List")
partner_ids = fields.Many2many(
comodel_name="res.partner",
relation="mail_list_wizard_partner",
default=lambda self: self.env.context.get("active_ids"),
)
def add_to_mail_list(self):
contact_obj = self.env["mailing.contact"]
partners = self.partner_ids
add_list = partners.filtered("mass_mailing_contact_ids")
for partner in add_list:
self.mail_list_id.contact_ids = [
(4, partner.mass_mailing_contact_ids[0].id)
]
to_create = partners - add_list
for partner in to_create:
if not partner.email:
raise UserError(_("Partner '%s' has no email.") % partner.name)
contact_vals = {
"partner_id": partner.id,
"list_ids": [(4, self.mail_list_id.id)],
"title_id": partner.title or False,
"company_name": partner.company_id.name or False,
"country_id": partner.country_id or False,
"tag_ids": partner.category_id or False,
}
contact_obj.create(contact_vals)
| 39.386364 | 1,733 |
1,013 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
class BasePartnerMergeAutomaticWizard(models.TransientModel):
_inherit = "base.partner.merge.automatic.wizard"
def _merge(self, partner_ids, dst_partner=None, extra_checks=True):
if dst_partner:
contacts = (
self.env["mailing.contact"]
.sudo()
.search([("partner_id", "in", partner_ids)])
)
if contacts:
contacts = contacts.sorted(
lambda x: 1 if x.partner_id == dst_partner else 0
)
list_ids = contacts.mapped("list_ids").ids
contacts[1:].unlink()
contacts[0].partner_id = dst_partner
contacts[0].list_ids = [(4, x) for x in list_ids]
return super()._merge(
partner_ids, dst_partner=dst_partner, extra_checks=extra_checks
)
| 37.444444 | 1,011 |
4,068 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Pedro M. Baeza <[email protected]>
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2017 David Vidal <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# Copyright 2020 Hibou Corp.
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class MailingContact(models.Model):
_inherit = "mailing.contact"
partner_id = fields.Many2one(
comodel_name="res.partner", string="Partner", domain=[("email", "!=", False)]
)
@api.constrains("partner_id", "list_ids")
def _check_partner_id_list_ids(self):
for contact in self:
if contact.partner_id:
other_contact = self.search(
[
("partner_id", "=", contact.partner_id.id),
("id", "!=", contact.id),
]
)
if contact.list_ids & other_contact.mapped("list_ids"):
raise ValidationError(
_("Partner already exists in one of these mailing lists")
+ ": %s" % contact.partner_id.display_name
)
@api.onchange("partner_id")
def _onchange_partner_mass_mailing_partner(self):
if self.partner_id:
self.name = self.partner_id.name
self.email = self.partner_id.email
self.title_id = self.partner_id.title
self.company_name = self.partner_id.company_id.name
self.country_id = self.partner_id.country_id
category_ids = self.partner_id.category_id
if category_ids:
self.tag_ids = category_ids
@api.model
def create(self, vals):
record = self.new(vals)
if not record.partner_id:
record._set_partner()
record._onchange_partner_mass_mailing_partner()
new_vals = record._convert_to_write(record._cache)
new_vals.update(
subscription_list_ids=vals.get("subscription_list_ids", []),
list_ids=vals.get("list_ids", []),
)
return super().create(new_vals)
def write(self, vals):
for contact in self:
new_vals = contact.copy_data(vals)[0]
record = self.new(new_vals)
if not record.partner_id:
record._set_partner()
record._onchange_partner_mass_mailing_partner()
new_vals = record._convert_to_write(record._cache)
new_vals.update(
subscription_list_ids=vals.get("subscription_list_ids", []),
list_ids=vals.get("list_ids", []),
)
super(MailingContact, contact).write(new_vals)
return True
def _get_categories(self):
ca_ids = self.tag_ids.ids + self.list_ids.mapped("partner_category.id")
return [[6, 0, ca_ids]]
def _prepare_partner(self):
return {
"name": self.name or self.email,
"email": self.email,
"country_id": self.country_id.id,
"title": self.title_id.id,
"company_name": self.company_name,
"company_id": False,
"category_id": self._get_categories(),
}
def _set_partner(self):
self.ensure_one()
if not self.email:
return
m_partner = self.env["res.partner"]
# Look for a partner with that email
email = self.email.strip()
partner = m_partner.search([("email", "=ilike", email)], limit=1)
if partner:
# Partner found
self.partner_id = partner
else:
lts = self.subscription_list_ids.mapped("list_id") | self.list_ids
if lts.filtered("partner_mandatory"):
# Create partner
partner_vals = self._prepare_partner()
self.partner_id = m_partner.sudo().create(partner_vals)
| 38.018692 | 4,068 |
1,165 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
class MailingTrace(models.Model):
_inherit = "mailing.trace"
partner_id = fields.Many2one(
string="Partner", comodel_name="res.partner", readonly=True
)
@api.model
def partner_id_from_obj(self, model, res_id):
partner_id = False
obj = self.env[model].browse(res_id)
if obj.exists():
if model == "res.partner":
partner_id = res_id
elif "partner_id" in obj._fields:
partner_id = obj.partner_id.id
return partner_id
def partner_link(self):
for stat in self.filtered(lambda r: r.model and r.res_id):
partner_id = self.partner_id_from_obj(stat.model, stat.res_id)
if partner_id != stat.partner_id.id:
stat.partner_id = partner_id
return True
@api.model
def create(self, vals):
stat = super().create(vals)
stat.partner_link()
return stat
| 31.486486 | 1,165 |
787 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Ernesto Tejeda
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, api, models
from odoo.exceptions import ValidationError
class MailingContactSubscription(models.Model):
_inherit = "mailing.contact.subscription"
@api.constrains("contact_id", "list_id")
def _check_contact_id_partner_id_list_id(self):
for rel in self:
if rel.contact_id.partner_id:
contacts = rel.list_id.contact_ids - rel.contact_id
if rel.contact_id.partner_id in contacts.mapped("partner_id"):
raise ValidationError(
_("A partner cannot be multiple times in the same list")
)
| 39.35 | 787 |
1,288 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Pedro M. Baeza <[email protected]>
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class MailingList(models.Model):
_inherit = "mailing.list"
partner_mandatory = fields.Boolean(string="Mandatory Partner", default=False)
partner_category = fields.Many2one(
comodel_name="res.partner.category", string="Partner Tag"
)
@api.constrains("contact_ids")
def _check_contact_ids_partner_id(self):
contact_obj = self.env["mailing.contact"]
for mailing_list in self:
data = contact_obj.read_group(
[
("id", "in", mailing_list.contact_ids.ids),
("partner_id", "!=", False),
],
["partner_id"],
["partner_id"],
)
if len(list(filter(lambda r: r["partner_id_count"] > 1, data))):
raise ValidationError(
_("A partner cannot be multiple times " "in the same list")
)
| 37.882353 | 1,288 |
3,545 |
py
|
PYTHON
|
15.0
|
# Copyright 2015 Pedro M. Baeza <[email protected]>
# Copyright 2015 Antonio Espinosa <[email protected]>
# Copyright 2015 Javier Iniesta <[email protected]>
# Copyright 2017 David Vidal <[email protected]>
# Copyright 2020 Tecnativa - Manuel Calero
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import _, api, fields, models
from odoo.exceptions import ValidationError
class ResPartner(models.Model):
_inherit = "res.partner"
mass_mailing_contact_ids = fields.One2many(
string="Mailing contacts",
comodel_name="mailing.contact",
inverse_name="partner_id",
)
mass_mailing_contacts_count = fields.Integer(
string="Mailing contacts number",
compute="_compute_mass_mailing_contacts_count",
store=True,
compute_sudo=True,
)
mass_mailing_stats_ids = fields.One2many(
string="Mass mailing stats",
comodel_name="mailing.trace",
inverse_name="partner_id",
)
mass_mailing_stats_count = fields.Integer(
string="Mass mailing stats number",
compute="_compute_mass_mailing_stats_count",
store=True,
)
@api.constrains("email")
def _check_email_mass_mailing_contacts(self):
for partner in self:
if not partner.email and partner.sudo().mass_mailing_contact_ids:
raise ValidationError(
_(
"This partner '%s' is linked to one or more mass "
"mailing contact. Email must be assigned."
)
% partner.name
)
@api.depends("mass_mailing_contact_ids")
def _compute_mass_mailing_contacts_count(self):
contact_data = self.env["mailing.contact"].read_group(
[("partner_id", "in", self.ids)], ["partner_id"], ["partner_id"]
)
mapped_data = {
contact["partner_id"][0]: contact["partner_id_count"]
for contact in contact_data
}
for partner in self:
partner.mass_mailing_contacts_count = mapped_data.get(partner.id, 0)
@api.depends("mass_mailing_stats_ids")
def _compute_mass_mailing_stats_count(self):
contact_data = self.env["mailing.trace"].read_group(
[("partner_id", "in", self.ids)], ["partner_id"], ["partner_id"]
)
mapped_data = {
contact["partner_id"][0]: contact["partner_id_count"]
for contact in contact_data
}
for partner in self:
partner.mass_mailing_stats_count = mapped_data.get(partner.id, 0)
def write(self, vals):
res = super().write(vals)
mm_vals = {}
if vals.get("name"):
mm_vals["name"] = vals["name"]
if vals.get("email"):
mm_vals["email"] = vals["email"]
if vals.get("title"):
mm_vals["title_id"] = vals["title"]
if vals.get("company_id"):
company = self.env["res.company"].browse(vals.get("company_id"))
mm_vals["company_name"] = company.name
if vals.get("country_id"):
mm_vals["country_id"] = vals["country_id"]
if vals.get("category_id"):
mm_vals["tag_ids"] = vals["category_id"]
if mm_vals:
# Using sudo because ACLs shouldn't produce data inconsistency
self.env["mailing.contact"].sudo().search(
[("partner_id", "in", self.ids)]
).write(mm_vals)
return res
| 37.712766 | 3,545 |
1,974 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# Copyright 2018 David Vidal - <[email protected]>
# Copyright 2018 Tecnativa - Ernesto Tejeda
# Copyright 2019 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Email tracking",
"summary": "Email tracking system for all mails sent",
"version": "15.0.3.0.0",
"category": "Social Network",
"website": "https://github.com/OCA/social",
"author": ("Tecnativa, " "Odoo Community Association (OCA)"),
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["mail"],
"data": [
"data/tracking_data.xml",
"security/mail_tracking_email_security.xml",
"security/ir.model.access.csv",
"views/mail_tracking_email_view.xml",
"views/mail_tracking_event_view.xml",
"views/mail_message_view.xml",
"views/res_partner_view.xml",
],
"assets": {
"web.assets_backend": [
"mail_tracking/static/src/css/mail_tracking.scss",
"mail_tracking/static/src/css/failed_message.scss",
"mail_tracking/static/src/js/mail_tracking.esm.js",
"mail_tracking/static/src/js/message.esm.js",
"mail_tracking/static/src/js/failed_message/mail_failed_box.esm.js",
"mail_tracking/static/src/js/failed_message/thread.esm.js",
"mail_tracking/static/src/js/models/thread.esm.js",
"mail_tracking/static/src/js/chatter.esm.js",
"mail_tracking/static/src/js/discuss/discuss.esm.js",
],
"web.assets_qweb": [
"mail_tracking/static/src/xml/mail_tracking.xml",
"mail_tracking/static/src/xml/failed_message/common.xml",
"mail_tracking/static/src/xml/failed_message/thread.xml",
"mail_tracking/static/src/xml/failed_message/discuss.xml",
],
},
"demo": ["demo/demo.xml"],
}
| 42 | 1,974 |
28,589 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import base64
import time
import mock
import psycopg2
import psycopg2.errorcodes
from odoo import http
from odoo.tests import users
from odoo.tests.common import TransactionCase
from odoo.tools import mute_logger
from ..controllers.main import BLANK, MailTrackingController
mock_send_email = "odoo.addons.base.models.ir_mail_server." "IrMailServer.send_email"
class FakeUserAgent(object):
browser = "Test browser"
platform = "Test platform"
def __str__(self):
"""Return name"""
return "Test suite"
class TestMailTracking(TransactionCase):
def setUp(self, *args, **kwargs):
super(TestMailTracking, self).setUp(*args, **kwargs)
self.sender = self.env["res.partner"].create(
{"name": "Test sender", "email": "[email protected]"}
)
self.recipient = self.env["res.partner"].create(
{"name": "Test recipient", "email": "[email protected]"}
)
self.last_request = http.request
http.request = type(
"obj",
(object,),
{
"env": self.env,
"cr": self.env.cr,
"db": self.env.cr.dbname,
"endpoint": type("obj", (object,), {"routing": []}),
"httprequest": type(
"obj",
(object,),
{"remote_addr": "123.123.123.123", "user_agent": FakeUserAgent()},
),
},
)
def tearDown(self, *args, **kwargs):
http.request = self.last_request
return super(TestMailTracking, self).tearDown(*args, **kwargs)
def test_empty_email(self):
self.recipient.write({"email_bounced": True})
self.recipient.write({"email": False})
self.assertEqual(False, self.recipient.email)
self.assertEqual(False, self.recipient.email_bounced)
self.recipient.write({"email_bounced": True})
self.recipient.write({"email": ""})
self.assertEqual(False, self.recipient.email_bounced)
self.assertEqual(False, self.env["mail.tracking.email"].email_is_bounced(False))
self.assertEqual(
0.0, self.env["mail.tracking.email"].email_score_from_email(False)
)
def test_recipient_address_compute(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.write({"recipient": False})
self.assertEqual(False, tracking.recipient_address)
@users("admin", "demo")
def test_message_post(self):
# This message will generate a notification for recipient
message = (
self.env["mail.message"]
.sudo()
.create(
{
"subject": "Message test",
"author_id": self.sender.id,
"email_from": self.sender.email,
"message_type": "comment",
"model": "res.partner",
"res_id": self.recipient.id,
"partner_ids": [(4, self.recipient.id)],
"body": "<p>This is a test message</p>",
}
)
)
if message.is_thread_message():
self.env[message.model].browse(message.res_id)._notify_thread(message)
# Search tracking created
tracking_email = self.env["mail.tracking.email"].search(
[
("mail_message_id", "=", message.id),
("partner_id", "=", self.recipient.id),
]
)
# The tracking email must be sent
self.assertTrue(tracking_email)
self.assertEqual(tracking_email.state, "sent")
# message_dict read by web interface
message_dict = message.message_format()[0]
self.assertTrue(len(message_dict["partner_ids"]) > 0)
# First partner is recipient
partner_id = message_dict["partner_ids"][0]
self.assertEqual(partner_id, self.recipient.id)
status = message_dict["partner_trackings"][0]
# Tracking status must be sent and
# mail tracking must be the one search before
self.assertEqual(status["status"], "sent")
self.assertEqual(status["tracking_id"], tracking_email.id)
self.assertEqual(status["recipient"], self.recipient.display_name)
self.assertEqual(status["partner_id"], self.recipient.id)
self.assertEqual(status["isCc"], False)
# And now open the email
metadata = {
"ip": "127.0.0.1",
"user_agent": "Odoo Test/1.0",
"os_family": "linux",
"ua_family": "odoo",
}
tracking_email.event_create("open", metadata)
self.assertEqual(tracking_email.state, "opened")
def test_message_post_partner_no_email(self):
# Create message with recipient without defined email
self.recipient.write({"email": False})
message = self.env["mail.message"].create(
{
"subject": "Message test",
"author_id": self.sender.id,
"email_from": self.sender.email,
"message_type": "comment",
"model": "res.partner",
"res_id": self.recipient.id,
"partner_ids": [(4, self.recipient.id)],
"body": "<p>This is a test message</p>",
}
)
if message.is_thread_message():
self.env[message.model].browse(message.res_id).with_context(
do_not_send_copy=True
)._notify_thread(message)
# Search tracking created
tracking_email = self.env["mail.tracking.email"].search(
[
("mail_message_id", "=", message.id),
("partner_id", "=", self.recipient.id),
]
)
# No email should generate a error state: no_recipient
self.assertEqual(tracking_email.state, "error")
self.assertEqual(tracking_email.error_type, "no_recipient")
self.assertFalse(self.recipient.email_bounced)
def _check_partner_trackings_cc(self, message):
message_dict = message.message_format()[0]
self.assertEqual(len(message_dict["partner_trackings"]), 3)
# mail cc
foundPartner = False
foundNoPartner = False
for tracking in message_dict["partner_trackings"]:
if tracking["partner_id"] == self.sender.id:
foundPartner = True
self.assertTrue(tracking["isCc"])
elif tracking["recipient"] == "[email protected]":
foundNoPartner = True
self.assertFalse(tracking["partner_id"])
self.assertTrue(tracking["isCc"])
elif tracking["partner_id"] == self.recipient.id:
self.assertFalse(tracking["isCc"])
self.assertTrue(foundPartner)
self.assertTrue(foundNoPartner)
def test_email_cc(self):
sender_user = self.env["res.users"].create(
{
"name": "Sender User Test",
"partner_id": self.sender.id,
"login": "sender-test",
}
)
# pylint: disable=C8107
message = self.recipient.with_user(sender_user).message_post(
body="<p>This is a test message</p>",
email_cc="Dominique Pinon <[email protected]>, [email protected]",
)
# suggested recipients
recipients = self.recipient._message_get_suggested_recipients()
suggested_mails = {email[1] for email in recipients[self.recipient.id]}
self.assertIn("[email protected]", suggested_mails)
self.assertEqual(len(recipients[self.recipient.id]), 3)
# Repeated Cc recipients
message = self.env["mail.message"].create(
{
"subject": "Message test",
"author_id": self.sender.id,
"email_from": self.sender.email,
"message_type": "comment",
"model": "res.partner",
"res_id": self.recipient.id,
"partner_ids": [(4, self.recipient.id)],
"email_cc": "Dominique Pinon <[email protected]>, [email protected]"
", [email protected]",
"body": "<p>This is another test message</p>",
}
)
if message.is_thread_message():
self.env[message.model].browse(message.res_id)._notify_thread(message)
recipients = self.recipient._message_get_suggested_recipients()
self.assertEqual(len(recipients[self.recipient.id]), 3)
self._check_partner_trackings_cc(message)
def _check_partner_trackings_to(self, message):
message_dict = message.message_format()[0]
self.assertEqual(len(message_dict["partner_trackings"]), 4)
# mail cc
foundPartner = False
foundNoPartner = False
for tracking in message_dict["partner_trackings"]:
if tracking["partner_id"] == self.sender.id:
foundPartner = True
elif tracking["recipient"] == "[email protected]":
foundNoPartner = True
self.assertFalse(tracking["partner_id"])
self.assertTrue(foundPartner)
self.assertTrue(foundNoPartner)
def test_email_to(self):
sender_user = self.env["res.users"].create(
{
"name": "Sender User Test",
"partner_id": self.sender.id,
"login": "sender-test",
}
)
# pylint: disable=C8107
message = self.recipient.with_user(sender_user).message_post(
body="<p>This is a test message</p>",
email_to="Dominique Pinon <[email protected]>, [email protected]",
)
# suggested recipients
recipients = self.recipient._message_get_suggested_recipients()
suggested_mails = {email[1] for email in recipients[self.recipient.id]}
self.assertIn("[email protected]", suggested_mails)
self.assertEqual(len(recipients[self.recipient.id]), 3)
# Repeated To recipients
message = self.env["mail.message"].create(
{
"subject": "Message test",
"author_id": self.sender.id,
"email_from": self.sender.email,
"message_type": "comment",
"model": "res.partner",
"res_id": self.recipient.id,
"partner_ids": [(4, self.recipient.id)],
"email_to": "Dominique Pinon <[email protected]>"
", [email protected], [email protected]"
", [email protected]",
"body": "<p>This is another test message</p>",
}
)
if message.is_thread_message():
self.env[message.model].browse(message.res_id)._notify_thread(message)
recipients = self.recipient._message_get_suggested_recipients()
self.assertEqual(len(recipients[self.recipient.id]), 4)
self._check_partner_trackings_to(message)
# Catchall + Alias
IrConfigParamObj = self.env["ir.config_parameter"].sudo()
IrConfigParamObj.set_param("mail.catchall.alias", "TheCatchall")
IrConfigParamObj.set_param("mail.catchall.domain", "test.com")
self.env["mail.alias"].create(
{
"alias_model_id": self.env["ir.model"]._get("res.partner").id,
"alias_name": "support+unnamed",
}
)
recipients = self.recipient._message_get_suggested_recipients()
self.assertEqual(len(recipients[self.recipient.id]), 2)
suggested_mails = {email[1] for email in recipients[self.recipient.id]}
self.assertNotIn("[email protected]", suggested_mails)
def test_failed_message(self):
MailMessageObj = self.env["mail.message"]
# Create message
mail, tracking = self.mail_send(self.recipient.email)
self.assertFalse(tracking.mail_message_id.mail_tracking_needs_action)
# Force error state
tracking.state = "error"
self.assertTrue(tracking.mail_message_id.mail_tracking_needs_action)
failed_count = MailMessageObj.get_failed_count()
self.assertTrue(failed_count > 0)
values = tracking.mail_message_id.get_failed_messages()
self.assertEqual(values[0]["id"], tracking.mail_message_id.id)
messages = MailMessageObj.search([])
messages_failed = MailMessageObj.search([["is_failed_message", "=", True]])
self.assertTrue(messages)
self.assertTrue(messages_failed)
self.assertTrue(len(messages) > len(messages_failed))
tracking.mail_message_id.set_need_action_done()
self.assertFalse(tracking.mail_message_id.mail_tracking_needs_action)
self.assertTrue(MailMessageObj.get_failed_count() < failed_count)
# No author_id
tracking.mail_message_id.author_id = False
values = tracking.mail_message_id.get_failed_messages()[0]
if values and values.get("author"):
self.assertEqual(values["author"][0], -1)
def test_resend_failed_message(self):
# This message will generate a notification for recipient
message = self.env["mail.message"].create(
{
"subject": "Message test",
"author_id": self.sender.id,
"email_from": self.sender.email,
"message_type": "comment",
"model": "res.partner",
"res_id": self.recipient.id,
"partner_ids": [(4, self.recipient.id)],
"body": "<p>This is a test message</p>",
}
)
if message.is_thread_message():
self.env[message.model].browse(message.res_id)._notify_thread(message)
# Search tracking created
tracking_email = self.env["mail.tracking.email"].search(
[
("mail_message_id", "=", message.id),
("partner_id", "=", self.recipient.id),
]
)
# Force error state
tracking_email.state = "error"
# Create resend mail wizard
wizard = (
self.env["mail.resend.message"]
.sudo()
.with_context(mail_message_to_resend=message.id)
.create({})
)
# Check failed recipient)s
self.assertTrue(any(wizard.partner_ids))
self.assertEqual(self.recipient.email, wizard.partner_ids[0].email)
# Resend message
wizard.resend_mail_action()
# Check tracking reset
self.assertFalse(tracking_email.state)
def mail_send(self, recipient):
mail = self.env["mail.mail"].create(
{
"subject": "Test subject",
"email_from": "[email protected]",
"email_to": recipient,
"body_html": "<p>This is a test message</p>",
}
)
mail.send()
# Search tracking created
tracking_email = self.env["mail.tracking.email"].search(
[("mail_id", "=", mail.id)]
)
return mail, tracking_email
def test_mail_send(self):
controller = MailTrackingController()
db = self.env.cr.dbname
image = base64.b64decode(BLANK)
mail, tracking = self.mail_send(self.recipient.email)
self.assertEqual(mail.email_to, tracking.recipient)
self.assertEqual(mail.email_from, tracking.sender)
with mock.patch("odoo.http.db_filter") as mock_client:
mock_client.return_value = True
res = controller.mail_tracking_open(db, tracking.id, tracking.token)
self.assertEqual(image, res.response[0])
# Two events: sent and open
self.assertEqual(2, len(tracking.tracking_event_ids))
# Fake event: tracking_email_id = False
res = controller.mail_tracking_open(db, False, False)
self.assertEqual(image, res.response[0])
# Two events again because no tracking_email_id found for False
self.assertEqual(2, len(tracking.tracking_event_ids))
def test_mail_tracking_open(self):
controller = MailTrackingController()
db = self.env.cr.dbname
with mock.patch("odoo.http.db_filter") as mock_client:
mock_client.return_value = True
mail, tracking = self.mail_send(self.recipient.email)
# Tracking is in sent or delivered state. But no token give.
# Don't generates tracking event
controller.mail_tracking_open(db, tracking.id)
self.assertEqual(1, len(tracking.tracking_event_ids))
tracking.write({"state": "opened"})
# Tracking isn't in sent or delivered state.
# Don't generates tracking event
controller.mail_tracking_open(db, tracking.id, tracking.token)
self.assertEqual(1, len(tracking.tracking_event_ids))
tracking.write({"state": "sent"})
# Tracking is in sent or delivered state and a token is given.
# Generates tracking event
controller.mail_tracking_open(db, tracking.id, tracking.token)
self.assertEqual(2, len(tracking.tracking_event_ids))
# Generate new email due concurrent event filter
mail, tracking = self.mail_send(self.recipient.email)
tracking.write({"token": False})
# Tracking is in sent or delivered state but a token is given for a
# record that doesn't have a token.
# Don't generates tracking event
controller.mail_tracking_open(db, tracking.id, "tokentest")
self.assertEqual(1, len(tracking.tracking_event_ids))
# Tracking is in sent or delivered state and not token is given for
# a record that doesn't have a token.
# Generates tracking event
controller.mail_tracking_open(db, tracking.id, False)
self.assertEqual(2, len(tracking.tracking_event_ids))
def test_concurrent_open(self):
mail, tracking = self.mail_send(self.recipient.email)
ts = time.time()
metadata = {
"ip": "127.0.0.1",
"user_agent": "Odoo Test/1.0",
"os_family": "linux",
"ua_family": "odoo",
"timestamp": ts,
}
# First open event
tracking.event_create("open", metadata)
opens = tracking.tracking_event_ids.filtered(lambda r: r.event_type == "open")
self.assertEqual(len(opens), 1)
# Concurrent open event
metadata["timestamp"] = ts + 2
tracking.event_create("open", metadata)
opens = tracking.tracking_event_ids.filtered(lambda r: r.event_type == "open")
self.assertEqual(len(opens), 1)
# Second open event
metadata["timestamp"] = ts + 350
tracking.event_create("open", metadata)
opens = tracking.tracking_event_ids.filtered(lambda r: r.event_type == "open")
self.assertEqual(len(opens), 2)
def test_concurrent_click(self):
mail, tracking = self.mail_send(self.recipient.email)
ts = time.time()
metadata = {
"ip": "127.0.0.1",
"user_agent": "Odoo Test/1.0",
"os_family": "linux",
"ua_family": "odoo",
"timestamp": ts,
"url": "https://www.example.com/route/1",
}
# First click event (URL 1)
tracking.event_create("click", metadata)
opens = tracking.tracking_event_ids.filtered(lambda r: r.event_type == "click")
self.assertEqual(len(opens), 1)
# Concurrent click event (URL 1)
metadata["timestamp"] = ts + 2
tracking.event_create("click", metadata)
opens = tracking.tracking_event_ids.filtered(lambda r: r.event_type == "click")
self.assertEqual(len(opens), 1)
# Second click event (URL 1)
metadata["timestamp"] = ts + 350
tracking.event_create("click", metadata)
opens = tracking.tracking_event_ids.filtered(lambda r: r.event_type == "click")
self.assertEqual(len(opens), 2)
# Concurrent click event (URL 2)
metadata["timestamp"] = ts + 2
metadata["url"] = "https://www.example.com/route/2"
tracking.event_create("click", metadata)
opens = tracking.tracking_event_ids.filtered(lambda r: r.event_type == "click")
self.assertEqual(len(opens), 3)
@mute_logger("odoo.addons.mail.models.mail_mail")
def test_smtp_error(self):
with mock.patch(mock_send_email) as mock_func:
mock_func.side_effect = Warning("Test error")
mail, tracking = self.mail_send(self.recipient.email)
self.assertEqual("error", tracking.state)
self.assertEqual("Warning", tracking.error_type)
self.assertEqual("Test error", tracking.error_description)
self.assertTrue(self.recipient.email_bounced)
def test_partner_email_change(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("open", {})
orig_score = self.recipient.email_score
orig_count = self.recipient.tracking_emails_count
orig_email = self.recipient.email
self.recipient.email = orig_email + "2"
self.assertEqual(50.0, self.recipient.email_score)
self.assertEqual(0, self.recipient.tracking_emails_count)
self.recipient.email = orig_email
self.assertEqual(orig_score, self.recipient.email_score)
self.assertEqual(orig_count, self.recipient.tracking_emails_count)
def test_process_hard_bounce(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("hard_bounce", {})
self.assertEqual("bounced", tracking.state)
self.assertTrue(self.recipient.email_score < 50.0)
def test_process_soft_bounce(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("soft_bounce", {})
self.assertEqual("soft-bounced", tracking.state)
self.assertTrue(self.recipient.email_score < 50.0)
def test_process_delivered(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("delivered", {})
self.assertEqual("delivered", tracking.state)
self.assertTrue(self.recipient.email_score > 50.0)
def test_process_deferral(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("deferral", {})
self.assertEqual("deferred", tracking.state)
def test_process_spam(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("spam", {})
self.assertEqual("spam", tracking.state)
self.assertTrue(self.recipient.email_score < 50.0)
def test_process_unsub(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("unsub", {})
self.assertEqual("unsub", tracking.state)
self.assertTrue(self.recipient.email_score < 50.0)
def test_process_reject(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("reject", {})
self.assertEqual("rejected", tracking.state)
self.assertTrue(self.recipient.email_score < 50.0)
def test_process_open(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("open", {})
self.assertEqual("opened", tracking.state)
self.assertTrue(self.recipient.email_score > 50.0)
def test_process_click(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("click", {})
self.assertEqual("opened", tracking.state)
self.assertTrue(self.recipient.email_score > 50.0)
def test_process_several_bounce(self):
for _i in range(1, 10):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("hard_bounce", {})
self.assertEqual("bounced", tracking.state)
self.assertEqual(0.0, self.recipient.email_score)
def test_bounce_new_partner(self):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("hard_bounce", {})
new_partner = self.env["res.partner"].create({"name": "Test New Partner"})
new_partner.email = self.recipient.email
self.assertTrue(new_partner.email_bounced)
def test_recordset_email_score(self):
"""For backwords compatibility sake"""
trackings = self.env["mail.tracking.email"]
for _i in range(11):
mail, tracking = self.mail_send(self.recipient.email)
tracking.event_create("click", {})
trackings |= tracking
self.assertEqual(100.0, trackings.email_score())
def test_db(self):
db = self.env.cr.dbname
controller = MailTrackingController()
with mock.patch("odoo.http.db_filter") as mock_client:
mock_client.return_value = True
with self.assertRaises(psycopg2.OperationalError):
controller.mail_tracking_event("not_found_db")
none = controller.mail_tracking_event(db)
self.assertEqual(b"NONE", none.response[0])
none = controller.mail_tracking_event(db, "open")
self.assertEqual(b"NONE", none.response[0])
def test_bounce_tracking_event_created(self):
mail, tracking = self.mail_send(self.recipient.email)
message = self.env.ref("mail.mail_message_channel_1_1")
message.mail_tracking_ids = [(4, tracking.id, False)]
mail.mail_message_id = message
message_dict = {
"bounced_email": "[email protected]",
"bounced_message": message,
"bounced_msg_id": [message.message_id],
"bounced_partner": self.recipient,
"cc": "",
"date": "2023-02-07 12:35:53",
"email_from": "[email protected]",
"from": "[email protected]",
"in_reply_to": "<010201864d109aa7-west-1.amazonses.com>",
"is_internal": False,
"message_id": "<010201862be01f29-west-1.amazonses.com>",
"message_type": "email",
"parent_id": 15894917,
"partner_ids": [],
"recipients": "[email protected]",
"references": "<010201862bdfa5e9-west-1.amazonses.com>",
"subject": "bounce notification",
"to": "[email protected]",
}
self.env["mail.thread"]._routing_handle_bounce(message, message_dict)
self.assertTrue(
"soft_bounce"
in message.mail_tracking_ids.tracking_event_ids.mapped("event_type")
)
def test_tracking_img_tag(self):
# As the img tag is not in the body of the returned mail.mail record,
# we have to intercept the IrMailServer.send_email method here to get
# the real outgoing mail body and check for the img tag with a
# side_effect function:
def assert_tracking_tag_side_effect(*args, **kwargs):
mail = args[0]
msg = "data-odoo-tracking-email not found"
if "data-odoo-tracking-email=" in mail.as_string():
msg = "data-odoo-tracking-email found"
raise AssertionError(msg)
with mock.patch(mock_send_email) as mock_func:
mock_func.side_effect = assert_tracking_tag_side_effect
self.env["ir.config_parameter"].set_param(
"mail_tracking.tracking_img_disabled", False
)
mail, tracking = self.mail_send(self.recipient.email)
self.assertEqual(
"data-odoo-tracking-email found", tracking.error_description
)
# now we change the system parameter "mail_tracking.img.disable"
# to True and check that the img tag is not in the outgoing mail
self.env["ir.config_parameter"].set_param(
"mail_tracking.tracking_img_disabled", True
)
mail, tracking = self.mail_send(self.recipient.email)
self.assertEqual(
"data-odoo-tracking-email not found", tracking.error_description
)
| 43.647328 | 28,589 |
6,282 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import re
import threading
from odoo import api, models, tools
class IrMailServer(models.Model):
_inherit = "ir.mail_server"
def _tracking_headers_add(self, tracking_email_id, headers):
"""Allow other addons to add its own tracking SMTP headers"""
headers = headers or {}
headers["X-Odoo-Database"] = getattr(threading.current_thread(), "dbname", None)
headers["X-Odoo-MailTracking-ID"] = tracking_email_id
return headers
def _tracking_email_id_body_get(self, body):
body = body or ""
# https://regex101.com/r/lW4cB1/2
match = re.search(r'<img[^>]*data-odoo-tracking-email=["\']([0-9]*)["\']', body)
return str(match.group(1)) if match and match.group(1) else False
def _tracking_img_disabled(self, tracking_email_id):
# while tracking_email_id is not needed in this implementation, it can
# be useful for other addons extending this function to make a more
# fine-grained decision
return (
self.env["ir.config_parameter"]
.sudo()
.get_param("mail_tracking.tracking_img_disabled", False)
)
def _tracking_img_remove(self, body):
return re.sub(
r'<img[^>]*data-odoo-tracking-email=["\'][0-9]*["\'][^>]*>', "", body
)
def build_email(
self,
email_from,
email_to,
subject,
body,
email_cc=None,
email_bcc=None,
reply_to=False,
attachments=None,
message_id=None,
references=None,
object_id=False,
subtype="plain",
headers=None,
body_alternative=None,
subtype_alternative="plain",
):
# Unfortunately we currently have to extract the mail.tracking.email
# record id from the tracking image in the body here as the core
# mail module does not allow headers to be inserted in the
# MailMail._send_prepare_values function.
# Things to consider before refactoring this:
# - There are third party modules completely replacing the
# MailMail._send function, so even when a future version
# of the core mail module supports adding headers there, we might
# want to wait a little until this feature has trickled through.
# - While it would be possible to find the mail.tracking.email
# record via the message_id and the email_to criteria, this
# would rely on the message having no duplicate recipient
# (e.g. different contacts having the same email address) and
# no other module inheriting the _send_prepare_values function
# modifying the email_to parameter.
tracking_email_id = self._tracking_email_id_body_get(body)
if tracking_email_id:
headers = self._tracking_headers_add(tracking_email_id, headers)
# Only after the X-Odoo-MailTracking-ID header is set we can remove
# the tracking image in case it's to be disabled
if self._tracking_img_disabled(tracking_email_id):
body = self._tracking_img_remove(body)
msg = super(IrMailServer, self).build_email(
email_from=email_from,
email_to=email_to,
subject=subject,
body=body,
email_cc=email_cc,
email_bcc=email_bcc,
reply_to=reply_to,
attachments=attachments,
message_id=message_id,
references=references,
object_id=object_id,
subtype=subtype,
headers=headers,
body_alternative=body_alternative,
subtype_alternative=subtype_alternative,
)
return msg
def _tracking_email_get(self, message):
try:
tracking_email_id = int(
message.get(
"X-Odoo-MailTracking-ID",
# Deprecated tracking header, kept as fallback
message["X-Odoo-Tracking-ID"],
)
)
except (TypeError, ValueError, KeyError):
tracking_email_id = False
return self.env["mail.tracking.email"].browse(tracking_email_id)
def _smtp_server_get(self, mail_server_id, smtp_server):
smtp_server_used = False
mail_server = None
if mail_server_id:
mail_server = self.browse(mail_server_id)
elif not smtp_server:
mail_server_ids = self.search([], order="sequence", limit=1)
mail_server = mail_server_ids[0] if mail_server_ids else None
if mail_server:
smtp_server_used = mail_server.smtp_host
else:
smtp_server_used = smtp_server or tools.config.get("smtp_server")
return smtp_server_used
@api.model
def send_email(
self,
message,
mail_server_id=None,
smtp_server=None,
smtp_port=None,
smtp_user=None,
smtp_password=None,
smtp_encryption=None,
smtp_debug=False,
smtp_session=None,
):
message_id = False
tracking_email = self._tracking_email_get(message)
smtp_server_used = self.sudo()._smtp_server_get(mail_server_id, smtp_server)
try:
message_id = super(IrMailServer, self).send_email(
message,
mail_server_id=mail_server_id,
smtp_server=smtp_server,
smtp_port=smtp_port,
smtp_user=smtp_user,
smtp_password=smtp_password,
smtp_encryption=smtp_encryption,
smtp_debug=smtp_debug,
smtp_session=smtp_session,
)
except Exception as e:
if tracking_email:
tracking_email.smtp_error(self, smtp_server_used, e)
if message_id and tracking_email:
vals = tracking_email._tracking_sent_prepare(
self, smtp_server_used, message, message_id
)
if vals:
self.env["mail.tracking.event"].sudo().create(vals)
return message_id
| 38.304878 | 6,282 |
2,275 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Alexandre Díaz
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, models
class MailResendMessage(models.TransientModel):
_inherit = "mail.resend.message"
@api.model
def default_get(self, fields):
rec = super().default_get(fields)
message_id = self._context.get("mail_message_to_resend")
if message_id:
MailMessageObj = self.env["mail.message"]
mail_message_id = MailMessageObj.browse(message_id)
failed_states = MailMessageObj.get_failed_states()
tracking_ids = mail_message_id.mail_tracking_ids.filtered(
lambda x: x.state in failed_states
)
if any(tracking_ids):
partner_ids = [
(
0,
0,
{
"partner_id": tracking.partner_id.id,
"name": tracking.partner_id.name,
"email": tracking.partner_id.email,
"resend": True,
"message": tracking.error_description,
},
)
for tracking in tracking_ids
]
rec["partner_ids"].extend(partner_ids)
return rec
def resend_mail_action(self):
for wizard in self:
to_send = wizard.partner_ids.filtered("resend").mapped("partner_id")
if to_send:
# Set as reviewed
wizard.mail_message_id.mail_tracking_needs_action = False
# Reset mail.tracking.email state
tracking_ids = wizard.mail_message_id.mail_tracking_ids.filtered(
lambda x: x.partner_id in to_send
)
tracking_ids.sudo().write({"state": False})
# Send bus notifications to update Discuss and
# mail_failed_messages widget
self.env["bus.bus"]._sendone(
self.env.user.partner_id.id,
"toggle_tracking_status",
self.mail_message_id.id,
)
return super().resend_mail_action()
| 39.894737 | 2,274 |
6,324 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import re
import time
from datetime import datetime
from odoo import api, fields, models
class MailTrackingEvent(models.Model):
_name = "mail.tracking.event"
_order = "timestamp desc"
_rec_name = "event_type"
_description = "MailTracking event"
recipient = fields.Char(readonly=True)
recipient_address = fields.Char(
string="Recipient email address",
readonly=True,
store=True,
compute="_compute_recipient_address",
index=True,
)
timestamp = fields.Float(
string="UTC timestamp", readonly=True, digits="MailTracking Timestamp"
)
time = fields.Datetime(readonly=True)
date = fields.Date(readonly=True, compute="_compute_date", store=True)
tracking_email_id = fields.Many2one(
string="Message",
readonly=True,
required=True,
ondelete="cascade",
comodel_name="mail.tracking.email",
index=True,
)
event_type = fields.Selection(
selection=[
("sent", "Sent"),
("delivered", "Delivered"),
("deferral", "Deferral"),
("hard_bounce", "Hard bounce"),
("soft_bounce", "Soft bounce"),
("open", "Open"),
("click", "Clicked"),
("spam", "Spam"),
("unsub", "Unsubscribed"),
("reject", "Rejected"),
],
readonly=True,
)
smtp_server = fields.Char(string="SMTP server", readonly=True)
url = fields.Char(string="Clicked URL", readonly=True)
ip = fields.Char(string="User IP", readonly=True)
user_agent = fields.Char(readonly=True)
mobile = fields.Boolean(string="Is mobile?", readonly=True)
os_family = fields.Char(string="Operating system family", readonly=True)
ua_family = fields.Char(string="User agent family", readonly=True)
ua_type = fields.Char(string="User agent type", readonly=True)
user_country_id = fields.Many2one(
string="User country", readonly=True, comodel_name="res.country"
)
error_type = fields.Char(readonly=True)
error_description = fields.Char(readonly=True)
error_details = fields.Text(readonly=True)
@api.depends("recipient")
def _compute_recipient_address(self):
for email in self:
if email.recipient:
matches = re.search(r"<(.*@.*)>", email.recipient)
if matches:
email.recipient_address = matches.group(1).lower()
else:
email.recipient_address = email.recipient.lower()
else:
email.recipient_address = False
@api.depends("time")
def _compute_date(self):
for email in self:
email.date = fields.Date.to_string(fields.Date.from_string(email.time))
def _process_data(self, tracking_email, metadata, event_type, state):
ts = time.time()
dt = datetime.utcfromtimestamp(ts)
return {
"recipient": metadata.get("recipient", tracking_email.recipient),
"timestamp": metadata.get("timestamp", ts),
"time": metadata.get("time", fields.Datetime.to_string(dt)),
"date": metadata.get("date", fields.Date.to_string(dt)),
"tracking_email_id": tracking_email.id,
"event_type": event_type,
"ip": metadata.get("ip", False),
"url": metadata.get("url", False),
"user_agent": metadata.get("user_agent", False),
"mobile": metadata.get("mobile", False),
"os_family": metadata.get("os_family", False),
"ua_family": metadata.get("ua_family", False),
"ua_type": metadata.get("ua_type", False),
"user_country_id": metadata.get("user_country_id", False),
"error_type": metadata.get("error_type", False),
"error_description": metadata.get("error_description", False),
"error_details": metadata.get("error_details", False),
}
def _process_status(self, tracking_email, metadata, event_type, state):
tracking_email.sudo().write({"state": state})
return self._process_data(tracking_email, metadata, event_type, state)
def _process_bounce(self, tracking_email, metadata, event_type, state):
tracking_email.sudo().write(
{
"state": state,
"bounce_type": metadata.get("bounce_type", False),
"bounce_description": metadata.get("bounce_description", False),
}
)
return self._process_data(tracking_email, metadata, event_type, state)
@api.model
def process_sent(self, tracking_email, metadata):
return self._process_status(tracking_email, metadata, "sent", "sent")
@api.model
def process_delivered(self, tracking_email, metadata):
return self._process_status(tracking_email, metadata, "delivered", "delivered")
@api.model
def process_deferral(self, tracking_email, metadata):
return self._process_status(tracking_email, metadata, "deferral", "deferred")
@api.model
def process_hard_bounce(self, tracking_email, metadata):
return self._process_bounce(tracking_email, metadata, "hard_bounce", "bounced")
@api.model
def process_soft_bounce(self, tracking_email, metadata):
return self._process_bounce(
tracking_email, metadata, "soft_bounce", "soft-bounced"
)
@api.model
def process_open(self, tracking_email, metadata):
return self._process_status(tracking_email, metadata, "open", "opened")
@api.model
def process_click(self, tracking_email, metadata):
return self._process_status(tracking_email, metadata, "click", "opened")
@api.model
def process_spam(self, tracking_email, metadata):
return self._process_status(tracking_email, metadata, "spam", "spam")
@api.model
def process_unsub(self, tracking_email, metadata):
return self._process_status(tracking_email, metadata, "unsub", "unsub")
@api.model
def process_reject(self, tracking_email, metadata):
return self._process_status(tracking_email, metadata, "reject", "rejected")
| 39.037037 | 6,324 |
5,802 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 Alexandre Díaz
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from email.utils import getaddresses
from lxml import etree
from odoo import _, api, fields, models
from odoo.tools import email_split, email_split_and_format
class MailThread(models.AbstractModel):
_inherit = "mail.thread"
failed_message_ids = fields.One2many(
"mail.message",
"res_id",
string="Failed Messages",
domain=lambda self: [("model", "=", self._name)]
+ self._get_failed_message_domain(),
)
def _get_failed_message_domain(self):
"""Domain used to display failed messages on the 'failed_messages'
widget"""
failed_states = self.env["mail.message"].get_failed_states()
return [
("mail_tracking_needs_action", "=", True),
("mail_tracking_ids.state", "in", list(failed_states)),
]
@api.model
def _message_route_process(self, message, message_dict, routes):
"""Adds CC recipient to the message.
Because Odoo implementation avoid store 'from, to, cc' recipients we
ensure that this information its written into the mail.message record.
"""
message_dict.update(
{
"email_cc": message_dict.get("cc", False),
"email_to": message_dict.get("to", False),
}
)
return super()._message_route_process(message, message_dict, routes)
def _routing_handle_bounce(self, email_message, message_dict):
bounced_message = message_dict["bounced_message"]
if bounced_message.mail_tracking_ids:
# TODO detect hard of soft bounce
bounced_message.mail_tracking_ids.event_create("soft_bounce", message_dict)
return super()._routing_handle_bounce(email_message, message_dict)
def _message_get_suggested_recipients(self):
"""Adds email 'extra' recipients as suggested recipients.
If the recipient has a res.partner, use it.
"""
res = super()._message_get_suggested_recipients()
self._add_extra_recipients_suggestions(res, "email_cc", _("Cc"))
self._add_extra_recipients_suggestions(res, "email_to", _("Anon. To"))
return res
def _add_extra_recipients_suggestions(self, suggestions, field_mail, reason):
ResPartnerObj = self.env["res.partner"]
aliases = self.env["mail.alias"].get_aliases()
email_extra_formated_list = []
for record in self:
emails_extra = record.message_ids.mapped(field_mail)
for email in emails_extra:
email_extra_formated_list.extend(email_split_and_format(email))
email_extra_formated_list = set(email_extra_formated_list)
email_extra_list = [x[1] for x in getaddresses(email_extra_formated_list)]
partners_info = self.sudo()._message_partner_info_from_emails(email_extra_list)
for pinfo in partners_info:
partner_id = pinfo["partner_id"]
email = email_split(pinfo["full_name"])[0].lower()
if not partner_id:
if email not in aliases:
self._message_add_suggested_recipient(
suggestions, email=email, reason=reason
)
else:
partner = ResPartnerObj.browse(partner_id)
self._message_add_suggested_recipient(
suggestions, partner=partner, reason=reason
)
@api.model
def _fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
"""Add filters for failed messages.
These filters will show up on any form or search views of any
model inheriting from ``mail.thread``.
"""
res = super()._fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type not in {"search", "form"}:
return res
doc = etree.XML(res["arch"])
if view_type == "search":
# Modify view to add new filter element
nodes = doc.xpath("//search")
if nodes:
# Create filter element
new_filter = etree.Element(
"filter",
{
"string": _("Failed sent messages"),
"name": "failed_message_ids",
"domain": str(
[
[
"failed_message_ids.mail_tracking_ids.state",
"in",
list(self.env["mail.message"].get_failed_states()),
],
[
"failed_message_ids.mail_tracking_needs_action",
"=",
True,
],
]
),
},
)
nodes[0].append(etree.Element("separator"))
nodes[0].append(new_filter)
elif view_type == "form":
# Modify view to add new field element
nodes = doc.xpath("//field[@name='message_ids' and @widget='mail_thread']")
if nodes:
# Create field
field_failed_messages = etree.Element(
"field",
{"name": "failed_message_ids", "widget": "mail_failed_message"},
)
nodes[0].addprevious(field_failed_messages)
res["arch"] = etree.tostring(doc, encoding="unicode")
return res
| 40.566434 | 5,801 |
635 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - Alexandre Díaz
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, models
class IrConfigParameter(models.Model):
_inherit = "ir.config_parameter"
@api.model_create_multi
def create(self, vals_list):
res = super().create(vals_list)
self.env["mail.alias"].clear_caches()
return res
def write(self, vals):
res = super().write(vals)
self.env["mail.alias"].clear_caches()
return res
def unlink(self):
res = super().unlink()
self.env["mail.alias"].clear_caches()
return res
| 26.416667 | 634 |
1,099 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Alexandre Díaz
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, models, tools
class MailAlias(models.Model):
_inherit = "mail.alias"
@api.model
@tools.ormcache()
def get_aliases(self):
aliases = {
x["display_name"]
for x in self.search_read([("alias_name", "!=", False)], ["display_name"])
}
IrConfigParamObj = self.env["ir.config_parameter"].sudo()
catchall = "{}@{}".format(
IrConfigParamObj.get_param("mail.catchall.alias"),
IrConfigParamObj.get_param("mail.catchall.domain"),
)
aliases.add(catchall)
return aliases
@api.model_create_multi
def create(self, vals_list):
res = super().create(vals_list)
self.clear_caches()
return res
def write(self, vals):
res = super().write(vals)
if "alias_name" in vals:
self.clear_caches()
return res
def unlink(self):
res = super().unlink()
self.clear_caches()
return res
| 27.45 | 1,098 |
18,209 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import logging
import re
import time
import urllib.parse
import uuid
from datetime import datetime
from odoo import _, api, fields, models, tools
from odoo.exceptions import AccessError
from odoo.tools import email_split
_logger = logging.getLogger(__name__)
EVENT_OPEN_DELTA = 10 # seconds
EVENT_CLICK_DELTA = 5 # seconds
class MailTrackingEmail(models.Model):
_name = "mail.tracking.email"
_order = "time desc"
_rec_name = "display_name"
_description = "MailTracking email"
# This table is going to grow fast and to infinite, so we index:
# - name: Search in tree view
# - time: default order fields
# - recipient_address: Used for email_store calculation (non-store)
# - state: Search and group_by in tree view
name = fields.Char(string="Subject", readonly=True, index=True)
display_name = fields.Char(
readonly=True,
store=True,
compute="_compute_tracking_display_name",
)
timestamp = fields.Float(
string="UTC timestamp", readonly=True, digits="MailTracking Timestamp"
)
time = fields.Datetime(readonly=True, index=True)
date = fields.Date(readonly=True, compute="_compute_date", store=True)
mail_message_id = fields.Many2one(
string="Message", comodel_name="mail.message", readonly=True, index=True
)
message_id = fields.Char(compute="_compute_message_id")
mail_id = fields.Many2one(string="Email", comodel_name="mail.mail", readonly=True)
partner_id = fields.Many2one(
string="Partner", comodel_name="res.partner", readonly=True
)
recipient = fields.Char(string="Recipient email", readonly=True)
recipient_address = fields.Char(
string="Recipient email address",
readonly=True,
store=True,
compute="_compute_recipient_address",
index=True,
)
sender = fields.Char(string="Sender email", readonly=True)
state = fields.Selection(
[
("error", "Error"),
("deferred", "Deferred"),
("sent", "Sent"),
("delivered", "Delivered"),
("opened", "Opened"),
("rejected", "Rejected"),
("spam", "Spam"),
("unsub", "Unsubscribed"),
("bounced", "Bounced"),
("soft-bounced", "Soft bounced"),
],
index=True,
readonly=True,
default=False,
help=" * The 'Error' status indicates that there was an error "
"when trying to sent the email, for example, "
"'No valid recipient'\n"
" * The 'Sent' status indicates that message was succesfully "
"sent via outgoing email server (SMTP).\n"
" * The 'Delivered' status indicates that message was "
"succesfully delivered to recipient Mail Exchange (MX) server.\n"
" * The 'Opened' status indicates that message was opened or "
"clicked by recipient.\n"
" * The 'Rejected' status indicates that recipient email "
"address is blacklisted by outgoing email server (SMTP). "
"It is recomended to delete this email address.\n"
" * The 'Spam' status indicates that outgoing email "
"server (SMTP) consider this message as spam.\n"
" * The 'Unsubscribed' status indicates that recipient has "
"requested to be unsubscribed from this message.\n"
" * The 'Bounced' status indicates that message was bounced "
"by recipient Mail Exchange (MX) server.\n"
" * The 'Soft bounced' status indicates that message was soft "
"bounced by recipient Mail Exchange (MX) server.\n",
)
error_smtp_server = fields.Char(string="Error SMTP server", readonly=True)
error_type = fields.Char(readonly=True)
error_description = fields.Char(readonly=True)
bounce_type = fields.Char(readonly=True)
bounce_description = fields.Char(readonly=True)
tracking_event_ids = fields.One2many(
string="Tracking events",
comodel_name="mail.tracking.event",
inverse_name="tracking_email_id",
readonly=True,
)
# Token isn't generated here to have compatibility with older trackings.
# New trackings have token and older not
token = fields.Char(
string="Security Token",
readonly=True,
default=lambda s: uuid.uuid4().hex,
groups="base.group_system",
)
@api.depends("mail_message_id")
def _compute_message_id(self):
"""This helper field will allow us to map the message_id from either the linked
mail.message or a mass.mailing mail.trace.
"""
self.message_id = False
for tracking in self.filtered("mail_message_id"):
tracking.message_id = tracking.mail_message_id.message_id
@api.model_create_multi
def create(self, vals_list):
records = super().create(vals_list)
failed_states = self.env["mail.message"].get_failed_states()
records.filtered(lambda one: one.state in failed_states).mapped(
"mail_message_id"
).write({"mail_tracking_needs_action": True})
return records
def write(self, vals):
res = super().write(vals)
state = vals.get("state")
if state and state in self.env["mail.message"].get_failed_states():
self.mapped("mail_message_id").write({"mail_tracking_needs_action": True})
return res
def _find_allowed_tracking_ids(self):
"""Filter trackings based on related records ACLs"""
# Admins passby this filter
if not self or self.env.user.has_group("base.group_system"):
return self.ids
# Override ORM to get the values directly
self._cr.execute(
"""
SELECT id, mail_message_id, partner_id
FROM mail_tracking_email WHERE id IN %s
""",
(tuple(self.ids),),
)
msg_linked = self._cr.fetchall()
if not msg_linked:
return []
_, msg_ids, partner_ids = zip(*msg_linked)
# Filter messages with their ACL rules avoiding False values fetched in the set
msg_ids = self.env["mail.message"]._search(
[("id", "in", [x for x in msg_ids if x])]
)
partner_ids = self.env["res.partner"]._search(
[("id", "in", [x for x in partner_ids if x])]
)
return [
track_id
for track_id, mail_msg_id, partner_id in msg_linked
if (mail_msg_id in msg_ids) # We can read the linked message
or (
not mail_msg_id and partner_id in partner_ids
) # No linked mail.message but we can read the linked partner
or (not any({mail_msg_id, partner_id})) # No linked record
]
@api.model
def _search(
self,
args,
offset=0,
limit=None,
order=None,
count=False,
access_rights_uid=None,
):
"""Filter ids based on related records ACLs"""
ids = super()._search(
args, offset, limit, order, count=count, access_rights_uid=access_rights_uid
)
if not self.env.user.has_group("base.group_system") and not count:
ids = self.browse(ids)._find_allowed_tracking_ids()
return ids
def check_access_rule(self, operation):
"""Rely on related messages ACLs"""
super().check_access_rule(operation)
allowed_ids = self._search([("id", "in", self._find_allowed_tracking_ids())])
disallowed_ids = set(self.exists().ids).difference(set(allowed_ids))
if not disallowed_ids:
return
raise AccessError(
_(
"The requested operation cannot be completed due to security "
"restrictions. Please contact your system administrator.\n\n"
"(Document type: %(desc)s, Operation: %(operation)s)"
)
% {"desc": self._description, "operation": operation}
+ " - ({} {}, {} {})".format(
_("Records:"), list(disallowed_ids), _("User:"), self._uid
)
)
def read(self, fields=None, load="_classic_read"):
"""Override to explicitly call check_access_rule, that is not called
by the ORM. It instead directly fetches ir.rules and apply them.
"""
if not self.env.user.has_group("base.group_system"):
self.check_access_rule("read")
return super().read(fields=fields, load=load)
@api.model
def email_is_bounced(self, email):
if not email:
return False
res = self.sudo()._email_last_tracking_state(email)
return res and res[0].get("state", "") in {
"rejected",
"error",
"spam",
"bounced",
}
@api.model
def _email_last_tracking_state(self, email):
return self.search_read(
[("recipient_address", "=", email.lower())],
["state"],
limit=1,
order="time DESC",
)
@api.model
def email_score_from_email(self, email):
if not email:
return 0.0
data = self.sudo().read_group(
[("recipient_address", "=", email.lower())],
["recipient_address", "state"],
["state"],
)
mapped_data = {state["state"]: state["state_count"] for state in data}
return self.with_context(mt_states=mapped_data).sudo().email_score()
@api.model
def _email_score_weights(self):
"""Default email score weights. Ready to be inherited"""
return {
"error": -50.0,
"rejected": -25.0,
"spam": -25.0,
"bounced": -25.0,
"soft-bounced": -10.0,
"unsub": -10.0,
"delivered": 1.0,
"opened": 5.0,
}
def email_score(self):
"""Default email score algorimth. Ready to be inherited
It can receive a recordset or mapped states dictionary via context.
Must return a value beetwen 0.0 and 100.0
- Bad reputation: Value between 0 and 50.0
- Unknown reputation: Value 50.0
- Good reputation: Value between 50.0 and 100.0
"""
weights = self._email_score_weights()
score = 50.0
states = self.env.context.get("mt_states", False)
if states:
for state in states.keys():
score += weights.get(state, 0.0) * states[state]
else:
for tracking in self:
score += weights.get(tracking.state, 0.0)
if score > 100.0:
score = 100.0
elif score < 0.0:
score = 0.0
return score
@api.depends("recipient")
def _compute_recipient_address(self):
for email in self:
email.recipient_address = False
recipient_email = email_split(email.recipient)
if recipient_email:
email.recipient_address = recipient_email[0].lower()
@api.depends("name", "recipient")
def _compute_tracking_display_name(self):
for email in self:
parts = [email.name or ""]
if email.recipient:
parts.append(email.recipient)
email.display_name = " - ".join(parts)
@api.depends("time")
def _compute_date(self):
for email in self:
email.date = fields.Date.to_string(fields.Date.from_string(email.time))
def _get_mail_tracking_img(self):
m_config = self.env["ir.config_parameter"]
base_url = m_config.get_param("mail_tracking.base.url") or m_config.get_param(
"web.base.url"
)
if self.token:
path_url = (
"mail/tracking/open/%(db)s/%(tracking_email_id)s/%(token)s/"
"blank.gif"
% {
"db": self.env.cr.dbname,
"tracking_email_id": self.id,
"token": self.token,
}
)
else:
# This is here for compatibility with older records
path_url = "mail/tracking/open/{db}/{tracking_email_id}/blank.gif".format(
db=self.env.cr.dbname, tracking_email_id=self.id
)
track_url = urllib.parse.urljoin(base_url, path_url)
return (
'<img src="%(url)s" alt="" '
'data-odoo-tracking-email="%(tracking_email_id)s"/>'
% {"url": track_url, "tracking_email_id": self.id}
)
def _partners_email_bounced_set(self, reason, event=None):
recipients = []
if event and event.recipient_address:
recipients.append(event.recipient_address)
else:
recipients = [x for x in self.mapped("recipient_address") if x]
for recipient in recipients:
self.env["res.partner"].search(
[("email", "=ilike", recipient)]
).email_bounced_set(self, reason, event=event)
def smtp_error(self, mail_server, smtp_server, exception):
values = {"state": "error"}
IrMailServer = self.env["ir.mail_server"]
if (
str(exception) == IrMailServer.NO_VALID_RECIPIENT
and not self.recipient_address
):
values.update(
{
"error_type": "no_recipient",
"error_description": "The partner doesn't have a defined email",
}
)
else:
values.update(
{
"error_smtp_server": tools.ustr(smtp_server),
"error_type": exception.__class__.__name__,
"error_description": tools.ustr(exception),
}
)
self.sudo()._partners_email_bounced_set("error")
self.sudo().write(values)
def tracking_img_add(self, email):
self.ensure_one()
tracking_url = self._get_mail_tracking_img()
if tracking_url:
content = email.get("body", "")
content = re.sub(
r'<img[^>]*data-odoo-tracking-email=["\'][0-9]*["\'][^>]*>', "", content
)
body = tools.append_content_to_html(
content, tracking_url, plaintext=False, container_tag="div"
)
email["body"] = body
return email
def _message_partners_check(self, message, message_id):
if not self.mail_message_id.exists(): # pragma: no cover
return True
mail_message = self.mail_message_id
partners = mail_message.notified_partner_ids | mail_message.partner_ids
if self.partner_id and self.partner_id not in partners:
# If mail_message haven't tracking partner, then
# add it in order to see his tracking status in chatter
if mail_message.subtype_id:
mail_message.sudo().write(
{"notified_partner_ids": [(4, self.partner_id.id)]}
)
else:
mail_message.sudo().write({"partner_ids": [(4, self.partner_id.id)]})
return True
def _tracking_sent_prepare(self, mail_server, smtp_server, message, message_id):
self.ensure_one()
ts = time.time()
dt = datetime.utcfromtimestamp(ts)
self._message_partners_check(message, message_id)
self.sudo().write({"state": "sent"})
return {
"recipient": message["To"],
"timestamp": "%.6f" % ts,
"time": fields.Datetime.to_string(dt),
"tracking_email_id": self.id,
"event_type": "sent",
"smtp_server": smtp_server,
}
def _event_prepare(self, event_type, metadata):
self.ensure_one()
m_event = self.env["mail.tracking.event"]
method = getattr(m_event, "process_" + event_type, None)
if method and callable(method):
return method(self, metadata)
else: # pragma: no cover
_logger.info("Unknown event type: %s" % event_type)
return False
def _concurrent_events(self, event_type, metadata):
m_event = self.env["mail.tracking.event"]
self.ensure_one()
concurrent_event_ids = False
if event_type in {"open", "click"}:
ts = metadata.get("timestamp", time.time())
delta = EVENT_OPEN_DELTA if event_type == "open" else EVENT_CLICK_DELTA
domain = [
("timestamp", ">=", ts - delta),
("timestamp", "<=", ts + delta),
("tracking_email_id", "=", self.id),
("event_type", "=", event_type),
]
if event_type == "click":
domain.append(("url", "=", metadata.get("url", False)))
concurrent_event_ids = m_event.search(domain)
return concurrent_event_ids
def event_create(self, event_type, metadata):
event_ids = self.env["mail.tracking.event"]
for tracking_email in self:
other_ids = tracking_email._concurrent_events(event_type, metadata)
if not other_ids:
vals = tracking_email._event_prepare(event_type, metadata)
if vals:
events = event_ids.sudo().create(vals)
if event_type in {"hard_bounce", "spam", "reject"}:
for event in events:
self.sudo()._partners_email_bounced_set(
event_type, event=event
)
event_ids += events
else:
_logger.debug("Concurrent event '%s' discarded", event_type)
return event_ids
# TODO Remove useless method
@api.model
def event_process(self, request, post, metadata, event_type=None):
# Generic event process hook, inherit it and
# - return 'OK' if processed
# - return 'NONE' if this request is not for you
# - return 'ERROR' if any error
return "NONE" # pragma: no cover
| 38.57839 | 18,209 |
1,643 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import time
from datetime import datetime
from email.utils import COMMASPACE
from odoo import fields, models
class MailMail(models.Model):
_inherit = "mail.mail"
def _tracking_email_prepare(self, partner, email):
"""Prepare email.tracking.email record values"""
ts = time.time()
dt = datetime.utcfromtimestamp(ts)
email_to_list = email.get("email_to", [])
email_to = COMMASPACE.join(email_to_list)
return {
"name": self.subject,
"timestamp": "%.6f" % ts,
"time": fields.Datetime.to_string(dt),
"mail_id": self.id,
"mail_message_id": self.mail_message_id.id,
"partner_id": partner.id if partner else False,
"recipient": email_to,
"sender": self.email_from,
}
def _send_prepare_values(self, partner=None):
"""Creates the mail.tracking.email record and adds the image tracking
to the email. Please note that because we can't add mail headers in this
function, the added tracking image will later (IrMailServer.build_email)
also be used to extract the mail.tracking.email record id and to set the
X-Odoo-MailTracking-ID header there.
"""
email = super()._send_prepare_values(partner=partner)
vals = self._tracking_email_prepare(partner, email)
tracking_email = self.env["mail.tracking.email"].sudo().create(vals)
return tracking_email.tracking_img_add(email)
| 40.073171 | 1,643 |
12,453 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# Copyright 2019 Alexandre Díaz
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from email.utils import getaddresses
from odoo import _, api, fields, models
from odoo.osv import expression
from odoo.tools import email_split
class MailMessage(models.Model):
_inherit = "mail.message"
# Recipients
email_cc = fields.Char(
"Cc", help="Additional recipients that receive a " '"Carbon Copy" of the e-mail'
)
email_to = fields.Char("To", help="Raw TO recipients")
mail_tracking_ids = fields.One2many(
comodel_name="mail.tracking.email",
inverse_name="mail_message_id",
auto_join=True,
string="Mail Trackings",
)
mail_tracking_needs_action = fields.Boolean(
help="The message tracking will be considered" " to filter tracking issues",
default=False,
)
is_failed_message = fields.Boolean(
compute="_compute_is_failed_message",
search="_search_is_failed_message",
)
@api.model
def get_failed_states(self):
"""The 'failed' states of the message"""
return {"error", "rejected", "spam", "bounced", "soft-bounced"}
@api.depends(
"mail_tracking_needs_action",
"author_id",
"notification_ids",
"mail_tracking_ids.state",
)
def _compute_is_failed_message(self):
"""Compute 'is_failed_message' field for the active user"""
failed_states = self.get_failed_states()
for message in self:
needs_action = message.mail_tracking_needs_action
involves_me = self.env.user.partner_id in (
message.author_id | message.notification_ids.mapped("res_partner_id")
)
has_failed_trackings = failed_states.intersection(
message.mapped("mail_tracking_ids.state")
)
message.is_failed_message = bool(
needs_action and involves_me and has_failed_trackings
)
def _search_is_failed_message(self, operator, value):
"""Search for messages considered failed for the active user.
Be notice that 'notificacion_ids' is a record that change if
the user mark the message as readed.
"""
# FIXME: Due to ORM issue with auto_join and 'OR' we construct the domain
# using an extra query to get valid results.
# For more information see: https://github.com/odoo/odoo/issues/25175
notification_partner_ids = self.search(
[("notification_ids.res_partner_id", "=", self.env.user.partner_id.id)]
)
return expression.normalize_domain(
[
(
"mail_tracking_ids.state",
"in" if value else "not in",
list(self.get_failed_states()),
),
("mail_tracking_needs_action", "=", True),
"|",
("author_id", "=", self.env.user.partner_id.id),
("id", "in", notification_partner_ids.ids),
]
)
def _tracking_status_map_get(self):
"""Map tracking states to be used in chatter"""
return {
"False": "waiting",
"error": "error",
"deferred": "sent",
"sent": "sent",
"delivered": "delivered",
"opened": "opened",
"rejected": "error",
"spam": "error",
"unsub": "opened",
"bounced": "error",
"soft-bounced": "error",
}
def _partner_tracking_status_get(self, tracking_email):
"""Determine tracking status"""
tracking_status_map = self._tracking_status_map_get()
status = "unknown"
if tracking_email:
tracking_email_status = str(tracking_email.state)
status = tracking_status_map.get(tracking_email_status, "unknown")
return status
def _partner_tracking_status_human_get(self, status):
"""Translations for tracking statuses to be used on qweb"""
statuses = {
"waiting": _("Waiting"),
"error": _("Error"),
"sent": _("Sent"),
"delivered": _("Delivered"),
"opened": _("Opened"),
"unknown": _("Unknown"),
}
return _("Status: %s") % statuses[status]
@api.model
def _get_error_description(self, tracking):
"""Translations for error descriptions to be used on qweb"""
descriptions = {"no_recipient": _("The partner doesn't have a defined email")}
return descriptions.get(tracking.error_type, tracking.error_description)
def tracking_status(self):
"""Generates a complete status tracking of the messages by partner"""
res = {}
for message in self:
partner_trackings = []
partners_already = self.env["res.partner"]
partners = self.env["res.partner"]
trackings = (
self.env["mail.tracking.email"]
.sudo()
.search([("mail_message_id", "=", message.id)])
)
# String to List
email_cc_list = self._drop_aliases(email_split(message.email_cc))
email_to_list = self._drop_aliases(email_split(message.email_to))
# Search related partners recipients
partners |= partners.search(
[("email", "in", email_cc_list + email_to_list)]
)
# Operate over set's instead of lists
email_cc_list = set(email_cc_list)
email_to_list = set(email_to_list) - email_cc_list
# Search all trackings for this message
for tracking in trackings:
status = self._partner_tracking_status_get(tracking)
recipient = tracking.partner_id.name or tracking.recipient
partner_trackings.append(
{
"status": status,
"status_human": self._partner_tracking_status_human_get(status),
"error_type": tracking.error_type,
"error_description": self._get_error_description(tracking),
"tracking_id": tracking.id,
"recipient": recipient,
"partner_id": tracking.partner_id.id,
"isCc": False,
}
)
if tracking.partner_id:
# Discard mails with tracking
email_cc_list.discard(tracking.partner_id.email)
email_to_list.discard(tracking.partner_id.email)
partners_already |= tracking.partner_id
# Search all partner recipients for this message
if message.partner_ids:
partners |= message.partner_ids
if message.notified_partner_ids:
partners |= message.notified_partner_ids
# Discard partner recipients already included
partners -= partners_already
# Default tracking values
tracking_unknown_values = {
"status": "unknown",
"status_human": self._partner_tracking_status_human_get("unknown"),
"error_type": False,
"error_description": False,
"tracking_id": False,
}
# Process tracking status of partner recipients without tracking
for partner in partners:
# Discard 'To' with partner
if partner.email in email_to_list:
email_to_list.discard(partner.email)
# If there is partners not included, then status is 'unknown'
# and perhaps a Cc recipient
isCc = False
if partner.email in email_cc_list:
email_cc_list.discard(partner.email)
isCc = True
tracking_status = tracking_unknown_values.copy()
tracking_status.update(
{"recipient": partner.name, "partner_id": partner.id, "isCc": isCc}
)
partner_trackings.append(tracking_status)
# Process Cc/To recipients without partner
for cc, lst in [(True, email_cc_list), (False, email_to_list)]:
for email in lst:
tracking_status = tracking_unknown_values.copy()
tracking_status.update(
{"recipient": email, "partner_id": False, "isCc": cc}
)
partner_trackings.append(tracking_status)
res[message.id] = {
"partner_trackings": partner_trackings,
"is_failed_message": message.is_failed_message,
}
return res
@api.model
def _drop_aliases(self, mail_list):
aliases = self.env["mail.alias"].get_aliases()
def _filter_alias(email):
email_wn = getaddresses([email])[0][1]
if email_wn not in aliases:
return email_wn
return list(filter(_filter_alias, mail_list))
def message_format(self, format_reply=True):
"""Preare values to be used by the chatter widget"""
res = super().message_format(format_reply)
mail_message_ids = {m.get("id") for m in res if m.get("id")}
mail_messages = self.browse(mail_message_ids)
tracking_statuses = mail_messages.tracking_status()
for message_dict in res:
mail_message_id = message_dict.get("id", False)
if mail_message_id:
message_dict.update(tracking_statuses[mail_message_id])
return res
def _prepare_dict_failed_message(self):
"""Preare values to be used by the chatter widget"""
self.ensure_one()
failed_trackings = self.mail_tracking_ids.filtered(
lambda x: x.state in self.get_failed_states()
)
if not failed_trackings or not self.mail_tracking_needs_action:
return
failed_partners = failed_trackings.mapped("partner_id")
failed_recipients = failed_partners.name_get()
if self.author_id:
author = self.author_id.name_get()[0]
else:
author = (-1, _("-Unknown Author-"))
return {
"id": self.id,
"date": self.date,
"author": author,
"body": self.body,
"failed_recipients": failed_recipients,
}
def get_failed_messages(self):
"""Returns the list of failed messages to be used by the
failed_messages widget"""
return [
msg._prepare_dict_failed_message()
for msg in self.sorted("date", reverse=True)
]
def set_need_action_done(self):
"""Set message tracking action as done
This will mark them to be ignored in the tracking issues filter.
"""
self.check_access_rule("read")
self.write({"mail_tracking_needs_action": False})
self.env["bus.bus"]._sendone(
self.env.user.partner_id, "toggle_tracking_status", self.ids
)
@api.model
def get_failed_count(self):
"""Gets the number of failed messages used on discuss mailbox item"""
return self.search_count([("is_failed_message", "=", True)])
@api.model
def set_all_as_reviewed(self):
"""Sets all messages in the given domain as reviewed.
Used by Discuss"""
unreviewed_messages = self.search([("is_failed_message", "=", True)])
unreviewed_messages.write({"mail_tracking_needs_action": False})
ids = unreviewed_messages.ids
self.env["bus.bus"].sendone(
(self._cr.dbname, "res.partner", self.env.user.partner_id.id),
{
"type": "toggle_tracking_status",
"message_ids": ids,
"needs_actions": False,
},
)
return ids
@api.model
def get_failed_messsage_info(self, ids, model):
msg_ids = self.search([("res_id", "=", ids), ("model", "=", model)])
res = [
msg._prepare_dict_failed_message()
for msg in msg_ids.sorted("date", reverse=True)
if msg._prepare_dict_failed_message()
]
return res
| 39.530159 | 12,452 |
1,355 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, fields, models
class ResPartner(models.Model):
_name = "res.partner"
_inherit = ["res.partner", "mail.bounced.mixin"]
# tracking_emails_count and email_score are non-store fields in order
# to improve performance
tracking_emails_count = fields.Integer(
compute="_compute_email_score_and_count", readonly=True
)
email_score = fields.Float(compute="_compute_email_score_and_count", readonly=True)
@api.depends("email")
def _compute_email_score_and_count(self):
self.email_score = 50.0
self.tracking_emails_count = 0
partners_mail = self.filtered("email")
mt_obj = self.env["mail.tracking.email"].sudo()
for partner in partners_mail:
partner.email_score = mt_obj.email_score_from_email(partner.email)
# We don't want performance issues due to heavy ACLs check for large
# recordsets. Our option is to hide the number for regular users.
if not self.env.user.has_group("base.group_system"):
continue
partner.tracking_emails_count = len(
mt_obj._search([("recipient_address", "=", partner.email.lower())])
)
| 42.34375 | 1,355 |
1,755 |
py
|
PYTHON
|
15.0
|
# Copyright 2018 Tecnativa - Ernesto Tejeda
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import fields, models
class MailBouncedMixin(models.AbstractModel):
"""A mixin class to use if you want to add is_bounced flag on a model.
The field '_primary_email' must be overridden in the model that inherit
the mixin and must contain the email field of the model.
"""
_name = "mail.bounced.mixin"
_description = "Mail bounced mixin"
_primary_email = "email"
email_bounced = fields.Boolean(index=True)
def email_bounced_set(self, tracking_emails, reason, event=None):
"""Inherit this method to make any other actions to the model that
inherit the mixin"""
if self.env.context.get("write_loop"):
# We avoid with the context an infinite recursion calling write
# method from other write method.
return True
partners = self.filtered(lambda r: not r.email_bounced)
return partners.write({"email_bounced": True})
def write(self, vals):
email_field = self._primary_email
if email_field not in vals:
return super().write(vals)
email = vals[email_field].lower() if vals[email_field] else False
mte_obj = self.env["mail.tracking.email"]
vals["email_bounced"] = mte_obj.email_is_bounced(email)
if vals["email_bounced"]:
res = mte_obj._email_last_tracking_state(email)
tracking = mte_obj.browse(res[0].get("id"))
event = tracking.tracking_event_ids[:1]
self.with_context(write_loop=True).email_bounced_set(
tracking, event.error_details, event
)
return super().write(vals)
| 40.813953 | 1,755 |
893 |
py
|
PYTHON
|
15.0
|
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import http
from odoo.addons.mail.controllers.discuss import DiscussController
class MailTrackingDiscussController(DiscussController):
@http.route()
def mail_init_messaging(self):
"""Route used to initial values of Discuss app"""
values = super().mail_init_messaging()
values.update(
{"failed_counter": http.request.env["mail.message"].get_failed_count()}
)
return values
@http.route("/mail/failed/messages", methods=["POST"], type="json", auth="user")
def discuss_failed_messages(self, max_id=None, min_id=None, limit=30, **kwargs):
return http.request.env["mail.message"]._message_fetch(
domain=[("is_failed_message", "=", True)],
max_id=max_id,
min_id=min_id,
limit=limit,
)
| 37.208333 | 893 |
3,348 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Antonio Espinosa - <[email protected]>
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import base64
import logging
from contextlib import contextmanager
import werkzeug
import odoo
from odoo import SUPERUSER_ID, api, http
from odoo.addons.mail.controllers.mail import MailController
_logger = logging.getLogger(__name__)
BLANK = "R0lGODlhAQABAIAAANvf7wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw=="
@contextmanager
def db_env(dbname):
if not http.db_filter([dbname]):
raise werkzeug.exceptions.BadRequest()
cr = None
if dbname == http.request.db:
cr = http.request.cr
if not cr:
cr = odoo.sql_db.db_connect(dbname).cursor()
yield api.Environment(cr, SUPERUSER_ID, {})
class MailTrackingController(MailController):
def _request_metadata(self):
"""Prepare remote info metadata"""
request = http.request.httprequest
return {
"ip": request.remote_addr or False,
"user_agent": request.user_agent or False,
"os_family": request.user_agent.platform or False,
"ua_family": request.user_agent.browser or False,
}
# TODO Remove useless controller
@http.route(
[
"/mail/tracking/all/<string:db>",
"/mail/tracking/event/<string:db>/<string:event_type>",
],
type="http",
auth="none",
csrf=False,
)
def mail_tracking_event(self, db, event_type=None, **kw):
"""Route used by external mail service"""
metadata = self._request_metadata()
res = None
with db_env(db) as env:
try:
res = env["mail.tracking.email"].event_process(
http.request, kw, metadata, event_type=event_type
)
except Exception as e:
_logger.warning(e)
if not res or res == "NOT FOUND":
return werkzeug.exceptions.NotAcceptable()
return res
@http.route(
[
"/mail/tracking/open/<string:db>" "/<int:tracking_email_id>/blank.gif",
"/mail/tracking/open/<string:db>"
"/<int:tracking_email_id>/<string:token>/blank.gif",
],
type="http",
auth="none",
methods=["GET"],
)
def mail_tracking_open(self, db, tracking_email_id, token=False, **kw):
"""Route used to track mail openned (With & Without Token)"""
metadata = self._request_metadata()
with db_env(db) as env:
try:
tracking_email = (
env["mail.tracking.email"]
.sudo()
.search([("id", "=", tracking_email_id), ("token", "=", token)])
)
if not tracking_email:
_logger.warning(
"MailTracking email '%s' not found", tracking_email_id
)
elif tracking_email.state in ("sent", "delivered"):
tracking_email.event_create("open", metadata)
except Exception as e:
_logger.warning(e)
# Always return GIF blank image
response = werkzeug.wrappers.Response()
response.mimetype = "image/gif"
response.data = base64.b64decode(BLANK)
return response
| 33.148515 | 3,348 |
969 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Jairo Llopis
# Copyright 2017 Tecnativa - Pedro M. Baeza
# Copyright 2019 ForgeFlow S.L. - Lois Rilo <[email protected]>
# 2020 NextERP Romania
# Copyright 2021 Tecnativa - João Marques
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Mail Debrand",
"summary": """Remove Odoo branding in sent emails
Removes anchor <a href odoo.com togheder with it's parent
( for powerd by) form all the templates
removes any 'odoo' that are in tempalte texts > 20characters
""",
"version": "15.0.1.2.4",
"category": "Social Network",
"website": "https://github.com/OCA/social",
"author": """Tecnativa, ForgeFlow, Onestein, Sodexis, Nexterp Romania,
Odoo Community Association (OCA)""",
"license": "AGPL-3",
"installable": True,
"depends": ["mail"],
"development_status": "Production/Stable",
"maintainers": ["pedrobaeza", "joao-p-marques"],
}
| 38.72 | 968 |
4,559 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Tecnativa - Pedro M. Baeza
# Copyright 2020 Onestein - Andrea Stirpe
# Copyright 2021 Sodexis
# Copyright 2021 Tecnativa - João Marques
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.tests import common
from odoo.tools.misc import mute_logger
class TestMailDebrand(common.TransactionCase):
def setUp(self):
super().setUp()
self.default_template = self.env.ref("mail.message_notification_email")
self.paynow_template = self.env.ref("mail.mail_notification_paynow")
def test_debrand_binary_value(self):
"""
Regression test: ensure binary input is gracefully handled
"""
try:
self.env["mail.template"].remove_href_odoo(
b"Binary value with more than 20 characters"
)
except TypeError:
self.fail("Debranding binary string raised TypeError")
def test_default_debrand(self):
self.assertIn("using", self.default_template.arch)
res = self.env["mail.template"]._render_template(
self.default_template.arch, "ir.ui.view", [self.default_template]
)
self.assertNotIn("using", res)
def test_paynow_debrand(self):
self.assertIn("Powered by", self.paynow_template.arch)
res = self.env["mail.template"]._render_template(
self.paynow_template.arch, "ir.ui.view", [self.paynow_template]
)
self.assertNotIn("Powered by", res)
def test_lang_paynow_debrand(self):
with mute_logger("odoo.addons.base.models.ir_translation"):
self.env["base.language.install"].create(
{"lang": "nl_NL", "overwrite": True}
).lang_install()
with mute_logger("odoo.tools.translate"):
self.env["base.update.translations"].create({"lang": "nl_NL"}).act_update()
ctx = dict(lang="nl_NL")
paynow_arch = self.paynow_template.with_context(**ctx).arch
self.assertIn("Aangeboden door", paynow_arch)
res = self.env["mail.template"]
self.assertNotIn("Aangeboden door", res)
def test_plaintext_email(self):
MailMessage = self.env["mail.mail"]
email_values = {
"email_from": "[email protected]",
"subject": "Hello",
"email_to": "[email protected]",
"reply_to": "[email protected]",
}
# No exception expected
MailMessage.create(email_values)
def test_body_intact(self):
"""The message body should never be changed"""
MailMessage = self.env["mail.mail"]
original_body = (
"<p>And if I send odoo.example.com<br><br>And odoo.com"
'<br><br>And <a target="_blank" rel="noreferrer noopener" '
'href="https://odoo.com">https://odoo.com</a><br><br>And '
'<a target="_blank" rel="noreferrer noopener" '
'href="https://odoo.example.com">https://odoo.example.com</a></p>'
)
email_values = {
"email_from": "[email protected]",
"subject": "Hello",
"email_to": "[email protected]",
"reply_to": "[email protected]",
"body": original_body,
"body_html": (
"\n<div>\n\n\n<div><p>And if I send odoo.example.com<br><br>"
'And odoo.com<br><br>And <a target="_blank" '
'rel="noreferrer noopener" href="https://odoo.com">'
'https://odoo.com</a><br><br>And <a target="_blank" '
'rel="noreferrer noopener" href="https://odoo.example.com">'
"https://odoo.example.com</a></p></div>\n\n"
'<div style="font-size: 13px;"><span data-o-mail-quote="1">-- '
'<br data-o-mail-quote="1">\nAdministrator</span></div>\n'
'<p style="color: #555555; margin-top:32px;">\n Sent\n '
'<span>\n by\n <a style="text-decoration:none; '
'color: #875A7B;" href="http://www.example.com">\n '
"<span>YourCompany</span>\n </a>\n \n </span>\n "
'using\n <a target="_blank" '
'href="https://www.odoo.com?utm_source=db&utm_medium=email"'
' style="text-decoration:none; color: #875A7B;">Odoo'
"</a>.\n</p>\n</div>\n "
),
}
# No exception expected
message = MailMessage.create(email_values)
self.assertTrue(original_body in message._send_prepare_body())
| 44.252427 | 4,558 |
2,762 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Tecnativa - Pedro M. Baeza
# Copyright 2020 Onestein - Andrea Stirpe
# Copyright 2021 Sodexis
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from datetime import datetime
from werkzeug.urls import url_join
from odoo import _
from odoo.tests import common, tagged
@tagged("-at_install", "post_install")
class TestMailDebrandDigest(common.TransactionCase):
def setUp(self):
super().setUp()
if "digest.digest" in self.env:
self.mail_digest_id = self.env["digest.digest"].create(
{
"name": "Test Digest",
"user_ids": False,
"company_id": self.env.company.id,
"kpi_res_users_connected": True,
"kpi_mail_message_total": True,
}
)
else:
self.mail_digest_id = False
def test_mail_digest(self):
if not self.mail_digest_id:
self.assertEqual(True, True)
return
web_base_url = self.env["ir.config_parameter"].sudo().get_param("web.base.url")
rendered_body = self.env["mail.render.mixin"]._render_template(
"digest.digest_mail_main",
"digest.digest",
self.mail_digest_id.ids,
engine="qweb_view",
add_context={
"title": self.mail_digest_id.name,
"top_button_label": _("Connect"),
"top_button_url": url_join(web_base_url, "/web/login"),
"company": self.env.user.company_id,
"user": self.env.user,
"tips_count": 1,
"formatted_date": datetime.today().strftime("%B %d, %Y"),
"display_mobile_banner": True,
"kpi_data": self.mail_digest_id._compute_kpis(
self.env.user.company_id, self.env.user
),
"tips": self.mail_digest_id._compute_tips(
self.env.user.company_id, self.env.user, tips_count=1, consumed=True
),
"preferences": self.mail_digest_id._compute_preferences(
self.env.user.company_id, self.env.user
),
},
post_process=True,
)[self.mail_digest_id.id]
# ensure the template rendered correctly. if rendering failed,
# we sometimes end up with a string only containing the template
# name, or a null-ish value
self.assertNotEqual(rendered_body, "digest.digest_mail_main")
self.assertNotEqual(rendered_body, None)
self.assertNotEqual(rendered_body, False)
self.assertNotEqual(rendered_body, "")
self.assertNotIn("Powered by", rendered_body)
| 38.901408 | 2,762 |
4,420 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 O4SB - Graeme Gellatly
# Copyright 2019 Tecnativa - Ernesto Tejeda
# Copyright 2020 Onestein - Andrea Stirpe
# Copyright 2021 Tecnativa - João Marques
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import re
from lxml import etree, html
from markupsafe import Markup
from odoo import api, models, tools
class MailRenderMixin(models.AbstractModel):
_inherit = "mail.render.mixin"
def remove_href_odoo(
self, value, remove_parent=True, remove_before=False, to_keep=None
):
if len(value) < 20:
return value
# value can be bytes type; ensure we get a proper string
if type(value) is bytes:
back_to_bytes = True
value = value.decode()
else:
back_to_bytes = False
has_dev_odoo_link = re.search(
r"<a\s(.*)dev\.odoo\.com", value, flags=re.IGNORECASE
)
has_odoo_link = re.search(r"<a\s(.*)odoo\.com", value, flags=re.IGNORECASE)
if has_odoo_link and not has_dev_odoo_link:
# We don't want to change what was explicitly added in the message body,
# so we will only change what is before and after it.
if to_keep:
value = value.replace(to_keep, "<body_msg></body_msg>")
tree = html.fromstring(value)
odoo_anchors = tree.xpath('//a[contains(@href,"odoo.com")]')
for elem in odoo_anchors:
parent = elem.getparent()
previous = elem.getprevious()
if remove_before and not remove_parent and previous is not None:
# remove 'using' that is before <a and after </span>
previous.tail = ""
if remove_parent and parent.getparent() is not None:
# anchor <a href odoo has a parent powered by that must be removed
parent.getparent().remove(parent)
else:
# also here can be powered by
if parent.tag == "td" and parent.getparent():
parent.getparent().remove(parent)
else:
parent.remove(elem)
value = etree.tostring(
tree, pretty_print=True, method="html", encoding="unicode"
)
if to_keep:
value = value.replace("<body_msg></body_msg>", to_keep)
if back_to_bytes:
value = value.encode()
return value
@api.model
def _render_template(
self,
template_src,
model,
res_ids,
engine="inline_template",
add_context=None,
options=None,
post_process=False,
):
"""replace anything that is with odoo in templates
if is a <a that contains odoo will delete it completely
original:
Render the given string on records designed by model / res_ids using
the given rendering engine.
:param str template_src: template text to render (jinja) or (qweb)
this could be cleaned but hey, we are in a rush
:param str model: model name of records on which we want to perform rendering
:param list res_ids: list of ids of records (all belonging to same model)
:param string engine: inline_template, qweb or qweb_view;
:param post_process: perform rendered str / html post processing (see
``_render_template_postprocess``)
:return dict: {res_id: string of rendered template based on record}"""
orginal_rendered = super()._render_template(
template_src,
model,
res_ids,
engine=engine,
add_context=add_context,
options=options,
post_process=post_process,
)
for key in res_ids:
orginal_rendered[key] = self.remove_href_odoo(orginal_rendered[key])
return orginal_rendered
def _replace_local_links(self, html, base_url=None):
message = super()._replace_local_links(html, base_url=base_url)
wrapper = Markup if isinstance(message, Markup) else str
message = tools.ustr(message)
if isinstance(message, Markup):
wrapper = Markup
message = re.sub(
r"""(Powered by\s(.*)Odoo</a>)""", "<div> </div>", message
)
return wrapper(message)
| 38.094828 | 4,419 |
524 |
py
|
PYTHON
|
15.0
|
# Copyright 2019 O4SB - Graeme Gellatly
# Copyright 2019 Tecnativa - Ernesto Tejeda
# Copyright 2020 Onestein - Andrea Stirpe
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import models
class MailMail(models.AbstractModel):
_inherit = "mail.mail"
def _send_prepare_body(self):
body_html = super()._send_prepare_body()
return self.env["mail.render.mixin"].remove_href_odoo(
body_html or "", remove_parent=0, remove_before=1, to_keep=self.body
)
| 34.933333 | 524 |
733 |
py
|
PYTHON
|
15.0
|
# Copyright 2022-2023 Moduon Team S.L. <[email protected]>
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
import logging
from odoo import SUPERUSER_ID, api
_logger = logging.getLogger(__name__)
def post_init_hook(cr, registry):
"""Increase cadence of mail queue cron."""
env = api.Environment(cr, SUPERUSER_ID, {})
try:
cron = env.ref("mail.ir_cron_mail_scheduler_action")
except ValueError:
_logger.warning(
"Couldn't find the standard mail scheduler cron. "
"Maybe no mails will be ever sent!"
)
else:
_logger.info("Setting mail queue cron cadence to 1 minute")
cron.interval_number = 1
cron.interval_type = "minutes"
| 31.869565 | 733 |
777 |
py
|
PYTHON
|
15.0
|
# Copyright 2022-2023 Moduon Team S.L. <[email protected]>
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
{
"name": "Deferred Message Posting",
"summary": "Faster and cancellable outgoing messages",
"version": "15.0.1.0.0",
"development_status": "Alpha",
"category": "Productivity/Discuss",
"website": "https://github.com/OCA/social",
"author": "Moduon, Odoo Community Association (OCA)",
"maintainers": ["Yajo"],
"license": "LGPL-3",
"depends": [
"mail",
],
"post_init_hook": "post_init_hook",
"assets": {
"web.assets_backend": [
"mail_post_defer/static/src/**/*.js",
],
"web.assets_qweb": [
"mail_post_defer/static/src/**/*.xml",
],
},
}
| 31.08 | 777 |
6,364 |
py
|
PYTHON
|
15.0
|
# Copyright 2022-2023 Moduon Team S.L. <[email protected]>
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
import freezegun
from odoo.exceptions import UserError
from odoo.addons.mail.tests.common import MailCommon
@freezegun.freeze_time("2023-01-02 10:00:00")
class MessagePostCase(MailCommon):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls._create_portal_user()
# Notify employee by email
cls.user_employee.notification_type = "email"
def test_standard(self):
"""A normal call just uses the queue by default."""
with self.mock_mail_gateway():
self.partner_portal.message_post(
body="test body",
subject="test subject",
message_type="comment",
partner_ids=self.partner_employee.ids,
)
self.assertMailMail(
self.partner_employee,
"outgoing",
author=self.env.user.partner_id,
content="test body",
fields_values={"scheduled_date": "2023-01-02 10:00:30"},
)
def test_forced_arg(self):
"""A forced send via method argument is sent directly."""
with self.mock_mail_gateway():
self.partner_portal.message_post(
body="test body",
subject="test subject",
message_type="comment",
partner_ids=self.partner_employee.ids,
force_send=True,
)
self.assertMailMail(
self.partner_employee,
"sent",
author=self.env.user.partner_id,
content="test body",
fields_values={"scheduled_date": False},
)
def test_forced_context(self):
"""A forced send via context is sent directly."""
with self.mock_mail_gateway():
self.partner_portal.with_context(mail_notify_force_send=True).message_post(
body="test body",
subject="test subject",
message_type="comment",
partner_ids=self.partner_employee.ids,
)
self.assertMailMail(
self.partner_employee,
"sent",
author=self.env.user.partner_id,
content="test body",
fields_values={"scheduled_date": False},
)
def test_no_msg_edit(self):
"""Cannot update messages.
This is normal upstream Odoo behavior. It is not a feature of this
module, but it is important to make sure this protection is still
respected, because we disable it for queued message deletion.
A non-malicious end user won't get to this code because the edit button
is hidden. Still, the server-side protection is important.
If, at some point, this module is improved to support this use case,
then this test should change; and that would be a good thing probably.
"""
with self.mock_mail_gateway():
msg = self.partner_portal.message_post(
body="test body",
subject="test subject",
message_type="comment",
partner_ids=self.partner_employee.ids,
subtype_xmlid="mail.mt_comment",
)
# Emulate user clicking on edit button and going through the
# `/mail/message/update_content` controller
with self.assertRaises(UserError):
msg._update_content("new body", [])
self.assertMailMail(
self.partner_employee,
"outgoing",
author=self.env.user.partner_id,
content="test body",
fields_values={"scheduled_date": "2023-01-02 10:00:30"},
)
def test_queued_msg_delete(self):
"""A user can delete a message before it's sent."""
with self.mock_mail_gateway():
msg = self.partner_portal.message_post(
body="test body",
subject="test subject",
message_type="comment",
partner_ids=self.partner_employee.ids,
subtype_xmlid="mail.mt_comment",
)
# Emulate user clicking on delete button and going through the
# `/mail/message/update_content` controller
msg._update_content("", [])
self.assertNoMail(
self.partner_employee,
author=self.env.user.partner_id,
)
# One minute later, the cron has no mails to send
with freezegun.freeze_time("2023-01-02 10:01:00"):
self.env["mail.mail"].process_email_queue()
self.assertNoMail(
self.partner_employee,
author=self.env.user.partner_id,
)
def test_no_sent_msg_delete(self):
"""A user cannot delete a message after it's sent.
Usually, the trash button will be hidden in UI if the message is sent.
However, the server-side protection is still important, because there
can be a race condition when the mail is sent in the background but
the user didn't refresh the view.
"""
with self.mock_mail_gateway():
msg = self.partner_portal.message_post(
body="test body",
subject="test subject",
message_type="comment",
partner_ids=self.partner_employee.ids,
subtype_xmlid="mail.mt_comment",
)
# One minute later, the cron sends the mail
with freezegun.freeze_time("2023-01-02 10:01:00"):
self.env["mail.mail"].process_email_queue()
self.assertMailMail(
self.partner_employee,
"sent",
author=self.env.user.partner_id,
content="test body",
fields_values={"scheduled_date": "2023-01-02 10:00:30"},
)
# Emulate user clicking on delete button and going through the
# `/mail/message/update_content` controller
with self.assertRaises(UserError):
msg._update_content("", [])
| 40.025157 | 6,364 |
487 |
py
|
PYTHON
|
15.0
|
# Copyright 2022-2023 Moduon Team S.L. <[email protected]>
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
from odoo.tests.common import TransactionCase
class InstallationCase(TransactionCase):
def test_cron_cadence(self):
"""Test that the post_init_hook was properly executed."""
cron = self.env.ref("mail.ir_cron_mail_scheduler_action")
cadence = cron.interval_number, cron.interval_type
self.assertEqual(cadence, (1, "minutes"))
| 40.583333 | 487 |
1,635 |
py
|
PYTHON
|
15.0
|
# Copyright 2022-2023 Moduon Team S.L. <[email protected]>
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
from datetime import timedelta
from odoo import fields, models
class MailThread(models.AbstractModel):
_inherit = "mail.thread"
def message_post(self, **kwargs):
"""Post messages using queue by default."""
_self = self
force_send = self.env.context.get("mail_notify_force_send") or kwargs.get(
"force_send", False
)
kwargs.setdefault("force_send", force_send)
if not force_send:
# If deferring message, give the user some minimal time to revert it
_self = self.with_context(mail_defer_seconds=30)
return super(MailThread, _self).message_post(**kwargs)
def _notify_by_email_add_values(self, base_mail_values):
"""Defer emails by default."""
result = super()._notify_by_email_add_values(base_mail_values)
defer_seconds = self.env.context.get("mail_defer_seconds")
if defer_seconds:
result.setdefault(
"scheduled_date",
fields.Datetime.now() + timedelta(seconds=defer_seconds),
)
return result
def _check_can_update_message_content(self, message):
"""Allow deleting unsent mails."""
if (
self.env.context.get("deleting")
and set(message.notification_ids.mapped("notification_status")) == {"ready"}
and set(message.mail_ids.mapped("state")) == {"outgoing"}
):
return
return super()._check_can_update_message_content(message)
| 38.023256 | 1,635 |
659 |
py
|
PYTHON
|
15.0
|
# Copyright 2022-2023 Moduon Team S.L. <[email protected]>
# License LGPL-3.0 or later (https://www.gnu.org/licenses/lgpl).
from odoo import models
class MailMessage(models.Model):
_inherit = "mail.message"
def _cleanup_side_records(self):
"""Delete pending outgoing mails."""
self.mail_ids.filtered(lambda mail: mail.state == "outgoing").unlink()
return super()._cleanup_side_records()
def _update_content(self, body, attachment_ids):
"""Let checker know about empty body."""
_self = self.with_context(deleting=body == "")
return super(MailMessage, _self)._update_content(body, attachment_ids)
| 36.611111 | 659 |
471 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Mail Activity Creator",
"summary": """
Show activities creator""",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/social",
"depends": ["mail"],
"data": ["views/mail_activity_views.xml"],
"qweb": ["static/src/xml/activity.xml"],
}
| 31.4 | 471 |
1,531 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo.tests.common import TransactionCase
class TestCreator(TransactionCase):
def setUp(self):
super().setUp()
self.partner = self.env["res.partner"].create({"name": "DEMO"})
self.user_01 = self.env["res.users"].create(
{
"name": "user_01",
"login": "demo_user_01",
"email": "[email protected]",
"notification_type": "inbox",
}
)
self.partner_model = self.env["ir.model"]._get("res.partner")
self.ActivityType = self.env["mail.activity.type"]
self.activity1 = self.ActivityType.create(
{
"name": "Initial Contact",
"delay_count": 5,
"summary": "ACT 1 : Presentation, barbecue, ... ",
"res_model": self.partner_model.model,
}
)
def test_activity_creator(self):
activity = (
self.env["mail.activity"]
.sudo()
.with_user(self.user_01.id)
.create(
{
"activity_type_id": self.activity1.id,
"note": "Partner activity 3.",
"res_id": self.partner.id,
"res_model_id": self.partner_model.id,
"user_id": self.user_01.id,
}
)
)
self.assertEqual(activity.creator_uid, self.user_01)
| 32.574468 | 1,531 |
324 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class MailActivity(models.Model):
_inherit = "mail.activity"
creator_uid = fields.Many2one(
"res.users",
default=lambda r: r.env.user.id,
string="Creator",
)
| 21.6 | 324 |
706 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License LGPL-3.0 or later (http://www.gnu.org/licenses/lgpl).
{
"name": "Mail Preview",
"summary": """
Base to add more previewing options""",
"version": "15.0.1.0.0",
"license": "LGPL-3",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/social",
"depends": ["mail"],
"data": [
"views/ir_attachment_view.xml",
],
"assets": {
"web.assets_backend": [
"mail_preview_base/static/src/js/preview.js",
"mail_preview_base/static/src/scss/preview.scss",
],
"web.assets_qweb": ["mail_preview_base/static/src/xml/preview.xml"],
},
}
| 30.695652 | 706 |
671 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Valentin Vinagre <[email protected]>
# Copyright 2022 Eduardo de Miguel <[email protected]>
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Mail Show Follower",
"summary": "Show CC document followers in mails.",
"version": "15.0.1.2.2",
"category": "Mail",
"website": "https://github.com/OCA/social",
"author": "Sygel, Moduon, Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["base", "mail"],
"maintainers": ["yajo"],
"data": [
"views/res_config_settings.xml",
"views/res_users.xml",
],
}
| 31.952381 | 671 |
886 |
py
|
PYTHON
|
15.0
|
from odoo import fields, models
class ResCompany(models.Model):
_inherit = "res.company"
show_internal_users_cc = fields.Boolean(
string="Show Internal Users CC",
default=True,
)
show_followers_message_sent_to = fields.Html(
string="Text 'Sent to'",
translate=True,
default="This message has been sent to",
)
show_followers_partner_format = fields.Char(
string="Partner format",
default="%(partner_name)s",
help="Supported parameters:\n"
"%(partner_name)s = Partner Name\n"
"%(partner_email)s = Partner Email\n"
"%(partner_email_domain)s = Partner Email Domain",
)
show_followers_message_response_warning = fields.Html(
string="Text 'Replies'",
translate=True,
default="Notice: Replies to this email will be sent to all recipients",
)
| 31.642857 | 886 |
158 |
py
|
PYTHON
|
15.0
|
from odoo import fields, models
class ResUser(models.Model):
_inherit = "res.users"
show_in_cc = fields.Boolean(string="Show in CC", default=True)
| 22.571429 | 158 |
1,785 |
py
|
PYTHON
|
15.0
|
from odoo import api, fields, models
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
show_internal_users_cc = fields.Boolean(
related="company_id.show_internal_users_cc",
readonly=False,
)
show_followers_message_sent_to = fields.Html(
related="company_id.show_followers_message_sent_to",
readonly=False,
)
show_followers_partner_format = fields.Char(
related="company_id.show_followers_partner_format",
readonly=False,
help="Supported parameters:\n"
"%(partner_name)s = Partner Name\n"
"%(partner_email)s = Partner Email\n"
"%(partner_email_domain)s = Partner Email Domain",
)
show_followers_message_response_warning = fields.Html(
related="company_id.show_followers_message_response_warning",
readonly=False,
)
show_followers_message_preview = fields.Html(
string="Message preview",
readonly=True,
store=False,
)
@api.onchange(
"show_followers_message_sent_to",
"show_followers_partner_format",
"show_followers_message_response_warning",
)
def onchange_show_followers_message_preview(self):
self.show_followers_message_preview = (
self.env["mail.mail"]
.with_context(
# Use current data before
partner_format=self.show_followers_partner_format or "",
msg_sent_to=self.show_followers_message_sent_to or "",
msg_warn=self.show_followers_message_response_warning or "",
)
._build_cc_text(
# Sample partners
self.env["res.partner"].search([("email", "!=", False)], limit=3),
)
)
| 35 | 1,785 |
6,694 |
py
|
PYTHON
|
15.0
|
from markupsafe import Markup
from odoo import api, models, tools
class MailMail(models.Model):
_inherit = "mail.mail"
@api.model
def _build_cc_text(self, partners):
if not partners:
return ""
def get_ctx_param(ctx_key, default_parm):
if ctx_key in self.env.context:
return self.env.context[ctx_key]
return default_parm
def remove_p(markup_txt):
if markup_txt.startswith("<p>") and markup_txt.endswith("</p>"):
return markup_txt[3:-4]
return markup_txt
company = self.env.company
partner_format = get_ctx_param(
"partner_format", company.show_followers_partner_format
)
msg_sent_to = get_ctx_param(
"msg_sent_to", company.show_followers_message_sent_to
)
msg_warn = get_ctx_param(
"msg_warn", company.show_followers_message_response_warning
)
partner_message = ", ".join(
[
partner_format
% {
# Supported parameters
"partner_name": p.name,
"partner_email": p.email,
"partner_email_domain": tools.email_domain_extract(p.email),
}
for p in partners
]
)
full_text = """
<div summary='o_mail_notification' style='padding:5px;
margin:10px 0px 10px 0px;font-size:13px;border-radius:5px;
font-family:Arial;border:1px solid #E0E2E6;background-color:#EBEBEB;'>
{msg_sent_to} {partner_message}
{rc}{msg_warn}
</div>
""".format(
msg_sent_to=remove_p(msg_sent_to),
partner_message=Markup.escape(partner_message),
rc=msg_warn.striptags() and "<br/>" or "",
msg_warn=msg_warn.striptags() and remove_p(msg_warn) or "",
)
return full_text
def _send(self, auto_commit=False, raise_exception=False, smtp_session=None):
group_portal = self.env.ref("base.group_portal")
for mail_id in self.ids:
mail = self.browse(mail_id)
message_recipients = self.search(
[
("message_id", "=", mail.message_id),
]
).mapped("recipient_ids")
# if the email has a model, id and it belongs to the portal group
if mail.model and mail.res_id and group_portal:
obj = self.env[mail.model].browse(mail.res_id)
# those partners are obtained, who do not have a user and
# if they do it must be a portal, we exclude internal
# users of the system.
if hasattr(obj, "message_follower_ids"):
partners_obj = (
obj.message_follower_ids.mapped("partner_id")
| message_recipients
)
# internal partners
user_partner_ids = (
self.env["res.users"]
.search(
[
("active", "in", (True, False)),
("show_in_cc", "=", False),
]
)
.filtered(lambda x: group_portal not in x.groups_id)
.mapped("partner_id")
.ids
)
partners_len = len(
partners_obj.filtered(
lambda x: x.id not in user_partner_ids
and (
not x.user_ids
or group_portal in x.user_ids.mapped("groups_id")
)
)
)
if partners_len > 1:
# get partners
cc_internal = True
# else get company in object
if hasattr(obj, "company_id") and obj.company_id:
cc_internal = obj.company_id.show_internal_users_cc
# get company in user
elif mail.env and mail.env.user and mail.env.user.company_id:
cc_internal = (
self.env.user.company_id.show_internal_users_cc
)
if cc_internal:
partners = partners_obj.filtered(
lambda x: x.id not in user_partner_ids
and (
not x.user_ids
or any(x.mapped("user_ids.show_in_cc"))
)
)
else:
partners = partners_obj.filtered(
lambda x: x.id not in user_partner_ids
and (
not x.user_ids
or group_portal in x.user_ids.mapped("groups_id")
)
)
partners = partners.filtered(
lambda x: not x.user_ids
or x.user_ids # otherwise, email is not sent
and "email" in x.user_ids.mapped("notification_type")
)
# set proper lang for recipients
langs = list(
filter(
bool,
mail.mapped("recipient_ids.lang")
+ [
mail.author_id.lang,
self.env.company.partner_id.lang,
],
)
)
# get show follower text
final_cc = mail.with_context(
lang=langs and langs[0]
)._build_cc_text(partners)
# it is saved in the body_html field so that it does
# not appear in the odoo log
mail.body_html = final_cc + mail.body_html
return super()._send(
auto_commit=auto_commit,
raise_exception=raise_exception,
smtp_session=smtp_session,
)
| 42.636943 | 6,694 |
777 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# Copyright 2016 Tecnativa - Carlos Dauden
# Copyright 2017 Tecnativa - Pedro M. Baeza
# Copyright 2017-18 Tecnativa - David Vidal
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Mail tracking for Mailgun",
"summary": "Mail tracking and Mailgun webhooks integration",
"version": "15.0.1.1.0",
"category": "Social Network",
"website": "https://github.com/OCA/social",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"application": False,
"installable": True,
"depends": ["mail_tracking"],
"data": [
"views/res_partner.xml",
"views/mail_tracking_email.xml",
"wizards/res_config_settings_views.xml",
],
}
| 35.318182 | 777 |
19,054 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# Copyright 2017 Tecnativa - David Vidal
# Copyright 2021 Tecnativa - Jairo Llopis
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from contextlib import contextmanager, suppress
import mock
from freezegun import freeze_time
from werkzeug.exceptions import NotAcceptable
from odoo.exceptions import MissingError, UserError, ValidationError
from odoo.tests.common import Form, TransactionCase
from odoo.tools import mute_logger
from ..controllers.main import MailTrackingController
# HACK https://github.com/odoo/odoo/pull/78424 because website is not dependency
try:
from odoo.addons.website.tools import MockRequest
except ImportError:
MockRequest = None
_packagepath = "odoo.addons.mail_tracking_mailgun"
@freeze_time("2016-08-12 17:00:00", tick=True)
class TestMailgun(TransactionCase):
def mail_send(self):
mail = self.env["mail.mail"].create(
{
"subject": "Test subject",
"email_from": "[email protected]",
"email_to": self.recipient,
"body_html": "<p>This is a test message</p>",
"message_id": "<test-id@f187c54734e8>",
}
)
mail.send()
# Search tracking created
tracking_email = self.env["mail.tracking.email"].search(
[("mail_id", "=", mail.id)]
)
return mail, tracking_email
def setUp(self):
super().setUp()
self.recipient = "[email protected]"
self.mail, self.tracking_email = self.mail_send()
self.domain = "example.com"
# Configure Mailgun through GUI
cf = Form(self.env["res.config.settings"])
cf.mail_tracking_mailgun_enabled = True
cf.mail_tracking_mailgun_api_key = (
cf.mail_tracking_mailgun_webhook_signing_key
) = (
cf.mail_tracking_mailgun_validation_key
) = "key-12345678901234567890123456789012"
cf.mail_tracking_mailgun_domain = False
cf.mail_tracking_mailgun_auto_check_partner_emails = False
config = cf.save()
# Done this way as `hr_expense` adds this field again as readonly, and thus Form
# doesn't process it correctly
config.alias_domain = self.domain
config.execute()
self.token = "f1349299097a51b9a7d886fcb5c2735b426ba200ada6e9e149"
self.timestamp = "1471021089"
self.signature = (
"4fb6d4dbbe10ce5d620265dcd7a3c0b8" "ca0dede1433103891bc1ae4086e9d5b2"
)
self.event = {
"log-level": "info",
"id": "oXAVv5URCF-dKv8c6Sa7T",
"timestamp": 1471021089.0,
"message": {
"headers": {
"to": "[email protected]",
"message-id": "test-id@f187c54734e8",
"from": "Mr. Odoo <[email protected]>",
"subject": "This is a test",
},
},
"event": "delivered",
"recipient": "[email protected]",
"user-variables": {
"odoo_db": self.env.cr.dbname,
"tracking_email_id": self.tracking_email.id,
},
}
self.metadata = {
"ip": "127.0.0.1",
"user_agent": False,
"os_family": False,
"ua_family": False,
}
self.partner = self.env["res.partner"].create(
{"name": "Mr. Odoo", "email": "[email protected]"}
)
self.response = {"items": [self.event]}
self.MailTrackingController = MailTrackingController()
@contextmanager
def _request_mock(self, reset_replay_cache=True):
# HACK https://github.com/odoo/odoo/pull/78424
if MockRequest is None:
self.skipTest("MockRequest not found, sorry")
if reset_replay_cache:
with suppress(AttributeError):
del self.env.registry._mail_tracking_mailgun_processed_tokens
# Imitate Mailgun JSON request
mock = MockRequest(self.env)
with mock as request:
request.jsonrequest = {
"signature": {
"timestamp": self.timestamp,
"token": self.token,
"signature": self.signature,
},
"event-data": self.event,
}
request.params = {"db": self.env.cr.dbname}
request.session.db = self.env.cr.dbname
yield request
def event_search(self, event_type):
event = self.env["mail.tracking.event"].search(
[
("tracking_email_id", "=", self.tracking_email.id),
("event_type", "=", event_type),
]
)
self.assertTrue(event)
return event
def test_no_api_key(self):
self.env["ir.config_parameter"].set_param("mailgun.apikey", "")
with self.assertRaises(ValidationError):
self.env["mail.tracking.email"]._mailgun_values()
def test_no_domain(self):
self.env["ir.config_parameter"].set_param("mail.catchall.domain", "")
with self.assertRaises(ValidationError):
self.env["mail.tracking.email"]._mailgun_values()
# now we set an specific domain for Mailgun:
# i.e: we configure new EU zone without loosing old domain statistics
self.env["ir.config_parameter"].set_param("mailgun.domain", "eu.example.com")
self.test_event_delivered()
@mute_logger("odoo.addons.mail_tracking_mailgun.models.mail_tracking_email")
def test_bad_signature(self):
self.signature = "bad_signature"
with self._request_mock(), self.assertRaises(NotAcceptable):
self.MailTrackingController.mail_tracking_mailgun_webhook()
@mute_logger("odoo.addons.mail_tracking_mailgun.models.mail_tracking_email")
def test_bad_event_type(self):
old_events = self.tracking_email.tracking_event_ids
self.event.update({"event": "bad_event"})
with self._request_mock():
self.MailTrackingController.mail_tracking_mailgun_webhook()
self.assertFalse(self.tracking_email.tracking_event_ids - old_events)
def test_bad_ts(self):
self.timestamp = "7a" # Now time will be used instead
self.signature = (
"06cc05680f6e8110e59b41152b2d1c0f1045d755ef2880ff922344325c89a6d4"
)
with self._request_mock(), self.assertRaises(ValueError):
self.MailTrackingController.mail_tracking_mailgun_webhook()
@mute_logger("odoo.addons.mail_tracking_mailgun.models.mail_tracking_email")
def test_tracking_not_found(self):
self.event.update(
{
"event": "delivered",
"message": {
"headers": {
"to": "[email protected]",
"message-id": "test-id-else@f187c54734e8",
"from": "Mr. Odoo <[email protected]>",
"subject": "This is a bad test",
},
},
"user-variables": {
"odoo_db": self.env.cr.dbname,
"tracking_email_id": -1,
},
}
)
with self._request_mock(), self.assertRaises(MissingError):
self.MailTrackingController.mail_tracking_mailgun_webhook()
@mute_logger("odoo.addons.mail_tracking_mailgun.models.mail_tracking_email")
def test_tracking_wrong_db(self):
self.event["user-variables"]["odoo_db"] = "%s_nope" % self.env.cr.dbname
with self._request_mock(), self.assertRaises(ValidationError):
self.MailTrackingController.mail_tracking_mailgun_webhook()
# https://documentation.mailgun.com/en/latest/user_manual.html#tracking-deliveries
def test_event_delivered(self):
self.event.update({"event": "delivered"})
with self._request_mock():
self.MailTrackingController.mail_tracking_mailgun_webhook()
events = self.event_search("delivered")
for event in events:
self.assertEqual(event.timestamp, float(self.timestamp))
self.assertEqual(event.recipient, self.recipient)
# https://documentation.mailgun.com/en/latest/user_manual.html#tracking-opens
def test_event_opened(self):
ip = "127.0.0.1"
user_agent = "Odoo Test/8.0 Gecko Firefox/11.0"
os_family = "Linux"
ua_family = "Firefox"
ua_type = "browser"
self.event.update(
{
"event": "opened",
"city": "Mountain View",
"country": "US",
"region": "CA",
"client-name": ua_family,
"client-os": os_family,
"client-type": ua_type,
"device-type": "desktop",
"ip": ip,
"user-agent": user_agent,
}
)
with self._request_mock():
self.MailTrackingController.mail_tracking_mailgun_webhook()
event = self.event_search("open")
self.assertEqual(event.timestamp, float(self.timestamp))
self.assertEqual(event.recipient, self.recipient)
self.assertEqual(event.ip, ip)
self.assertEqual(event.user_agent, user_agent)
self.assertEqual(event.os_family, os_family)
self.assertEqual(event.ua_family, ua_family)
self.assertEqual(event.ua_type, ua_type)
self.assertEqual(event.mobile, False)
self.assertEqual(event.user_country_id.code, "US")
# https://documentation.mailgun.com/en/latest/user_manual.html#tracking-clicks
def test_event_clicked(self):
ip = "127.0.0.1"
user_agent = "Odoo Test/8.0 Gecko Firefox/11.0"
os_family = "Linux"
ua_family = "Firefox"
ua_type = "browser"
url = "https://odoo-community.org"
self.event.update(
{
"event": "clicked",
"city": "Mountain View",
"country": "US",
"region": "CA",
"client-name": ua_family,
"client-os": os_family,
"client-type": ua_type,
"device-type": "tablet",
"ip": ip,
"user-agent": user_agent,
"url": url,
}
)
with self._request_mock():
self.MailTrackingController.mail_tracking_mailgun_webhook()
event = self.event_search("click")
self.assertEqual(event.timestamp, float(self.timestamp))
self.assertEqual(event.recipient, self.recipient)
self.assertEqual(event.ip, ip)
self.assertEqual(event.user_agent, user_agent)
self.assertEqual(event.os_family, os_family)
self.assertEqual(event.ua_family, ua_family)
self.assertEqual(event.ua_type, ua_type)
self.assertEqual(event.mobile, True)
self.assertEqual(event.url, url)
# https://documentation.mailgun.com/en/latest/user_manual.html#tracking-unsubscribes
def test_event_unsubscribed(self):
ip = "127.0.0.1"
user_agent = "Odoo Test/8.0 Gecko Firefox/11.0"
os_family = "Linux"
ua_family = "Firefox"
ua_type = "browser"
self.event.update(
{
"event": "unsubscribed",
"city": "Mountain View",
"country": "US",
"region": "CA",
"client-name": ua_family,
"client-os": os_family,
"client-type": ua_type,
"device-type": "mobile",
"ip": ip,
"user-agent": user_agent,
}
)
with self._request_mock():
self.MailTrackingController.mail_tracking_mailgun_webhook()
event = self.event_search("unsub")
self.assertEqual(event.timestamp, float(self.timestamp))
self.assertEqual(event.recipient, self.recipient)
self.assertEqual(event.ip, ip)
self.assertEqual(event.user_agent, user_agent)
self.assertEqual(event.os_family, os_family)
self.assertEqual(event.ua_family, ua_family)
self.assertEqual(event.ua_type, ua_type)
self.assertEqual(event.mobile, True)
# https://documentation.mailgun.com/en/latest/user_manual.html#tracking-spam-complaints
def test_event_complained(self):
self.event.update({"event": "complained"})
with self._request_mock():
self.MailTrackingController.mail_tracking_mailgun_webhook()
event = self.event_search("spam")
self.assertEqual(event.timestamp, float(self.timestamp))
self.assertEqual(event.recipient, self.recipient)
self.assertEqual(event.error_type, "spam")
# https://documentation.mailgun.com/en/latest/user_manual.html#tracking-bounces
def test_event_failed(self):
code = 550
error = (
"5.1.1 The email account does not exist.\n"
"5.1.1 double-checking the recipient's email address"
)
notification = "Please, check recipient's email address"
self.event.update(
{
"event": "failed",
"delivery-status": {
"attempt-no": 1,
"code": code,
"description": notification,
"message": error,
"session-seconds": 0.0,
},
"severity": "permanent",
}
)
with self._request_mock():
self.MailTrackingController.mail_tracking_mailgun_webhook()
event = self.event_search("hard_bounce")
self.assertEqual(event.timestamp, float(self.timestamp))
self.assertEqual(event.recipient, self.recipient)
self.assertEqual(event.error_type, str(code))
self.assertEqual(event.error_description, error)
self.assertEqual(event.error_details, notification)
def test_event_rejected(self):
reason = "hardfail"
description = "Not delivering to previously bounced address"
self.event.update(
{
"event": "rejected",
"reject": {"reason": reason, "description": description},
}
)
with self._request_mock():
self.MailTrackingController.mail_tracking_mailgun_webhook()
event = self.event_search("reject")
self.assertEqual(event.timestamp, float(self.timestamp))
self.assertEqual(event.recipient, self.recipient)
self.assertEqual(event.error_type, "rejected")
self.assertEqual(event.error_description, reason)
self.assertEqual(event.error_details, description)
@mock.patch(_packagepath + ".models.res_partner.requests")
def test_email_validity(self, mock_request):
self.partner.email_bounced = False
mock_request.get.return_value.apparent_encoding = "ascii"
mock_request.get.return_value.status_code = 200
mock_request.get.return_value.json.return_value = {
"is_valid": True,
"mailbox_verification": "true",
}
# Trigger email auto validation in partner
self.env["ir.config_parameter"].set_param(
"mailgun.auto_check_partner_email", "True"
)
self.partner.email = "[email protected]"
self.assertFalse(self.partner.email_bounced)
self.partner.email = "[email protected]"
# Not a valid mailbox
mock_request.get.return_value.json.return_value = {
"is_valid": True,
"mailbox_verification": "false",
}
with self.assertRaises(UserError):
self.partner.check_email_validity()
# Not a valid mail address
mock_request.get.return_value.json.return_value = {
"is_valid": False,
"mailbox_verification": "false",
}
with self.assertRaises(UserError):
self.partner.check_email_validity()
# If we autocheck, the mail will be bounced
self.partner.with_context(mailgun_auto_check=True).check_email_validity()
self.assertTrue(self.partner.email_bounced)
# Unable to fully validate
mock_request.get.return_value.json.return_value = {
"is_valid": True,
"mailbox_verification": "unknown",
}
with self.assertRaises(UserError):
self.partner.check_email_validity()
@mock.patch(_packagepath + ".models.res_partner.requests")
def test_email_validity_exceptions(self, mock_request):
mock_request.get.return_value.status_code = 404
with self.assertRaises(UserError):
self.partner.check_email_validity()
self.env["ir.config_parameter"].set_param("mailgun.validation_key", "")
with self.assertRaises(UserError):
self.partner.check_email_validity()
@mock.patch(_packagepath + ".models.res_partner.requests")
def test_bounced(self, mock_request):
self.partner.email_bounced = True
mock_request.get.return_value.status_code = 404
self.partner.check_email_bounced()
self.assertFalse(self.partner.email_bounced)
mock_request.get.return_value.status_code = 200
self.partner.force_set_bounced()
self.partner.check_email_bounced()
self.assertTrue(self.partner.email_bounced)
mock_request.delete.return_value.status_code = 200
self.partner.force_unset_bounced()
self.assertFalse(self.partner.email_bounced)
def test_email_bounced_set(self):
message_number = len(self.partner.message_ids) + 1
self.partner._email_bounced_set("test_error", False)
self.assertEqual(len(self.partner.message_ids), message_number)
self.partner.email = ""
self.partner._email_bounced_set("test_error", False)
self.assertEqual(len(self.partner.message_ids), message_number)
@mock.patch(_packagepath + ".models.mail_tracking_email.requests")
def test_manual_check(self, mock_request):
mock_request.get.return_value.json.return_value = self.response
mock_request.get.return_value.status_code = 200
self.tracking_email.action_manual_check_mailgun()
event = self.env["mail.tracking.event"].search(
[("mailgun_id", "=", self.response["items"][0]["id"])]
)
self.assertTrue(event)
self.assertEqual(event.event_type, self.response["items"][0]["event"])
@mock.patch(_packagepath + ".models.mail_tracking_email.requests")
def test_manual_check_exceptions(self, mock_request):
mock_request.get.return_value.status_code = 404
with self.assertRaises(UserError):
self.tracking_email.action_manual_check_mailgun()
mock_request.get.return_value.status_code = 200
mock_request.get.return_value.json.return_value = {}
with self.assertRaises(UserError):
self.tracking_email.action_manual_check_mailgun()
| 41.242424 | 19,054 |
606 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
import json
from odoo import models
class IrMailServer(models.Model):
_inherit = "ir.mail_server"
def _tracking_headers_add(self, tracking_email_id, headers):
headers = super()._tracking_headers_add(tracking_email_id, headers)
headers = headers or {}
metadata = {
"odoo_db": self.env.cr.dbname,
"tracking_email_id": tracking_email_id,
}
headers["X-Mailgun-Variables"] = json.dumps(metadata)
return headers
| 30.3 | 606 |
724 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 Tecnativa - David Vidal
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import fields, models
class MailTrackingEvent(models.Model):
_inherit = "mail.tracking.event"
_sql_constraints = [
("mailgun_id_unique", "UNIQUE(mailgun_id)", "Mailgun event IDs must be unique!")
]
mailgun_id = fields.Char(
string="Mailgun Event ID",
copy="False",
readonly=True,
index=True,
)
def _process_data(self, tracking_email, metadata, event_type, state):
res = super()._process_data(tracking_email, metadata, event_type, state)
res.update({"mailgun_id": metadata.get("mailgun_id", False)})
return res
| 30.166667 | 724 |
8,438 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# Copyright 2017 Tecnativa - David Vidal
# Copyright 2021 Tecnativa - Jairo Llopis
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
import logging
from collections import namedtuple
from datetime import datetime
from urllib.parse import urljoin
import requests
from odoo import _, api, fields, models
from odoo.exceptions import UserError, ValidationError
from odoo.tools import email_split
_logger = logging.getLogger(__name__)
MailgunParameters = namedtuple(
"MailgunParameters",
(
"api_key",
"api_url",
"domain",
"validation_key",
"webhooks_domain",
"webhook_signing_key",
),
)
class EventNotFoundWarning(Warning):
pass
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
@api.model
def _mailgun_event2type(self, event, default="UNKNOWN"):
"""Return the ``mail.tracking.event`` equivalent event
Args:
event: Mailgun event response from API.
default: Value to return when not found.
"""
# Mailgun event type: tracking event type
equivalents = {
"delivered": "delivered",
"opened": "open",
"clicked": "click",
"unsubscribed": "unsub",
"complained": "spam",
"accepted": "sent",
"failed": (
"hard_bounce" if event.get("severity") == "permanent" else "soft_bounce"
),
"rejected": "reject",
}
return equivalents.get(event.get("event"), default)
@api.model
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")
web_base_url = icp.get_param("web.base.url")
webhooks_domain = icp.get_param("mailgun.webhooks_domain", web_base_url)
webhook_signing_key = icp.get_param("mailgun.webhook_signing_key")
return MailgunParameters(
api_key,
api_url,
domain,
validation_key,
webhooks_domain,
webhook_signing_key,
)
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 == "failed":
delivery_status = event.get("delivery-status", {})
metadata.update(
{
"error_type": delivery_status.get("code", False),
"error_description": delivery_status.get("message", False),
"error_details": delivery_status.get("description", False),
}
)
elif mailgun_event_type == "rejected":
reject = event.get("reject", {})
metadata.update(
{
"error_type": "rejected",
"error_description": reject.get("reason", False),
"error_details": reject.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
@api.model
def _mailgun_event_process(self, event_data, metadata):
"""Retrieve (and maybe create) mailgun event from API data payload.
In https://documentation.mailgun.com/en/latest/api-events.html#event-structure
you can read the event payload format as obtained from webhooks or calls to API.
"""
if event_data["user-variables"]["odoo_db"] != self.env.cr.dbname:
raise ValidationError(_("Wrong database for event!"))
# Do nothing if event was already processed
mailgun_id = event_data["id"]
db_event = self.env["mail.tracking.event"].search(
[("mailgun_id", "=", mailgun_id)], limit=1
)
if db_event:
_logger.debug("Mailgun event already found in DB: %s", mailgun_id)
return db_event
# Do nothing if tracking email for event is not found
message_id = event_data["message"]["headers"]["message-id"]
recipient = event_data["recipient"]
tracking_email = self.browse(
int(event_data["user-variables"]["tracking_email_id"])
)
mailgun_event_type = event_data["event"]
# Process event
state = self._mailgun_event2type(event_data, mailgun_event_type)
metadata = self._mailgun_metadata(mailgun_event_type, event_data, metadata)
_logger.info(
"Importing mailgun event %s (%s message %s for %s)",
mailgun_id,
mailgun_event_type,
message_id,
recipient,
)
tracking_email.event_create(state, metadata)
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, *__ = self._mailgun_values()
for tracking in self.filtered("message_id"):
message_id = tracking.message_id.replace("<", "").replace(">", "")
events = []
url = urljoin(api_url, "/v3/%s/events" % domain)
params = {
"begin": tracking.timestamp,
"ascending": "yes",
"message-id": message_id,
"recipient": email_split(tracking.recipient)[0],
}
while url:
res = requests.get(
url,
auth=("api", api_key),
params=params,
)
if not res or res.status_code != 200:
raise UserError(_("Couldn't retrieve Mailgun information"))
iter_events = res.json().get("items", [])
if not iter_events:
# Loop no more
break
events.extend(iter_events)
# Loop over pagination
url = res.json().get("paging", {}).get("next")
if not events:
raise UserError(_("Event information not longer stored"))
for event in events:
self.sudo()._mailgun_event_process(event, {})
| 36.214592 | 8,438 |
7,544 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 Tecnativa - Antonio Espinosa
# Copyright 2016 Tecnativa - Carlos Dauden
# Copyright 2017 Tecnativa - Pedro M. Baeza
# Copyright 2017 Tecnativa - David Vidal
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from urllib.parse import urljoin
import requests
from odoo import _, api, models
from odoo.exceptions import UserError
class ResPartner(models.Model):
_inherit = "res.partner"
def email_bounced_set(self, tracking_emails, reason, event=None):
res = super().email_bounced_set(tracking_emails, reason, event=event)
self._email_bounced_set(reason, event)
return res
def _email_bounced_set(self, reason, event):
for partner in self:
if not partner.email:
continue
event = event or self.env["mail.tracking.event"]
event_str = """
<a href="#"
data-oe-model="mail.tracking.event" data-oe-id="%d">%s</a>
""" % (
event.id or 0,
event.id or _("unknown"),
)
body = _(
"Email has been bounced: %(email)s\nReason: %(reason)s\nEvent: %(event_str)s"
) % ({"email": partner.email, "reason": reason, "event_str": event_str})
partner.message_post(body=body)
def check_email_validity(self):
"""
Checks mailbox validity with Mailgun's API
API documentation:
https://documentation.mailgun.com/en/latest/api-email-validation.html
"""
params = self.env["mail.tracking.email"]._mailgun_values()
if not params.validation_key:
raise UserError(
_(
"You need to configure mailgun.validation_key"
" in order to be able to check mails validity"
)
)
for partner in self.filtered("email"):
res = requests.get(
urljoin(params.api_url, "/v3/address/validate"),
auth=("api", params.validation_key),
params={"address": partner.email, "mailbox_verification": True},
)
if (
not res
or res.status_code != 200
and not self.env.context.get("mailgun_auto_check")
):
raise UserError(
_(
"Error %s trying to check mail" % res.status_code
or "of connection"
)
)
content = res.json()
if "mailbox_verification" not in content:
if not self.env.context.get("mailgun_auto_check"):
raise UserError(
_(
"Mailgun Error. Mailbox verification value wasn't"
" returned"
)
)
# Not a valid address: API sets 'is_valid' as False
# and 'mailbox_verification' as None
if not content["is_valid"]:
partner.email_bounced = True
body = (
_(
"%s is not a valid email address. Please check it"
" in order to avoid sending issues"
)
% partner.email
)
if not self.env.context.get("mailgun_auto_check"):
raise UserError(body)
partner.message_post(body=body)
# If the mailbox is not valid API returns 'mailbox_verification'
# as a string with value 'false'
if content["mailbox_verification"] == "false":
partner.email_bounced = True
body = (
_(
"%s failed the mailbox verification. Please check it"
" in order to avoid sending issues"
)
% partner.email
)
if not self.env.context.get("mailgun_auto_check"):
raise UserError(body)
partner.message_post(body=body)
# If Mailgun can't complete the validation request the API returns
# 'mailbox_verification' as a string set to 'unknown'
if content["mailbox_verification"] == "unknown":
if not self.env.context.get("mailgun_auto_check"):
raise UserError(
_(
"%s couldn't be verified. Either the request couln't"
" be completed or the mailbox provider doesn't "
"support email verification"
)
% (partner.email)
)
def check_email_bounced(self):
"""
Checks if the partner's email is in Mailgun's bounces list
API documentation:
https://documentation.mailgun.com/en/latest/api-suppressions.html
"""
api_key, api_url, domain, *__ = self.env[
"mail.tracking.email"
]._mailgun_values()
for partner in self:
res = requests.get(
urljoin(api_url, "/v3/%s/bounces/%s" % (domain, partner.email)),
auth=("api", api_key),
)
if res.status_code == 200 and not partner.email_bounced:
partner.email_bounced = True
elif res.status_code == 404 and partner.email_bounced:
partner.email_bounced = False
def force_set_bounced(self):
"""
Forces partner's email into Mailgun's bounces list
API documentation:
https://documentation.mailgun.com/en/latest/api-suppressions.html
"""
api_key, api_url, domain, *__ = self.env[
"mail.tracking.email"
]._mailgun_values()
for partner in self:
res = requests.post(
urljoin(api_url, "/v3/%s/bounces" % domain),
auth=("api", api_key),
data={"address": partner.email},
)
partner.email_bounced = res.status_code == 200 and not partner.email_bounced
def force_unset_bounced(self):
"""
Forces partner's email deletion from Mailgun's bounces list
API documentation:
https://documentation.mailgun.com/en/latest/api-suppressions.html
"""
api_key, api_url, domain, *__ = self.env[
"mail.tracking.email"
]._mailgun_values()
for partner in self:
res = requests.delete(
urljoin(api_url, "/v3/%s/bounces/%s" % (domain, partner.email)),
auth=("api", api_key),
)
if res.status_code in (200, 404) and partner.email_bounced:
partner.email_bounced = False
def _autocheck_partner_email(self):
for partner in self:
partner.with_context(mailgun_auto_check=True).check_email_validity()
@api.model
def create(self, vals):
if "email" in vals and self.env["ir.config_parameter"].sudo().get_param(
"mailgun.auto_check_partner_email"
):
self._autocheck_partner_email()
return super().create(vals)
def write(self, vals):
if "email" in vals and self.env["ir.config_parameter"].sudo().get_param(
"mailgun.auto_check_partner_email"
):
self._autocheck_partner_email()
return super().write(vals)
| 39.497382 | 7,544 |
4,442 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Jairo Llopis
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import logging
from urllib.parse import urljoin
import requests
from odoo import fields, models
_logger = logging.getLogger(__name__)
WEBHOOK_EVENTS = (
"clicked",
"complained",
"delivered",
"opened",
"permanent_fail",
"temporary_fail",
"unsubscribed",
)
class ResConfigSettings(models.TransientModel):
_inherit = "res.config.settings"
mail_tracking_mailgun_enabled = fields.Boolean(
string="Enable mail tracking with Mailgun",
help="Enable to enhance mail tracking with Mailgun",
)
mail_tracking_mailgun_api_key = fields.Char(
string="Mailgun API key",
config_parameter="mailgun.apikey",
help="Secret API key used to authenticate with Mailgun.",
)
mail_tracking_mailgun_webhook_signing_key = fields.Char(
string="Mailgun webhook signing key",
config_parameter="mailgun.webhook_signing_key",
help="Secret key used to validate incoming webhooks payload.",
)
mail_tracking_mailgun_validation_key = fields.Char(
string="Mailgun validation key",
config_parameter="mailgun.validation_key",
help="Key used to validate emails.",
)
mail_tracking_mailgun_api_url = fields.Char(
string="Mailgun API endpoint",
config_parameter="mailgun.api_url",
help=(
"Leave this empty if your API endpoint is the default "
"(https://api.mailgun.net/)."
),
)
mail_tracking_mailgun_domain = fields.Char(
string="Mailgun domain",
config_parameter="mailgun.domain",
help="Leave empty to use the catch-all domain.",
)
mail_tracking_mailgun_webhooks_domain = fields.Char(
string="Mailgun webhooks domain",
config_parameter="mailgun.webhooks_domain",
help="Leave empty to use the base Odoo URL.",
)
mail_tracking_mailgun_auto_check_partner_emails = fields.Boolean(
string="Check partner emails automatically",
config_parameter="mailgun.auto_check_partner_email",
help="Attempt to check partner emails always. This may cost money.",
)
def get_values(self):
"""Is Mailgun enabled?"""
result = super().get_values()
result["mail_tracking_mailgun_enabled"] = bool(
self.env["ir.config_parameter"].get_param("mailgun.apikey")
)
return result
def mail_tracking_mailgun_unregister_webhooks(self):
"""Remove existing Mailgun webhooks."""
params = self.env["mail.tracking.email"]._mailgun_values()
_logger.info("Getting current webhooks")
webhooks = requests.get(
urljoin(params.api_url, "/v3/domains/%s/webhooks" % params.domain),
auth=("api", params.api_key),
)
webhooks.raise_for_status()
for event, data in webhooks.json()["webhooks"].items():
# Modern webhooks return a list of URLs; old ones just one
urls = []
if "urls" in data:
urls.extend(data["urls"])
elif "url" in data:
urls.append(data["url"])
_logger.info(
"Deleting webhooks. Event: %s. URLs: %s", event, ", ".join(urls)
)
response = requests.delete(
urljoin(
params.api_url,
"/v3/domains/%s/webhooks/%s" % (params.domain, event),
),
auth=("api", params.api_key),
)
response.raise_for_status()
def mail_tracking_mailgun_register_webhooks(self):
"""Register Mailgun webhooks to get mail statuses automatically."""
params = self.env["mail.tracking.email"]._mailgun_values()
for event in WEBHOOK_EVENTS:
odoo_webhook = urljoin(
params.webhooks_domain,
"/mail/tracking/mailgun/all?db=%s" % self.env.cr.dbname,
)
_logger.info("Registering webhook. Event: %s. URL: %s", event, odoo_webhook)
response = requests.post(
urljoin(params.api_url, "/v3/domains/%s/webhooks" % params.domain),
auth=("api", params.api_key),
data={"id": event, "url": [odoo_webhook]},
)
# Assert correct registration
response.raise_for_status()
| 36.710744 | 4,442 |
2,922 |
py
|
PYTHON
|
15.0
|
# Copyright 2021 Tecnativa - Jairo Llopis
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
import hashlib
import hmac
import logging
from datetime import datetime, timedelta
from werkzeug.exceptions import NotAcceptable
from odoo import _
from odoo.exceptions import ValidationError
from odoo.http import request, route
from ...mail_tracking.controllers import main
from ...web.controllers.main import ensure_db
_logger = logging.getLogger(__name__)
class MailTrackingController(main.MailTrackingController):
def _mail_tracking_mailgun_webhook_verify(self, timestamp, token, signature):
"""Avoid mailgun webhook attacks.
See https://documentation.mailgun.com/en/latest/user_manual.html#securing-webhooks
""" # noqa: E501
# Request cannot be old
processing_time = datetime.utcnow() - datetime.utcfromtimestamp(int(timestamp))
if not timedelta() < processing_time < timedelta(minutes=10):
raise ValidationError(_("Request is too old"))
# Avoid replay attacks
try:
processed_tokens = (
request.env.registry._mail_tracking_mailgun_processed_tokens
)
except AttributeError:
processed_tokens = (
request.env.registry._mail_tracking_mailgun_processed_tokens
) = set()
if token in processed_tokens:
raise ValidationError(_("Request was already processed"))
processed_tokens.add(token)
params = request.env["mail.tracking.email"]._mailgun_values()
# Assert signature
if not params.webhook_signing_key:
_logger.warning(
"Skipping webhook payload verification. "
"Set `mailgun.webhook_signing_key` config parameter to enable"
)
return
hmac_digest = hmac.new(
key=params.webhook_signing_key.encode(),
msg=("{}{}".format(timestamp, token)).encode(),
digestmod=hashlib.sha256,
).hexdigest()
if not hmac.compare_digest(str(signature), str(hmac_digest)):
raise ValidationError(_("Wrong signature"))
@route(["/mail/tracking/mailgun/all"], auth="none", type="json", csrf=False)
def mail_tracking_mailgun_webhook(self):
"""Process webhooks from Mailgun."""
ensure_db()
# Verify and return 406 in case of failure, to avoid retries
# See https://documentation.mailgun.com/en/latest/user_manual.html#routes
try:
self._mail_tracking_mailgun_webhook_verify(
**request.jsonrequest["signature"]
)
except ValidationError as error:
raise NotAcceptable from error
# Process event
request.env["mail.tracking.email"].sudo()._mailgun_event_process(
request.jsonrequest["event-data"],
self._request_metadata(),
)
| 38.96 | 2,922 |
721 |
py
|
PYTHON
|
15.0
|
# Copyright 2020-2021 Tecnativa - João Marques
# Copyright 2021 Tecnativa - Pedro M. Baeza
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
{
"name": "Mail Notification Custom Subject",
"summary": "Apply a custom subject to mail notifications",
"version": "15.0.1.0.2",
"category": "Social Network",
"website": "https://github.com/OCA/social",
"author": "Tecnativa, Odoo Community Association (OCA)",
"license": "AGPL-3",
"installable": True,
"depends": ["mail"],
"data": [
"security/ir.model.access.csv",
"views/mail_notification_custom_subject_views.xml",
],
"development_status": "Production/Stable",
"maintainers": ["yajo"],
}
| 34.285714 | 720 |
475 |
py
|
PYTHON
|
15.0
|
# pylint: disable=C7902
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from openupgradelib import openupgrade
@openupgrade.migrate()
def migrate(env, version):
env.cr.execute(
"""
UPDATE mail_message_custom_subject
SET subject_template=REPLACE(
REPLACE(
subject_template,
'${',
'{{'),
'}',
'}}'
)
"""
)
| 23.75 | 475 |
8,274 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - João Marques
# Copyright 2022 Tecnativa - Víctor Martínez
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
# pylint: disable=C8107
from odoo.tests import common
from odoo.tools import mute_logger
class TestMailNotificationCustomSubject(common.TransactionCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
cls.partner_1, cls.partner_2 = (
cls.env["res.partner"]
.with_context(tracking_disable=True)
.create(
[
{"name": "Test partner 1", "email": "[email protected]"},
{"name": "Test partner 2", "email": "[email protected]"},
]
)
)
cls.admin = common.new_test_user(cls.env, "boss", "base.group_system")
def setUp(self):
super().setUp()
self.uid = common.new_test_user(self.env, "worker")
def test_email_subject_template_overrides(self):
with self.with_user("boss"):
self.env["mail.message.custom.subject"].create(
{
"name": "Test template 1",
"model_id": self.env.ref("base.model_res_partner").id,
"subtype_ids": [(6, 0, [self.env.ref("mail.mt_comment").id])],
"subject_template": "{{object.name or 'n/a'}} and something more",
}
)
# Send message in partner
mail_message_1 = self.partner_1.message_post(
body="Test", subtype_xmlid="mail.mt_comment"
)
# Get message and check subject
self.assertEqual(mail_message_1.subject, "Test partner 1 and something more")
# Send message in partner 2
mail_message_2 = self.partner_2.message_post(
body="Test", subtype_xmlid="mail.mt_comment"
)
# Get message and check subject
self.assertEqual(mail_message_2.subject, "Test partner 2 and something more")
# Explicit subject should also be overwritten
mail_message_3 = self.partner_2.message_post(
body="Test", subtype_xmlid="mail.mt_comment", subject="Test"
)
# Get message and check subject
self.assertEqual(mail_message_3.subject, "Test partner 2 and something more")
def test_email_subject_template_normal(self):
with self.with_user("boss"):
self.env["mail.message.custom.subject"].create(
{
"name": "Test template 1",
"model_id": self.env.ref("base.model_res_partner").id,
"subtype_ids": [(6, 0, [self.env.ref("mail.mt_comment").id])],
"subject_template": "{{object.name or 'n/a'}} and something more",
}
)
# Send note in partner
mail_message_1 = self.partner_1.message_post(
body="Test", subtype_xmlid="mail.mt_note", subject="Test"
)
# Get message and check subject. Subject Template should not apply
self.assertEqual(mail_message_1.subject, "Test")
def test_email_subject_template_multi(self):
with self.with_user("boss"):
self.env["mail.message.custom.subject"].create(
{
"name": "Test template 1",
"model_id": self.env.ref("base.model_res_partner").id,
"subtype_ids": [(6, 0, [self.env.ref("mail.mt_comment").id])],
"subject_template": "{{object.name or 'n/a'}} and something more",
}
)
with self.with_user("boss"):
self.env["mail.message.custom.subject"].create(
{
"name": "Test template 2",
"model_id": self.env.ref("base.model_res_partner").id,
"subtype_ids": [(6, 0, [self.env.ref("mail.mt_comment").id])],
"subject_template": "{{object.name or 'n/a'}} and something different",
}
)
# Send message in partner
mail_message_1 = self.partner_1.message_post(
body="Test", subtype_xmlid="mail.mt_comment"
)
# Get message and check subject
self.assertEqual(
mail_message_1.subject, "Test partner 1 and something different"
)
with self.with_user("boss"):
self.env["mail.message.custom.subject"].create(
{
"name": "Test template 3",
"model_id": self.env.ref("base.model_res_partner").id,
"subtype_ids": [(6, 0, [self.env.ref("mail.mt_comment").id])],
"subject_template": "{{' and yet something else'}}",
"position": "append_after",
}
)
# Send message in partner
mail_message_2 = self.partner_1.message_post(
body="Test", subtype_xmlid="mail.mt_comment"
)
# Get message and check subject
self.assertEqual(
mail_message_2.subject,
"Test partner 1 and something different and yet something else",
)
with self.with_user("boss"):
self.env["mail.message.custom.subject"].create(
{
"name": "Test template 4",
"model_id": self.env.ref("base.model_res_partner").id,
"subtype_ids": [(6, 0, [self.env.ref("mail.mt_comment").id])],
"subject_template": "{{'Re: '}}",
"position": "append_before",
}
)
# Send message in partner
mail_message_3 = self.partner_1.message_post(
body="Test", subtype_xmlid="mail.mt_comment"
)
# Get message and check subject
self.assertEqual(
mail_message_3.subject,
"Re: Test partner 1 and something different and yet something else",
)
def test_email_subject_template_w_original(self):
with self.with_user("boss"):
self.env["mail.message.custom.subject"].create(
{
"name": "Test template 1",
"model_id": self.env.ref("base.model_res_partner").id,
"subtype_ids": [(6, 0, [self.env.ref("mail.mt_comment").id])],
"subject_template": "{{' and something more'}}",
"position": "append_after",
}
)
# Send message in partner
mail_message_1 = self.partner_1.message_post(
body="Test",
subtype_xmlid="mail.mt_comment",
subject="Test",
)
# Get message and check subject
self.assertEqual(mail_message_1.subject, "Test and something more")
def test_bad_template_does_not_break(self):
"""Create template with error (obaject) to test error."""
with self.with_user("boss"):
self.env["mail.message.custom.subject"].create(
{
"name": "Test bad template 1",
"model_id": self.env.ref("base.model_res_partner").id,
"subtype_ids": [(6, 0, [self.env.ref("mail.mt_comment").id])],
"subject_template": "{{obaject.number_a}} and something",
"position": "append_after",
}
)
# Send message in partner
with mute_logger("odoo.addons.mail.models.mail_render_mixin"):
mail_message_1 = self.partner_1.message_post(
body="Test",
subtype_xmlid="mail.mt_comment",
subject="Test",
)
# Get message and check subject
# No exception should be raised but subject should remain as original.
self.assertEqual(mail_message_1.subject, "Test")
def test_no_template_default_result(self):
# Send message in partner
mail_message_1 = self.partner_1.message_post(
body="Test", subtype_xmlid="mail.mt_comment", subject="Test partner 1"
)
# Get message and check subject
# No exception should be raised but subject should remain as original.
self.assertEqual(mail_message_1.subject, "Test partner 1")
| 42.854922 | 8,271 |
3,091 |
py
|
PYTHON
|
15.0
|
# Copyright 2020-2021 Tecnativa - João Marques
# Copyright 2021 Tecnativa - Pedro M. Baeza
# Copyright 2022 Moduon - Eduardo de Miguel
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import api, models
class MailThread(models.AbstractModel):
_inherit = "mail.thread"
@api.returns("mail.message", lambda value: value.id)
def message_post(
self,
*,
body="",
subject=None,
message_type="notification",
email_from=None,
author_id=None,
parent_id=False,
subtype_xmlid=None,
subtype_id=False,
partner_ids=None,
attachments=None,
attachment_ids=None,
add_sign=True,
record_name=False,
**kwargs
):
if subtype_xmlid:
subtype_id = self.env["ir.model.data"]._xmlid_to_res_id(
subtype_xmlid,
raise_if_not_found=False,
)
if not subtype_id:
subtype_id = self.env["ir.model.data"]._xmlid_to_res_id("mail.mt_note")
if subtype_id:
custom_subjects = (
self.env["mail.message.custom.subject"]
.sudo()
.search(
[
("model_id.model", "=", self._name),
("subtype_ids", "=", subtype_id),
]
)
.sudo(False)
)
if not subject:
subject = "Re: %s" % self.env["mail.message"].with_context(
default_model=self._name,
default_res_id=self.id,
)._get_record_name({})
for template in custom_subjects:
try:
rendered_subject_template = self.env[
"mail.template"
]._render_template(
template_src=template.subject_template,
model=self._name,
res_ids=[self.id],
)[
self.id
]
if template.position == "replace":
subject = rendered_subject_template
elif template.position == "append_before":
subject = rendered_subject_template + subject
elif template.position == "append_after":
subject += rendered_subject_template
except Exception:
rendered_subject_template = False
return super().message_post(
body=body,
subject=subject,
message_type=message_type,
email_from=email_from,
author_id=author_id,
parent_id=parent_id,
subtype_xmlid=subtype_xmlid,
subtype_id=subtype_id,
partner_ids=partner_ids,
attachments=attachments,
attachment_ids=attachment_ids,
add_sign=add_sign,
record_name=record_name,
**kwargs,
)
| 34.719101 | 3,090 |
1,154 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Tecnativa - João Marques
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo import fields, models
class MailMessageCustomSubject(models.Model):
_name = "mail.message.custom.subject"
_description = "Mail Message Custom Subject"
name = fields.Char(string="Template Name")
model_id = fields.Many2one(
comodel_name="ir.model",
string="Model",
required=True,
help="Model where this template applies",
ondelete="cascade",
)
subtype_ids = fields.Many2many(
comodel_name="mail.message.subtype",
string="Applied Subtypes",
required=True,
)
subject_template = fields.Char(
required=True,
help="Subject (placeholders may be used here)",
)
position = fields.Selection(
selection=[
("append_before", "Append Before"),
("append_after", "Append After"),
("replace", "Replace"),
],
default="replace",
help="Whether to replace, append at beggining or append at end to other"
" templates that apply to a given context",
)
| 31.162162 | 1,153 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
2,480 |
py
|
PYTHON
|
15.0
|
import setuptools
with open('VERSION.txt', 'r') as f:
version = f.read().strip()
setuptools.setup(
name="odoo-addons-oca-social",
description="Meta package for oca-social Odoo addons",
version=version,
install_requires=[
'odoo-addon-base_search_mail_content>=15.0dev,<15.1dev',
'odoo-addon-email_template_qweb>=15.0dev,<15.1dev',
'odoo-addon-mail_activity_board>=15.0dev,<15.1dev',
'odoo-addon-mail_activity_creator>=15.0dev,<15.1dev',
'odoo-addon-mail_activity_done>=15.0dev,<15.1dev',
'odoo-addon-mail_activity_partner>=15.0dev,<15.1dev',
'odoo-addon-mail_activity_team>=15.0dev,<15.1dev',
'odoo-addon-mail_attach_existing_attachment>=15.0dev,<15.1dev',
'odoo-addon-mail_autosubscribe>=15.0dev,<15.1dev',
'odoo-addon-mail_debrand>=15.0dev,<15.1dev',
'odoo-addon-mail_layout_force>=15.0dev,<15.1dev',
'odoo-addon-mail_notification_custom_subject>=15.0dev,<15.1dev',
'odoo-addon-mail_optional_autofollow>=15.0dev,<15.1dev',
'odoo-addon-mail_optional_follower_notification>=15.0dev,<15.1dev',
'odoo-addon-mail_outbound_static>=15.0dev,<15.1dev',
'odoo-addon-mail_parent_recipient>=15.0dev,<15.1dev',
'odoo-addon-mail_post_defer>=15.0dev,<15.1dev',
'odoo-addon-mail_preview_audio>=15.0dev,<15.1dev',
'odoo-addon-mail_preview_base>=15.0dev,<15.1dev',
'odoo-addon-mail_quoted_reply>=15.0dev,<15.1dev',
'odoo-addon-mail_restrict_follower_selection>=15.0dev,<15.1dev',
'odoo-addon-mail_send_copy>=15.0dev,<15.1dev',
'odoo-addon-mail_show_follower>=15.0dev,<15.1dev',
'odoo-addon-mail_tracking>=15.0dev,<15.1dev',
'odoo-addon-mail_tracking_mailgun>=15.0dev,<15.1dev',
'odoo-addon-mail_tracking_mass_mailing>=15.0dev,<15.1dev',
'odoo-addon-mass_mailing_custom_unsubscribe>=15.0dev,<15.1dev',
'odoo-addon-mass_mailing_custom_unsubscribe_event>=15.0dev,<15.1dev',
'odoo-addon-mass_mailing_event_registration_exclude>=15.0dev,<15.1dev',
'odoo-addon-mass_mailing_list_dynamic>=15.0dev,<15.1dev',
'odoo-addon-mass_mailing_partner>=15.0dev,<15.1dev',
'odoo-addon-mass_mailing_resend>=15.0dev,<15.1dev',
'odoo-addon-microsoft_outlook_single_tenant>=15.0dev,<15.1dev',
],
classifiers=[
'Programming Language :: Python',
'Framework :: Odoo',
'Framework :: Odoo :: 15.0',
]
)
| 49.6 | 2,480 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
100 |
py
|
PYTHON
|
15.0
|
import setuptools
setuptools.setup(
setup_requires=['setuptools-odoo'],
odoo_addon=True,
)
| 16.666667 | 100 |
610 |
py
|
PYTHON
|
15.0
|
# Copyright 2020 Creu Blanca
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
{
"name": "Preview audio files",
"summary": "Allow to preview audio files",
"version": "15.0.1.0.0",
"license": "AGPL-3",
"author": "Creu Blanca,Odoo Community Association (OCA)",
"website": "https://github.com/OCA/social",
"depends": ["mail_preview_base"],
"data": [],
"qweb": ["static/src/xml/preview.xml"],
"assets": {
"web.assets_backend": ["mail_preview_audio/static/src/js/*.js"],
"web.assets_qweb": ["mail_preview_audio/static/src/xml/*.xml"],
},
}
| 33.888889 | 610 |
590 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ForgeFlow S.L.
# (http://www.forgeflow.com)
# Copyright 2016 Serpent Consulting Services Pvt. Ltd.
# (<http://www.serpentcs.com>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
{
"name": "Base Search Mail Content",
"version": "15.0.1.0.1",
"author": "ForgeFlow, SerpentCS, Tecnativa, Odoo Community Association (OCA)",
"website": "https://github.com/OCA/social",
"category": "Social",
"data": ["data/trgm_index_data.xml"],
"depends": ["mail", "base_search_fuzzy"],
"license": "AGPL-3",
"installable": True,
}
| 34.705882 | 590 |
908 |
py
|
PYTHON
|
15.0
|
# Copyright 2017 ForgeFlow S.L.
# (http://www.forgeflow.com)
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
from odoo.tests.common import TransactionCase
class TestBaseSearchMailContent(TransactionCase):
def setUp(self):
super().setUp()
self.channel_obj = self.env["mail.channel"]
def test_base_search_mail_content_1(self):
res = self.channel_obj.search([("message_content", "ilike", "xxxyyyzzz")])
self.assertFalse(res, "You have a channel with xxxyyyzzz :O")
def test_base_search_mail_content_2(self):
res = self.channel_obj.load_views(
[[False, "search"]],
{"load_fields": False, "load_filters": True, "toolbar": True},
)
self.assertIn(
"message_content",
res["fields_views"]["search"]["fields"],
"message_content field was not detected",
)
| 36.32 | 908 |
561 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ForgeFlow S.L.
# Copyright 2016 Serpent Consulting Services Pvt. Ltd.
# Copyright 2017 LasLabs Inc.
# Copyright 2018 Tecnativa - Vicent Cubells
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl).
from odoo import fields, models
class TrgmIndex(models.Model):
_inherit = "trgm.index"
# We take advantage of field inheritance to redefine help instead of do
# inheritance in views that throws an error
field_id = fields.Many2one(
help="You can either select a field of type 'text', 'char' or 'html'."
)
| 33 | 561 |
2,227 |
py
|
PYTHON
|
15.0
|
# Copyright 2016-17 ForgeFlow S.L.
# (http://www.forgeflow.com)
# Copyright 2016 Serpent Consulting Services Pvt. Ltd.
# (<http://www.serpentcs.com>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from lxml import etree
from odoo import _, api, fields, models
from odoo.osv import expression
class MailThread(models.AbstractModel):
_inherit = "mail.thread"
def _search_message_content(self, operator, value):
model_domain = [("model", "=", self._name)]
if operator not in expression.NEGATIVE_TERM_OPERATORS:
model_domain += ["|"] * 4
model_domain += [
("record_name", operator, value),
("subject", operator, value),
("body", operator, value),
("email_from", operator, value),
("reply_to", operator, value),
]
recs = self.env["mail.message"].search(model_domain)
return [("id", "in", recs.mapped("res_id"))]
message_content = fields.Text(
help="Message content, to be used only in searches",
compute="_compute_message_content",
search="_search_message_content",
)
def _compute_message_content(self):
# Always assign a value to avoid CacheMiss errors
self.message_content = False
@api.model
def fields_view_get(
self, view_id=None, view_type="form", toolbar=False, submenu=False
):
"""
Override to add message_content field in all the objects
that inherits mail.thread
"""
res = super(MailThread, self).fields_view_get(
view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu
)
if view_type == "search" and self._fields.get("message_content"):
doc = etree.XML(res["arch"])
res["fields"].update(
{"message_content": {"type": "char", "string": _("Message Content")}}
)
for node in doc.xpath("/search/field[last()]"):
# Add message_content in search view
elem = etree.Element("field", {"name": "message_content"})
node.addnext(elem)
res["arch"] = etree.tostring(doc)
return res
| 36.508197 | 2,227 |
521 |
py
|
PYTHON
|
15.0
|
# Copyright 2016 ACSONE SA/NV (<http://acsone.eu>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl).
{
"name": "Mail optional follower notification",
"summary": "Choose to notify followers on mail.compose.message",
"author": "ACSONE SA/NV," "Odoo Community Association (OCA)",
"website": "https://github.com/OCA/social",
"category": "Social Network",
"version": "15.0.1.0.1",
"license": "AGPL-3",
"depends": ["mail"],
"data": ["wizard/mail_compose_message_view.xml"],
}
| 40.076923 | 521 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.