Dear
This is a friendly reminder that you have outstanding invoices on + your account. We understand that things happen — please let us know + if there is anything we can do to help resolve this.
+You can review your account statement at any time, or contact our + accounts receivable team with any questions.
+Best regards,
+
Dear
Our records show outstanding invoices that require your immediate + attention. We request that you remit payment as soon as possible to + avoid further escalation.
+If you have already remitted payment, please disregard this notice + and contact us with the payment details so we can update our records.
+If there are any disputes or concerns regarding these invoices, + please contact our accounts receivable team immediately.
+Regards,
+
Dear
This is a FINAL NOTICE regarding outstanding invoices on your + account. Despite previous reminders, your balance remains unpaid.
+If full payment is not received within 7 days from the date of this + notice, we will be forced to refer this matter to our legal department + for collection. This may include reporting the delinquency to credit + bureaus and pursuing further legal action as permitted by law.
+Please contact us immediately to resolve this matter.
+Regards,
+
{}'.format(body_text),
+ 'email_to': partner.email,
+ 'recipient_ids': [(4, partner.id)],
+ }).send()
+ run.write({'sent_to_email': partner.email})
diff --git a/fusion_accounting_followup/models/fusion_followup_level.py b/fusion_accounting_followup/models/fusion_followup_level.py
new file mode 100644
index 00000000..e2e5d9d2
--- /dev/null
+++ b/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.',
+ )
diff --git a/fusion_accounting_followup/models/fusion_followup_run.py b/fusion_accounting_followup/models/fusion_followup_run.py
new file mode 100644
index 00000000..327039ea
--- /dev/null
+++ b/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})
diff --git a/fusion_accounting_followup/models/fusion_followup_text_cache.py b/fusion_accounting_followup/models/fusion_followup_text_cache.py
new file mode 100644
index 00000000..2c0eef40
--- /dev/null
+++ b/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
diff --git a/fusion_accounting_followup/models/fusion_migration_wizard.py b/fusion_accounting_followup/models/fusion_migration_wizard.py
new file mode 100644
index 00000000..f9ceec36
--- /dev/null
+++ b/fusion_accounting_followup/models/fusion_migration_wizard.py
@@ -0,0 +1,87 @@
+"""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 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)
+ return result
diff --git a/fusion_accounting_followup/models/res_partner.py b/fusion_accounting_followup/models/res_partner.py
new file mode 100644
index 00000000..2aaa5936
--- /dev/null
+++ b/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},
+ }
diff --git a/fusion_accounting_followup/reports/__init__.py b/fusion_accounting_followup/reports/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/fusion_accounting_followup/security/ir.model.access.csv b/fusion_accounting_followup/security/ir.model.access.csv
new file mode 100644
index 00000000..fa38cd4d
--- /dev/null
+++ b/fusion_accounting_followup/security/ir.model.access.csv
@@ -0,0 +1,8 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_fusion_followup_level_user,fusion.followup.level.user,model_fusion_followup_level,base.group_user,1,0,0,0
+access_fusion_followup_level_admin,fusion.followup.level.admin,model_fusion_followup_level,fusion_accounting_core.group_fusion_accounting_admin,1,1,1,1
+access_fusion_followup_run_user,fusion.followup.run.user,model_fusion_followup_run,base.group_user,1,0,0,0
+access_fusion_followup_run_admin,fusion.followup.run.admin,model_fusion_followup_run,fusion_accounting_core.group_fusion_accounting_admin,1,1,1,1
+access_fusion_followup_text_cache_user,fusion.followup.text.cache.user,model_fusion_followup_text_cache,base.group_user,1,0,0,0
+access_fusion_followup_text_cache_admin,fusion.followup.text.cache.admin,model_fusion_followup_text_cache,fusion_accounting_core.group_fusion_accounting_admin,1,1,1,1
+access_fusion_batch_followup_wizard_user,fusion.batch.followup.wizard.user,model_fusion_batch_followup_wizard,base.group_user,1,1,1,0
diff --git a/fusion_accounting_followup/services/__init__.py b/fusion_accounting_followup/services/__init__.py
new file mode 100644
index 00000000..8a72cd93
--- /dev/null
+++ b/fusion_accounting_followup/services/__init__.py
@@ -0,0 +1,6 @@
+from . import overdue_aging
+from . import level_resolver
+from . import risk_scorer
+from . import tone_selector
+from . import followup_text_prompt
+from . import followup_text_generator
diff --git a/fusion_accounting_followup/services/followup_text_generator.py b/fusion_accounting_followup/services/followup_text_generator.py
new file mode 100644
index 00000000..66478f15
--- /dev/null
+++ b/fusion_accounting_followup/services/followup_text_generator.py
@@ -0,0 +1,123 @@
+"""AI-generated follow-up text with templated fallback."""
+
+import json
+import logging
+
+_logger = logging.getLogger(__name__)
+
+
+TEMPLATES = {
+ 'gentle': {
+ 'subject': 'Friendly reminder: invoice payment',
+ 'body': 'Dear {partner_name},\n\nThis is a friendly reminder that you have '
+ '{currency_code} {total_overdue:,.2f} outstanding on invoices that '
+ 'are now {longest_overdue_days} days past due. We understand things '
+ 'happen — please let us know if there is anything we can do to help '
+ 'resolve this.\n\nBest regards.',
+ },
+ 'firm': {
+ 'subject': 'Outstanding invoices — action required',
+ 'body': 'Dear {partner_name},\n\nOur records show {currency_code} '
+ '{total_overdue:,.2f} outstanding on {invoice_count} invoice(s), '
+ 'with the longest now {longest_overdue_days} days overdue. We '
+ 'request immediate payment to avoid further action.\n\nRegards.',
+ },
+ 'legal': {
+ 'subject': 'FINAL NOTICE — outstanding balance',
+ 'body': 'Dear {partner_name},\n\nDespite previous reminders, '
+ '{currency_code} {total_overdue:,.2f} remains outstanding on your '
+ 'account, with the longest invoice {longest_overdue_days} days '
+ 'overdue. If full payment is not received within 7 days, we will '
+ 'be forced to refer this matter for legal collection.\n\n'
+ 'Regards.',
+ },
+}
+
+
+def generate_followup_text(env, *, partner_name: str, total_overdue: float,
+ currency_code: str, longest_overdue_days: int,
+ tone: str, invoice_count: int = 0,
+ last_payment_date: str = None,
+ risk_drivers: list[str] = None,
+ provider=None) -> dict:
+ """Generate follow-up text via LLM, with templated fallback.
+
+ Returns: {subject, body, tone_used, key_points}"""
+ if provider is None:
+ provider = _get_provider(env)
+ if provider is None:
+ return _templated_fallback(
+ partner_name=partner_name, total_overdue=total_overdue,
+ currency_code=currency_code,
+ longest_overdue_days=longest_overdue_days,
+ tone=tone, invoice_count=invoice_count,
+ )
+
+ try:
+ from .followup_text_prompt import build_prompt
+ system, user = build_prompt(
+ partner_name=partner_name, total_overdue=total_overdue,
+ currency_code=currency_code,
+ longest_overdue_days=longest_overdue_days, tone=tone,
+ invoice_count=invoice_count, last_payment_date=last_payment_date,
+ risk_drivers=risk_drivers,
+ )
+ response = provider.complete(
+ system=system,
+ messages=[{'role': 'user', 'content': user}],
+ max_tokens=800, temperature=0.3,
+ )
+ content = response.get('content') if isinstance(response, dict) else response
+ parsed = json.loads(content)
+ for key in ('subject', 'body', 'tone_used'):
+ if key not in parsed:
+ raise ValueError(f"Missing key: {key}")
+ parsed.setdefault('key_points', [])
+ return parsed
+ except Exception as e:
+ _logger.warning("Follow-up text LLM generation failed (%s); falling back", e)
+ return _templated_fallback(
+ partner_name=partner_name, total_overdue=total_overdue,
+ currency_code=currency_code,
+ longest_overdue_days=longest_overdue_days,
+ tone=tone, invoice_count=invoice_count,
+ )
+
+
+def _templated_fallback(*, partner_name, total_overdue, currency_code,
+ longest_overdue_days, tone, invoice_count) -> dict:
+ template = TEMPLATES.get(tone, TEMPLATES['gentle'])
+ return {
+ 'subject': template['subject'],
+ 'body': template['body'].format(
+ partner_name=partner_name, total_overdue=total_overdue,
+ currency_code=currency_code,
+ longest_overdue_days=longest_overdue_days,
+ invoice_count=invoice_count or 0,
+ ),
+ 'tone_used': tone,
+ 'key_points': [
+ f"${total_overdue:,.2f} outstanding",
+ f"{longest_overdue_days} days overdue",
+ ],
+ }
+
+
+def _get_provider(env):
+ """Look up provider for 'followup_text' feature."""
+ param = env['ir.config_parameter'].sudo()
+ name = param.get_param('fusion_accounting.provider.followup_text')
+ if not name:
+ name = param.get_param('fusion_accounting.provider.default')
+ if not name:
+ return None
+ try:
+ from odoo.addons.fusion_accounting_ai.services.adapters.openai_adapter import OpenAIAdapter
+ from odoo.addons.fusion_accounting_ai.services.adapters.claude import ClaudeAdapter
+ except ImportError:
+ return None
+ if name.startswith('openai'):
+ return OpenAIAdapter(env)
+ elif name.startswith('claude'):
+ return ClaudeAdapter(env)
+ return None
diff --git a/fusion_accounting_followup/services/followup_text_prompt.py b/fusion_accounting_followup/services/followup_text_prompt.py
new file mode 100644
index 00000000..f3635c01
--- /dev/null
+++ b/fusion_accounting_followup/services/followup_text_prompt.py
@@ -0,0 +1,56 @@
+"""LLM prompt for AI-generated follow-up text.
+
+Output contract: {
+ "subject": str,
+ "body": str,
+ "tone_used": str,
+ "key_points": [str, ...]
+}"""
+
+
+SYSTEM_PROMPT = """You are an experienced credit collections specialist writing a
+follow-up email for an unpaid invoice. Output MUST be valid JSON of this
+exact shape:
+
+{
+ "subject": "| Date | +Level | +Tone | +State | +Overdue | +
|---|---|---|---|---|
|
+ |
+
+ Customer follow-ups +
++ AI-augmented dunning sequences for unpaid invoices. +
+