ODOOV8

Building a Module

Start/Stop the Odoo server

Odoo uses a client/server architecture in which clients are web browsers accessing the Odoo server via RPC.

Business logic and extension is generally performed on the server side, although supporting client features (e.g. new data representation such as interactive maps) can be added to the client.

In order to start the server, simply invoke the command odoo.py in the shell, adding the full path to the file if necessary:

 
    odoo.py

The server is stopped by hitting Ctrl-C twice from the terminal, or by killing the corresponding OS process.

Build an Odoo module

Both server and client extensions are packaged as modules which are optionally loaded in a database.

Odoo modules can either add brand new business logic to an Odoo system, or alter and extend existing business logic: a module can be created to add your country's accounting rules to Odoo's generic accounting support, while the next module adds support for real-time visualisation of a bus fleet.

Everything in Odoo thus starts and ends with modules.

Composition of a module

An Odoo module can contain a number of elements:

Business objects: declared as Python classes, these resources are automatically persisted by Odoo based on their configuration
Data files: XML or CSV files declaring metadata (views or workflows), configuration data (modules parameterization), demonstration data and more
Web controllers: Handle requests from web browsers
Static web data: Images, CSS or javascript files used by the web interface or website

Module structure

Each module is a directory within a module directory. Module directories are specified by using the --addons-path option.

Tip

most command-line options can also be set using a configuration file

An Odoo module is declared by its manifest. See the manifest documentation information about it.

A module is also a Python package with a __init__.py file, containing import instructions for various Python files in the module.

For instance, if the module has a single mymodule.py file __init__.py might contain:

 
    from . import mymodule

Odoo provides a mechanism to help set up a new module, odoo.py has a subcommand scaffold to create an empty module:

$ odoo.py scaffold

The command creates a subdirectory for your module, and automatically creates a bunch of standard files for a module. Most of them simply contain commented code or XML. The usage of most of those files will be explained along this tutorial.

Exercise

Module creation

Use the command line above to create an empty module Open Academy, and install it in Odoo.

Invoke the command odoo.py scaffold openacademy addons.
Adapt the manifest file to your module.
Don't bother about the other files.

openacademy/__openerp__.py

 
       # -*- coding: utf-8 -*-
{
    'name': "Open Academy",

    'summary': """Manage trainings""",

    'description': """
        Open Academy module for managing trainings:
            - training courses
            - training sessions
            - attendees registration
    """,

    'author': "My Company",
    'website': "http://www.yourcompany.com",

    # Categories can be used to filter modules in modules listing
    # Check https://github.com/odoo/odoo/blob/master/openerp/addons/base/module/module_data.xml
    # for the full list
    'category': 'Test',
    'version': '0.1',

    # any module necessary for this one to work correctly
    'depends': ['base'],

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

openacademy/__init__.py

 
       # -*- coding: utf-8 -*-
from . import controllers
from . import models

openacademy/controllers.py

 
       # -*- coding: utf-8 -*-
from openerp import http

# class Openacademy(http.Controller):
#     @http.route('/openacademy/openacademy/', auth='public')
#     def index(self, **kw):
#         return "Hello, world"

#     @http.route('/openacademy/openacademy/objects/', auth='public')
#     def list(self, **kw):
#         return http.request.render('openacademy.listing', {
#             'root': '/openacademy/openacademy',
#             'objects': http.request.env['openacademy.openacademy'].search([]),
#         })

#     @http.route('/openacademy/openacademy/objects//', auth='public')
#     def object(self, obj, **kw):
#         return http.request.render('openacademy.object', {
#             'object': obj
#         })
 
      

openacademy/demo.xml

openacademy/models.py

 
       # -*- coding: utf-8 -*-

from openerp import models, fields, api

# class openacademy(models.Model):
#     _name = 'openacademy.openacademy'

#     name = fields.Char()

openacademy/security/ir.model.access.csv

 
       id,name,model_id/id,group_id/id,perm_read,perm_write,perm_create,perm_unlink
access_openacademy_openacademy,openacademy.openacademy,model_openacademy_openacademy,,1,0,0,0

openacademy/templates.xml

Object-Relational Mapping

A key component of Odoo is the ORM layer. This layer avoids having to write most SQL by hand and provides extensibility and security services2.

Business objects are declared as Python classes extending Model which integrates them into the automated persistence system.

Models can be configured by setting a number of attributes at their definition. The most important attribute is _name which is required and defines the name for the model in the Odoo system. Here is a minimally complete definition of a model:

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

Model fields

Fields are used to define what the model can store and where. Fields are defined as attributes on the model class:

 
    from openerp import models, fields

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

    name = fields.Char()

Common Attributes

Much like the model itself, its fields can be configured, by passing configuration attributes as parameters:

 
    name = field.Char(required=True)

Some attributes are available on all fields, here are the most common ones:

string ( unicode, default: field's name): The label of the field in UI (visible by users).
required ( bool, default: False): If True, the field can not be empty, it must either have a default value or always be given a value when creating a record.
help ( unicode, default: ''): Long-form, provides a help tooltip to users in the UI.
index ( bool, default: False): Requests that Odoo create a database index on the column

Simple fields

There are two broad categories of fields: "simple" fields which are atomic values stored directly in the model's table and "relational" fields linking records (of the same model or of different models).

Example of simple fields are Boolean, Date, Char.

Reserved fields

Odoo creates a few fields in all models1. These fields are managed by the system and shouldn't be written to. They can be read if useful or necessary:

id ( Id): the unique identifier for a record in its model
create_date ( Datetime): creation date of the record
create_uid ( Many2one): user who created the record
write_date ( Datetime): last modification date of the record
write_uid ( Many2one): user who last modified the record

Special fields

By default, Odoo also requires a name field on all models for various display and search behaviors. The field used for these purposes can be overridden by setting _rec_name.

Exercise

Define a model

Define a new data model Course in the openacademy module. A course has a title and a description. Courses must have a title.

Edit the file openacademy/models/models.py to include a Course class.

openacademy/models.py

 
from openerp import models, fields, api

class Course(models.Model):
    _name = 'openacademy.course'

    name = fields.Char(string="Title", required=True)
    description = fields.Text()

Data files

Odoo is a highly data driven system. Although behavior is customized using Python code part of a module's value is in the data it sets up when loaded.

Tip

some modules exist solely to add data into Odoo

Module data is declared via data files, XML files with elements. Each element creates or updates a database record.

 
         model="{model name}" id="{record identifier}">
             name="{a field name}">{a value}

model is the name of the Odoo model for the record
id is an external identifier, it allows referring to the record (without having to know its in-database identifier)
elements have a name which is the name of the field in the model (e.g. description). Their body is the field's value.

Data files have to be declared in the manifest file to be loaded, they can be declared in the 'data' list (always loaded) or in the 'demo' list (only loaded in demonstration mode).

Exercise

Define demonstration data

Create demonstration data filling the Courses model with a few demonstration courses.

Edit the file openacademy/demo/demo.xml to include some data.

openacademy/demo.xml

 
         model="openacademy.course" id="course0">
             name="name">Course 0
             name="description">Course 0's description

Can have multiple lines
            
         model="openacademy.course" id="course1">
             name="name">Course 1
            
         model="openacademy.course" id="course2">
             name="name">Course 2
             name="description">Course 2's description

Actions and Menus

Actions and menus are regular records in database, usually declared through data files. Actions can be triggered in three ways:

by clicking on menu items (linked to specific actions)
by clicking on buttons in views (if these are connected to actions)
as contextual actions on object

Because menus are somewhat complex to declare there is a shortcut to declare an ir.ui.menu and connect it to the corresponding action more easily.

 
     model="ir.actions.act_window" id="action_list_ideas">
     name="name">Ideas
     name="res_model">idea.idea
     name="view_mode">tree,form

 id="menu_ideas" parent="menu_root" name="Ideas" sequence="10"
          action="action_list_ideas"/>
 
   

Danger

The action must be declared before its corresponding menu in the XML file.

Data files are executed sequentially, the action's id must be present in the database before the menu can be created.

Exercise

Define new menu entries

Define new menu entries to access courses under the OpenAcademy menu entry. A user should be able to

display a list of all the courses
create/modify courses

Create openacademy/views/openacademy.xml with an action and the menus triggering the action
Add it to the data list of openacademy/__openerp__.py

openacademy/__openerp__.py

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

openacademy/views/openacademy.xml



    
        
        
         model="ir.actions.act_window" id="course_list_action">
             name="name">Courses
             name="res_model">openacademy.course
             name="view_type">form
             name="view_mode">tree,form
             name="help" type="html">
                 class="oe_view_nocontent_create">Create the first course
                
            
        

        
         id="main_openacademy_menu" name="Open Academy"/>
        
         id="openacademy_menu" name="Open Academy"
                  parent="main_openacademy_menu"/>
        
         id="courses_menu" name="Courses" parent="openacademy_menu"
                  action="course_list_action"/>

Basic views

Views define the way the records of a model are displayed. Each type of view represents a mode of visualization (a list of records, a graph of their aggregation, …). Views can either be requested generically via their type (e.g. a list of partners) or specifically via their id. For generic requests, the view with the correct type and the lowest priority will be used (so the lowest-priority view of each type is the default view for that type).

View inheritance allows altering views declared elsewhere (adding or removing content).

Generic view declaration

A view is declared as a record of the model ir.ui.view. The view type is implied by the root element of the arch field:

 
     model="ir.ui.view" id="view_id">
     name="name">view.name
     name="model">object_name
     name="priority" eval="16"/>
     name="arch" type="xml">

Danger

The view's content is XML.

The arch field must thus be declared as type="xml" to be parsed correctly.

Tree views

Tree views, also called list views, display records in a tabular form.

Their root element is . The simplest form of the tree view simply lists all the fields to display in the table (each field as a column):

 
     string="Idea list">
     name="name"/>
     name="inventor_id"/>

Form views

Forms are used to create and edit single records.

Their root element is

Exercise

Customise form view using XML

Create your own form view for the Course object. Data displayed should be: the name and the description of the course.

openacademy/views/openacademy.xml

 
         model="ir.ui.view" id="course_form_view">
             name="name">course.form
             name="model">openacademy.course
             name="arch" type="xml">
                 string="Course Form">
                    
                             name="name"/>
                             name="description"/>
                        
         model="ir.ui.view" id="session_form_view">
             name="name">session.form
             name="model">openacademy.session
             name="arch" type="xml">
                 string="Session Form">
                    
                             name="name"/>
                             name="start_date"/>
                             name="duration"/>
                             name="seats"/>
                        
         model="ir.actions.act_window" id="session_list_action">
             name="name">Sessions
             name="res_model">openacademy.session
             name="view_type">form
             name="view_mode">tree,form
        
         id="session_menu" name="Sessions"
                  parent="openacademy_menu"
                  action="session_list_action"/>

Note

digits=(6, 2) specifies the precision of a float number: 6 is the total number of digits, while 2 is the number of digits after the comma. Note that it results in the number digits before the comma is a maximum 4

Relational fields

Relational fields link records, either of the same model (hierarchies) or between different models.

Relational field types are:

Many2one(other_model, ondelete='set null')

A simple link to an other object:

 
      print foo.other_id.name

Inheritance

Model inheritance

Odoo provides two inheritance mechanisms to extend an existing model in a modular way.

The first inheritance mechanism allows a module to modify the behavior of a model defined in another module:

add fields to a model,
override the definition of fields on a model,
add constraints to a model,
add methods to a model,
override existing methods on a model.

The second inheritance mechanism (delegation) allows to link every record of a model to a record in a parent model, and provides transparent access to the fields of the parent record.

View inheritance

Instead of modifying existing views in place (by overwriting them), Odoo provides view inheritance where children "extension" views are applied on top of root views, and can add or remove content from their parent.

An extension view references its parent using the inherit_id field, and instead of a single view its arch field is composed of any number of xpath elements selecting and altering the content of their parent view:

 
 id="idea_category_list2" model="ir.ui.view">
     name="name">id.category.list2
     name="model">idea.category
     name="inherit_id" ref="id_category_list"/>
     name="arch" type="xml">
        
         expr="//field[@name='description']" position="after">
           name="idea_ids" string="Number of ideas"/>

expr

An XPath expression selecting a single element in the parent view. Raises an error if it matches no element or more than one

position

Operation to apply to the matched element:

inside: appends xpath's body at the end of the matched element
replace: replaces the matched element by the xpath's body
before: inserts the xpath's body as a sibling before the matched element
after: inserts the xpaths's body as a sibling after the matched element
attributes: alters the attributes of the matched element using special attribute elements in the xpath's body

Tip

When matching a single element, the position attribute can be set directly on the element to be found. Both inheritances below will give the same result.

 
      expr="//field[@name='description']" position="after">
     name="idea_ids" />

 name="description" position="after">
     name="idea_ids" />

Exercise

Alter existing content

Using model inheritance, modify the existing Partner model to add an instructor boolean field, and a many2many field that corresponds to the session-partner relation
Using view inheritance, display this fields in the partner form view

Note

This is the opportunity to introduce the developer mode to inspect the view, find its external ID and the place to put the new field.

Create a file openacademy/models/partner.py and import it in __init__.py
Create a file openacademy/views/partner.xml and add it to __openerp__.py

openacademy/__init__.py

 
       # -*- coding: utf-8 -*-
from . import controllers
from . import models
from . import partner

openacademy/__openerp__.py

 
               # 'security/ir.model.access.csv',
        'templates.xml',
        'views/openacademy.xml',
        'views/partner.xml',
    ],
    # only loaded in demonstration mode
    'demo': [
 
      

openacademy/partner.py

 
       # -*- coding: utf-8 -*-
from openerp import fields, models

class Partner(models.Model):
    _inherit = 'res.partner'

    # Add a new column to the res.partner model, by default partners are not
    # instructors
    instructor = fields.Boolean("Instructor", default=False)

    session_ids = fields.Many2many('openacademy.session',
        string="Attended Sessions", readonly=True)
 
      

openacademy/views/partner.xml

 
         model="ir.ui.view" id="partner_instructor_form_view">
             name="name">partner.instructor
             name="model">res.partner
             name="inherit_id" ref="base.view_partner_form"/>
             name="arch" type="xml">
                 position="inside">
                     string="Sessions">
                        
                             name="instructor"/>
                             name="session_ids"/>
                        
         model="ir.actions.act_window" id="contact_list_action">
             name="name">Contacts
             name="res_model">res.partner
             name="view_mode">tree,form
        
         id="configuration_menu" name="Configuration"
                  parent="main_openacademy_menu"/>
         id="contact_menu" name="Contacts"
                  parent="configuration_menu"
                  action="contact_list_action"/>

Domains

In Odoo, Domains are values that encode conditions on records. A domain is a list of criteria used to select a subset of a model's records. Each criteria is a triple with a field name, an operator and a value.

For instance, when used on the Product model the following domain selects all services with a unit price over 1000:

 
    [('product_type', '=', 'service'), ('unit_price', '>', 1000)]

By default criteria are combined with an implicit AND. The logical operators & (AND), | (OR) and ! (NOT) can be used to explicitly combine criteria. They are used in prefix position (the operator is inserted before its arguments rather than between). For instance to select products "which are services OR have a unit price which is NOT between 1000 and 2000":

 
    ['|',
    ('product_type', '=', 'service'),
    '!', '&',
        ('unit_price', '>=', 1000),
        ('unit_price', '<', 2000)]
 
   

A domain parameter can be added to relational fields to limit valid records for the relation when trying to select records in the client interface.

Exercise

Domains on relational fields

When selecting the instructor for a Session, only instructors (partners with instructor set to True) should be visible.

openacademy/models.py

 
           duration = fields.Float(digits=(6, 2), help="Duration in days")
    seats = fields.Integer(string="Number of seats")

    instructor_id = fields.Many2one('res.partner', string="Instructor",
        domain=[('instructor', '=', True)])
    course_id = fields.Many2one('openacademy.course',
        ondelete='cascade', string="Course", required=True)
    attendee_ids = fields.Many2many('res.partner', string="Attendees")
 
      

Note

A domain declared as a literal list is evaluated server-side and can't refer to dynamic values on the right-hand side, a domain declared as a string is evaluated client-side and allows field names on the right-hand side

Exercise

More complex domains

Create new partner categories Teacher / Level 1 and Teacher / Level 2. The instructor for a session can be either an instructor or a teacher (of any level).

Modify the Session model's domain
Modify openacademy/view/partner.xml to get access to Partner categories:

openacademy/models.py

 
           seats = fields.Integer(string="Number of seats")

    instructor_id = fields.Many2one('res.partner', string="Instructor",
        domain=['|', ('instructor', '=', True),
                     ('category_id.name', 'ilike', "Teacher")])
    course_id = fields.Many2one('openacademy.course',
        ondelete='cascade', string="Course", required=True)
    attendee_ids = fields.Many2many('res.partner', string="Attendees")
 
      

openacademy/views/partner.xml

 
                id="contact_menu" name="Contacts"
                  parent="configuration_menu"
                  action="contact_list_action"/>

         model="ir.actions.act_window" id="contact_cat_list_action">
             name="name">Contact Tags
             name="res_model">res.partner.category
             name="view_mode">tree,form
        
         id="contact_cat_menu" name="Contact Tags"
                  parent="configuration_menu"
                  action="contact_cat_list_action"/>

         model="res.partner.category" id="teacher1">
             name="name">Teacher / Level 1
        
         model="res.partner.category" id="teacher2">
             name="name">Teacher / Level 2

Computed fields and default values

So far fields have been stored directly in and retrieved directly from the database. Fields can also be computed. In that case, the field's value is not retrieved from the database but computed on-the-fly by calling a method of the model.

To create a computed field, create a field and set its attribute compute to the name of a method. The computation method should simply set the value of the field to compute on every record in self.

Danger

self is a collection

The object self is a recordset, i.e., an ordered collection of records. It supports the standard Python operations on collections, like len(self) and iter(self), plus extra set operations like recs1 + recs2.

Iterating over self gives the records one by one, where each record is itself a collection of size 1. You can access/assign fields on single records by using the dot notation, like record.name.

 
    import random
from openerp import models, fields, api

class ComputedModel(models.Model):
    _name = 'test.computed'

    name = fields.Char(compute='_compute_name')

    @api.multi
    def _compute_name(self):
        for record in self:
            record.name = str(random.randint(1, 1e6))
 
   

Dependencies

The value of a computed field usually depends on the values of other fields on the computed record. The ORM expects the developer to specify those dependencies on the compute method with the decorator depends(). The given dependencies are used by the ORM to trigger the recomputation of the field whenever some of its dependencies have been modified:

 
    from openerp import models, fields, api

class ComputedModel(models.Model):
    _name = 'test.computed'

    name = fields.Char(compute='_compute_name')
    value = fields.Integer()

    @api.depends('value')
    def _compute_name(self):
        for record in self:
            record.name = "Record with value %s" % record.value
 
   

Exercise

Computed fields

Add the percentage of taken seats to the Session model
Display that field in the tree and form views
Display the field as a progress bar

Add a computed field to Session
Show the field in the Session view:

openacademy/models.py

 
           course_id = fields.Many2one('openacademy.course',
        ondelete='cascade', string="Course", required=True)
    attendee_ids = fields.Many2many('res.partner', string="Attendees")

    taken_seats = fields.Float(string="Taken seats", compute='_taken_seats')

    @api.depends('seats', 'attendee_ids')
    def _taken_seats(self):
        for r in self:
            if not r.seats:
                r.taken_seats = 0.0
            else:
                r.taken_seats = 100.0 * len(r.attendee_ids) / r.seats
 
      

openacademy/views/openacademy.xml

 
                                        name="start_date"/>
                                 name="duration"/>
                                 name="seats"/>
                                 name="taken_seats" widget="progressbar"/>
                            
                         for="attendee_ids"/>

 
                        string="Session Tree">
                     name="name"/>
                     name="course_id"/>
                     name="taken_seats" widget="progressbar"/>

Default values

Any field can be given a default value. In the field definition, add the option default=X where X is either a Python literal value (boolean, integer, float, string), or a function taking a recordset and returning a value:

 
    name = fields.Char(default="Unknown")
user_id = fields.Many2one('res.users', default=lambda self: self.env.user)

Note

The object self.env gives access to request parameters and other useful things:

self.env.cr or self._cr is the database cursor object; it is used for querying the database
self.env.uid or self._uid is the current user's database id
self.env.user is the current user's record
self.env.context or self._context is the context dictionary
self.env.ref(xml_id) returns the record corresponding to an XML id
self.env[model_name] returns an instance of the given model

Exercise

Active objects – Default values

Define the start_date default value as today (see Date).
Add a field active in the class Session, and set sessions as active by default.

openacademy/models.py

 
           _name = 'openacademy.session'

    name = fields.Char(required=True)
    start_date = fields.Date(default=fields.Date.today)
    duration = fields.Float(digits=(6, 2), help="Duration in days")
    seats = fields.Integer(string="Number of seats")
    active = fields.Boolean(default=True)

    instructor_id = fields.Many2one('res.partner', string="Instructor",
        domain=['|', ('instructor', '=', True),
 
      

openacademy/views/openacademy.xml

 
                                        name="course_id"/>
                                 name="name"/>
                                 name="instructor_id"/>
                                 name="active"/>
                            
                             string="Schedule">
                                 name="start_date"/>
 
      

Note

Odoo has built-in rules making fields with an active field set to Falseinvisible.

Onchange

The "onchange" mechanism provides a way for the client interface to update a form whenever the user has filled in a value in a field, without saving anything to the database.

For instance, suppose a model has three fields amount, unit_price and price, and you want to update the price on the form when any of the other fields is modified. To achieve this, define a method where self represents the record in the form view, and decorate it with onchange() to specify on which field it has to be triggered. Any change you make on selfwill be reflected on the form.

 
 name="amount"/>
 name="unit_price"/>
 name="price" readonly="1"/>

 
    # onchange handler
@api.onchange('amount', 'unit_price')
def _onchange_price(self):
    # set auto-changing field
    self.price = self.amount * self.unit_price
    # Can optionally return a warning and domains
    return {
        'warning': {
            'title': "Something bad happened",
            'message': "It was very bad indeed",
        }
    }
 
   

For computed fields, valued onchange behavior is built-in as can be seen by playing with the Session form: change the number of seats or participants, and the taken_seats progressbar is automatically updated.

Exercise

Warning

Add an explicit onchange to warn about invalid values, like a negative number of seats, or more participants than seats.

openacademy/models.py

 
                       r.taken_seats = 0.0
            else:
                r.taken_seats = 100.0 * len(r.attendee_ids) / r.seats

    @api.onchange('seats', 'attendee_ids')
    def _verify_valid_seats(self):
        if self.seats < 0:
            return {
                'warning': {
                    'title': "Incorrect 'seats' value",
                    'message': "The number of available seats may not be negative",
                },
            }
        if self.seats < len(self.attendee_ids):
            return {
                'warning': {
                    'title': "Too many attendees",
                    'message': "Increase seats or remove excess attendees",
                },
            }
 
      

Model constraints

Odoo provides two ways to set up automatically verified invariants: Python constraints and SQL constraints.

A Python constraint is defined as a method decorated with constrains(), and invoked on a recordset. The decorator specifies which fields are involved in the constraint, so that the constraint is automatically evaluated when one of them is modified. The method is expected to raise an exception if its invariant is not satisfied:

 
    from openerp.exceptions import ValidationError

@api.constrains('age')
def _check_something(self):
    for record in self:
        if record.age > 20:
            raise ValidationError("Your record is too old: %s" % record.age)
    # all records passed the test, don't return anything
 
   

Exercise

Add Python constraints

Add a constraint that checks that the instructor is not present in the attendees of his/her own session.

openacademy/models.py

 
       # -*- coding: utf-8 -*-

from openerp import models, fields, api, exceptions

class Course(models.Model):
    _name = 'openacademy.course'

 
                           'message': "Increase seats or remove excess attendees",
                },
            }

    @api.constrains('instructor_id', 'attendee_ids')
    def _check_instructor_not_in_attendees(self):
        for r in self:
            if r.instructor_id and r.instructor_id in r.attendee_ids:
                raise exceptions.ValidationError("A session's instructor can't be an attendee")
 
      

SQL constraints are defined through the model attribute _sql_constraints. The latter is assigned to a list of triples of strings (name, sql_definition, message), where name is a valid SQL constraint name, sql_definition is a table_constraint expression, and message is the error message.

Exercise

Add SQL constraints

With the help of PostgreSQL's documentation , add the following constraints:

CHECK that the course description and the course title are different
Make the Course's name UNIQUE

openacademy/models.py

 
           session_ids = fields.One2many(
        'openacademy.session', 'course_id', string="Sessions")

    _sql_constraints = [
        ('name_description_check',
         'CHECK(name != description)',
         "The title of the course should not be the description"),

        ('name_unique',
         'UNIQUE(name)',
         "The course title must be unique"),
    ]


class Session(models.Model):
    _name = 'openacademy.session'
 
      

Exercise

Exercise 6 - Add a duplicate option

Since we added a constraint for the Course name uniqueness, it is not possible to use the "duplicate" function anymore (Form ‣ Duplicate).

Re-implement your own "copy" method which allows to duplicate the Course object, changing the original name into "Copy of [original name]".

openacademy/models.py

 
           session_ids = fields.One2many(
        'openacademy.session', 'course_id', string="Sessions")

    @api.multi
    def copy(self, default=None):
        default = dict(default or {})

        copied_count = self.search_count(
            [('name', '=like', u"Copy of {}%".format(self.name))])
        if not copied_count:
            new_name = u"Copy of {}".format(self.name)
        else:
            new_name = u"Copy of {} ({})".format(self.name, copied_count)

        default['name'] = new_name
        return super(Course, self).copy(default)

    _sql_constraints = [
        ('name_description_check',
         'CHECK(name != description)',
 
      

Advanced Views

Tree views

Tree views can take supplementary attributes to further customize their behavior:

decoration-{$name}

allow changing the style of a row's text based on the corresponding record's attributes.

Values are Python expressions. For each record, the expression is evaluated with the record's attributes as context values and if true, the corresponding style is applied to the row. Other context values are uid (the id of the current user) and current_date (the current date as a string of the form yyyy-MM-dd).

{$name} can be bf (font-weight: bold), it (font-style: italic), or any bootstrap contextual color (danger,info, muted, primary, success or warning).

 
       string="Idea Categories" decoration-info="state=='draft'"
    decoration-danger="state=='trashed'">
     name="name"/>
     name="state"/>

editable

Either "top" or "bottom". Makes the tree view editable in-place (rather than having to go through the form view), the value is the position where new rows appear.

Exercise

List coloring

Modify the Session tree view in such a way that sessions lasting less than 5 days are colored blue, and the ones lasting more than 15 days are colored red.

Modify the session tree view:

openacademy/views/openacademy.xml

 
                    name="name">session.tree
             name="model">openacademy.session
             name="arch" type="xml">
                 string="Session Tree" decoration-info="duration<5" decoration-danger="duration>15">
                     name="name"/>
                     name="course_id"/>
                     name="duration" invisible="1"/>
                     name="taken_seats" widget="progressbar"/>
                
            
 
      

Calendars

Displays records as calendar events. Their root element is and their most common attributes are:

color: The name of the field used for color segmentation. Colors are automatically distributed to events, but events in the same color segment (records which have the same value for their @color field) will be given the same color.
date_start: record's field holding the start date/time for the event
date_stop (optional): record's field holding the end date/time for the event

field (to define the label for each calendar event)

 
     string="Ideas" date_start="invent_date" color="inventor_id">
     name="name"/>

Exercise

Calendar view

Add a Calendar view to the Session model enabling the user to view the events associated to the Open Academy.

Add an end_date field computed from start_date and duration

Tip

the inverse function makes the field writable, and allows moving the sessions (via drag and drop) in the calendar view
Add a calendar view to the Session model
And add the calendar view to the Session model's actions

openacademy/models.py

 
       # -*- coding: utf-8 -*-

from datetime import timedelta
from openerp import models, fields, api, exceptions

class Course(models.Model):

 
           attendee_ids = fields.Many2many('res.partner', string="Attendees")

    taken_seats = fields.Float(string="Taken seats", compute='_taken_seats')
    end_date = fields.Date(string="End Date", store=True,
        compute='_get_end_date', inverse='_set_end_date')

    @api.depends('seats', 'attendee_ids')
    def _taken_seats(self):

 
                       },
            }

    @api.depends('start_date', 'duration')
    def _get_end_date(self):
        for r in self:
            if not (r.start_date and r.duration):
                r.end_date = r.start_date
                continue

            # Add duration to start_date, but: Monday + 5 days = Saturday, so
            # subtract one second to get on Friday instead
            start = fields.Datetime.from_string(r.start_date)
            duration = timedelta(days=r.duration, seconds=-1)
            r.end_date = start + duration

    def _set_end_date(self):
        for r in self:
            if not (r.start_date and r.end_date):
                continue

            # Compute the difference between dates, but: Friday - Monday = 4 days,
            # so add one day to get 5 days instead
            start_date = fields.Datetime.from_string(r.start_date)
            end_date = fields.Datetime.from_string(r.end_date)
            r.duration = (end_date - start_date).days + 1

    @api.constrains('instructor_id', 'attendee_ids')
    def _check_instructor_not_in_attendees(self):
        for r in self:
 
      

openacademy/views/openacademy.xml

 
         model="ir.ui.view" id="session_calendar_view">
             name="name">session.calendar
             name="model">openacademy.session
             name="arch" type="xml">
                 string="Session Calendar" date_start="start_date"
                          date_stop="end_date"
                          color="instructor_id">
                     name="name"/>
                
         model="ir.actions.act_window" id="session_list_action">
             name="name">Sessions
             name="res_model">openacademy.session
             name="view_type">form
             name="view_mode">tree,form,calendar
        
         id="session_menu" name="Sessions"

Search views

Search view elements can have a @filter_domain that overrides the domain generated for searching on the given field. In the given domain, self represents the value entered by the user. In the example below, it is used to search on both fields name and description.

Search views can also contain elements, which act as toggles for predefined searches. Filters must have one of the following attributes:

domain: add the given domain to the current search
context: add some context to the current search; use the key group_by to group results on the given field name

 
     string="Ideas">
     name="name"/>
     name="description" string="Name and description"
           filter_domain="['|', ('name', 'ilike', self), ('description', 'ilike', self)]"/>
     name="inventor_id"/>
     name="country_id" widget="selection"/>

     name="my_ideas" string="My Ideas"
            domain="[('inventor_id', '=', uid)]"/>
     string="Group By">
         name="group_by_inventor" string="Inventor"
                context="{'group_by': 'inventor_id'}"/>
    

 
   

To use a non-default search view in an action, it should be linked using the search_view_id field of the action record.

The action can also set default values for search fields through its context field: context keys of the formsearch_default_field_name will initialize field_name with the provided value. Search filters must have an optional @name to have a default and behave as booleans (they can only be enabled by default).

Exercise

Search views

Add a button to filter the courses for which the current user is the responsible in the course search view. Make it selected by default.
Add a button to group courses by responsible user.

openacademy/views/openacademy.xml

 
                     name="name"/>
                     name="description"/>
                     name="my_courses" string="My Courses"
                            domain="[('responsible_id', '=', uid)]"/>
                     string="Group By">
                         name="by_responsible" string="Responsible"
                                context="{'group_by': 'responsible_id'}"/>

             name="res_model">openacademy.course
             name="view_type">form
             name="view_mode">tree,form
             name="context" eval="{'search_default_my_courses': 1}"/>
             name="help" type="html">
                 class="oe_view_nocontent_create">Create the first course

Gantt

Horizontal bar charts typically used to show project planning and advancement, their root element is .

 
     string="Ideas"
       date_start="invent_date"
       date_stop="date_finished"
       progress="progress"
       default_group_by="inventor_id" />
 
   

Exercise

Gantt charts

Add a Gantt Chart enabling the user to view the sessions scheduling linked to the Open Academy module. The sessions should be grouped by instructor.

Create a computed field expressing the session's duration in hours
Add the gantt view's definition, and add the gantt view to the Session model's action

openacademy/models.py

 
           end_date = fields.Date(string="End Date", store=True,
        compute='_get_end_date', inverse='_set_end_date')

    hours = fields.Float(string="Duration in hours",
                         compute='_get_hours', inverse='_set_hours')

    @api.depends('seats', 'attendee_ids')
    def _taken_seats(self):
        for r in self:

 
                   end_date = fields.Datetime.from_string(r.end_date)
            r.duration = (end_date - start_date).days + 1

    @api.depends('duration')
    def _get_hours(self):
        for r in self:
            r.hours = r.duration * 24

    def _set_hours(self):
        for r in self:
            r.duration = r.hours / 24

    @api.constrains('instructor_id', 'attendee_ids')
    def _check_instructor_not_in_attendees(self):
        for r in self:
 
      

openacademy/views/openacademy.xml

 
         model="ir.ui.view" id="session_gantt_view">
             name="name">session.gantt
             name="model">openacademy.session
             name="arch" type="xml">
                 string="Session Gantt" color="course_id"
                       date_start="start_date" date_delay="hours"
                       default_group_by='instructor_id'>
                     name="name"/>
                
         model="ir.actions.act_window" id="session_list_action">
             name="name">Sessions
             name="res_model">openacademy.session
             name="view_type">form
             name="view_mode">tree,form,calendar,gantt
        
         id="session_menu" name="Sessions"

Graph views

Graph views allow aggregated overview and analysis of models, their root element is .

Note

Pivot views (element ) a multidimensional table, allows the selection of filers and dimensions to get the right aggregated dataset before moving to a more graphical overview. The pivot view shares the same content definition as graph views.

Graph views have 4 display modes, the default mode is selected using the @type attribute.

Bar (default)

a bar chart, the first dimension is used to define groups on the horizontal axis, other dimensions define aggregated bars within each group.

By default bars are side-by-side, they can be stacked by using @stacked="True" on the

Line

2-dimensional line chart

Pie

2-dimensional pie

Graph views contain with a mandatory @type attribute taking the values:

row (default): the field should be aggregated by default
measure: the field should be aggregated rather than grouped on

 
     string="Total idea score by Inventor">
     name="inventor_id"/>
     name="score" type="measure"/>

Warning

Graph views perform aggregations on database values, they do not work with non-stored computed fields.

Exercise

Graph view

Add a Graph view in the Session object that displays, for each course, the number of attendees under the form of a bar chart.

Add the number of attendees as a stored computed field
Then add the relevant view

openacademy/models.py

 
           hours = fields.Float(string="Duration in hours",
                         compute='_get_hours', inverse='_set_hours')

    attendees_count = fields.Integer(
        string="Attendees count", compute='_get_attendees_count', store=True)

    @api.depends('seats', 'attendee_ids')
    def _taken_seats(self):
        for r in self:

 
               for r in self:
            r.duration = r.hours / 24

    @api.depends('attendee_ids')
    def _get_attendees_count(self):
        for r in self:
            r.attendees_count = len(r.attendee_ids)

    @api.constrains('instructor_id', 'attendee_ids')
    def _check_instructor_not_in_attendees(self):
        for r in self:
 
      

openacademy/views/openacademy.xml

 
         model="ir.ui.view" id="openacademy_session_graph_view">
             name="name">openacademy.session.graph
             name="model">openacademy.session
             name="arch" type="xml">
                 string="Participations by Courses">
                     name="course_id"/>
                     name="attendees_count" type="measure"/>
                
         model="ir.actions.act_window" id="session_list_action">
             name="name">Sessions
             name="res_model">openacademy.session
             name="view_type">form
             name="view_mode">tree,form,calendar,gantt,graph
        
         id="session_menu" name="Sessions"

Kanban

Used to organize tasks, production processes, etc… their root element is .

A kanban view shows a set of cards possibly grouped in columns. Each card represents a record, and each column the values of an aggregation field.

For instance, project tasks may be organized by stage (each column is a stage), or by responsible (each column is a user), and so on.

Kanban views define the structure of each card as a mix of form elements (including basic HTML) and QWeb.

Exercise

Kanban view

Add a Kanban view that displays sessions grouped by course (columns are thus courses).

Add an integer color field to the Session model
Add the kanban view and update the action

openacademy/models.py

 
           duration = fields.Float(digits=(6, 2), help="Duration in days")
    seats = fields.Integer(string="Number of seats")
    active = fields.Boolean(default=True)
    color = fields.Integer()

    instructor_id = fields.Many2one('res.partner', string="Instructor",
        domain=['|', ('instructor', '=', True),
 
      

openacademy/views/openacademy.xml

 
            openacad.session.kanban
            openacademy.session
            
                                    t-attf-class="oe_kanban_color_{{kanban_getcolor(record.color.raw_value)}}
                                                  oe_kanban_global_click_edit oe_semantic_html_override
                                                  oe_kanban_card {{record.group_fancy==1 ? 'oe_kanban_card_fancy' : ''}}">

                                                Delete
                                            
                                                                                                    data-field="color"/>
                                            
                                    Session name:
                                    
                                    Start date:
                                    
                                    duration:
                                    
            Sessions
            openacademy.session
            form
            tree,form,calendar,gantt,graph,kanban

Building a Module

Start/Stop the Odoo server

Build an Odoo module

Composition of a module

Module structure

Object-Relational Mapping

Model fields

Common Attributes

Simple fields

Reserved fields

Special fields

Data files

Actions and Menus

Basic views

Generic view declaration

Tree views

Form views

Relational fields

Inheritance

Model inheritance

View inheritance

Domains

Computed fields and default values

Dependencies

Default values

Onchange

Model constraints

Advanced Views

Tree views

Calendars

Search views

Gantt

Graph views

Kanban

Workflows

Security

Group-based access control mechanisms

Access rights

Record rules

Wizards

Launching wizards

Internationalization

Reporting

Printed reports

Report title

Attendees:

Dashboards

WebServices

XML-RPC Library

JSON-RPC Library

你可能感兴趣的:(odoo)