cb56a38680
Reports of literal '<b>Client Self-Service</b>' showing in the chatter
instead of bold formatting. Cause: message_post(body=str) HTML-escapes
the string. The Odoo idiom for HTML chatter bodies is markupsafe.Markup,
with the % operator auto-escaping substitution values for XSS safety.
Fixed every message_post call:
models/intake_service.py
- 'Service call submitted via <b>...</b>' (the reported one)
- 'This repair MAY be covered by our active warranty <b>...</b>'
models/maintenance_contract.py
- 'Sent N-day maintenance reminder to <email>'
- 'Maintenance visit <b>...</b> booked from reminder link'
models/technician_task.py
- 'Rolled forward after maintenance task <b>...</b> completed'
wizard/repair_visit_report_wizard.py
- 'Spawned follow-up repair <b>...</b> for "found another issue"'
Pattern used: Markup(_('... <b>%(x)s</b> ...')) % {'x': escaped_value}.
Verified on local westin-v19 (BR-WA/RO/00026): DB row now reads
'<p>Service call submitted via <b>Client Self-Service</b> by Gurpreet
Singh. Session reference: RIS000015.</p>' which renders correctly in
the chatter UI.
Bumped to 19.0.1.0.3.
Co-authored-by: Cursor <cursoragent@cursor.com>
228 lines
8.6 KiB
Python
228 lines
8.6 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright 2024-2026 Nexa Systems Inc.
|
|
# License OPL-1 (Odoo Proprietary License v1.0)
|
|
|
|
"""Maintenance contracts.
|
|
|
|
One contract per sold unit (partner + product + lot). When the underlying
|
|
sale order is delivered and the product has x_fc_maintenance_interval_months>0,
|
|
a contract is auto-created. A daily cron walks active contracts and sends
|
|
the client a reminder email at 30, 7, and 1 days before next_due_date with
|
|
a tokenized booking link.
|
|
"""
|
|
|
|
import secrets
|
|
from datetime import timedelta
|
|
|
|
from dateutil.relativedelta import relativedelta
|
|
from markupsafe import Markup
|
|
|
|
from odoo import _, api, fields, models
|
|
|
|
|
|
CONTRACT_STATES = [
|
|
('draft', 'Draft'),
|
|
('active', 'Active'),
|
|
('paused', 'Paused'),
|
|
('cancelled', 'Cancelled'),
|
|
]
|
|
|
|
|
|
class FusionRepairMaintenanceContract(models.Model):
|
|
_name = 'fusion.repair.maintenance.contract'
|
|
_inherit = ['mail.thread']
|
|
_description = 'Repair Maintenance Contract'
|
|
_order = 'next_due_date, id'
|
|
|
|
name = fields.Char(string='Reference', required=True, default='New',
|
|
copy=False, readonly=True)
|
|
partner_id = fields.Many2one(
|
|
'res.partner',
|
|
string='Client',
|
|
required=True,
|
|
index=True,
|
|
ondelete='restrict',
|
|
)
|
|
product_id = fields.Many2one(
|
|
'product.product',
|
|
string='Equipment',
|
|
required=True,
|
|
index=True,
|
|
)
|
|
lot_id = fields.Many2one('stock.lot', string='Serial Number')
|
|
original_sale_order_id = fields.Many2one(
|
|
'sale.order',
|
|
string='Original Sale Order',
|
|
index=True,
|
|
)
|
|
|
|
interval_months = fields.Integer(string='Interval (months)', default=12, required=True)
|
|
last_service_date = fields.Date(string='Last Service')
|
|
next_due_date = fields.Date(string='Next Due', required=True, index=True)
|
|
state = fields.Selection(CONTRACT_STATES, default='active', required=True,
|
|
tracking=True, index=True)
|
|
|
|
booking_token = fields.Char(string='Booking Token', copy=False, index=True)
|
|
last_reminder_band = fields.Selection(
|
|
[('30', '30 days'), ('7', '7 days'), ('1', '1 day')],
|
|
string='Last Reminder Sent',
|
|
copy=False,
|
|
help='The most recent reminder band sent for the current cycle.',
|
|
)
|
|
booking_repair_id = fields.Many2one(
|
|
'repair.order',
|
|
string='Booked Repair',
|
|
copy=False,
|
|
help='The repair.order created when the client used the booking link for this cycle.',
|
|
)
|
|
|
|
company_id = fields.Many2one(
|
|
'res.company', default=lambda self: self.env.company,
|
|
)
|
|
|
|
_booking_token_unique = models.Constraint(
|
|
'unique(booking_token)',
|
|
'Booking token must be unique.',
|
|
)
|
|
|
|
@api.model_create_multi
|
|
def create(self, vals_list):
|
|
for vals in vals_list:
|
|
if vals.get('name', 'New') == 'New':
|
|
vals['name'] = self.env['ir.sequence'].next_by_code(
|
|
'fusion.repair.maintenance.contract'
|
|
) or 'MC/NEW'
|
|
if not vals.get('booking_token'):
|
|
vals['booking_token'] = secrets.token_urlsafe(20)
|
|
return super().create(vals_list)
|
|
|
|
# ------------------------------------------------------------------
|
|
# ROLL FORWARD
|
|
# ------------------------------------------------------------------
|
|
def roll_next_due_date(self):
|
|
"""Advance next_due_date by interval_months and reset cycle state.
|
|
|
|
Called from technician_task.write() when a maintenance task moves to
|
|
'completed' (see technician_task.py).
|
|
"""
|
|
for c in self:
|
|
base = c.last_service_date or fields.Date.context_today(c)
|
|
# relativedelta handles month boundaries correctly (28/29/30/31).
|
|
c.next_due_date = base + relativedelta(months=c.interval_months or 12)
|
|
c.last_reminder_band = False
|
|
c.booking_repair_id = False
|
|
|
|
# ------------------------------------------------------------------
|
|
# REMINDER CRON
|
|
# ------------------------------------------------------------------
|
|
@api.model
|
|
def cron_send_due_reminders(self):
|
|
"""Daily cron - send reminder emails at 30/7/1 days before next_due_date."""
|
|
ICP = self.env['ir.config_parameter'].sudo()
|
|
if ICP.get_param('fusion_repairs.enable_email_notifications', 'True') != 'True':
|
|
return
|
|
today = fields.Date.context_today(self)
|
|
bands = [
|
|
('30', 30),
|
|
('7', 7),
|
|
('1', 1),
|
|
]
|
|
tpl = self.env.ref(
|
|
'fusion_repairs.email_template_maintenance_due_reminder',
|
|
raise_if_not_found=False,
|
|
)
|
|
if not tpl:
|
|
return
|
|
for band_label, days in bands:
|
|
target = today + timedelta(days=days)
|
|
domain = [
|
|
('state', '=', 'active'),
|
|
('next_due_date', '=', target),
|
|
('partner_id.email', '!=', False),
|
|
]
|
|
# Don't re-send a smaller band if we already sent a larger one
|
|
# for the same cycle - the band order is 30 -> 7 -> 1.
|
|
contracts = self.search(domain)
|
|
for c in contracts:
|
|
if c.last_reminder_band == band_label:
|
|
continue
|
|
try:
|
|
tpl.send_mail(c.id, force_send=False)
|
|
c.last_reminder_band = band_label
|
|
c.message_post(
|
|
body=Markup(_(
|
|
'Sent %(band)s-day maintenance reminder to %(email)s.'
|
|
)) % {
|
|
'band': band_label,
|
|
'email': c.partner_id.email or '',
|
|
},
|
|
)
|
|
except Exception:
|
|
continue
|
|
|
|
# ------------------------------------------------------------------
|
|
# PORTAL BOOKING
|
|
# ------------------------------------------------------------------
|
|
def create_repair_from_booking(self, scheduled_date=None):
|
|
"""Spawn a repair.order from the booking link (or any manual booking)."""
|
|
self.ensure_one()
|
|
if self.booking_repair_id and self.booking_repair_id.state != 'cancel':
|
|
return self.booking_repair_id
|
|
Repair = self.env['repair.order'].sudo()
|
|
repair = Repair.create({
|
|
'partner_id': self.partner_id.id,
|
|
'product_id': self.product_id.id,
|
|
'lot_id': self.lot_id.id if self.lot_id else False,
|
|
'schedule_date': scheduled_date or fields.Datetime.now(),
|
|
'x_fc_intake_source': 'client_portal',
|
|
'x_fc_urgency': 'normal',
|
|
'x_fc_repair_category_id':
|
|
self.product_id.product_tmpl_id.x_fc_repair_category_id.id
|
|
if self.product_id.product_tmpl_id.x_fc_repair_category_id else False,
|
|
'x_fc_maintenance_contract_id': self.id,
|
|
'internal_notes':
|
|
f'<p>Maintenance visit booked from reminder for contract <b>{self.name}</b>.</p>',
|
|
})
|
|
self.booking_repair_id = repair
|
|
self.message_post(
|
|
body=Markup(_(
|
|
'Maintenance visit <b>%(ref)s</b> booked from reminder link.'
|
|
)) % {'ref': repair.name or ''},
|
|
)
|
|
return repair
|
|
|
|
|
|
class SaleOrder(models.Model):
|
|
_inherit = 'sale.order'
|
|
|
|
def _spawn_maintenance_contracts(self):
|
|
"""Create maintenance contracts for any delivered SO line whose
|
|
product has x_fc_maintenance_interval_months > 0."""
|
|
Contract = self.env['fusion.repair.maintenance.contract'].sudo()
|
|
today = fields.Date.context_today(self)
|
|
for so in self:
|
|
if so.state not in ('sale', 'done'):
|
|
continue
|
|
for line in so.order_line:
|
|
product = line.product_id
|
|
if not product:
|
|
continue
|
|
interval = product.product_tmpl_id.x_fc_maintenance_interval_months or 0
|
|
if interval <= 0:
|
|
continue
|
|
existing = Contract.search([
|
|
('partner_id', '=', so.partner_id.id),
|
|
('product_id', '=', product.id),
|
|
('original_sale_order_id', '=', so.id),
|
|
], limit=1)
|
|
if existing:
|
|
continue
|
|
Contract.create({
|
|
'partner_id': so.partner_id.id,
|
|
'product_id': product.id,
|
|
'original_sale_order_id': so.id,
|
|
'interval_months': interval,
|
|
'next_due_date': today + relativedelta(months=interval),
|
|
'state': 'active',
|
|
})
|