admin/Odoo-Modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(fusion_repairs): Bundle 8 - rush service + emergency pricing + parts-ordered workflow

Browse Source 
The grumpy-old-customer-with-broken-stairlift scenario. Four real workflows
the office faces every week, with comms baked in so the client never has to
call back asking for status.

NEW MODELS
- fusion.repair.emergency.charge (rate card)
  Per (category, tier) rate with per_tech_multiplier; 5 tiers
  (same_day / next_day / after_hours / weekend / holiday). Each category
  can have its own rates - bed motors need 2 techs, stairlift is single.
  Seeded with realistic Westin rates: stairlift same-day $250, weekend
  $450; porch lift same-day $300; bed same-day $175 with 0.6 multiplier
  (2-tech jobs frequent); powerchair same-day $200.

- fusion.repair.part.order (procurement-facing record)
  One per distinct part the tech needs from the manufacturer. Carries
  description + OEM # + manufacturer + quantity + photos + notes.
  4-state lifecycle: draft -> ordered -> received -> fitted (or
  cancelled). On state transitions:
    draft -> ordered:  email client "ordered, expected by X"
    ordered -> received: email client "arrived, scheduling return visit"
                         + auto-create follow-up dispatch task when ALL
                         outstanding parts on the repair have arrived.

REPAIR.ORDER EXTENSIONS
- Rush fields: x_fc_rush_requested, x_fc_rush_tier,
  x_fc_rush_techs_required, x_fc_rush_surcharge (computed via rate card),
  x_fc_rush_acknowledged_at + x_fc_rush_acknowledged_by_id (audit trail
  proving CS got verbal OK before charging).
- Parts-awaiting fields: x_fc_parts_awaiting + x_fc_parts_eta_date +
  x_fc_part_order_ids One2many + x_fc_part_order_count.

- New methods:
  * action_acknowledge_rush() - one-click "client agreed" with audit.
  * action_squeeze_into_today() - picks the lightest-loaded skilled tech,
    finds their first free 1-hour slot between 9am-6pm, schedules the
    task in it, sends:
      1) live bus.bus push to the tech (sticky notification in their
         web client - so they see it MID-SHIFT)
      2) rush-alert email (force_send=True - this can't wait in the queue)
      3) chatter post on the tech task itself
    Validates against fusion_tasks' time-conflict rule by passing
    force_schedule via context (intake.service honours it).
  * action_view_part_orders() - smart button.

WIZARD EXTENSIONS
- repair.intake.wizard:
  New rush_requested + rush_tier + rush_techs_required + rush_acknowledged
  controls. Live rush_surcharge_preview compute shows CS the price in
  real-time as they change category / tier / tech count. Yellow alert
  reminds CS to read the price to the client BEFORE submitting.

- repair.visit.report.wizard:
  New outcome radio: completed / parts_needed / rescheduled.
  When outcome=parts_needed, needs_parts_line_ids One2many appears for
  the tech to capture each part (description, OEM, manufacturer, qty,
  lead days, notes, photos). On submit each line creates a
  fusion.repair.part.order, the repair flips to x_fc_parts_awaiting=True
  with an ETA, and the client gets the "we found the problem, here's the
  plan" email immediately.

INTAKE SERVICE
- _create_dispatch_task now honours force_schedule (date + time_start +
  time_end) via context so squeeze + auto-redispatch don't crash on
  fusion_tasks' time-window validator.
- _create_single_repair carries rush_requested/tier/techs through to
  the new repair fields.

MAIL TEMPLATES (4 new)
- email_template_rush_tech_alert: red 4px accent, address + phone + the
  $surcharge - what the tech needs to know mid-shift.
- email_template_repair_awaiting_parts: amber accent, "we found the
  problem, parts ordered, return visit ~ETA, no action needed".
- email_template_parts_ordered: blue, per-part confirmation.
- email_template_parts_received: green, "arrived, office will call to
  confirm visit".

UI / NAVIGATION
- Backend wizard: rush controls + live surcharge preview + verbal-OK alert.
- repair.order form: new Rush / Parts notebook tab with all the fields
  + linked part orders list. Two new header buttons (Squeeze into
  Today / Client Agreed to Rush Price). Two new search filters
  (Rush, Awaiting Parts).
- Part Order form: statusbar with the 4 transitions + Cancel; notes +
  photos notebook tabs; full chatter for audit.
- Menus: 'Parts to Order' under root; 'Emergency Surcharges' under
  Configuration.

SECURITY
- 8 new ACL entries (emergency_charge user/manager; part_order
  user/dispatcher/manager/technician; visit_report partline for office
  and field tech). Office sees parts but only managers can edit
  emergency rates.

Verified end-to-end on local westin-v19 - all 4 scenarios green:
  S1 Same-day rush stairlift -> $250 surcharge, ack stamped, squeeze
     assigned garry@ at first free 1h slot today, alert email queued,
     chatter posted.
  S2 Next-day priority bed -> $0 surcharge (no rate seeded for bed
     next_day - office can configure), 4 emails queued (client + office).
  S3 2-tech weekend stairlift -> $675 (450 base + 0.5x base for 2nd tech).
  S4 Parts-needed visit-report -> 2 PART-#### records created, repair
     awaiting_parts=True, ETA=2026-06-06, office activity scheduled,
     client email sent. Marking part ordered -> client mail. Marking
     all parts received -> auto-dispatch follow-up + client mail.

Bumped to 19.0.1.9.1.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
gsinghpal
2026-05-21 01:28:13 -04:00
parent 4f1b7c2df6
commit ebbadb3002
18 changed files with 1367 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

252
fusion_repairs/models/repair_part_order.py Normal file
View File

@@ -0,0 +1,252 @@
# -*- coding: utf-8 -*-
# Copyright 2024-2026 Nexa Systems Inc.
# License OPL-1 (Odoo Proprietary License v1.0)
"""Parts-ordering workflow.
When the tech arrives, diagnoses, and discovers the unit needs a part we
don't stock (most common with manufacturer-specific items like Handicare
stairlift control boards), they capture the part info via the mobile
visit-report wizard in a structured way so:
1. Office can order from the manufacturer in one click (description + OEM
part number + photos are exactly what procurement needs)
2. Client gets an immediate "we found the problem - here's the timeline" email
3. When parts arrive, office marks the order received and the system
auto-creates a follow-up dispatch task
The grumpy-old-client never has to call us asking for status updates.
"""
from datetime import timedelta
from markupsafe import Markup
from odoo import _, api, fields, models
class FusionRepairPartOrder(models.Model):
_name = 'fusion.repair.part.order'
_inherit = ['mail.thread']
_description = 'Repair Part Order'
_order = 'create_date desc, id desc'
name = fields.Char(
string='Reference',
default='New',
copy=False,
readonly=True,
tracking=True,
)
repair_order_id = fields.Many2one(
'repair.order',
string='Repair',
required=True,
ondelete='cascade',
index=True,
)
partner_id = fields.Many2one(
related='repair_order_id.partner_id',
store=True,
readonly=True,
)
description = fields.Char(
string='Part Description',
required=True,
tracking=True,
help='Plain English - what the tech needs (e.g. "Handicare 1100 control board, '
'silver casing").',
)
oem_part_number = fields.Char(
string='OEM Part Number',
tracking=True,
help='If the tech could read a part number off the broken component.',
)
manufacturer = fields.Char(
string='Manufacturer',
tracking=True,
)
quantity = fields.Float(
string='Quantity',
default=1.0,
required=True,
)
notes = fields.Text(
string='Tech Notes',
help='Anything procurement needs to know (alternative SKUs, colour, '
'dimensions, etc.)',
)
photo_ids = fields.Many2many(
'ir.attachment',
'fusion_repair_part_order_photo_rel',
'part_order_id', 'attachment_id',
string='Photos',
help='Photos of the broken part / label / packaging. The more the better.',
)
state = fields.Selection(
[
('draft', 'Captured by Tech'),
('ordered', 'Ordered from Manufacturer'),
('received', 'Received in Warehouse'),
('fitted', 'Fitted - Repair Complete'),
('cancelled', 'Cancelled'),
],
string='Status',
default='draft',
tracking=True,
copy=False,
)
ordered_date = fields.Date(string='Ordered On', tracking=True)
expected_date = fields.Date(string='Expected Arrival', tracking=True)
received_date = fields.Date(string='Received On', tracking=True, copy=False)
ordered_by_id = fields.Many2one(
'res.users',
string='Ordered By',
tracking=True,
copy=False,
)
company_id = fields.Many2one(
'res.company',
default=lambda self: self.env.company,
)
# ------------------------------------------------------------------
# CRUD
# ------------------------------------------------------------------
@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.part.order'
) or 'PART/NEW'
records = super().create(vals_list)
for rec in records:
rec._post_creation_to_repair()
return records
def _post_creation_to_repair(self):
for rec in self:
rec.repair_order_id.message_post(body=Markup(_(
'Part order <b>%(ref)s</b> captured: %(desc)s '
'(qty %(qty)s%(oem)s).'
)) % {
'ref': rec.name,
'desc': rec.description,
'qty': rec.quantity,
'oem': f' / OEM {rec.oem_part_number}' if rec.oem_part_number else '',
})
# ------------------------------------------------------------------
# ACTIONS
# ------------------------------------------------------------------
def action_mark_ordered(self):
"""Office marks this part as ordered with the manufacturer."""
for rec in self:
rec.state = 'ordered'
rec.ordered_date = fields.Date.context_today(rec)
rec.ordered_by_id = self.env.user
if not rec.expected_date:
rec.expected_date = fields.Date.context_today(rec) + timedelta(days=7)
rec._notify_client_parts_ordered()
def action_mark_received(self):
"""Office marks this part as received - triggers follow-up dispatch."""
for rec in self:
rec.state = 'received'
rec.received_date = fields.Date.context_today(rec)
rec._maybe_redispatch()
rec._notify_client_parts_received()
def action_mark_fitted(self):
for rec in self:
rec.state = 'fitted'
def action_cancel(self):
for rec in self:
rec.state = 'cancelled'
# ------------------------------------------------------------------
# WORKFLOW HELPERS
# ------------------------------------------------------------------
def _notify_client_parts_ordered(self):
for rec in self:
tpl = self.env.ref(
'fusion_repairs.email_template_parts_ordered',
raise_if_not_found=False,
)
if tpl and rec.partner_id and rec.partner_id.email:
try:
tpl.send_mail(rec.id, force_send=False)
except Exception:
pass
def _notify_client_parts_received(self):
for rec in self:
tpl = self.env.ref(
'fusion_repairs.email_template_parts_received',
raise_if_not_found=False,
)
if tpl and rec.partner_id and rec.partner_id.email:
try:
tpl.send_mail(rec.id, force_send=False)
except Exception:
pass
def _maybe_redispatch(self):
"""When the LAST outstanding part on a repair arrives, auto-create
a follow-up tech task so the office doesn't have to remember.
Schedules for tomorrow + first free hour slot to avoid colliding
with existing day-of tasks (the fusion_tasks model raises on
time-window conflicts).
"""
from datetime import date as _date
for rec in self:
repair = rec.repair_order_id
outstanding = repair.x_fc_part_order_ids.filtered(
lambda p: p.state in ('draft', 'ordered')
)
if outstanding:
continue # still waiting on other parts
repair.x_fc_parts_awaiting = False
repair.x_fc_parts_eta_date = False
# Find tomorrow's first free slot for the same tech (or
# lightest-loaded skilled tech).
target_date = _date.today() + timedelta(days=1)
target_tech = (
repair.x_fc_technician_task_ids[:1].technician_id.id
if repair.x_fc_technician_task_ids else False
)
if not target_tech:
target_tech = self.env['repair.order'] \
.sudo()._fc_find_lightest_today_tech.__func__(repair)
ctx = {
'force_schedule': {
'scheduled_date': target_date,
'time_start': 9.0,
'time_end': 10.0,
},
}
if target_tech:
ctx['force_tech_id'] = target_tech
try:
self.env['fusion.repair.intake.service'].sudo() \
.with_context(**ctx) \
._create_dispatch_task(repair)
repair.message_post(body=Markup(_(
'All ordered parts received. Auto-dispatched a follow-up '
'visit for <b>%(date)s 09:00 - 10:00</b>.'
)) % {'date': target_date.isoformat()})
except Exception as e:
# If slot 9-10 collides, just log and let the dispatcher
# pick a slot manually - we don't want to swallow the email.
repair.message_post(body=Markup(_(
'All ordered parts received but the auto-dispatch slot '
'%(date)s 09:00-10:00 collided. Please pick a time '
'manually. (%(err)s)'
)) % {'date': target_date.isoformat(), 'err': str(e)})