Odoo Fields Selection: Types, Customization, and Validation

What are Fields in Odoo?

Fields are crucial parts of models in the Odoo context since they specify the kind and structure of data that can be stored. Each field relates to a particular feature of a model, making it possible for users to efficiently gather and organize data. Because fields make it easier to enter, store, and retrieve data, they are essential to the general functionality of Odoo and the ERP system running on it.

Definition of Fields in Odoo

In Odoo, fields are similar to variables that store data in a model. The type of data that can be stored in each field is determined by its individual data type. For instance, a field of type "Char" can store brief text strings, whereas a field of type "Float" can store decimal numbers. Developers can establish a structured representation of the data essential to their business operations by creating fields within a model.

How Fields are Used to Store Data in Models

In Odoo, models are Python classes that represent database tables. Each model can have multiple fields, each corresponding to a column in the database table. When a user interacts with the Odoo interface—such as filling out a form or viewing a record—these fields are used to capture and display data. The data entered into these fields is then stored in the database, allowing for efficient data management and retrieval.

Take a model that represents a consumer, for instance. Fields like "name" (Char), "email" (Char), "phone_number" (Char), and "is_active" (Boolean) could be included in this model. By capturing distinct details about the consumer in each of these fields, the organization may efficiently manage customer data.

Overview of the Role of Fields in Odoo's ORM (Object-Relational Mapping)

Odoo employs an Object-Relational Mapping (ORM) system that simplifies the interaction between the application and the underlying database. The ORM allows developers to work with Python objects instead of writing complex SQL queries. Fields are integral to this ORM, as they define the attributes of these objects and dictate how data is stored and retrieved.

Based on the fields listed in the model, the ORM automatically creates the matching database table and columns when a model is defined in Odoo. By freeing developers to concentrate on business logic instead of database administration, this abstraction layer not only improves the overall development experience but also streamlines database operations.

Fields in Odoo enable effective data storage, retrieval, and manipulation, playing a crucial role in the functionality of Odoo's ORM. Understanding how fields work is essential for anyone looking to customize or develop applications within the Odoo ecosystem.

Types of Fields in Odoo

To meet various needs for data storage, Odoo offers a range of field kinds. Each field type has its own characteristics and use cases, allowing developers to choose the most appropriate type for the data they need to manage. In this section, we will explore the various types of fields available in Odoo, including basic field types, date and time fields, selection fields, related fields, and relational fields.

Basic Field Types

• Char:

​ ​The Char field is used to store short text strings, such as names or titles. It has a ​ ​ ​ ​maximum length, which can be defined when creating the field.

Example: 

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

• Text:

​ ​The Text field is designed for longer text entries, such as descriptions or comments. ​ ​Unlike Char fields, there is no maximum length for Text fields.

Example:

description = fields.Text(string='Description')

• Integer:

​ ​The Integer field is used to store whole numbers. It is suitable for counting items, ​ ​ ​quantities, or any other numeric data that does not require decimal precision.

Example:

quantity = fields.Integer(string='Quantity', default=0)

• Float:

​ ​The Float field is used to store decimal numbers. It is ideal for financial data, ​ ​ ​ ​measurements, or any other data that requires precision.

Example:

price = fields.Float(string='Price', digits=(6, 2)) (where digits specifies the total number of digits and the number of decimal places)

• Boolean:

​ ​The Boolean field is used to store True/False values. It is often used for flags or ​ ​ ​ ​indicators, such as whether a record is active or inactive.

Example:

is_active = fields.Boolean(string='Active', default=True)

Date and Time Fields

• Date:

​ ​The Date field is used to store calendar dates. It allows users to select a date from a ​ ​date picker in the Odoo interface.

Example:

start_date = fields.Date(string='Start Date')

• Datetime:

​ ​The Datetime field is used to store both date and time information. It is helpful for ​ ​monitoring things that happen at certain times.

Example: 

event_datetime = fields.Datetime(string='Event Date and Time')

• Time:

​ ​The Time field is used to store time values without a date component. It is suitable for ​ ​scheduling events or tracking durations.

Example:

duration = fields.Time(string='Duration')

Selection Fields

• Selection:

​ ​The Selection field allows users to choose a value from a predefined list of options. ​ ​This is useful for fields that have a limited set of valid values, such as status or ​ ​ ​ ​category.

​ ​Syntax for defining selection fields:

status = fields.Selection(

    selection=[('draft', 'Draft'), ('confirmed', 'Confirmed'), ('done', 'Done')],

    string='Status',

    default='draft'

)

Example: In a project management application, a task might have a status field with options like "Not Started," "In Progress," and "Completed."

Related Fields

• Related fields

​ ​Related fields allow you to access data from another model without duplicating it. ​ ​They create a link to a field in a related model, making it easy to retrieve and display ​ ​related information.

Example:

customer_name = fields.Char(related='partner_id.name', string='Customer Name', store=True)

In this example, customer_name retrieves the name of the customer from the related partner_id model.

Many2one, One2many, and Many2many Fields

• Many2one:

​ ​The Many2one field creates a relationship where multiple records in one model can ​ ​be linked to a single record in another model. This is commonly used for relationships ​ ​like orders to customers.

Example:

customer_id = fields.Many2one('res.partner', string='Customer')

• One2many:

​ ​The One2many field establishes a reverse relationship, allowing a single record in one ​ ​model to be linked to multiple records in another model. This is often used for parent- ​ ​child relationships, such as a project with multiple tasks.

Example:

task_ids = fields.One2many('project.task', 'project_id', string='Tasks')

• Many2many:

​The Many2many field allows for a many-to-many relationship between two models, where ​multiple records in one model can be linked to multiple records in another model. This is ​useful for scenarios like tagging or categorizing items.

Example:

tag_ids = fields.Many2many('project.tag', string='Tags')

Odoo offers a diverse range of field types that cater to various data storage needs. By selecting the appropriate field types, developers can create robust and efficient applications tailored to their business requirements.

Creating Custom Fields

Creating custom fields in Odoo is a fundamental aspect of tailoring the ERP system to meet specific business needs. With custom fields, developers can add new features to pre-existing models or build completely new ones that collect special information pertinent to their business processes. In this section, we will provide a step-by-step guide on how to create custom fields in Odoo, discuss best practices for naming and defining fields, and highlight considerations for selecting appropriate field types based on data requirements.

How to Create Custom Fields in Odoo

1. Define the Model:

​ ​Start by defining the model in which you want to add custom fields. This is typically ​ ​done in a Python file within a custom Odoo module.

Example:

from odoo import models, fields

class CustomModel(models.Model):

    _name = 'custom.model'

    _description = 'Custom Model'

2. Add Custom Fields:

​ ​Within the model definition, you can add custom fields by declaring them as class ​ ​attributes. Specify the field type, name, and any additional parameters such as string ​ ​labels, default values, and constraints.

Example:

class CustomModel(models.Model):

    _name = 'custom.model'

    _description = 'Custom Model'

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

    description = fields.Text(string='Description')

    start_date = fields.Date(string='Start Date')

    is_active = fields.Boolean(string='Active', default=True)

3. Update the Module:

​ ​After defining the custom fields, you need to update the module to apply the ​ ​ ​ ​changes. This can be done by going to the Odoo interface, navigating to the Apps ​ ​menu, and clicking on the "Update Apps List" option. Then, find your custom module ​ ​and click "Upgrade."

4. Test the Custom Fields:

• Once the module is updated, navigate to the relevant model in the Odoo interface to verify that the custom fields are displayed correctly. Test the functionality by creating or editing records to ensure that the fields behave as expected.

Using Fields in Views

In Odoo, views are the user interface components that allow users to interact with the data stored in models. Fields play a crucial role in views, as they determine how data is displayed and how users can input or modify information. This section will provide an overview of how fields are used in different types of Odoo views, discuss how to customize views to display fields effectively, and provide an example of a custom view that incorporates various field types.

How Fields are Used in Odoo Views

Odoo supports several types of views, each serving a different purpose in the user interface:

• Form View:

​ ​The Form view is used for creating and editing individual records. It displays fields in a ​ ​structured layout, allowing users to input data easily. Each field in the model can be ​ ​represented in the Form view, and developers can customize the layout to enhance ​ ​usability.

• Tree View:

​ ​The Tree view (also known as List view) is used to display multiple records in a tabular ​ ​format. It provides a quick overview of data, allowing users to see key information at a ​ ​glance. Fields can be selected to be displayed as columns in the Tree view, and users ​ ​can sort and filter records based on these fields.

• Kanban View:

​ ​The Kanban view presents records as cards, making it ideal for visualizing workflows ​ ​or statuses. Each card can display key fields, and users can drag and drop cards to ​ ​change their status or order. This view is particularly useful for project management ​ ​and task tracking.

• Calendar View:

​ ​The Calendar view is used to display records with date fields in a calendar format. This ​ ​view is useful for scheduling events, appointments, or tasks, allowing users to see their ​ ​data in a time-based context.

Customizing Views to Display Fields Effectively

Customizing views in Odoo allows developers to tailor the user interface to meet specific business needs. Here are some key considerations for customizing views:

• XML Definition:

​ ​Views in Odoo are defined using XML. Developers can create or modify views by ​ ​ ​writing XML code that specifies how fields should be displayed. This includes defining ​ ​the layout, grouping fields, and setting attributes for each field.

• Field Arrangement:

​ ​Organize fields logically within the view to enhance user experience. Group related ​ ​fields together, and consider using tabs or sections to separate different categories of ​ ​information.

• Field Attributes:

​ ​Use attributes such as required, readonly, and invisible to control how fields behave in ​ ​the view. For example, you might want to make certain fields read-only for users who ​ ​should not modify them.

• Dynamic Fields:

​ ​Leverage Odoo's capabilities to show or hide fields dynamically based on user input ​ ​or conditions. This can be achieved using the attrs attribute in XML, allowing for a ​ ​more interactive user experience.

Example of a Custom View with Various Field Types

Here’s an example of how to create a custom Form view for a model called custom.model that includes various field types:

<record id="view_custom_model_form" model="ir.ui.view">

    <field name="name">custom.model.form</field>

    <field name="model">custom.model</field>

    <field name="arch" type="xml">

        <form string="Custom Model">

            <sheet>

                <group>

                    <field name="name" required="1"/>

                    <field name="description"/>

                    <field name="start_date"/>

                    <field name="is_active"/>

                </group>

                <group>

                    <field name="customer_id" widget="many2one"/>

                    <field name="task_ids" widget="one2many"/>

                </group>

            </sheet>

        </form>

    </field>

</record>

In this example:

The Form view is defined for the custom.model model. The name, description, start_date, and is_active fields are included in the first group, with the name field marked as required. The second group includes a Many2one field for selecting a customer and a One2many field for displaying related tasks.

By customizing views in this way, developers can create intuitive and user-friendly interfaces that enhance data entry and management within Odoo.

Field Constraints and Validation

Field constraints and validation are essential components of data integrity in Odoo. They ensure that the data entered into the system meets specific criteria, preventing errors and maintaining the quality of the information stored in the database. This section will explain the different types of field constraints available in Odoo, how to implement validation for fields, and provide examples of common validation scenarios.

Explanation of Field Constraints

Field constraints in Odoo are rules that restrict the type of data that can be entered into a field. These constraints help enforce data integrity and ensure that the information stored in the database is accurate and consistent. Some common types of field constraints include:

Required Constraint

This constraint ensures that a field must be filled out before a record can be saved. If a user attempts to save a record without providing a value for a required field, Odoo will display an error message.

Example:

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

Unique Constraint

The unique constraint ensures that the values in a field are distinct across all records in the model. This is useful for fields like email addresses or identification numbers, where duplicates are not allowed.

Example:

email = fields.Char(string='Email', required=True, unique=True)

Size Constraint

This constraint limits the length of data that can be entered into a field. For example, a Char field can have a maximum length defined, ensuring that users do not enter excessively long strings.

Example:

code = fields.Char(string='Code', size=10)

Domain Constraint

A domain constraint restricts the values that can be entered into a field based on specific criteria. This is often used with selection fields to limit the options available to users.

Example:

status = fields.Selection(

    selection=[('draft', 'Draft'), ('confirmed', 'Confirmed')],

    string='Status',

    default='draft',

    domain="[('status', '!=', 'done')]"

)

How to Implement Validation for Fields in Odoo

In addition to built-in constraints, Odoo allows developers to implement custom validation logic for fields. This can be done by overriding the create and write methods of a model or by using the @api.constrains decorator to define validation rules. Here’s how to implement validation:

1. Using the @api.constrains Decorator:

​ ​This decorator allows you to define custom validation methods that will be called ​ ​ ​automatically when records are created or updated. If the validation fails, an ​ ​ ​ ​exception can be raised to prevent the operation.

Example:

rom odoo import models, fields, api
from odoo.exceptions import ValidationError


class CustomModel(models.Model):
    _name = 'custom.model'


    start_date = fields.Date(string='Start Date')
    end_date = fields.Date(string='End Date')


    @api.constrains('end_date')

  def _check_end_date(self):

for record in self:

if record.end_date < record.start_date:

raise ValidationError("End date must be greater than or equal to start date.")

2. Overriding the create and write Methods:

​ ​You can also implement validation logic by overriding these methods to include ​ ​ ​custom checks before saving records.

Example:

class CustomModel(models.Model):

_name = 'custom.model'


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


 @api.model

def create(self, vals):

 if 'name' in vals and len(vals['name']) < 3:

raise ValidationError("Name must be at least 3 characters long.")


  return super(CustomModel, self).create(vals)


def write(self, vals):

if 'name' in vals and len(vals['name']) < 3:

raise ValidationError("Name must be at least 3 characters long.")

return super(CustomModel, self).write(vals)

Examples of Common Validation Scenarios

1. Email Format Validation:

​ ​You can validate that an email address is in the correct format using a regular ​ ​ ​ ​expression.

Example:

import re

@api.constrains('email')

def _check_email_format(self):

 email_regex = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

  for record in self:

 if record.email and not re.match(email_regex, record.email):

raise ValidationError("Invalid email format.")

2. Date Validation:

​ ​ ​Ensure that a start date is not in the past or that an end date is not earlier than a ​ ​ ​start date.

Example:

@api.constrains('start_date')

def _check_start_date(self):
	​for record in self:
	​	​if record.start_date and record.start_date < fields.Date.today():
	​	​	​raise ValidationError("Start date cannot be in the past.")

By implementing required, unique, size, and domain constraints, as well as custom validation logic, developers can ensure that the data entered into the system is accurate and meets specific business requirements.