changes

fusion_accounting/fusion_accounting_followup/models/__init__.py

@@ -0,0 +1,8 @@
+from . import fusion_followup_level
+from . import fusion_followup_run
+from . import fusion_followup_text_cache
+from . import res_partner
+from . import account_move_line
+from . import fusion_followup_engine
+from . import fusion_followup_cron
+from . import fusion_migration_wizard

fusion_accounting/fusion_accounting_followup/models/account_move_line.py

@@ -0,0 +1,14 @@
+"""Inherit account.move.line: track last follow-up level."""
+
+from odoo import _, api, fields, models
+
+
+class AccountMoveLine(models.Model):
+    _inherit = "account.move.line"
+
+    fusion_followup_level_id = fields.Many2one(
+        'fusion.followup.level', copy=False,
+        help="Last follow-up level at which this line was contacted.")
+    fusion_followup_last_run_date = fields.Datetime(
+        copy=False,
+        help="When the line was most-recently included in a follow-up.")

fusion_accounting/fusion_accounting_followup/models/fusion_followup_cron.py

@@ -0,0 +1,84 @@
+"""Cron handlers for fusion_accounting_followup.
+
+Two scheduled jobs:
+- Daily scan: walk every partner with an open overdue receivable line and
+  call the engine to send/escalate where appropriate.
+- Weekly risk refresh: recompute fusion_followup_risk_score on every
+  partner with overdue.
+"""
+
+import logging
+from datetime import date
+
+from odoo import api, models
+
+_logger = logging.getLogger(__name__)
+
+
+class FusionFollowupCron(models.AbstractModel):
+    _name = "fusion.followup.cron"
+    _description = "Fusion Follow-up Cron Handlers"
+
+    @api.model
+    def _cron_daily_scan(self):
+        """Scan every partner with overdue and send follow-ups when due."""
+        engine = self.env['fusion.followup.engine']
+        Line = self.env['account.move.line'].sudo()
+        overdue_lines = Line.search([
+            ('parent_state', '=', 'posted'),
+            ('account_id.account_type', '=', 'asset_receivable'),
+            ('reconciled', '=', False),
+            ('amount_residual', '>', 0),
+            ('date_maturity', '<', date.today()),
+        ])
+        partner_ids = list(set(overdue_lines.mapped('partner_id').ids))
+        sent = 0
+        skipped = 0
+        for pid in partner_ids:
+            partner = self.env['res.partner'].sudo().browse(pid)
+            if not partner.exists():
+                continue
+            try:
+                with self.env.cr.savepoint():
+                    result = engine.send_followup_email(partner)
+                    if result.get('status') == 'sent':
+                        sent += 1
+                    else:
+                        skipped += 1
+            except Exception as e:
+                _logger.warning(
+                    "Cron daily_scan failed for partner %s: %s", pid, e,
+                )
+                skipped += 1
+        _logger.info(
+            "Cron: scanned %d partners, sent %d, skipped %d",
+            len(partner_ids), sent, skipped,
+        )
+
+    @api.model
+    def _cron_risk_refresh(self):
+        """Refresh fusion_followup_risk_score on every partner with overdue."""
+        Partner = self.env['res.partner'].sudo()
+        engine = self.env['fusion.followup.engine']
+        Line = self.env['account.move.line'].sudo()
+        partner_ids = list(set(Line.search([
+            ('parent_state', '=', 'posted'),
+            ('account_id.account_type', '=', 'asset_receivable'),
+            ('reconciled', '=', False),
+            ('amount_residual', '>', 0),
+        ]).mapped('partner_id').ids))
+        updated = 0
+        for pid in partner_ids:
+            partner = Partner.browse(pid)
+            try:
+                overdue = engine.get_overdue_for_partner(partner)
+                partner.write({
+                    'fusion_followup_risk_score': overdue['risk']['score'],
+                    'fusion_followup_risk_band': overdue['risk']['band'],
+                })
+                updated += 1
+            except Exception as e:
+                _logger.warning(
+                    "Risk refresh failed for partner %s: %s", pid, e,
+                )
+        _logger.info("Cron: refreshed risk on %d partners", updated)

fusion_accounting/fusion_accounting_followup/models/fusion_followup_engine.py

@@ -0,0 +1,379 @@
+"""The follow-up engine — orchestrator for customer follow-ups.
+
+7-method public API. All controllers, AI tools, wizards, cron must
+go through this engine; no direct ORM writes to fusion.followup.run
+from elsewhere."""
+
+import logging
+from datetime import date, timedelta
+
+from odoo import _, api, fields, models
+from odoo.exceptions import ValidationError, UserError
+
+from ..services.overdue_aging import compute_aging
+from ..services.level_resolver import resolve_level, FollowupLevelSpec
+from ..services.risk_scorer import score_partner
+from ..services.tone_selector import select_tone
+from ..services.followup_text_generator import generate_followup_text
+
+_logger = logging.getLogger(__name__)
+
+
+class FusionFollowupEngine(models.AbstractModel):
+    _name = "fusion.followup.engine"
+    _description = "Fusion Follow-up Engine"
+
+    # ============================================================
+    # PUBLIC API (7 methods)
+    # ============================================================
+
+    @api.model
+    def get_overdue_for_partner(self, partner) -> dict:
+        """Return aging report + risk score for a partner."""
+        partner.ensure_one()
+        as_of = fields.Date.today()
+        move_lines = self._fetch_overdue_lines(partner)
+        aging = compute_aging(
+            move_lines=[{
+                'date_maturity': l.date_maturity,
+                'amount_residual': l.amount_residual,
+            } for l in move_lines],
+            as_of=as_of,
+        )
+        risk = self._compute_risk(partner, move_lines)
+        return {
+            'partner_id': partner.id,
+            'as_of': str(as_of),
+            'aging': aging.to_dict(),
+            'risk': {
+                'score': risk.score,
+                'band': risk.band,
+                'drivers': risk.drivers,
+            },
+            'overdue_line_count': len(move_lines),
+        }
+
+    @api.model
+    def compute_followup_level(self, partner, *, ignore_pause=False):
+        """Return the fusion.followup.level recordset that should fire now,
+        or empty recordset if no action needed."""
+        partner.ensure_one()
+        Level = self.env['fusion.followup.level']
+        if not ignore_pause and partner.fusion_followup_paused_until and \
+                partner.fusion_followup_paused_until > fields.Date.today():
+            return Level
+
+        as_of = fields.Date.today()
+        move_lines = self._fetch_overdue_lines(partner)
+        if not move_lines:
+            return Level
+        aging = compute_aging(
+            move_lines=[{
+                'date_maturity': l.date_maturity,
+                'amount_residual': l.amount_residual,
+            } for l in move_lines],
+            as_of=as_of,
+        )
+
+        company_id = partner.company_id.id if partner.company_id else self.env.company.id
+        levels = Level.search([
+            ('active', '=', True),
+            '|', ('company_id', '=', company_id), ('company_id', '=', False),
+        ], order='sequence')
+        if not levels:
+            return Level
+
+        specs = [FollowupLevelSpec(
+            sequence=l.sequence, name=l.name,
+            delay_days=l.delay_days, tone=l.tone,
+        ) for l in levels]
+
+        chosen_spec = resolve_level(aging_report=aging, levels=specs)
+        if chosen_spec is None:
+            return Level
+
+        return levels.filtered(lambda l: l.sequence == chosen_spec.sequence)[:1]
+
+    @api.model
+    def send_followup_email(self, partner, *, level=None, force=False) -> dict:
+        """Send a follow-up email at the given level (or auto-resolve if None).
+
+        Creates a fusion.followup.run record. Uses cached text if available."""
+        partner.ensure_one()
+
+        if not force and partner.fusion_followup_paused_until and \
+                partner.fusion_followup_paused_until > fields.Date.today():
+            return {
+                'status': 'paused_until_' + str(partner.fusion_followup_paused_until),
+                'partner_id': partner.id,
+            }
+
+        if not level:
+            level = self.compute_followup_level(partner, ignore_pause=force)
+            if not level:
+                return {'status': 'no_action', 'partner_id': partner.id}
+
+        if level.requires_manual_review and not force:
+            run = self._create_run(partner, level, state='manual_review')
+            return {
+                'status': 'manual_review',
+                'partner_id': partner.id,
+                'run_id': run.id,
+            }
+
+        overdue_data = self.get_overdue_for_partner(partner)
+        if overdue_data['overdue_line_count'] == 0:
+            return {'status': 'no_overdue', 'partner_id': partner.id}
+
+        tone = select_tone(
+            level_sequence=level.sequence,
+            risk_score=overdue_data['risk']['score'],
+        )
+
+        text_data = self._get_or_generate_text(
+            partner=partner, level=level,
+            overdue_amount=overdue_data['aging']['total_overdue_amount'],
+            longest_overdue_days=self._max_overdue_days_from_aging(overdue_data['aging']),
+            invoice_count=overdue_data['overdue_line_count'],
+            tone=tone, risk_drivers=overdue_data['risk']['drivers'],
+        )
+
+        run = self._create_run(
+            partner, level, state='draft',
+            overdue_amount=overdue_data['aging']['total_overdue_amount'],
+            longest_overdue_days=self._max_overdue_days_from_aging(overdue_data['aging']),
+            risk_score=overdue_data['risk']['score'],
+            risk_band=overdue_data['risk']['band'],
+            subject=text_data['subject'],
+            body=text_data['body'],
+            tone_used=text_data['tone_used'],
+            text_was_ai_generated=text_data.get('_was_ai', False),
+        )
+
+        try:
+            self._send_email(partner, run)
+            run.write({'state': 'sent'})
+            partner.write({
+                'fusion_followup_status': 'no_action',
+                'fusion_followup_last_level_id': level.id,
+                'fusion_followup_last_run_date': fields.Datetime.now(),
+            })
+        except Exception as e:
+            _logger.warning("Email send failed for partner %s: %s", partner.id, e)
+            run.write({'state': 'failed', 'error_message': str(e)})
+
+        return {
+            'status': 'sent', 'partner_id': partner.id,
+            'run_id': run.id, 'level_id': level.id, 'tone': tone,
+        }
+
+    @api.model
+    def escalate_to_next_level(self, partner) -> dict:
+        """Force the next-higher level than the partner's current last_level."""
+        partner.ensure_one()
+        Level = self.env['fusion.followup.level']
+        current = partner.fusion_followup_last_level_id
+        next_seq = (current.sequence + 1) if current else 1
+        company_id = partner.company_id.id if partner.company_id else self.env.company.id
+        next_level = Level.search([
+            ('active', '=', True),
+            ('sequence', '>=', next_seq),
+            '|', ('company_id', '=', company_id), ('company_id', '=', False),
+        ], order='sequence', limit=1)
+        if not next_level:
+            return {'status': 'at_max_level', 'partner_id': partner.id}
+        return self.send_followup_email(partner, level=next_level, force=True)
+
+    @api.model
+    def pause_followup(self, partner, until_date: date = None) -> dict:
+        """Pause follow-ups for a partner until a date (default 30 days)."""
+        partner.ensure_one()
+        until = until_date or (fields.Date.today() + timedelta(days=30))
+        partner.write({
+            'fusion_followup_paused_until': until,
+            'fusion_followup_status': 'paused',
+        })
+        return {'partner_id': partner.id, 'paused_until': str(until)}
+
+    @api.model
+    def reset_followup(self, partner) -> dict:
+        """Reset partner's follow-up state to no_action."""
+        partner.ensure_one()
+        partner.write({
+            'fusion_followup_status': 'no_action',
+            'fusion_followup_paused_until': False,
+            'fusion_followup_last_level_id': False,
+        })
+        return {'partner_id': partner.id, 'status': 'reset'}
+
+    @api.model
+    def snapshot_followup_history(self, partner, *, limit: int = 50) -> dict:
+        """Return audit history for a partner."""
+        partner.ensure_one()
+        Run = self.env['fusion.followup.run']
+        runs = Run.search([
+            ('partner_id', '=', partner.id),
+        ], order='execution_date desc', limit=int(limit))
+        return {
+            'partner_id': partner.id,
+            'count': len(runs),
+            'runs': [{
+                'id': r.id, 'date': str(r.execution_date),
+                'level_id': r.level_id.id if r.level_id else None,
+                'level_name': r.level_id.name if r.level_id else '',
+                'state': r.state,
+                'overdue_amount': r.overdue_amount,
+                'longest_overdue_days': r.longest_overdue_days,
+                'tone_used': r.tone_used,
+                'risk_score': r.risk_score,
+                'subject': r.subject or '',
+                'text_was_ai_generated': r.text_was_ai_generated,
+            } for r in runs],
+        }
+
+    # ============================================================
+    # PRIVATE HELPERS
+    # ============================================================
+
+    def _fetch_overdue_lines(self, partner):
+        """Fetch posted, unreconciled receivable lines for a partner."""
+        Line = self.env['account.move.line'].sudo()
+        return Line.search([
+            ('partner_id', '=', partner.id),
+            ('parent_state', '=', 'posted'),
+            ('account_id.account_type', '=', 'asset_receivable'),
+            ('reconciled', '=', False),
+            ('amount_residual', '>', 0),
+        ])
+
+    def _compute_risk(self, partner, overdue_lines):
+        """Compute risk score from partner's payment history."""
+        Line = self.env['account.move.line'].sudo()
+        all_lines = Line.search([
+            ('partner_id', '=', partner.id),
+            ('parent_state', '=', 'posted'),
+            ('account_id.account_type', '=', 'asset_receivable'),
+        ])
+        total_invoices = len(all_lines)
+        # Heavy paid-late computation deferred to Phase 4.5
+        paid_late_count = 0
+        avg_days_late = 0.0
+
+        as_of = fields.Date.today()
+        longest_overdue_days = 0
+        for line in overdue_lines:
+            if line.date_maturity:
+                days = (as_of - line.date_maturity).days
+                if days > longest_overdue_days:
+                    longest_overdue_days = days
+
+        open_overdue = sum(line.amount_residual for line in overdue_lines)
+        avg_invoice_amount = 1000.0
+        if total_invoices > 0:
+            total_amount = sum(all_lines.mapped('balance'))
+            if total_amount:
+                avg_invoice_amount = abs(total_amount) / total_invoices
+
+        return score_partner(
+            total_invoices=total_invoices,
+            paid_late_count=paid_late_count,
+            avg_days_late=avg_days_late,
+            longest_overdue_days=longest_overdue_days,
+            open_overdue_amount=open_overdue,
+            average_invoice_amount=avg_invoice_amount,
+        )
+
+    def _max_overdue_days_from_aging(self, aging_dict):
+        """Extract longest overdue days from aging dict."""
+        tracked = aging_dict.get('max_days_overdue', 0) or 0
+        if tracked:
+            return tracked
+        max_days = 0
+        for b in aging_dict.get('buckets', []):
+            if b['name'] == 'current' or b['amount'] <= 0:
+                continue
+            if b['days_max'] is None:
+                max_days = max(max_days, b['days_min'])
+            else:
+                max_days = max(max_days, b['days_max'])
+        return max_days
+
+    def _get_or_generate_text(self, *, partner, level, overdue_amount,
+                              longest_overdue_days, invoice_count, tone,
+                              risk_drivers=None) -> dict:
+        """Cache lookup + LLM fallback."""
+        Cache = self.env['fusion.followup.text.cache']
+        cached = Cache.lookup(
+            partner_id=partner.id, level_id=level.id,
+            overdue_amount=overdue_amount,
+            longest_overdue_days=longest_overdue_days,
+            invoice_count=invoice_count, tone=tone,
+        )
+        if cached:
+            cached.action_increment_use()
+            return {
+                'subject': cached.subject, 'body': cached.body,
+                'tone_used': cached.tone_used,
+                'key_points': cached.key_points or [],
+                '_was_ai': bool(cached.provider),
+            }
+
+        company = partner.company_id or self.env.company
+        currency = company.currency_id
+        text = generate_followup_text(
+            self.env,
+            partner_name=partner.name,
+            total_overdue=overdue_amount,
+            currency_code=currency.name or 'USD',
+            longest_overdue_days=longest_overdue_days,
+            tone=tone, invoice_count=invoice_count,
+            risk_drivers=risk_drivers,
+        )
+        try:
+            Cache.sudo().create({
+                'partner_id': partner.id, 'level_id': level.id,
+                'company_id': company.id,
+                'fingerprint': Cache.compute_fingerprint(
+                    partner_id=partner.id, level_id=level.id,
+                    overdue_amount=overdue_amount,
+                    longest_overdue_days=longest_overdue_days,
+                    invoice_count=invoice_count, tone=tone,
+                ),
+                'subject': text['subject'], 'body': text['body'],
+                'tone_used': text.get('tone_used', tone),
+                'key_points': text.get('key_points', []),
+            })
+        except Exception as e:
+            _logger.debug("Cache create failed (non-fatal): %s", e)
+
+        text['_was_ai'] = False
+        return text
+
+    def _create_run(self, partner, level, *, state='draft', **vals):
+        Run = self.env['fusion.followup.run'].sudo()
+        company = partner.company_id or self.env.company
+        defaults = {
+            'partner_id': partner.id,
+            'company_id': company.id,
+            'level_id': level.id if level else False,
+            'state': state,
+        }
+        defaults.update(vals)
+        return Run.create(defaults)
+
+    def _send_email(self, partner, run):
+        """Best-effort email send. Uses level's mail_template if set, else
+        creates a simple message."""
+        if not partner.email:
+            raise UserError(_("Partner %s has no email address.") % partner.name)
+        if run.level_id and run.level_id.mail_template_id:
+            run.level_id.mail_template_id.send_mail(partner.id, force_send=True)
+        else:
+            body_text = (run.body or '').replace('<', '&lt;').replace('>', '&gt;')
+            self.env['mail.mail'].sudo().create({
+                'subject': run.subject or 'Follow-up',
+                'body_html': '<pre>{}</pre>'.format(body_text),
+                'email_to': partner.email,
+                'recipient_ids': [(4, partner.id)],
+            }).send()
+        run.write({'sent_to_email': partner.email})

fusion_accounting/fusion_accounting_followup/models/fusion_followup_level.py

@@ -0,0 +1,42 @@
+"""Follow-up level definition (e.g. Reminder at 7 days, Warning at 30, Legal at 60)."""
+
+from odoo import _, api, fields, models
+
+
+TONE_SELECTION = [
+    ('gentle', 'Gentle'),
+    ('firm', 'Firm'),
+    ('legal', 'Legal'),
+]
+
+
+class FusionFollowupLevel(models.Model):
+    _name = "fusion.followup.level"
+    _description = "Fusion Follow-up Level"
+    _order = "sequence, id"
+
+    name = fields.Char(required=True, translate=True)
+    sequence = fields.Integer(required=True, default=10,
+                              help="Order in which levels escalate (1, 2, 3...).")
+    delay_days = fields.Integer(required=True,
+                                help="Min days overdue to trigger this level.")
+    tone = fields.Selection(TONE_SELECTION, required=True, default='gentle')
+    description = fields.Text()
+    company_id = fields.Many2one('res.company', default=lambda self: self.env.company)
+
+    mail_template_id = fields.Many2one('mail.template',
+                                       domain=[('model', '=', 'res.partner')])
+
+    requires_manual_review = fields.Boolean(default=False,
+        help="If True, follow-ups at this level need human approval before send.")
+
+    active = fields.Boolean(default=True)
+
+    _check_delay_positive = models.Constraint(
+        'CHECK(delay_days >= 0)',
+        'delay_days must be non-negative.',
+    )
+    _unique_sequence_per_company = models.Constraint(
+        'UNIQUE(company_id, sequence)',
+        'Sequence must be unique per company.',
+    )

fusion_accounting/fusion_accounting_followup/models/fusion_followup_run.py

@@ -0,0 +1,54 @@
+"""Audit record of one follow-up execution (per partner per level)."""
+
+from odoo import _, api, fields, models
+
+
+STATE_SELECTION = [
+    ('draft', 'Draft'),
+    ('sent', 'Sent'),
+    ('manual_review', 'Manual Review'),
+    ('skipped', 'Skipped'),
+    ('failed', 'Failed'),
+]
+
+
+class FusionFollowupRun(models.Model):
+    _name = "fusion.followup.run"
+    _description = "Fusion Follow-up Run (Per-Partner Audit)"
+    _order = "execution_date desc, id desc"
+
+    partner_id = fields.Many2one('res.partner', required=True, ondelete='cascade')
+    company_id = fields.Many2one('res.company', required=True,
+                                 default=lambda self: self.env.company)
+    level_id = fields.Many2one('fusion.followup.level', ondelete='restrict')
+
+    execution_date = fields.Datetime(default=fields.Datetime.now, required=True)
+    state = fields.Selection(STATE_SELECTION, default='draft', required=True)
+
+    overdue_amount = fields.Float()
+    longest_overdue_days = fields.Integer()
+
+    risk_score = fields.Integer()
+    risk_band = fields.Selection([
+        ('low', 'Low'), ('medium', 'Medium'),
+        ('high', 'High'), ('critical', 'Critical'),
+    ])
+
+    subject = fields.Char()
+    body = fields.Text()
+    tone_used = fields.Selection([
+        ('gentle', 'Gentle'), ('firm', 'Firm'), ('legal', 'Legal'),
+    ])
+    sent_to_email = fields.Char()
+
+    text_was_ai_generated = fields.Boolean(default=False)
+    ai_provider = fields.Char(help="LLM provider name (openai, claude, etc.) if AI was used.")
+
+    notes = fields.Text()
+    error_message = fields.Text()
+
+    def action_mark_sent(self):
+        self.write({'state': 'sent'})
+
+    def action_mark_failed(self, error: str = ''):
+        self.write({'state': 'failed', 'error_message': error})

fusion_accounting/fusion_accounting_followup/models/fusion_followup_text_cache.py

@@ -0,0 +1,60 @@
+"""Cache of AI-generated follow-up text to avoid LLM cost on repeats."""
+
+import hashlib
+
+from odoo import _, api, fields, models
+
+
+class FusionFollowupTextCache(models.Model):
+    _name = "fusion.followup.text.cache"
+    _description = "Cache of AI-generated follow-up text"
+    _order = "generated_at desc"
+
+    partner_id = fields.Many2one('res.partner', required=True, ondelete='cascade')
+    level_id = fields.Many2one('fusion.followup.level', ondelete='cascade')
+    company_id = fields.Many2one('res.company', required=True,
+                                 default=lambda self: self.env.company)
+
+    fingerprint = fields.Char(required=True, index=True,
+                              help="SHA-256 of input parameters")
+
+    subject = fields.Char()
+    body = fields.Text()
+    tone_used = fields.Selection([
+        ('gentle', 'Gentle'), ('firm', 'Firm'), ('legal', 'Legal'),
+    ])
+    key_points = fields.Json()
+
+    generated_at = fields.Datetime(default=fields.Datetime.now, required=True)
+    expires_at = fields.Datetime()
+    use_count = fields.Integer(default=0)
+    provider = fields.Char()
+
+    @api.model
+    def compute_fingerprint(self, *, partner_id: int, level_id: int,
+                            overdue_amount: float, longest_overdue_days: int,
+                            invoice_count: int, tone: str) -> str:
+        """Stable hash of the inputs that determine the generated text."""
+        s = f"{partner_id}|{level_id}|{round(overdue_amount, 2)}|" \
+            f"{longest_overdue_days}|{invoice_count}|{tone}"
+        return hashlib.sha256(s.encode('utf-8')).hexdigest()
+
+    @api.model
+    def lookup(self, *, partner_id: int, level_id: int,
+               overdue_amount: float, longest_overdue_days: int,
+               invoice_count: int, tone: str):
+        """Find a cached entry matching these inputs, or empty recordset."""
+        fp = self.compute_fingerprint(
+            partner_id=partner_id, level_id=level_id,
+            overdue_amount=overdue_amount,
+            longest_overdue_days=longest_overdue_days,
+            invoice_count=invoice_count, tone=tone,
+        )
+        return self.search([
+            ('partner_id', '=', partner_id),
+            ('fingerprint', '=', fp),
+        ], limit=1)
+
+    def action_increment_use(self):
+        for rec in self:
+            rec.use_count += 1

fusion_accounting/fusion_accounting_followup/models/fusion_migration_wizard.py

@@ -0,0 +1,197 @@
+"""Followup-specific migration step.
+
+Backfills fusion.followup.level from Enterprise's account_followup.followup.line
+records (if Enterprise account_followup is installed)."""
+
+import logging
+
+from odoo import api, fields, models
+
+_logger = logging.getLogger(__name__)
+
+
+class FusionMigrationWizard(models.TransientModel):
+    _inherit = "fusion.migration.wizard"
+
+    def _followup_bootstrap_step(self):
+        """Backfill fusion.followup.level from account_followup.followup.line."""
+        result = {
+            'step': 'followup_bootstrap',
+            'enterprise_module_present': False,
+            'created': 0, 'skipped': 0, 'errors': [],
+        }
+
+        # Enterprise's followup model — name varies by version
+        EnterpriseLine = self.env.get('account_followup.followup.line')
+        if EnterpriseLine is None:
+            EnterpriseLine = self.env.get('account.followup.line')
+        if EnterpriseLine is None:
+            result['enterprise_module_present'] = False
+            return result
+        result['enterprise_module_present'] = True
+
+        FusionLevel = self.env['fusion.followup.level'].sudo()
+        try:
+            ee_records = EnterpriseLine.sudo().search([])
+        except Exception as e:
+            result['errors'].append(f"Enterprise search failed: {e}")
+            return result
+
+        # Pick a starting offset that doesn't clash with anything already in
+        # fusion_followup_level (seeded defaults at 1..3 plus any prior
+        # migration runs). We allocate a unique sequence per Enterprise line
+        # by max(existing) + 1, ensuring idempotency + within-batch uniqueness.
+        existing_max = max(FusionLevel.search([]).mapped('sequence') or [100])
+        next_seq = max(existing_max + 1, 101)
+
+        # Map Enterprise tone-ish fields to ours
+        for ee in ee_records:
+            try:
+                raw_seq = getattr(ee, 'sequence', None) or 50
+                name = getattr(ee, 'name', None) or f"Migrated Level {raw_seq}"
+                # Idempotency: skip if a level with same name was already
+                # backfilled in a prior migration run.
+                existing = FusionLevel.search([('name', '=', name)], limit=1)
+                if existing:
+                    result['skipped'] += 1
+                    continue
+
+                delay = getattr(ee, 'delay', None) or getattr(ee, 'delay_days', 7)
+                # Enterprise tone heuristic: scale by sequence
+                tone = 'gentle' if raw_seq <= 1 else 'firm' if raw_seq <= 2 else 'legal'
+
+                with self.env.cr.savepoint():
+                    FusionLevel.create({
+                        'name': name,
+                        'sequence': next_seq,
+                        'delay_days': delay,
+                        'tone': tone,
+                        'active': True,
+                    })
+                next_seq += 1
+                result['created'] += 1
+            except Exception as e:
+                result['errors'].append(f"Line {ee.id}: {e}")
+
+        _logger.info(
+            "fusion_accounting_followup migration: %d created, %d skipped, %d errors",
+            result['created'], result['skipped'], len(result['errors']))
+        return result
+
+    def _followup_partner_state_bootstrap_step(self):
+        """Migration step: copy Enterprise account_followup per-partner state
+        onto Fusion's fields on res.partner.
+
+        Idempotent: only updates partners whose Fusion field is at default
+        (no_action) and whose Enterprise field has a non-default value.
+        """
+        self.ensure_one()
+        _logger.info("fusion_accounting_followup partner-state migration starting")
+
+        Partner = self.env['res.partner'].sudo()
+        has_status = 'followup_status' in Partner._fields
+        has_next_date = 'payment_next_action_date' in Partner._fields
+        has_line = 'followup_line_id' in Partner._fields
+        if not (has_status or has_next_date or has_line):
+            _logger.info(
+                "Enterprise account_followup partner fields not present \u2014 skipping")
+            return {
+                'step': 'followup_partner_state',
+                'enterprise_module_present': False,
+                'updated': 0, 'skipped': 0, 'errors': [],
+            }
+
+        result = {
+            'step': 'followup_partner_state',
+            'enterprise_module_present': True,
+            'updated': 0, 'skipped': 0, 'errors': [],
+        }
+
+        domain_terms = []
+        if has_status:
+            domain_terms.append(('followup_status', '!=', 'no_action_needed'))
+        if has_next_date:
+            domain_terms.append(('payment_next_action_date', '!=', False))
+        if not domain_terms:
+            _logger.info("No usable Enterprise follow-up fields \u2014 skipping")
+            return result
+        if len(domain_terms) > 1:
+            domain = ['|'] * (len(domain_terms) - 1) + domain_terms
+        else:
+            domain = domain_terms
+        candidates = Partner.search(domain)
+        _logger.info(
+            "Found %d partners with non-default Enterprise follow-up state",
+            len(candidates))
+
+        Level = self.env['fusion.followup.level'].sudo()
+        today = fields.Date.today()
+
+        status_map = {
+            'in_need_of_action': 'action_due',
+            'with_overdue_invoices': 'action_due',
+            'no_action_needed': 'no_action',
+        }
+
+        for partner in candidates:
+            try:
+                if partner.fusion_followup_status not in (False, 'no_action'):
+                    result['skipped'] += 1
+                    continue
+
+                vals = {}
+
+                ent_status = (
+                    getattr(partner, 'followup_status', None)
+                    if has_status else None)
+                if ent_status and ent_status in status_map:
+                    vals['fusion_followup_status'] = status_map[ent_status]
+
+                next_date = (
+                    getattr(partner, 'payment_next_action_date', False)
+                    if has_next_date else False)
+                if next_date and next_date > today:
+                    vals['fusion_followup_paused_until'] = next_date
+                    vals['fusion_followup_status'] = 'paused'
+
+                ent_line = (
+                    getattr(partner, 'followup_line_id', None)
+                    if has_line else None)
+                if ent_line:
+                    fusion_level = Level.search([
+                        ('name', '=', ent_line.name),
+                    ], limit=1)
+                    if fusion_level:
+                        vals['fusion_followup_last_level_id'] = fusion_level.id
+
+                if vals:
+                    partner.write(vals)
+                    result['updated'] += 1
+                    _logger.debug(
+                        "Migrated partner %s: %s", partner.name, vals)
+                else:
+                    result['skipped'] += 1
+
+            except Exception as e:
+                result['errors'].append(
+                    f"Partner {partner.id} ({partner.name}): {e}")
+                _logger.warning(
+                    "Migration failed for partner %s: %s", partner.id, e)
+
+        _logger.info(
+            "fusion_accounting_followup partner-state migration: "
+            "updated=%d skipped=%d errors=%d",
+            result['updated'], result['skipped'], len(result['errors']))
+        return result
+
+    def action_run_migration(self):
+        result = super().action_run_migration() if hasattr(super(), 'action_run_migration') else None
+        try:
+            self._followup_bootstrap_step()
+        except Exception as e:
+            _logger.warning("followup_bootstrap_step failed: %s", e)
+        try:
+            self._followup_partner_state_bootstrap_step()
+        except Exception as e:
+            _logger.warning("followup_partner_state_bootstrap_step failed: %s", e)
+        return result

fusion_accounting/fusion_accounting_followup/models/res_partner.py

@@ -0,0 +1,52 @@
+"""Inherit res.partner: add follow-up state fields."""
+
+from odoo import _, api, fields, models
+
+
+FOLLOWUP_STATUS = [
+    ('no_action', 'No Action Needed'),
+    ('action_due', 'Action Due'),
+    ('paused', 'Paused'),
+    ('blocked', 'Blocked'),
+    ('with_credit_team', 'With Credit Team'),
+]
+
+
+class ResPartner(models.Model):
+    _inherit = "res.partner"
+
+    fusion_followup_status = fields.Selection(
+        FOLLOWUP_STATUS, default='no_action', tracking=True,
+        help="Current follow-up status as computed by the engine.")
+    fusion_followup_paused_until = fields.Date(
+        tracking=True,
+        help="Pause follow-ups for this partner until this date.")
+    fusion_followup_last_level_id = fields.Many2one(
+        'fusion.followup.level',
+        help="The most-recent follow-up level this partner has been contacted at.")
+    fusion_followup_last_run_date = fields.Datetime(readonly=True)
+    fusion_followup_run_ids = fields.One2many(
+        'fusion.followup.run', 'partner_id', string='Follow-up History')
+    fusion_followup_run_count = fields.Integer(
+        compute='_compute_fusion_followup_run_count')
+    fusion_followup_risk_score = fields.Integer(
+        readonly=True, default=0,
+        help="Latest computed payment risk (0-100). Updated by cron.")
+    fusion_followup_risk_band = fields.Selection([
+        ('low', 'Low'), ('medium', 'Medium'),
+        ('high', 'High'), ('critical', 'Critical'),
+    ], default='low', readonly=True)
+
+    def _compute_fusion_followup_run_count(self):
+        for partner in self:
+            partner.fusion_followup_run_count = len(partner.fusion_followup_run_ids)
+
+    def action_view_followup_history(self):
+        self.ensure_one()
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': 'fusion.followup.run',
+            'view_mode': 'list,form',
+            'domain': [('partner_id', '=', self.id)],
+            'context': {'default_partner_id': self.id},
+        }