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&amp;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>&nbsp;</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