#!/usr/bin/env python3 # © 2021-2026 TechnoLibre (http://www.technolibre.ca) # License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl) """Les réglages qu'Odoo ne recrée qu'à des moments qu'une migration évite. Certains enregistrements de configuration ont cessé d'être LIVRÉS en données et sont devenus le produit d'un geste : créer une société, changer de devise, cocher une case, charger un plan comptable. Une migration ne fait aucun de ces gestes. L'enregistrement part avec le nettoyage des orphelins et rien ne le remet. Deux cas mesurés sur une chaîne 12 → 18 réelle : liste de prix `product.list0` est déclaré jusqu'en 16 et plus après. Odoo 18 crée les listes par défaut dans `_activate_or_create_pricelists()`, appelée à la création d'une société, au changement de devise et au basculement du réglage. Résultat : 1 liste en 16, 0 en 17 et en 18, alors que le groupe `product.group_product_pricelist` compte six membres. Toute commande s'ouvre alors sans liste de prix — elle ne casse rien, elle facture faux. rapprochement bancaire `account.reconciliation_model_default_rule` est déclaré en 12 et plus dès la 13 : la 18 le crée depuis le PLAN COMPTABLE (`_get_account_reconcile_model`), qu'une montée de version ne recharge jamais. Résultat : 1 en 12, 0 partout ensuite, et plus aucun lettrage automatique sur les journaux de trésorerie. On n'invente rien : on appelle les méthodes d'Odoo, celles-là mêmes que le geste manquant aurait appelées. `_load_data` est rejoué avec `ignore_duplicates`, donc l'outil se relance sans risque. Lecture seule par défaut. `--apply` écrit, puis RELIT pour vérifier. """ import argparse import os import sys sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) sys.path.append( os.path.normpath(os.path.join(os.path.dirname(__file__), "..", "..", "..")) ) import database_cleanup # noqa: E402 try: from script.todo.todo_i18n import t except Exception: # pragma: no cover - repli si i18n indisponible def t(key: str) -> str: return key # Les sentinelles de `run_shell`, pas les nôtres : il les impose, et en # poser d'autres ferait lire un rapport vide. DEBUT = database_cleanup.START FIN = database_cleanup.END SCRIPT = """ import json DRY = {dry} rapport = {{"dry_run": DRY}} try: Societe = env["res.company"].sudo() societes = Societe.search([]) rapport["companies"] = len(societes) # ── Listes de prix ────────────────────────────────────────────── if "product.pricelist" in env: Liste = env["product.pricelist"].sudo().with_context(active_test=False) rapport["pricelist_before"] = Liste.search_count([]) # Le groupe décide : sans lui la fonctionnalité est masquée et # l'absence de liste est normale, pas une perte. rapport["pricelist_group"] = env.user.has_group( "product.group_product_pricelist" ) if not DRY and rapport["pricelist_group"]: Societe._activate_or_create_pricelists() env.cr.commit() rapport["pricelist_after"] = Liste.search_count([]) else: rapport["pricelist_absent"] = True # ── Modèles de rapprochement bancaire ─────────────────────────── if "account.reconcile.model" in env: Modele = env["account.reconcile.model"].sudo() rapport["reconcile_before"] = Modele.search_count([]) # Sans journal de trésorerie il n'y a rien à rapprocher : créer # des modèles là serait du bruit dans un menu qu'on n'ouvre pas. rapport["cash_journals"] = env["account.journal"].sudo().search_count( [("type", "in", ("bank", "cash"))] ) rapport["charts"] = sorted( {{s.chart_template for s in societes if s.chart_template}} ) if not DRY and rapport["cash_journals"] and rapport["charts"]: Gabarit = env["account.chart.template"].sudo() for societe in societes: if not societe.chart_template: continue donnees = Gabarit._get_account_reconcile_model( societe.chart_template ) if not donnees: continue # `_load_data` est le chemin d'Odoo : il pose les xmlid # préfixés par la société, donc un rechargement futur du # plan comptable ne fera pas de doublon. Gabarit.with_company(societe)._load_data( {{"account.reconcile.model": donnees}}, ignore_duplicates=True, ) env.cr.commit() rapport["reconcile_after"] = Modele.search_count([]) else: rapport["reconcile_absent"] = True except Exception as exc: rapport["error"] = "%s: %s" % (type(exc).__name__, exc) print({debut!r}) print(json.dumps(rapport)) print({fin!r}) """ def build_script(dry_run): return SCRIPT.format( dry="True" if dry_run else "False", debut=DEBUT, fin=FIN ) def pricelist_missing(rapport, apres=False): """Une liste manque-t-elle vraiment ? Pas de liste ET le groupe actif : la fonctionnalité est offerte aux utilisateurs et ne répond rien. Groupe éteint, l'absence est normale. `apres` regarde le compte D'APRÈS la réparation. Sans ce choix, un `--apply` réussi se conclurait toujours par « il en manque encore » : le compte d'avant, lui, reste à zéro pour l'éternité. """ if rapport.get("pricelist_absent"): return False if not rapport.get("pricelist_group"): return False cle = "pricelist_after" if apres else "pricelist_before" return not rapport.get(cle) def reconcile_missing(rapport, apres=False): """Aucun modèle alors qu'il y a de quoi rapprocher.""" if rapport.get("reconcile_absent"): return False if not rapport.get("cash_journals"): return False cle = "reconcile_after" if apres else "reconcile_before" return not rapport.get(cle) def findings(rapport, apres=False): lst = [] if pricelist_missing(rapport, apres): lst.append("pricelist") if reconcile_missing(rapport, apres): lst.append("reconcile") return lst def render(rapport, dry_run): lignes = [] if not findings(rapport): return [f"✅ {t('Every default configuration record is there.')}"] lignes.append( f"🧾 {t('Configuration records a migration never recreates')}" ) lignes.append("") if pricelist_missing(rapport): lignes.append( f" 💲 {t('No pricelist, and the pricelist feature is on.')}" ) lignes.append( f" {t('Every quotation opens without one: raw price, no rule.')}" ) if reconcile_missing(rapport): lignes.append( f" 🏦 {t('No bank reconciliation model, for')}" f" {rapport.get('cash_journals', 0)} {t('cash/bank journal(s).')}" ) lignes.append(f" {t('Every statement line is matched by hand.')}") lignes.append("") if dry_run: lignes.append(f" {t('Use --apply to let Odoo recreate them.')}") else: lignes.append( f" {t('pricelists:')} {rapport.get('pricelist_before', 0)}" f" → {rapport.get('pricelist_after', 0)}" f" · {t('reconcile models:')}" f" {rapport.get('reconcile_before', 0)}" f" → {rapport.get('reconcile_after', 0)}" ) return lignes def main(argv=None): parser = argparse.ArgumentParser( description=( "Report the default configuration records a version bump drops" " and no event recreates, and optionally let Odoo recreate them." ) ) parser.add_argument("-d", "--database", required=True) parser.add_argument("-c", "--config", default="config.conf") parser.add_argument( "--apply", action="store_true", help="actually recreate them (default: report only)", ) config = parser.parse_args(argv) # Le même garde-fou que partout : un Odoo d'une autre version ÉCRIT # dans la base avant d'échouer. souci = database_cleanup.require_matching_version(config.database) if souci: print(f"❌ {souci}") return 2 try: rapport = database_cleanup.run_shell( config.database, config.config, build_script(not config.apply), echo=lambda texte: print(f"⧖ {texte}", flush=True), ) except RuntimeError as exc: print(f"❌ {exc}") return 2 if rapport.get("error"): print(f"❌ {rapport['error']}") return 2 print("\n".join(render(rapport, not config.apply))) if not findings(rapport): return 0 if not config.apply: return 1 # Juger sur le compte D'APRÈS : le script a recompté dans la même # session. Annoncer « recréé » sans regarder ferait découvrir # l'absence au premier devis. reste = findings(rapport, apres=True) if reste: print(f"⚠️ {t('Still missing after the repair.')} {', '.join(reste)}") return 1 print(f"✅ {t('Odoo recreated them.')}") return 0 if __name__ == "__main__": sys.exit(main())