Ce que tu vas apprendre
Mode développeur
Activer et utiliser le mode debug pour accéder aux outils techniques d'Odoo.
Structure d'un écran
Comprendre les 5 couches d'un écran Odoo : navbar, menus, actions, vues, pager.
Inspecteur technique
Identifier le modèle, la vue et l'action derrière n'importe quel écran.
Menus Technique
Explorer les modèles, champs, vues et actions via les menus Paramètres → Technique.
- Odoo 19 installé et lancé (article T01, T02 ou T03)
- Une base de données créée avec au moins un module installé (ex : Ventes ou CRM)
- Un compte administrateur sur cette base
Cet article est purement exploratoire — on n'écrit aucun code. L'objectif est de construire ta carte mentale du framework avant de plonger dans le développement.
Anatomie d'un écran Odoo
Chaque écran Odoo est composé de 5 couches empilées. Comprendre cette structure te permettra de savoir exactement où intervenir quand tu développes.
Les 5 couches d'un écran Odoo : navbar, sous-menus, control panel (boutons + recherche), vue (list/form/kanban) et pager.
Étape 1 — Activer le mode développeur
Le mode développeur débloque l'accès à tous les menus techniques d'Odoo : modèles, champs, vues, actions, séquences, etc. Il existe trois façons de l'activer :
Méthode 1 — Via les Paramètres (la plus simple)
- Va dans Paramètres (menu principal)
- Scroll tout en bas de la page
- Section Outils pour développeurs
- Clique sur Activer le mode développeur
Méthode 2 — Via l'URL (la plus rapide)
Ajoute ?debug=1 à l'URL :
http://localhost:8069/odoo?debug=1
Variantes utiles :
| URL | Effet |
|---|---|
?debug=1 | Mode développeur standard |
?debug=assets | Mode développeur + assets non minifiés (JS/CSS lisibles) |
?debug=tests | Mode développeur + exécution des tests QUnit frontend |
Méthode 3 — Via la commande Odoo
Si tu as lancé Odoo avec --dev=all (article T04), le mode développeur
est automatiquement disponible.
Étape 2 — Comprendre la structure d'un écran
Retourne sur le diagramme ci-dessus. Chaque couche correspond à un concept technique Odoo :
| # | Couche visuelle | Concept technique | Modèle Odoo |
|---|---|---|---|
| 1 | Navbar (barre supérieure violette) | Menus racine (applications) | ir.ui.menu |
| 2 | Sous-menus (barre grise) | Menus enfants | ir.ui.menu (parent_id) |
| 3 | Control Panel (boutons + recherche) | Action window | ir.actions.act_window |
| 4 | Vue (contenu principal) | Vue XML (list, form, kanban, search...) | ir.ui.view |
| 5 | Pager (bas de page) | Pagination automatique | (géré par le framework) |
ir.actions.act_window)
qui cible un modèle (ex : sale.order)
et affiche une vue (list, form, kanban...). Tout est données :
les menus, les actions et les vues sont des enregistrements en base.
Étape 3 — Utiliser l'inspecteur technique
Avec le mode développeur activé, chaque écran Odoo te donne accès à des informations techniques via l'icône insecte dans la navbar.
Inspecter un champ
En mode développeur, survole n'importe quel champ dans un formulaire. Une info-bulle apparaît avec :
- Nom technique du champ (ex :
partner_id) - Type (Many2one, Char, Selection...)
- Modèle sur lequel il est défini
- Relation (pour les champs relationnels)
Inspecter la vue courante
Clique sur l'icône insecte → Éditer la vue : Form (ou List, Kanban...). Odoo ouvre directement le XML de la vue courante. Tu vois :
- Le nom de la vue et son
xml_id - Le modèle cible
- La priorité (les vues de priorité basse sont chargées en premier)
- Le code XML complet de la vue
Inspecter l'action courante
Icône insecte → Éditer l'action. Tu vois :
- Le type d'action (
ir.actions.act_window) - Le modèle cible (
res_model) - Les modes de vue disponibles (
view_mode: list, form, kanban...) - Le domaine de filtrage (
domain) - Le contexte (
context)
Étape 4 — Explorer le menu Technique
En mode développeur, le menu Paramètres → Technique donne accès à toutes les entrailles d'Odoo. Voici les sous-menus les plus utiles :
Base de données
| Menu | Ce que tu y trouves |
|---|---|
| Modèles | Tous les modèles installés (sale.order, res.partner...), leurs champs, et les relations |
| Champs | Tous les champs de tous les modèles. Tu peux filtrer par modèle pour voir la structure complète |
| Vues | Toutes les vues XML (form, list, kanban, search...) avec leur priorité et leur héritage |
Actions
| Menu | Ce que tu y trouves |
|---|---|
| Actions → Window Actions | Les actions qui ouvrent des écrans (modèle, vues, domaine, contexte) |
| Actions → Server Actions | Actions côté serveur (code Python, envoi d'email, modification de valeurs) |
| Actions → Automated Actions | Règles automatiques déclenchées par des événements (création, modification...) |
Autres menus utiles
| Menu | Ce que tu y trouves |
|---|---|
| Séquences & identifiants | Les séquences automatiques (SO0001, INV/2026/0001...) et les identifiants XML |
| Structure du menu | L'arborescence complète des menus avec les actions associées |
| Données externes | Le mapping entre les XML ID (sale.action_quotations) et les enregistrements en base |
Étape 5 — Décoder l'URL Odoo
L'URL d'Odoo 19 contient des informations techniques précieuses. Voici comment la lire :
http://localhost:8069/odoo/sales?view_type=list
| Fragment | Signification |
|---|---|
/odoo | Préfixe du backend Odoo 19 (remplace l'ancien /web#) |
/sales | Chemin de l'application (défini par l'action) |
?view_type=list | Type de vue active (list, form, kanban...) |
En mode formulaire, l'URL contient aussi l'ID de l'enregistrement :
http://localhost:8069/odoo/sales/42?view_type=form
/odoo/path
au lieu de l'ancien /web#action=123&model=sale.order. Les URLs sont plus
propres et lisibles, mais l'action ID n'apparaît plus directement. Utilise l'inspecteur
(icône insecte) pour trouver l'action.
Étape 6 — Exercice : inspecter le module Ventes
Mets en pratique ce que tu viens d'apprendre. Installe le module Ventes si ce n'est pas déjà fait, puis réponds à ces questions :
| # | Question | Indice |
|---|---|---|
| 1 | Quel est le modèle derrière la liste des devis ? | Survole un champ dans le formulaire |
| 2 | Quel est le xml_id de la vue liste des devis ? | Icône insecte → Éditer la vue |
| 3 | Quel est le domaine de l'action qui affiche les devis (pas les commandes confirmées) ? | Icône insecte → Éditer l'action |
| 4 | Combien de champs a le modèle sale.order ? |
Paramètres → Technique → Champs, filtrer par modèle |
| 5 | Quel est le nom technique du champ Client sur le formulaire de devis ? | Survole le champ en mode développeur |
sale.ordersale.view_quotation_tree(ou similaire selon la version)[('state', 'in', ('draft', 'sent'))]— filtre les devis non confirmés- Plus de 100 champs (les modèles Odoo sont riches !)
partner_id(Many2one versres.partner)
Le chaînage complet : du clic à l'écran
Maintenant que tu connais chaque pièce du puzzle, voici comment elles s'assemblent quand un utilisateur clique sur un menu :
Clic sur "Devis" (menu)
└─ ir.ui.menu (parent_id = Ventes)
└─ action_id → ir.actions.act_window
├─ res_model = "sale.order"
├─ view_mode = "list,form,kanban"
├─ domain = [('state', 'in', ('draft', 'sent'))]
└─ view_ids → ir.ui.view
├─ sale.view_quotation_tree (list)
├─ sale.view_order_form (form)
└─ sale.view_quotation_kanban (kanban)
Ce chaînage Menu → Action → Modèle → Vue est le pattern fondamental d'Odoo. Quand tu développes un nouveau module, tu crées exactement ces quatre éléments.
Récapitulatif
| Concept | Modèle technique | Où le trouver |
|---|---|---|
| Menu | ir.ui.menu | Paramètres → Technique → Structure du menu |
| Action window | ir.actions.act_window | Paramètres → Technique → Actions → Window Actions |
| Vue | ir.ui.view | Paramètres → Technique → Vues |
| Modèle | ir.model | Paramètres → Technique → Modèles |
| Champ | ir.model.fields | Paramètres → Technique → Champs |
| Identifiant XML | ir.model.data | Paramètres → Technique → Données externes |
ir_*. C'est ce qui rend Odoo si extensible :
pour modifier un comportement, tu ajoutes ou modifies des enregistrements, pas du code compilé.
Pour aller plus loin
- Odoo Shell : lance
odoo-bin shell -d ma_basepour explorer les modèles en Python interactif :self.env['sale.order'].search_count([]) - psql : connecte-toi directement à PostgreSQL pour voir
la structure des tables :
psql -d odoo19_dev -c "\d sale_order" - Personnaliser un champ : en mode développeur, tu peux ajouter des champs personnalisés directement depuis l'interface (sans code). Utile pour du prototypage rapide.
Liens utiles
Télécharge le Guide Technique Odoo 19
Architecture, pièges v19, checklist premier module — tout dans un PDF gratuit.
Télécharger le guide← Configurer l'environnement dev Article suivant de la série : Architecture technique Odoo 19 →