Creating a basic module

In Odoo, tasks are performed by creating modules.

Modules customize the behavior of an Odoo installation, either by adding new behaviors or by altering existing ones (including behaviors added by other modules).

Odoo's scaffolding can setup a basic module. To quickly get started simply invoke:

$ ./odoo.py scaffold Academy my-modules
                    

This will automatically create a my-modules module directory with an academy module inside. The directory can be an existing module directory if you want, but the module name must be unique within the directory.

A demonstration module

We have a "complete" module ready for installation.

Although it does absolutely nothing we can install it:

• start the Odoo server

  $ ./odoo.py --addons-path addons,my-modules
                      

• go to http://localhost:8069
• create a new database including demonstration data
• to go Settings ‣ Modules ‣ Modules
• in the top-right corner remove the Installed filter and search for academy
• click the Install button for the Academy module

To the browser

Controllers interpret browser requests and send data back.

Add a simple controller and ensure it is imported by __init__.py (so Odoo can find it):

# -*- coding: utf-8 -*-
                    from openerp import http
                    
                    class Academy(http.Controller):
                        @http.route('/academy/academy/', auth='public')
                        def index(self, **kw):
                            return "Hello, world"
                    
                    #     @http.route('/academy/academy/objects/', auth='public')
                    #     def list(self, **kw):
                    

Shut down your server (^C) then restart it:

$ ./odoo.py --addons-path addons,my-modules
                    

and open a page to http://localhost:8069/academy/academy/, you should see your "page" appear:

Templates

Generating HTML in Python isn't very pleasant.

The usual solution is templates, pseudo-documents with placeholders and display logic. Odoo allows any Python templating system, but provides its own QWeb templating system which integrates with other features.

Create a template and ensure the template file is registered in the __openerp__.py manifest, and alter the controller to use our template:

class Academy(http.Controller):
                        @http.route('/academy/academy/', auth='public')
                        def index(self, **kw):
                            return http.request.render('academy.index', {
                                'teachers': ["Diana Padilla", "Jody Caroll", "Lester Vaughn"],
                            })
                    
                    #     @http.route('/academy/academy/objects/', auth='public')
                    #     def list(self, **kw):
                    

                        
                             id="index">
                                
                                 t-foreach="teachers" t-as="teacher">
                                  
 t-esc="teacher"/>
                                
                            
                            
                            
                            
                    

The templates iterates (t-foreach) on all the teachers (passed through the template context), and prints each teacher in its own paragraph.

Finally restart Odoo and update the module's data (to install the template) by going to Settings ‣ Modules ‣ Modules ‣ Academy and clicking Upgrade.

$ odoo.py --addons-path addons,my-modules -d academy -u academy
                    

Going to http://localhost:8069/academy/academy/ should now result in:

Storing data in Odoo

Odoo models map to database tables.

In the previous section we just displayed a list of string entered statically in the Python code. This doesn't allow modifications or persistent storage so we'll now move our data to the database.

Defining the data model

Define a teacher model, and ensure it is imported from __init__.py so it is correctly loaded:

                    from openerp import models, fields, api
                    
                    class Teachers(models.Model):
                        _name = 'academy.teachers'
                    
                        name = fields.Char()
                    

Then setup basic access control for the model and add them to the manifest:

                        # always loaded
                        'data': [
                            'security/ir.model.access.csv',
                            'templates.xml',
                        ],
                        # only loaded in demonstration mode
                    

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
                    access_academy_teachers,access_academy_teachers,model_academy_teachers,,1,0,0,0
                    

this simply gives read access (perm_read) to all users (group_id:id left empty).

Demonstration data

The second step is to add some demonstration data to the system so it's possible to test it easily. This is done by adding a demo data file, which must be linked from the manifest:

                        
                             id="padilla" model="academy.teachers">
                                 name="name">Diana Padilla
                            
                             id="carroll" model="academy.teachers">
                                 name="name">Jody Carroll
                            
                             id="vaughn" model="academy.teachers">
                                 name="name">Lester Vaughn
                            
                        
                    
                    

Accessing the data

The last step is to alter model and template to use our demonstration data:

1. fetch the records from the database instead of having a static list
2. Because search() returns a set of records matching the filter ("all records" here), alter the template to print each teacher's name

class Academy(http.Controller):
                        @http.route('/academy/academy/', auth='public')
                        def index(self, **kw):
                            Teachers = http.request.env['academy.teachers']
                            return http.request.render('academy.index', {
                                'teachers': Teachers.search([])
                            })
                    
                    #     @http.route('/academy/academy/objects/', auth='public')
                    

         id="index">
                                
                                 t-foreach="teachers" t-as="teacher">
                                    
 t-esc="teacher.id"/>  t-esc="teacher.name"/>
                                
                            
                            
                    

Restart the server and update the module (in order to update the manifest and templates and load the demo file) then navigate to http://localhost:8069/academy/academy/. The page should look slightly different: names should simply be prefixed by a number (the database identifier for the teacher).

Website support

Odoo bundles a module dedicated to building websites.

So far we've used controllers fairly directly, but Odoo 8 added deeper integration and a few other services (e.g. default styling, theming) via the website module.

1. first, add website as a dependency to academy
2. then add the website=True flag on the controller, this sets up a few new variables on the request object and allows using the website layout in our template
3. use the website layout in the template

    'version': '0.1',
                    
                        # any module necessary for this one to work correctly
                        'depends': ['website'],
                    
                        # always loaded
                        'data': [
                    

from openerp import http
                    
                    class Academy(http.Controller):
                        @http.route('/academy/academy/', auth='public', website=True)
                        def index(self, **kw):
                            Teachers = http.request.env['academy.teachers']
                            return http.request.render('academy.index', {
                    

                        
                             id="index">
                                 t-call="website.layout">
                                     t-set="title">Academy
                                     class="oe_structure">
                                         class="container">
                                             t-foreach="teachers" t-as="teacher">
                                                
 t-esc="teacher.id"/>  t-esc="teacher.name"/>