[ADD] doc: new documentation, with training tutorials, and new scaffolding

Raphael Collet 9 years ago
parent 97256fa1fb
commit 2ad092b5e5

@ -167,7 +167,7 @@ instance.web.ListView = instance.web.View.extend( /** @lends instance.web.ListVi
* @returns {String} CSS style declaration
style_for: function (record) {
var style= '';
var len, style= '';
var context = _.extend({}, record.attributes, {
uid: this.session.uid,

@ -1447,12 +1447,12 @@ instance.web.View = instance.web.Widget.extend({
if (action_data.special === 'cancel') {
return handler({"type":"ir.actions.act_window_close"});
} else if (action_data.type=="object") {
var args = [[record_id]], additional_args = [];
var args = [[record_id]];
if (action_data.args) {
try {
// Warning: quotes and double quotes problem due to json and xml clash
// Maybe we should force escaping in xml or do a better parse of the args array
additional_args = JSON.parse(action_data.args.replace(/'/g, '"'));
var additional_args = JSON.parse(action_data.args.replace(/'/g, '"'));
args = args.concat(additional_args);
} catch(e) {
console.error("Could not JSON.parse arguments", action_data.args);

@ -52,24 +52,21 @@ instance.web_graph.GraphView = instance.web.View.extend({
if (_.has(field.attrs, 'interval')) {
field_name = field.attrs.name + ':' + field.attrs.interval;
if (_.has(field.attrs, 'type')) {
switch (field.attrs.type) {
case 'row':
case 'col':
case 'measure':
} else { // old style, kept for backward compatibility
//noinspection FallThroughInSwitchStatementJS
switch (field.attrs.type) {
case 'measure':
case 'col':
if ('operator' in field.attrs) {
} else {
case 'row':
if (self.widget_config.measures.length === 0) {

@ -1,211 +0,0 @@
Getting started with OpenERP development
.. toctree::
:maxdepth: 1
Installation from sources
.. _getting_started_installation_source-link:
Source code is hosted on Launchpad_. In order to get the sources, you
will need Bazaar_ to pull the source from Launchpad. Bazaar is a
version control system that helps you track project history over time
and collaborate efficiently. You may have to create an account on
Launchpad to be able to collaborate on OpenERP development. Please
refer to the Launchpad and Bazaar documentation to install and setup
your development environment.
The running example of this section is based on an Ubuntu
environment. You may have to adapt the steps according to your
system. Once your working environment is ready, prepare a working
directory that will contain the sources. For a ``source`` base
directory, type::
mkdir source;cd source
OpenERP provides a setup script that automatizes the tasks of creating
a shared repository and getting the source code. Get the setup script
of OpenERP by typing::
bzr cat -d lp:~openerp-dev/openerp-tools/trunk setup.sh | sh
This will create the following two files in your ``source`` directory::
-rw-rw-r-- 1 openerp openerp 5465 2012-04-17 11:05 Makefile
-rw-rw-r-- 1 openerp openerp 2902 2012-04-17 11:05 Makefile_helper.py
If you want some help about the available options, please type::
make help
Next step is to initialize the shared repository and download the
sources. Get the current trunk version of OpenERP by typing::
make init-trunk
This will create the following structure inside your ``source``
directory, and fetch the latest source code from ``trunk``::
drwxrwxr-x 3 openerp openerp 4096 2012-04-17 11:10 addons
drwxrwxr-x 3 openerp openerp 4096 2012-04-17 11:10 misc
drwxrwxr-x 3 openerp openerp 4096 2012-04-17 11:10 server
drwxrwxr-x 3 openerp openerp 4096 2012-04-17 11:10 web
Some dependencies are necessary to use OpenERP. Depending on your
environment, you might have to install the following packages::
sudo apt-get install graphviz ghostscript postgresql-client \
python-dateutil python-feedparser python-gdata \
python-ldap python-libxslt1 python-lxml python-mako \
python-openid python-psycopg2 python-pybabel python-pychart \
python-pydot python-pyparsing python-reportlab python-simplejson \
python-tz python-vatnumber python-vobject python-webdav \
python-werkzeug python-xlwt python-yaml python-imaging \
Next step is to initialize the database. This will create a new openerp role::
make db-setup
Finally, launch the OpenERP server::
make server
Testing your installation can be done on http://localhost:8069/. You
should see the OpenERP main login page.
.. _Launchpad: https://launchpad.net/
.. _Bazaar: http://bazaar.canonical.com/en/
Command line options
.. program:: openerp-server
Using the command ::
./openerp-server --help
General Options
--version show program version number and exit
-h, --help show this help message and exit
-c CONFIG, --config=CONFIG specify alternate config file
-s, --save save configuration to ~/.terp_serverrc
-v, --verbose enable debugging
--pidfile=PIDFILE file where the server pid will be stored
--logfile=LOGFILE file where the server log will be stored
-n INTERFACE, --interface=INTERFACE specify the TCP IP address
-p PORT, --port=PORT specify the TCP port
--no-xmlrpc disable xmlrpc
-i INIT, --init=INIT init a module (use "all" for all modules)
--without-demo=WITHOUT_DEMO load demo data for a module (use "all" for all modules)
-u UPDATE, --update=UPDATE update a module (use "all" for all modules)
--stop-after-init stop the server after it initializes
--debug enable debug mode
-S, --secure launch server over https instead of http
--smtp=SMTP_SERVER specify the SMTP server for sending mail
Database related options
-d DB_NAME, --database=DB_NAME
specify the database name
-r DB_USER, --db_user=DB_USER
specify the database user name
-w DB_PASSWORD, --db_password=DB_PASSWORD
specify the database password
--pg_path=PG_PATH specify the pg executable path
--db_host=DB_HOST specify the database host
--db_port=DB_PORT specify the database port
Internationalization options
Use these options to translate OpenERP to another language.See i18n
section of the user manual. Option '-l' is mandatory.::
-l LANGUAGE, --language=LANGUAGE
specify the language of the translation file. Use it
with --i18n-export and --i18n-import
export all sentences to be translated to a CSV file
and exit
import a CSV file with translations and exit
specify modules to export. Use in combination with
Options from previous versions
Some options were removed in OpenERP version 6. For example,
``price_accuracy`` is now configured through the
:ref:`decimal_accuracy` screen.
.. _getting_started_configuration-link:
Two configuration files are available:
* one for the client: ``~/.openerprc``
* one for the server: ``~/.openerp_serverrc``
If they are not found, the server and the client will start with a
default configuration. Those files follow the convention used by
python's ConfigParser module. Please note that lines beginning with
"#" or ";" are comments. The client configuration file is
automatically generated upon the first start. The sezrver
configuration file can automatically be created using the command ::
./openerp-server -s or ./openerp-server --save
You can specify alternate configuration files with ::
-c CONFIG, --config=CONFIG specify alternate config file
Configure addons locations
By default, the only directory of addons known by the server is
server/bin/addons. It is possible to add new addons by
- copying them in server/bin/addons, or creating a symbolic link to
each of them in this directory, or
- specifying another directory containing addons to the server. The
later can be accomplished either by running the server with the
``--addons-path=`` option, or by configuring this option in the
openerp_serverrc file, automatically generated under Linux in your
home directory by the server when executed with the ``--save``
option. You can provide several addons to the ``addons_path`` =
option, separating them using commas.
Start-up script
.. versionadded:: 6.1
To run the OpenERP server, the conventional approach is to use the
`openerp-server` script. It loads the :ref:`openerp library`, sets a
few configuration variables corresponding to command-line arguments,
and starts to listen to incoming connections from clients.
Depending on your deployment needs, you can write such a start-up script very
easily. We also recommend you take a look at an alternative tool called
`openerp-command` that can, among other things, launch the server.
Yet another alternative is to use a WSGI-compatible HTTP server and let it call
into one of the WSGI entry points of the server.

@ -1,252 +0,0 @@
OpenERP as a multitenant three-tiers architecture
This section presents the OpenERP architecture along with technology details
of the application. The tiers composing OpenERP are presented. Communication
means and protocols between the application components are also presented.
Some details about used development languages and technology stack are then summarized.
OpenERP is a `multitenant <http://en.wikipedia.org/wiki/Multitenancy>`_, `three-tiers architecture
database tier for data storage, application tier for processing and functionalities
and presentation tier providing user interface. Those are separate layers
inside OpenERP. The application tier itself is written as a core; multiple
additional modules can be installed in order to create a particular instance
of OpenERP adapted to specific needs and requirements. Moreover, OpenERP
follows the Model-View-Controller (MVC) architectural pattern.
A typical deployment of OpenERP is shown on `Figure 1`_. This deployment is
called Web embedded deployment. As shown, an OpenERP system consists of
three main components:
- a PostgreSQL database server which contains all OpenERP databases.
Databases contain all application data, and also most of the OpenERP
system configuration elements. Note that this server can possibly be
deployed using clustered databases.
- the OpenERP Server, which contains all the enterprise logic and ensures
that OpenERP runs optimally. One layer of the server is dedicated to
communicate and interface with the PostgreSQL database, the ORM engine.
Another layer allows communications between the server and a web browser,
the Web layer. Having more than one server is possible, for example in
conjunction with a load balancing mechanism.
- the client running in the a web browser as javascript application.
The database server and the OpenERP server can be installed on the same
computer, or distributed onto separate computer servers, for example for
performance considerations.
.. _`Figure 1`:
.. figure:: _static/02_openerp_architecture.png
:width: 50%
:alt: OpenERP 6.1 architecture for embedded web deployment
:align: center
OpenERP 6.1 architecture for embedded web deployment
The next subsections give details about the different tiers of the OpenERP
PostgreSQL database
The data tier of OpenERP is provided by a PostgreSQL relational database.
While direct SQL queries can be executed from OpenERP modules, most accesses
to the relational database are done through the server Object Relational
Mapping layer.
Databases contain all application data, and also most of the OpenERP system
configuration elements. Note that this server can possibly be deployed using
clustered databases.
OpenERP server
OpenERP provides an application server on which specific business applications
can be built. It is also a complete development framework, offering a range
of features to write those applications. Among those features, the OpenERP
ORM provides functionalities and an interface on top of the PostgreSQL server.
The OpenERP server also features a specific layer designed to communicate
with the web browser-based client. This layer connects users using standard
browsers to the server.
From a developer perspective, the server acts both as a library which brings
the above benefits while hiding the low-level details, and as a simple way
to install, configure and run the written applications. The server also contains
other services, such as extensible data models and view, workflow engine or
reports engine. However, those are OpenERP services not specifically related
to security, and are therefore not discussed in details in this document.
**Server - ORM**
The Object Relational Mapping ORM layer is one of the salient features of
the OpenERP Server. It provides additional and essential functionalities
on top of PostgreSQL server. Data models are described in Python and OpenERP
creates the underlying database tables using this ORM. All the benefits of
RDBMS such as unique constraints, relational integrity or efficient querying
are used and completed by Python flexibility. For instance, arbitrary constraints
written in Python can be added to any model. Different modular extensibility
mechanisms are also afforded by OpenERP.
It is important to understand the ORM responsibility before attempting to
by-pass it and to access directly the underlying database via raw SQL queries.
When using the ORM, OpenERP can make sure the data remains free of any corruption.
For instance, a module can react to data creation in a particular table.
This behavior can occur only if queries go through the ORM.
The services granted by the ORM are among other :
- consistency validation by powerful validity checks,
- providing an interface on objects (methods, references, ...) allowing
to design and implement efficient modules,
- row-level security per user and group; more details about users and user
groups are given in the section Users and User Roles,
- complex actions on a group of resources,
- inheritance service allowing fine modeling of new resources
**Server - Web**
The web layer offers an interface to communicate with standard browsers.
In the 6.1 version of OpenERP, the web-client has been rewritten and integrated
into the OpenERP server tier. This web layer is a WSGI-compatible application
based on werkzeug. It handles regular http queries to server static file or
dynamic content and JSON-RPC queries for the RPC made from the browser.
By itself, the OpenERP server is a core. For any enterprise, the value of
OpenERP lies in its different modules. The role of the modules is to implement
any business requirement. The server is the only necessary component to
add modules. Any official OpenERP release includes a lot of modules, and
hundreds of modules are available thanks to the community. Examples of
such modules are Account, CRM, HR, Marketing, MRP, Sale, etc.
As the application logic is mainly contained server-side, the client is
conceptually simple. It issues a request to the server, gets data back
and display the result (e.g. a list of customers) in different ways
(as forms, lists, calendars, ...). Upon user actions, it sends queries
to modify data to the server.
The default client of OpenERP is an JavaScript application running in the
browser that communicates with the server using JSON-RPC.
MVC architecture in OpenERP
According to `Wikipedia <http://en.wikipedia.org/wiki/Model-view-controller>`_,
"a Model-view-controller (MVC) is an architectural pattern used in software
engineering". In complex computer applications presenting lots of data to
the user, one often wishes to separate data (model) and user interface (view)
concerns. Changes to the user interface does therefore not impact data
management, and data can be reorganized without changing the user interface.
The model-view-controller solves this problem by decoupling data access
and business logic from data presentation and user interaction, by
introducing an intermediate component: the controller.
.. _`Figure 3`:
.. figure:: _static/02_mvc_diagram.png
:width: 35%
:alt: Model-View-Controller diagram
:align: center
Model-View-Controller diagram
For example in the diagram above, the solid lines for the arrows starting
from the controller and going to both the view and the model mean that the
controller has a complete access to both the view and the model. The dashed
line for the arrow going from the view to the controller means that the view
has a limited access to the controller. The reasons of this design are :
- From **View** to **Model** : the model sends notification to the view
when its data has been modified in order the view to redraw its content.
The model doesn't need to know the inner workings of the view to perform
this operation. However, the view needs to access the internal parts of the model.
- From **View** to **Controller** : the reason why the view has limited
access to the controller is because the dependencies from the view to
the controller need to be minimal: the controller can be replaced at
any moment.
OpenERP follows the MVC semantic with
- model : The PostgreSQL tables.
- view : views are defined in XML files in OpenERP.
- controller : The objects of OpenERP.
Network communications and WSGI
OpenERP is an HTTP web server and may also be deployed as an WSGI-compliant
Clients may communicate with OpenERP using sessionless XML-RPC, the recommended
way to interoperate with OpenERP. Web-based clients communicates using the
session aware JSON-RPC.
Everything in OpenERP, and objects methods in particular, are exposed via
the network and a security layer. Access to the data model is in fact a service
and it is possible to expose new services. For instance, a WebDAV service and
a FTP service are available.
Services can make use of the `WSGI
<http://en.wikipedia.org/wiki/Web_Server_Gateway_Interface>`_ stack. WSGI is a
standard solution in the Python ecosystem to write HTTP servers, applications,
and middleware which can be used in a mix-and-match fashion. By using WSGI, it
is possible to run OpenERP in any WSGI compliant server. It is also possible to
use OpenERP to host a WSGI application.
A striking example of this possibility is the OpenERP Web layer that is
the server-side counter part to the web clients. It provides the requested
data to the browser and manages web sessions. It is a WSGI-compliant application.
As such, it can be run as a stand-alone HTTP server or embedded inside OpenERP.
The HTTP namespaces /openerp/ /object/ /common/ are reserved for the XML-RPC
layer, every module restrict it's HTTP namespace to /<name_of_the_module>/
Process model
In the past, the OpenERP server was using threads to handle HTTP requests
concurrently or to process cron jobs. Using threads is still the default
behavior when running the ``openerp-server`` script but not the recommended
one: it is in fact recommended to use the ``--workers`` option.
By using the ``--workers`` option, the OpenERP server will spawn a fixed number
of processes instead of spawning a new thread for each incoming request.
This has a number of advantages:
- Processes do not suffer from CPython's Global Interpreter Lock.
- Processes can be gracefully recycled while requests are still handled by the
- Resources such as CPU time and memory made available to a process can be
monitored on a per-process basis.
When using the ``--workers`` options, two types of processes may be spawned:
web process, and cron process.
.. versionadded:: 7.1
.. _longpolling-worker:
When using the ``--workers`` options, three types of processes may be spawned:
web process, and cron process, just as previsouly, but also an evented (using
gevent) web process is started. It is used for long-polling as needed by the
upcoming Instant Messaging feature. As for now, that process is listening on a
different port than the main web processes. A reverse proxy (e.g. Nginx) to
listen on a unique port, mapping all requests to the normal port, but mapping
the ``/longpolling`` route to the evented process is necessary (the web
interface cannot issue requests to different ports).
(It is possible to make the threaded server evented by passing the ``--gevent``
The goal is to drop support for the threaded model, and also make all web
processes evented; there would be no more distinction between "normal" and
"longpolling" processes. For this to happen, further testing is needed.

@ -1,16 +0,0 @@
.. _module-dev:
.. toctree::
:maxdepth: 2

@ -1,429 +0,0 @@
.. _module-dev-structure:
Module structure
A module can contain the following elements:
- **Business object** : declared as Python classes extending the class
osv.Model, the persistence of these resource is completly managed by
OpenERP's ORM.
- **Data** : XML/CSV files with meta-data (views and workflows declaration),
configuration data (modules parametrization) and demo data (optional but
recommended for testing),
- **Reports** : RML (XML format). HTML/MAKO or OpenOffice report templates, to
be merged with any kind of business data, and generate HTML, ODT or PDF
.. figure:: _static/03_module_gen_view.png
:width: 75%
:alt: Module composition
:align: center
Module composition
Each module is contained in its own directory within either the server/bin/addons
directory or another directory of addons, configured in server installation.
To create a new module for example the 'OpenAcademy' module, the following
steps are required:
- create a ``openacademy`` subdirectory in the source/addons directory
- create the module import file ``__init__.py``
- create the module manifield file ``__openerp__.py``
- create **Python** files containing **objects**
- create **.xml files** holding module data such as views, menu entries
or demo data
- optionally create **reports** or **workflows**
Python import file __init__.py
The ``__init__.py`` file is the Python import file, because an OpenERP module
is also a regular Python module. The file should import all the other python
file or submodules.
For example, if a module contains a single python file named ``openacademy.py``,
the file should look like:
import openacademy
Manifest file __openerp__.py
In the created module directory, you must add a **__openerp__.py** file.
This file, which must be a Python dict literal, is responsible to
1. determine the *XML files that will be parsed* during the initialization
of the server, and also to
2. determine the *dependencies* of the created module.
3. declare additional meta data
This file must contain a Python dictionary with the following values:
name The name of the module in English.
version The version of the module.
summary Short description or keywords
description The module description (text).
category The categrory of the module
author The author of the module.
website URL of the website of the module.
license The license of the module (default: AGPL-3).
depends List of modules on which this module depends beside base.
data List of .xml files to load when the module is installed or updated.
demo List of additional .xml files to load when the module is
installed or updated and demo flag is active.
installable True or False. Determines whether the module is installable
or not.
auto_install True or False (default: False). If set to ``True``, the
module is a link module. It will be installed as soon
as all its dependencies are installed.
For the ``openacademy`` module, here is an example of ``__openerp__.py``
declaration file:
.. code-block:: python
'name' : "OpenAcademy",
'version' : "1.0",
'author' : "OpenERP SA",
'category' : "Tools",
'depends' : ['mail'],
'data' : [
'demo' : [
'installable': True,
All OpenERP resources are objects: invoices, partners. Metadata are also object
too: menus, actions, reports... Object names are hierarchical, as in the
following examples:
* account.transfer : a money transfer
* account.invoice : an invoice
* account.invoice.line : an invoice line
Generally, the first word is the name of the module: account, stock, sale.
Those object are declared in python be subclassing osv.Model
The ORM of OpenERP is constructed over PostgreSQL. It is thus possible to
query the object used by OpenERP using the object interface (ORM) or by
directly using SQL statements.
But it is dangerous to write or read directly in the PostgreSQL database, as
you will shortcut important steps like constraints checking or workflow
.. .. figure:: images/pom_3_0_3.png
.. :scale: 50
.. :align: center
.. *The Physical Objects Model of [OpenERP version 3.0.3]*
XML Files
XML files located in the module directory are used to initialize or update the
the database when the module is installed or updated. They are used for many
purposes, among which we can cite :
* initialization and demonstration data declaration,
* views declaration,
* reports declaration,
* workflows declaration.
General structure of OpenERP XML files is more detailed in the
:ref:`xml-serialization` section. Look here if you are interested in learning
more about *initialization* and *demonstration data declaration* XML files. The
following section are only related to XML specific to *actions, menu entries,
reports, wizards* and *workflows* declaration.
Data can be inserted or updated into the PostgreSQL tables corresponding to the
OpenERP objects using XML files. The general structure of an OpenERP XML file
is as follows:
.. code-block:: xml
<?xml version="1.0"?>
<record model="model.name_1" id="id_name_1">
<field name="field1"> "field1 content" </field>
<field name="field2"> "field2 content" </field>
<record model="model.name_2" id="id_name_2">
Defines a new record in a specified OpenERP model.
``@model`` (required)
Name of the model in which this record will be created/inserted.
``@id`` (optional)
:term:`external ID` for the record, also allows referring to this record in
the rest of this file or in other files (through ``field/@ref`` or the
:py:func:`ref() <openerp.tools.convert._ref>` function)
A record tag generally contains multiple ``field`` tags specifying the values
set on the record's fields when creating it. Fields left out will be set to
their default value unless required.
In its most basic use, the ``field`` tag will set its body (as a string) as
the value of the corresponding ``record``'s ``@name`` field.
Extra attributes can either preprocess the body or replace its use entirely:
``@name`` (mandatory)
Name of the field in the containing ``record``'s model
``@type`` (optional)
One of ``char``, ``int``, ``float``, ``list``, ``tuple``, ``xml`` or
``html``, ``file`` or ``base64``. Converts the ``field``'s body to the
specified type (or validates the body's content)
* ``xml`` will join multiple XML nodes under a single ``<data>`` root
* in ``xml`` and ``html``, external ids can be referenced using
* ``list`` and ``tuple``'s element are specified using ``<value>``
sub-nodes with the same attributes as ``field``.
* ``file`` expects a module-local path and will save the path prefixed with
the current module's name, separated by a ``,`` (comma). For use with
* ``base64`` expects binary data, encodes it to base64 and sets it. Mostly
useful with ``@file``
Can be used with types ``char`` and ``base64``, sources the field's content
from the specified file instead of the field's text body.
Model used for ``@search``'s search, or registry object put in context for
``@eval``. Required if ``@search`` but optional if ``@eval``.
``@eval`` (optional)
A Python expression evaluated to obtain the value to set on the record
``@ref`` (optional)
Links to an other record through its :term:`external id`. The module prefix
may be ommitted to link to a record defined in the same module.
``@search`` (optional)
Search domain (evaluated Python expression) into ``@model`` to get the
records to set on the field.
Sets all the matches found for m2m fields, the first id for other field
.. code-block:: xml
<record model="ir.actions.report.xml" id="l0">
<field name="model">account.invoice</field>
<field name="name">Invoices List</field>
<field name="report_name">account.invoice.list</field>
<field name="report_xsl">account/report/invoice.xsl</field>
<field name="report_xml">account/report/invoice.xml</field>
Let's review an example taken from the OpenERP source (base_demo.xml in the base module):
.. code-block:: xml
<record model="res.company" id="main_company">
<field name="name">Tiny sprl</field>
<field name="partner_id" ref="main_partner"/>
<field name="currency_id" ref="EUR"/>
.. code-block:: xml
<record model="res.users" id="user_admin">
<field name="login">admin</field>
<field name="password">admin</field>
<field name="name">Administrator</field>
<field name="signature">Administrator</field>
<field name="action_id" ref="action_menu_admin"/>
<field name="menu_id" ref="action_menu_admin"/>
<field name="address_id" ref="main_address"/>
<field name="groups_id" eval="[(6,0,[group_admin])]"/>
<field name="company_id" ref="main_company"/>
This last record defines the admin user :
* The fields login, password, etc are straightforward.
* The ref attribute allows to fill relations between the records :
.. code-block:: xml
<field name="company_id" ref="main_company"/>
The field **company_id** is a many-to-one relation from the user object to the company object, and **main_company** is the id of to associate.
* The **eval** attribute allows to put some python code in the xml: here the groups_id field is a many2many. For such a field, "[(6,0,[group_admin])]" means : Remove all the groups associated with the current user and use the list [group_admin] as the new associated groups (and group_admin is the id of another record).
* The **search** attribute allows to find the record to associate when you do not know its xml id. You can thus specify a search criteria to find the wanted record. The criteria is a list of tuples of the same form than for the predefined search method. If there are several results, an arbitrary one will be chosen (the first one):
.. code-block:: xml
<field name="partner_id" search="[]" model="res.partner"/>
This is a classical example of the use of **search** in demo data: here we do not really care about which partner we want to use for the test, so we give an empty list. Notice the **model** attribute is currently mandatory.
Function tag
A function tag can contain other function tags.
model : mandatory
The model to be used
name : mandatory
the function given name
should evaluate to the list of parameters of the method to be called, excluding cr and uid
.. code-block:: xml
<function model="ir.ui.menu" name="search" eval="[[('name','=','Operations')]]"/>
Views are a way to represent the objects on the client side. They indicate to the client how to lay out the data coming from the objects on the screen.
There are two types of views:
* form views
* tree views
Lists are simply a particular case of tree views.
A same object may have several views: the first defined view of a kind (*tree, form*, ...) will be used as the default view for this kind. That way you can have a default tree view (that will act as the view of a one2many) and a specialized view with more or less information that will appear when one double-clicks on a menu item. For example, the products have several views according to the product variants.
Views are described in XML.
If no view has been defined for an object, the object is able to generate a view to represent itself. This can limit the developer's work but results in less ergonomic views.
Usage example
When you open an invoice, here is the chain of operations followed by the client:
* An action asks to open the invoice (it gives the object's data (account.invoice), the view, the domain (e.g. only unpaid invoices) ).
* The client asks (with XML-RPC) to the server what views are defined for the invoice object and what are the data it must show.
* The client displays the form according to the view
.. .. figure:: images/arch_view_use.png
.. :scale: 50
.. :align: center
To develop new objects
The design of new objects is restricted to the minimum: create the objects and optionally create the views to represent them. The PostgreSQL tables do not have to be written by hand because the objects are able to automatically create them (or adapt them in case they already exist).
OpenERP uses a flexible and powerful reporting system. Reports are generated either in PDF or in HTML. Reports are designed on the principle of separation between the data layer and the presentation layer.
Reports are described more in details in the `Reporting <http://openobject.com/wiki/index.php/Developers:Developper%27s_Book/Reports>`_ chapter.
The objects and the views allow you to define new forms very simply, lists/trees and interactions between them. But that is not enough, you must define the dynamics of these objects.
A few examples:
* a confirmed sale order must generate an invoice, according to certain conditions
* a paid invoice must, only under certain conditions, start the shipping order
The workflows describe these interactions with graphs. One or several workflows may be associated to the objects. Workflows are not mandatory; some objects don't have workflows.
Below is an example workflow used for sale orders. It must generate invoices and shipments according to certain conditions.
.. .. figure:: images/arch_workflow_sale.png
.. :scale: 85
.. :align: center
In this graph, the nodes represent the actions to be done:
* create an invoice,
* cancel the sale order,
* generate the shipping order, ...
The arrows are the conditions;
* waiting for the order validation,
* invoice paid,
* click on the cancel button, ...
The squared nodes represent other Workflows;
* the invoice
* the shipping
.. versionchanged:: 5.0
Each module has its own ``i18n`` folder. In addition, OpenERP can now deal with
``.po`` [#f_po]_ files as import/export format. The translation files of the
installed languages are automatically loaded when installing or updating a
Translations are managed by the `Launchpad Web interface
<https://translations.launchpad.net/openobject>`_. Here, you'll find the list
of translatable projects.
Please read the `FAQ <https://answers.launchpad.net/rosetta/+faqs>`_ before asking questions.
.. [#f_po] http://www.gnu.org/software/autoconf/manual/gettext/PO-Files.html#PO-Files

@ -1,961 +0,0 @@
.. _module-dev-api:
Objects, Fields and Methods
OpenERP Objects
.. This chapter is dedicated to detailed objects definition:
all fields
all objects
All the ERP's pieces of data are accessible through "objects". As an example, there is a res.partner object to access the data concerning the partners, an account.invoice object for the data concerning the invoices, etc...
Please note that there is an object for every type of resource, and not an
object per resource. We have thus a res.partner object to manage all the
partners and not a *res.partner* object per partner. If we talk in "object
oriented" terms, we could also say that there is an object per level.
The direct consequences is that all the methods of objects have a common parameter: the "ids" parameter. This specifies on which resources (for example, on which partner) the method must be applied. Precisely, this parameter contains a list of resource ids on which the method must be applied.
For example, if we have two partners with the identifiers 1 and 5, and we want to call the res_partner method "send_email", we will write something like::
res_partner.send_email(... , [1, 5], ...)
We will see the exact syntax of object method calls further in this document.
In the following section, we will see how to define a new object. Then, we will check out the different methods of doing this.
For developers:
* OpenERP "objects" are usually called classes in object oriented programming.
* A OpenERP "resource" is usually called an object in OO programming, instance of a class.
It's a bit confusing when you try to program inside OpenERP, because the language used is Python, and Python is a fully object oriented language, and has objects and instances ...
Luckily, an OpenERP "resource" can be converted magically into a nice Python object using the "browse" class method (OpenERP object method).
The ORM - Object-relational mapping - Models
The ORM, short for Object-Relational Mapping, is a central part of OpenERP.
In OpenERP, the data model is described and manipulated through Python classes
and objects. It is the ORM job to bridge the gap -- as transparently as
possible for the developer -- between Python and the underlying relational
database (PostgreSQL), which will provide the persistence we need for our
OpenERP Object Attributes
Objects Introduction
To define a new object, you must define a new Python class then instantiate it. This class must inherit from the osv class in the osv module.
Object definition
The first line of the object definition will always be of the form::
class name_of_the_object(osv.osv):
_name = 'name.of.the.object'
_columns = { ... }
An object is defined by declaring some fields with predefined names in the
class. Two of them are required (_name and _columns), the rest are optional.
The predefined fields are:
Predefined fields
Determines whether a corresponding PostgreSQL table must be generated
automatically from the object. Setting _auto to False can be useful in case
of OpenERP objects generated from PostgreSQL views. See the "Reporting From
PostgreSQL Views" section for more details.
`_columns (required)`
The object fields. See the :ref:`fields <fields-link>` section for further details.
The constraints on the object. See the constraints section for details.
The SQL Constraint on the object. See the SQL constraints section for further details.
The default values for some of the object's fields. See the default value section for details.
The name of the osv object which the current object inherits from. See the :ref:`object inheritance section<inherit-link>`
(first form) for further details.
The list of osv objects the object inherits from. This list must be given in
a python dictionary of the form: {'name_of_the_parent_object':
'name_of_the_field', ...}. See the :ref:`object inheritance section<inherits-link>`
(second form) for further details. Default value: {}.
Determines whether or not the write access to the resource must be logged.
If true, four fields will be created in the SQL table: create_uid,
create_date, write_uid, write_date. Those fields represent respectively the
id of the user who created the record, the creation date of record, the id
of the user who last modified the record, and the date of that last
modification. This data may be obtained by using the perm_read method.
`_name (required)`
Name of the object. Default value: None.
Name of the fields used to sort the results of the search and read methods.
Default value: 'id'.
_order = "name"
_order = "date_order desc"
Name of the field in which the name of every resource is stored. Default
value: 'name'. Note: by default, the name_get method simply returns the
content of this field.
Name of the SQL sequence that manages the ids for this object. Default value: None.
SQL code executed upon creation of the object (only if _auto is True). It means this code gets executed after the table is created.
Name of the SQL table. Default value: the value of the _name field above
with the dots ( . ) replaced by underscores ( _ ).
.. _inherit-link:
Object Inheritance - _inherit
Objects may be inherited in some custom or specific modules. It is better to
inherit an object to add/modify some fields.
It is done with::
Extension of an object
There are two possible ways to do this kind of inheritance. Both ways result in
a new class of data, which holds parent fields and behaviour as well as
additional fields and behaviour, but they differ in heavy programatical
While Example 1 creates a new subclass "custom_material" that may be "seen" or
"used" by any view or tree which handles "network.material", this will not be
the case for Example 2.
This is due to the table (other.material) the new subclass is operating on,
which will never be recognized by previous "network.material" views or trees.
Example 1::
class custom_material(osv.osv):
_name = 'network.material'
_inherit = 'network.material'
_columns = {
'manuf_warranty': fields.boolean('Manufacturer warranty?'),
_defaults = {
'manuf_warranty': lambda *a: False,
.. tip:: Notice
_name == _inherit
In this example, the 'custom_material' will add a new field 'manuf_warranty' to
the object 'network.material'. New instances of this class will be visible by
views or trees operating on the superclasses table 'network.material'.
This inheritancy is usually called "class inheritance" in Object oriented
design. The child inherits data (fields) and behavior (functions) of his
Example 2::
class other_material(osv.osv):
_name = 'other.material'
_inherit = 'network.material'
_columns = {
'manuf_warranty': fields.boolean('Manufacturer warranty?'),
_defaults = {
'manuf_warranty': lambda *a: False,
.. tip:: Notice
_name != _inherit
In this example, the 'other_material' will hold all fields specified by
'network.material' and it will additionally hold a new field 'manuf_warranty'.
All those fields will be part of the table 'other.material'. New instances of
this class will therefore never been seen by views or trees operating on the
superclasses table 'network.material'.
This type of inheritancy is known as "inheritance by prototyping" (e.g.
Javascript), because the newly created subclass "copies" all fields from the
specified superclass (prototype). The child inherits data (fields) and behavior
(functions) of his parent.
.. _inherits-link:
Inheritance by Delegation - _inherits
**Syntax :**::
class tiny_object(osv.osv)
_name = 'tiny.object'
_table = 'tiny_object'
_inherits = {
'tiny.object_a': 'object_a_id',
'tiny.object_b': 'object_b_id',
... ,
'tiny.object_n': 'object_n_id'
The object 'tiny.object' inherits from all the columns and all the methods from
the n objects 'tiny.object_a', ..., 'tiny.object_n'.
To inherit from multiple tables, the technique consists in adding one column to
the table tiny_object per inherited object. This column will store a foreign
key (an id from another table). The values *'object_a_id' 'object_b_id' ...
'object_n_id'* are of type string and determine the title of the columns in
which the foreign keys from 'tiny.object_a', ..., 'tiny.object_n' are stored.
This inheritance mechanism is usually called " *instance inheritance* " or "
*value inheritance* ". A resource (instance) has the VALUES of its parents.
.. _fields-link:
Fields Introduction
Objects may contain different types of fields. Those types can be divided into
three categories: simple types, relation types and functional fields. The
simple types are integers, floats, booleans, strings, etc ... ; the relation
types are used to represent relations between objects (one2one, one2many,
many2one). Functional fields are special fields because they are not stored in
the database but calculated in real time given other fields of the view.
Here's the header of the initialization method of the class any field defined
in OpenERP inherits (as you can see in server/bin/osv/fields.py)::
def __init__(self, string='unknown', required=False, readonly=False,
domain=None, context="", states=None, priority=0, change_default=False, size=None,
ondelete="set null", translate=False, select=False, **args) :
There are a common set of optional parameters that are available to most field
Whether or not the user can define default values on other fields depending
on the value of this field. Those default values need to be defined in
the ir.values table.
A description of how the field should be used: longer and more descriptive
than `string`. It will appear in a tooltip when the mouse hovers over the
How to handle deletions in a related record. Allowable values are:
'restrict', 'no action', 'cascade', 'set null', and 'set default'.
:priority: Not used?
:readonly: `True` if the user cannot edit this field, otherwise `False`.
`True` if this field must have a value before the object can be saved,
otherwise `False`.
:size: The size of the field in the database: number characters or digits.
Lets you override other parameters for specific states of this object.
Accepts a dictionary with the state names as keys and a list of name/value
tuples as the values. For example: `states={'posted':[('readonly',True)]}`
The field name as it should appear in a label or column header. Strings
containing non-ASCII characters must use python unicode objects.
For example: `'tested': fields.boolean(u'Testé')`
`True` if the *content* of this field should be translated, otherwise
There are also some optional parameters that are specific to some field types:
Define a variable's value visible in the view's context or an on-change
function. Used when searching child table of `one2many` relationship?
Domain restriction on a relational field.
Default value: [].
Example: domain=[('field','=',value)])
:invisible: Hide the field's value in forms. For example, a password.
Default value for the `on_change` attribute in the view. This will launch
a function on the server when the field changes in the client. For example,
Used when a field is an id reference to another table. This is the name of
the table to look in. Most commonly used with related and function field
Default value for the `select` attribute in the view. 1 means basic search,
and 2 means advanced search.
Type of Fields
Basic Types
A boolean (true, false).
fields.boolean('Field Name' [, Optional Parameters]),
An integer.
fields.integer('Field Name' [, Optional Parameters]),
A floating point number.
fields.float('Field Name' [, Optional Parameters]),
.. note::
The optional parameter digits defines the precision and scale of the
number. The scale being the number of digits after the decimal point
whereas the precision is the total number of significant digits in the
number (before and after the decimal point). If the parameter digits is
not present, the number will be a double precision floating point number.
Warning: these floating-point numbers are inexact (not any value can be
converted to its binary representation) and this can lead to rounding
errors. You should always use the digits parameter for monetary amounts.
'rate': fields.float(
'Relative Change rate',
digits=(12,6) [,
Optional Parameters]),
A string of limited length. The required size parameter determines its size.
'Field Name',
size=n [,
Optional Parameters]), # where ''n'' is an integer.
'city' : fields.char('City Name', size=30, required=True),
A text field with no limit in length.
fields.text('Field Name' [, Optional Parameters]),
A date.
fields.date('Field Name' [, Optional Parameters]),
Allows to store a date and the time of day in the same field.
fields.datetime('Field Name' [, Optional Parameters]),
A binary chain
A field which allows the user to make a selection between various predefined values.
fields.selection((('n','Unconfirmed'), ('c','Confirmed')),
'Field Name' [, Optional Parameters]),
.. note::
Format of the selection parameter: tuple of tuples of strings of the form::
(('key_or_value', 'string_to_display'), ... )
.. note::
You can specify a function that will return the tuple. Example ::
def _get_selection(self, cursor, user_id, context=None):
return (
('choice1', 'This is the choice 1'),
('choice2', 'This is the choice 2'))
_columns = {
'sel' : fields.selection(
'What do you want ?')
Using relation fields **many2one** with **selection**. In fields definitions add::
'my_field': fields.many2one(
And then define the _sel_func like this (but before the fields definitions)::
def _sel_func(self, cr, uid, context=None):
obj = self.pool.get('mymodule.relation.model')
ids = obj.search(cr, uid, [])
res = obj.read(cr, uid, ids, ['name', 'id'], context)
res = [(r['id'], r['name']) for r in res]
return res
Relational Types
A one2one field expresses a one:to:one relation between two objects. It is
deprecated. Use many2one instead.
fields.one2one('other.object.name', 'Field Name')
Associates this object to a parent object via this Field. For example
Department an Employee belongs to would Many to one. i.e Many employees will
belong to a Department
'Field Name',
optional parameters)
Optional parameters:
- ondelete: What should happen when the resource this field points to is deleted.
+ Predefined value: "cascade", "set null", "restrict", "no action", "set default"
+ Default value: "set null"
- required: True
- readonly: True
- select: True - (creates an index on the Foreign Key field)
*Example* ::
'commercial': fields.many2one(
'Field relation id',
optional parameter)
Optional parameters:
- invisible: True/False
- states: ?
- readonly: True/False
*Example* ::
'address': fields.one2many(
'relation object',
'Field Name')
- other.object.name is the other object which belongs to the relation
- relation object is the table that makes the link
- actual.object.id and other.object.id are the fields' names used in the relation table
To make it bidirectional (= create a field in the other object)::
class other_object_name2(osv.osv):
_inherit = 'other.object.name'
_columns = {
'other_fields': fields.many2many(
'relation object',
'Other Field Name'),
class res_partner_category2(osv.osv):
_inherit = 'res.partner.category'
_columns = {
'partner_ids': fields.many2many(
Sometimes you need to refer to the relation of a relation. For example,
supposing you have objects: City -> State -> Country, and you need to refer to
the Country from a City, you can define a field as below in the City object::
'country_id': fields.related(
- The first set of parameters are the chain of reference fields to
follow, with the desired field at the end.
- :guilabel:`type` is the type of that desired field.
- Use :guilabel:`relation` if the desired field is still some kind of
reference. :guilabel:`relation` is the table to look up that
reference in.
.. _fields-functional:
Functional Fields
A functional field is a field whose value is calculated by a function (rather
than being stored in the database).
**Parameters:** ::
fnct, arg=None, fnct_inv=None, fnct_inv_arg=None, type="float",
fnct_search=None, obj=None, method=False, store=False, multi=False
* :guilabel:`fnct` is the function or method that will compute the field
value. It must have been declared before declaring the functional field.
* :guilabel:`fnct_inv` is the function or method that will allow writing
values in that field.
* :guilabel:`type` is the field type name returned by the function. It can
be any field type name except function.
* :guilabel:`fnct_search` allows you to define the searching behaviour on
that field.
* :guilabel:`method` whether the field is computed by a method (of an
object) or a global function
* :guilabel:`store` If you want to store field in database or not. Default
is False.
* :guilabel:`multi` is a group name. All fields with the same `multi`
parameter will be calculated in a single function call.
fnct parameter
If *method* is True, the signature of the method must be::
def fnct(self, cr, uid, ids, field_name, arg, context):
otherwise (if it is a global function), its signature must be::
def fnct(cr, table, ids, field_name, arg, context):
Either way, it must return a dictionary of values of the form
**{id'_1_': value'_1_', id'_2_': value'_2_',...}.**
The values of the returned dictionary must be of the type specified by the type
argument in the field declaration.
If *multi* is set, then *field_name* is replaced by *field_names*: a list
of the field names that should be calculated. Each value in the returned
dictionary is also a dictionary from field name to value. For example, if the
fields `'name'`, and `'age'` are both based on the `vital_statistics` function,
then the return value of `vital_statistics` might look like this when `ids` is
`[1, 2, 5]`::
1: {'name': 'Bob', 'age': 23},
2: {'name': 'Sally', 'age', 19},
5: {'name': 'Ed', 'age': 62}
fnct_inv parameter
If *method* is true, the signature of the method must be::
def fnct(self, cr, uid, ids, field_name, field_value, arg, context):
otherwise (if it is a global function), it should be::
def fnct(cr, table, ids, field_name, field_value, arg, context):
fnct_search parameter
If method is true, the signature of the method must be::
def fnct(self, cr, uid, obj, name, args, context):
otherwise (if it is a global function), it should be::
def fnct(cr, uid, obj, name, args, context):
The return value is a list containing 3-part tuples which are used in search function::
return [('id','in',[1,3,5])]
*obj* is the same as *self*, and *name* receives the field name. *args* is a list
of 3-part tuples containing search criteria for this field, although the search
function may be called separately for each tuple.
Suppose we create a contract object which is :
.. code-block:: python
class hr_contract(osv.osv):
_name = 'hr.contract'
_description = 'Contract'
_columns = {
'name' : fields.char('Contract Name', size=30, required=True),
'employee_id' : fields.many2one('hr.employee', 'Employee', required=True),
'function' : fields.many2one('res.partner.function', 'Function'),