Chapitre 6 : Création d’un module sur Odoo (part 2)

Définir les modèles

Dans Odoo, les modèles, également connus sous le nom de classes de modèle, sont des composants essentiels pour la définition de la structure des données et de la logique métier d’une application. Les modèles sont définis dans les modules Odoo et représentent des entités telles que des objets, des tables de base de données ou des documents.

La classe de modèle est déclarée en utilisant le décorateur @api.model ou en héritant de la classe de base odoo.models.Model. Les modèles définissent les champs, les méthodes, les relations et les comportements spécifiques de l’entité qu’ils représentent. Voici quelques éléments importants que vous pouvez trouver dans la définition d’un modèle :

1. Champs : Les champs sont les attributs qui définissent les propriétés et les données d’un modèle. Les types de champs couramment utilisés incluent Char (chaîne de caractères), Integer (entier), Float (nombre décimal), Boolean (booléen), Date (date), Datetime (date et heure), Selection (sélection de choix), etc.
2. Méthodes : Les méthodes sont des fonctions définies à l’intérieur de la classe de modèle. Elles sont utilisées pour implémenter la logique métier spécifique au modèle. Par exemple, vous pouvez définir des méthodes pour effectuer des calculs, des validations, des actions ou des opérations spécifiques liées aux données du modèle.
3. Relations : Les relations sont des liens entre différents modèles. Elles permettent d’établir des liens logiques et de récupérer des informations d’autres modèles. Les types de relations couramment utilisés incluent Many2one (relation vers un modèle parent), One2many (relation vers plusieurs modèles enfants) et Many2many (relation de nombreux-à-plusieurs).
4. Contraintes : Les contraintes sont des règles qui sont appliquées lors de la création ou de la modification des enregistrements du modèle. Elles sont utilisées pour valider les données et garantir l’intégrité des données. Par exemple, vous pouvez définir une contrainte pour s’assurer qu’un champ obligatoire est renseigné ou qu’une valeur respecte certaines conditions.

Les modèles Odoo offrent une flexibilité et une puissance considérables pour définir la structure des données et la logique métier d’une application. Ils permettent de manipuler, de rechercher, de créer et de modifier des enregistrements dans la base de données, ainsi que d’interagir avec d’autres modèles et de mettre en œuvre des fonctionnalités spécifiques.

Il est important de bien comprendre la structure et les fonctionnalités des modèles dans Odoo pour développer efficacement des applications personnalisées ou étendre les fonctionnalités existantes d’Odoo. La documentation officielle d’Odoo fournit des informations détaillées sur la création et l’utilisation des modèles.

Les modèles peuvent être configurés en définissant un certain nombre d’attributs lors de leur définition. L’attribut le plus important est _name qui est obligatoire et définit le nom du modèle dans le système Odoo. Voici une définition minimale complète d’un modèle :

from odoo import models
class MinimalModel(models.Model):
    _name = 'test.model'

Voici un exemple qui illustre l’utilisation de différents types de champs dans Odoo :

from odoo import models, fields

class ExampleModel(models.Model):
    _name = 'example.model'

    name = fields.Char(string='Name', required=True)
    age = fields.Integer(string='Age')
    salary = fields.Float(string='Salary')
    is_employee = fields.Boolean(string='Is Employee')
    birthdate = fields.Date(string='Birthdate')
    created_at = fields.Datetime(string='Created At')
    status = fields.Selection([
        ('draft', 'Draft'),
        ('in_progress', 'In Progress'),
        ('done', 'Done')
    ], string='Status', default='draft')
    category_ids = fields.Many2many('example.category', string='Categories')
    parent_id = fields.Many2one('example.model', string='Parent')
    child_ids = fields.One2many('example.model', 'parent_id', string='Children')

class ExampleCategory(models.Model):
    _name = 'example.category'

    name = fields.Char(string='Name')

Dans cet exemple, nous avons défini un modèle ExampleModel avec différents types de champs :

• Char : Le champ name est une chaîne de caractères (texte) et est requis (required=True).
• Integer : Le champ age est un entier.
• Float : Le champ salary est un nombre décimal.
• Boolean : Le champ is_employee est un booléen, qui indique si la personne est employée ou non.
• Date : Le champ birthdate est une date.
• Datetime : Le champ created_at est une date et heure.
• Selection : Le champ status est une sélection de choix avec les valeurs ‘draft’, ‘in_progress’ et ‘done’.
• Many2many : Le champ category_ids établit une relation de nombreux-à-plusieurs avec le modèle example.category, permettant de lier plusieurs catégories à un enregistrement.
• Many2one : Le champ parent_id établit une relation vers un enregistrement parent du même modèle.
• One2many : Le champ child_ids établit une relation vers plusieurs enregistrements enfants du même modèle.

Notez que dans cet exemple, nous avons également défini un modèle ExampleCategory pour illustrer la relation Many2many avec le modèle ExampleModel.

Cet exemple couvre différentes possibilités de types de champs dans Odoo. Vous pouvez utiliser ces types de champs en fonction de vos besoins métier spécifiques et de la structure des données de votre application.

Les relations Many2many, One2many et Many2one sont des types de relations utilisés pour établir des liens entre différents modèles dans Odoo. Voici une explication détaillée de chaque type de relation :

1. Relation Many2many :

• Utilisation : Cette relation est utilisée lorsqu’il y a une relation de nombreux-à-plusieurs entre deux modèles. Par exemple, une personne peut appartenir à plusieurs groupes et un groupe peut contenir plusieurs personnes.
• Déclaration : Pour déclarer une relation Many2many, vous devez utiliser le champ Many2many et spécifier le modèle cible avec lequel vous voulez établir la relation.
• Exemple : category_ids = fields.Many2many('example.category', string='Categories')
• Dans cet exemple, le champ category_ids du modèle ExampleModel établit une relation Many2many avec le modèle example.category, permettant à un enregistrement de ExampleModel d’appartenir à plusieurs catégories.

1. Relation One2many :

• Utilisation : Cette relation est utilisée lorsqu’il y a une relation de un-à-plusieurs entre deux modèles. Par exemple, un projet peut avoir plusieurs tâches liées.
• Déclaration : Pour déclarer une relation One2many, vous devez utiliser le champ One2many et spécifier le modèle cible avec lequel vous voulez établir la relation. Vous devez également spécifier le champ inverse sur le modèle cible pour lier les enregistrements.
• Exemple : task_ids = fields.One2many('project.task', 'project_id', string='Tasks')
• Dans cet exemple, le champ task_ids du modèle Project établit une relation One2many avec le modèle project.task, en utilisant le champ project_id sur le modèle cible pour lier les enregistrements. Cela permet à un projet d’avoir plusieurs tâches liées.

1. Relation Many2one :

• Utilisation : Cette relation est utilisée lorsqu’il y a une relation de plusieurs-à-un entre deux modèles. Par exemple, une tâche peut être liée à un projet spécifique.
• Déclaration : Pour déclarer une relation Many2one, vous devez utiliser le champ Many2one et spécifier le modèle cible avec lequel vous voulez établir la relation.
• Exemple : project_id = fields.Many2one('project.project', string='Project')
• Dans cet exemple, le champ project_id du modèle Task établit une relation Many2one avec le modèle project.project, permettant de lier une tâche à un projet spécifique.

Ces types de relations sont essentiels pour modéliser les relations complexes entre les différentes entités d’une application Odoo. En utilisant ces relations, vous pouvez établir des liens logiques et récupérer des informations d’autres modèles, ce qui facilite la manipulation et l’organisation des données dans Odoo.

Champs du modèle

Les champs sont utilisés pour définir ce que le modèle peut stocker et où. Les champs sont définis comme des attributs de la classe de modèle :

from odoo import models, fields

class LessMinimalModel(models.Model):
    _name = 'test.model2'

    name = fields.Char()

Attributs communs

Tout comme le modèle lui-même, ses champs peuvent être configurés en passant des attributs de configuration en tant que paramètres :

name = fields.Char(required=True)

Dans Odoo, il existe certains attributs communs qui peuvent être utilisés lors de la définition des champs d’un modèle. Ces attributs fournissent des fonctionnalités supplémentaires et permettent de personnaliser le comportement des champs. Voici quelques-uns des attributs communs les plus couramment utilisés :

1. string : Cet attribut permet de définir l’étiquette ou le libellé associé à un champ. Il est utilisé pour afficher un texte descriptif dans l’interface utilisateur d’Odoo. Par exemple : name = fields.Char(string='Name').
2. required : Cet attribut indique si le champ est obligatoire lors de la création ou de la modification d’un enregistrement. Lorsque required=True, le champ doit être renseigné. Par défaut, required est défini sur False. Par exemple : name = fields.Char(string='Name', required=True).
3. readonly : Cet attribut spécifie si le champ est en lecture seule, ce qui signifie qu’il ne peut pas être modifié. Lorsque readonly=True, le champ est affiché en tant que valeur non modifiable dans l’interface utilisateur. Par défaut, readonly est défini sur False. Par exemple : name = fields.Char(string='Name', readonly=True).
4. default : Cet attribut permet de définir une valeur par défaut pour un champ lors de la création d’un nouvel enregistrement. La valeur par défaut peut être une valeur statique ou une fonction qui renvoie une valeur. Par exemple : name = fields.Char(string='Name', default='Default Name').
5. compute : Cet attribut permet de définir une fonction de calcul pour le champ. La fonction de calcul est exécutée chaque fois que la valeur du champ est accédée. Elle est utilisée pour calculer dynamiquement la valeur du champ en fonction d’autres champs ou de la logique métier. Par exemple :

def _compute_total_amount(self):
    for record in self:
        record.total_amount = record.price * record.quantity

total_amount = fields.Float(string='Total Amount', compute='_compute_total_amount')

6. inverse : Cet attribut permet de définir une fonction inverse pour le champ. La fonction inverse est appelée lorsque la valeur du champ est modifiée et permet de mettre à jour d’autres champs ou de réaliser des actions spécifiques en fonction de cette modification. Par exemple :

def _inverse_total_amount(self):
    for record in self:
        record.price = record.total_amount / record.quantity

total_amount = fields.Float(string='Total Amount', compute='_compute_total_amount', inverse='_inverse_total_amount')

7. store : Cet attribut indique si la valeur du champ doit être stockée dans la base de données. Par défaut, store est défini sur True. Cependant, pour les champs calculés (compute), store doit être défini sur False, car ils sont automatiquement calculés à partir d’autres champs et n’ont pas besoin d’être stockés.

Ces attributs communs permettent de personnaliser le comportement des champs et d’ajouter des fonctionnalités supplémentaires à votre modèle dans Odoo. Vous pouvez utiliser ces attributs en fonction des besoins spécifiques de votre application pour rendre vos champs plus interactifs, dynamiques et personnalisés.

from odoo import api,models, fields

class HospitalPatient(models.Model):
    _name = 'hospital.patient'

   name = fields.Char(string='Name',required=True)

   _description = "Patient Records"

   age = fields.Integer(string='Age')
   is_child = fields.Boolean(string='Is Child ?')
   notes = fileds.Text(string='Notes')
   gender = fields.Selection([('male','Male'),('female','Female')],string='Gender')

Voici l’intégralité du code avec la correction des fautes de frappe :

from odoo import api, models, fields

class HospitalPatient(models.Model):
    _name = 'hospital.patient'
    name = fields.Char(string='Name', required=True)
    _description = "Patient Records"
    age = fields.Integer(string='Age')
    is_child = fields.Boolean(string='Is Child?')
    notes = fields.Text(string='Notes')
    gender = fields.Selection([('male', 'Male'), ('female', 'Female')], string='Gender')

Ce code importe les classes nécessaires d’Odoo (api, models, fields) et définit un modèle Odoo appelé HospitalPatient.

Le modèle HospitalPatient hérite de la classe models.Model d’Odoo, ce qui permet de créer une nouvelle table dans la base de données pour stocker les enregistrements des patients.

Les champs du modèle sont définis comme suit :

• name : champ de type Char qui stocke le nom du patient. Il est obligatoire (required=True).
• _description : attribut de chaîne de caractères qui fournit une description du modèle. Dans ce cas, il est défini comme « Patient Records ».
• age : champ de type Integer qui stocke l’âge du patient.
• is_child : champ de type Boolean qui indique si le patient est un enfant ou non.
• notes : champ de type Text qui stocke des notes ou des commentaires sur le patient.
• gender : champ de type Selection qui stocke le genre du patient. Il offre deux options : « Male » (masculin) et « Female » (féminin).

Ce code permet de créer un modèle de base pour enregistrer les informations des patients dans Odoo, telles que leur nom, leur âge, leur statut d’enfant ou d’adulte, leurs notes et leur genre.