Made withOdooClip

How to Build a Custom Module in Odoo 16 | Odoo 16 Development Tutorials | Odoo 16 Videos

C

Cybrosys Technologies

Creator on the Odoo channel

Watch on YouTube ↗

69K viewsAug 9, 202210:51 runtime

Learn to build a custom module from scratch in Odoo 16 with this step-by-step development tutorial. This guide covers the essential structure of an Odoo module, including creating models for business objects, defining views with XML for the user interface, and setting up access…

Chapters

#odoo#clip#cmscrm

Key Concepts of an Odoo Module

An Odoo module is a set of business logic that either enhances existing Odoo functionality or adds new features.
Modules are the fundamental building blocks for customizing Odoo.

Building the 'School Management' Module

This tutorial walks through creating a custom module to manage student records.

Important
All custom modules should be placed in a separate directory (e.g., custom_addons), and this directory's path must be added to the addons_path in your odoo.conf file.

1. Directory & File Structure

A typical module contains several standard directories and files:

__init__.py: A required file that marks the directory as a Python package. It's used to import sub-packages (like the models directory).
__manifest__.py: Contains metadata about the module, such as its name, version, dependencies, and data files. This file is essential for Odoo to recognize and display the module in the Apps list.
models/: This directory holds the Python files that define the module's business objects (database models).
- models/__init__.py: Imports all the model files within the directory.
- models/school.py: Defines the school.student model.
views/: Contains XML files that define how the data is displayed in the user interface, including menus, actions, forms, and list views.
- views/school.xml: Defines the UI for the School Management module.
security/: This directory is used to manage access rights.
- security/ir.model.access.csv: A CSV file that defines which user groups can perform read, write, create, and delete operations on a model.
Other Directories:
- wizard/: For creating transient models that appear as pop-up windows.
- report/: For defining PDF reports and their templates.
- data/: For loading initial or necessary data.
- demo/: For loading demonstration data.
- controllers/: For managing frontend and backend web routes and actions.

2. The Model (`school.py`)

The model defines the data structure and business logic.

The school.student model is created by inheriting from models.Model.
The _name attribute is crucial as it defines the unique name of the model in the Odoo database (e.g., _name = 'school.student').
Fields are defined as class attributes using the fields API.

3. The View (`school.xml`)

The view defines the user interface elements. The XML file typically contains:

Menu Items (ir.ui.menu): To create new menus in the Odoo navigation bar.
Actions (ir.actions.act_window): To define what happens when a menu is clicked, specifying the target model and views.
Views (ir.ui.view): To structure the layout of forms, lists (trees), and other view types for a model.

4. Security (`ir.model.access.csv`)

Access control is mandatory for models to be usable by non-admin users.

The CSV file defines access rules for each model.
Columns: id, name, model_id:id, group_id:id, perm_read, perm_write, perm_create, perm_unlink.
The model_id uses the format model_<model_name_with_underscores> (e.g., model_school_student).
Permissions are set using 1 for True or 0 for False.
Example: Granting full access to internal users (base.group_user).

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink access_school_student,access.student,model_school_student,base.group_user,1,1,1,1


### 5. The Manifest File (`__manifest__.py`)

This file acts as the module's "ID card."

*   **`name`**: The human-readable name of the module.
*   **`summary`**: A short tagline describing the module's purpose.
*   **`version`**: The module version.
*   **`depends`**: A list of other modules that this module depends on.
*   **`data`**: A list of XML and CSV files to be loaded, in order. This must include security files and view files.
    ```python
    'data': [
        'security/ir.model.access.csv',
        'views/school.xml',
    ],
    ```
*   **`installable` & `application`**: Set to `True` to make the module installable as a main application.

## Installation Process

1.  Add the path to your custom modules folder (e.g., `custom_addons`) to the `addons_path` in your `odoo.conf` file.
2.  Restart the Odoo server.
3.  Go to the Odoo UI and activate Developer Mode.
4.  Navigate to **Apps** and click **Update Apps List**.
5.  Search for your module by its name (e.g., "School Management").
6.  Click **Install**.

Introduction to Odoo Modules

Hi all, welcome back to Odoo 16 development tutorials. In this video, let us check building a module in Odoo 16.

As we all know, Odoo is basically a web-based open-source framework which acts as a solution for all business requirements. An Odoo module is a set of business logic which helps to enhance the existing functionality or to add some new functionality in Odoo. So in this video, let's check how to create a custom module, School Management, in Odoo 16.

Setting Up the Project in PyCharm

For that, let's go to the PyCharm. So in the PyCharm, in the Odoo 16 folder, I am just creating a custom directory and giving its name as custom_addons.

And inside this directory custom_addons, I can create the modules that I needed and then I can add its path, as its path location is along with the addons path in the odoo.conf. So I'm just creating a new directory that is school_management. And this module helps to create the records of student admission in a school.

Essential Python Files: init and manifest

And then inside the school management, I am just creating the python file __init__.py, and which is the python module discriminator file where we can load the python packages that are needed for this module, school management.

And the next important python file that is needed is the manifest file, which is the metadata of the module. And this file helps to show the module name on the Odoo app list. And then the next is models.

Creating the Model and Fields

The models directory can be used to create business objects. That means we can add new business objects or we can inherit the current business object that is in the default Odoo.

So in the models folder, I am just creating the python file __init__.py, which helps to load the python files that are used in the models. Normally the business objects are created using the .py python files. And then the next python file I'm just creating is school.py.

And then here I can create the business object that is needed for my business logic or I can inherit other objects in the default Odoo. So I'm just importing from odoo import models that I need to define, comma fields.

And then I am just defining a new model, class School, and then models.Model. And then giving its name as school.student. And this is the name that I am giving for this particular business object. And then here we can define the fields that we needed to be shown on the school.student model. So I am just adding the field as name that is fields.Char, then class, and division. And if we need to add further more fields, we can add it along with the school.student business object.

Defining Views with XML

Then about the object views. Object views can be created under the views directory. So inside the school management module, I am just creating the directory views. Here I can create the object views, that means which contains the business objects in the UI. So I can create the .xml files. So I am just creating a school.xml file.

And inside this file, I can create the menu item of the school that I needed, and the actions, and the views that I needed for the school management module. And in the views/school.xml file where I can create the object views, and here I defined the menu item as school menu, and then the subsequent menu, school exams menu, with the parent of school menu and its action, and then a basic view of a form for that particular model. Likewise, whatever the objects that we need to see on the UI can be defined at here.

Configuring Security and Access Rights

Then about the next thing, that is security files. From here, we can create a directory as security. And then here we can define the access rights, and then we can give the access for each user on each model.

Here we can create ir.model.access.csv files. Here we can define the id, name, model_id, group_id, perm_read, perm_write, perm_create, and perm_unlink for each user. So for example, for our school.student model, I am just creating the ID as access_school_student. And then its name as access student. And its model name as model_school_student. And for which users? So I'm just defining it as base.group_user as a normal internal user. Then we can add its permission for write, read, create and unlink. Currently for this user, I am giving the full permission, so I add it as everything as 1. And then using these CSV files would help us to create the access rights for each user on each model. And also if we need to create some access restrictions, also can be created under this security file.

Overview of Optional Module Directories

Then next type of files that are inside a module, that is wizard files. If we need to create some pop-up windows for a particular function, then we can create the wizard directory. And inside this wizard directory, we can create an __init__.py python file and a subsequent wizard.py python file, and the __init__.py python file loads the python files that are created inside the wizard folder.

Then the next type of files in the module, that is report files. If you need to create some particular reports based on our module functionality, we can create those reports inside this report folder. We can create an __init__.py python file, which loads the python files that are used inside this report folder. And if you're using corresponding templates, those templates also can be created under this report file.

If you need to load some data along with the module installation, the data can be included in this data folder. And then if you need to load some demo data while we are installing this module, those demo data also can be added inside this demo folder.

And the controllers folder which helps to manage the frontend and backend actions.

Completing the Manifest File

Then moving to the manifest. A manifest which is the metadata of the module, and it has some required fields. name: we need to add a name for the module. And the summary: a short summary regarding the functionality of the module. And then the description, and then the author, website, category under which category this module is working. And then its version, and this version is based on the semantic versioning rule.

And then depends. If this module's functionality depends on any other modules of Odoo, or if in this module you are inheriting some functionality in the default Odoo, those dependent modules can be added here. And then the data file. Here inside the data key, you load the data files that are used inside this module. And then here I loaded the security file and then the views/school.xml.

And then if you are creating some demo files along with the demo data, those demo files can be loaded here. And then we need to keep it as installable=True, application=True, and auto_install=False.

Installing and Testing the Module

And then let's go to the odoo.conf and then give the path of this custom_addons along with the addons path in the odoo.conf and then run the PyCharm.

Let's go to the UI. And in the UI, let's go to the Apps. And here in the Apps, let's update the app list, and then apply scheduled upgrades. And then search for our module, School Management.

And if we added the manifest, then only this module is shown on the Odoo app list. And then let's click on the install. Then our module is successfully installed. Then go to our School, and our menu School, and from here we can create the records of students. And then here we can choose the class and then the particular division. Likewise, we can create similar student records using this module. Likewise, we can build a custom module in Odoo 16 using the models, views, security, and then the manifest and init file in Odoo.