Raphael Collet
9 years ago
parent
97256fa1fb
commit
2ad092b5e5
@ -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 \
|
||||
python-matplotlib
|
||||
|
||||
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
|
||||
--i18n-export=TRANSLATE_OUT
|
||||
export all sentences to be translated to a CSV file
|
||||
and exit
|
||||
--i18n-import=TRANSLATE_IN
|
||||
import a CSV file with translations and exit
|
||||
--modules=TRANSLATE_MODULES
|
||||
specify modules to export. Use in combination with
|
||||
--i18n-export
|
||||
|
||||
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.
|
||||
|
||||
Configuration
|
||||
==============
|
||||
|
||||
.. _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,16 +0,0 @@
|
||||
.. _module-dev:
|
||||
|
||||
=======
|
||||
Modules
|
||||
=======
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 2
|
||||
|
||||
03_module_dev_01
|
||||
03_module_dev_02
|
||||
03_module_dev_03
|
||||
03_module_dev_04
|
||||
03_module_dev_05
|
||||
03_module_dev_06
|
||||
report-declaration
|
||||
@ -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
|
||||
reports.
|
||||
|
||||
.. 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' : [
|
||||
'openacademy_view.xml',
|
||||
'openacademy_data.xml',
|
||||
'report/module_report.xml',
|
||||
'wizard/module_wizard.xml',
|
||||
],
|
||||
'demo' : [
|
||||
'openacademy_demo.xml'
|
||||
],
|
||||
'installable': True,
|
||||
}
|
||||
|
||||
Objects
|
||||
+++++++
|
||||
|
||||
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
|
||||
modification.
|
||||
|
||||
.. .. 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"?>
|
||||
<openerp>
|
||||
<data>
|
||||
<record model="model.name_1" id="id_name_1">
|
||||
<field name="field1"> "field1 content" </field>
|
||||
<field name="field2"> "field2 content" </field>
|
||||
(...)
|
||||
</record>
|
||||
<record model="model.name_2" id="id_name_2">
|
||||
(...)
|
||||
</record>
|
||||
(...)
|
||||
</data>
|
||||
</openerp>
|
||||
|
||||
``<record>``
|
||||
////////////
|
||||
|
||||
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.
|
||||
|
||||
``<field>``
|
||||
///////////
|
||||
|
||||
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
|
||||
``%(id_name)s``
|
||||
* ``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
|
||||
:py:func:`~openerp.modules.module.get_module_resource`.
|
||||
* ``base64`` expects binary data, encodes it to base64 and sets it. Mostly
|
||||
useful with ``@file``
|
||||
|
||||
``@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``
|
||||
|
||||
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
|
||||
types.
|
||||
|
||||
**Example**
|
||||
|
||||
.. 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>
|
||||
</record>
|
||||
|
||||
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"/>
|
||||
</record>
|
||||
|
||||
.. 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"/>
|
||||
</record>
|
||||
|
||||
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
|
||||
|
||||
eval
|
||||
should evaluate to the list of parameters of the method to be called, excluding cr and uid
|
||||
|
||||
**Example**
|
||||
|
||||
.. code-block:: xml
|
||||
|
||||
<function model="ir.ui.menu" name="search" eval="[[('name','=','Operations')]]"/>
|
||||
|
||||
|
||||
Views
|
||||
+++++
|
||||
|
||||
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).
|
||||
|
||||
Reports
|
||||
"""""""
|
||||
|
||||
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.
|
||||
|
||||
|
||||
Workflow
|
||||
""""""""
|
||||
|
||||
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
|
||||
|
||||
|
||||
i18n
|
||||
----
|
||||
|
||||
.. 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
|
||||
module.
|
||||
|
||||
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
|
||||
inheritancies
|
||||
|
||||
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
|
||||
objects.
|
||||
|
||||
|
||||
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 = { ... }
|
||||
...
|
||||
name_of_the_object()
|
||||
|
||||
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
|
||||
+++++++++++++++++
|
||||
|
||||
`_auto`
|
||||
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.
|
||||
|
||||
`_constraints`
|
||||
The constraints on the object. See the constraints section for details.
|
||||
|
||||
`_sql_constraints`
|
||||
The SQL Constraint on the object. See the SQL constraints section for further details.
|
||||
|
||||
`_defaults`
|
||||
The default values for some of the object's fields. See the default value section for details.
|
||||
|
||||
`_inherit`
|
||||
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.
|
||||
|
||||
`_inherits`
|
||||
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: {}.
|
||||
|
||||
`_log_access`
|
||||
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.
|
||||
|
||||
`_order`
|
||||
Name of the fields used to sort the results of the search and read methods.
|
||||
|
||||
Default value: 'id'.
|
||||
|
||||
Examples::
|
||||
|
||||
_order = "name"
|
||||
_order = "date_order desc"
|
||||
|
||||
`_rec_name`
|
||||
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.
|
||||
|
||||
`_sequence`
|
||||
Name of the SQL sequence that manages the ids for this object. Default value: None.
|
||||
|
||||
`_sql`
|
||||
SQL code executed upon creation of the object (only if _auto is True). It means this code gets executed after the table is created.
|
||||
|
||||
`_table`
|
||||
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
|
||||
-----------------------------
|
||||
|
||||
Introduction
|
||||
++++++++++++
|
||||
|
||||
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::
|
||||
|
||||
_inherit='object.name'
|
||||
|
||||
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
|
||||
consequences.
|
||||
|
||||
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,
|
||||
}
|
||||
custom_material()
|
||||
|
||||
.. 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
|
||||
parent.
|
||||
|
||||
|
||||
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,
|
||||
}
|
||||
other_material()
|
||||
|
||||
.. 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
|
||||
types:
|
||||
|
||||
:change_default:
|
||||
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.
|
||||
:help:
|
||||
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
|
||||
field.
|
||||
:ondelete:
|
||||
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`.
|
||||
:required:
|
||||
`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.
|
||||
:states:
|
||||
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)]}`
|
||||
:string:
|
||||
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é')`
|
||||
:translate:
|
||||
`True` if the *content* of this field should be translated, otherwise
|
||||
`False`.
|
||||
|
||||
There are also some optional parameters that are specific to some field types:
|
||||
|
||||
:context:
|
||||
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:
|
||||
Domain restriction on a relational field.
|
||||
|
||||
Default value: [].
|
||||
|
||||
Example: domain=[('field','=',value)])
|
||||
:invisible: Hide the field's value in forms. For example, a password.
|
||||
:on_change:
|
||||
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,
|
||||
`on_change="onchange_shop_id(shop_id)"`.
|
||||
:relation:
|
||||
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
|
||||
types.
|
||||
:select:
|
||||
Default value for the `select` attribute in the view. 1 means basic search,
|
||||
and 2 means advanced search.
|
||||
|
||||
|
||||
Type of Fields
|
||||
--------------
|
||||
|
||||
Basic Types
|
||||
+++++++++++
|
||||
|
||||
:boolean:
|
||||
|
||||
A boolean (true, false).
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.boolean('Field Name' [, Optional Parameters]),
|
||||
|
||||
:integer:
|
||||
|
||||
An integer.
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.integer('Field Name' [, Optional Parameters]),
|
||||
|
||||
:float:
|
||||
|
||||
A floating point number.
|
||||
|
||||
Syntax::
|
||||
|
||||
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.
|
||||
|
||||
Example::
|
||||
|
||||
'rate': fields.float(
|
||||
'Relative Change rate',
|
||||
digits=(12,6) [,
|
||||
Optional Parameters]),
|
||||
|
||||
:char:
|
||||
|
||||
A string of limited length. The required size parameter determines its size.
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.char(
|
||||
'Field Name',
|
||||
size=n [,
|
||||
Optional Parameters]), # where ''n'' is an integer.
|
||||
|
||||
Example::
|
||||
|
||||
'city' : fields.char('City Name', size=30, required=True),
|
||||
|
||||
:text:
|
||||
|
||||
A text field with no limit in length.
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.text('Field Name' [, Optional Parameters]),
|
||||
|
||||
:date:
|
||||
|
||||
A date.
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.date('Field Name' [, Optional Parameters]),
|
||||
|
||||
:datetime:
|
||||
|
||||
Allows to store a date and the time of day in the same field.
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.datetime('Field Name' [, Optional Parameters]),
|
||||
|
||||
:binary:
|
||||
|
||||
A binary chain
|
||||
|
||||
:selection:
|
||||
|
||||
A field which allows the user to make a selection between various predefined values.
|
||||
|
||||
Syntax::
|
||||
|
||||
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(
|
||||
_get_selection,
|
||||
'What do you want ?')
|
||||
}
|
||||
|
||||
*Example*
|
||||
|
||||
Using relation fields **many2one** with **selection**. In fields definitions add::
|
||||
|
||||
...,
|
||||
'my_field': fields.many2one(
|
||||
'mymodule.relation.model',
|
||||
'Title',
|
||||
selection=_sel_func),
|
||||
...,
|
||||
|
||||
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
|
||||
++++++++++++++++
|
||||
|
||||
:one2one:
|
||||
|
||||
A one2one field expresses a one:to:one relation between two objects. It is
|
||||
deprecated. Use many2one instead.
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.one2one('other.object.name', 'Field Name')
|
||||
|
||||
:many2one:
|
||||
|
||||
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
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.many2one(
|
||||
'other.object.name',
|
||||
'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(
|
||||
'res.users',
|
||||
'Commercial',
|
||||
ondelete='cascade'),
|
||||
|
||||
:one2many:
|
||||
|
||||
TODO
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.one2many(
|
||||
'other.object.name',
|
||||
'Field relation id',
|
||||
'Fieldname',
|
||||
optional parameter)
|
||||
|
||||
Optional parameters:
|
||||
- invisible: True/False
|
||||
- states: ?
|
||||
- readonly: True/False
|
||||
|
||||
*Example* ::
|
||||
|
||||
'address': fields.one2many(
|
||||
'res.partner.address',
|
||||
'partner_id',
|
||||
'Contacts'),
|
||||
|
||||
:many2many:
|
||||
|
||||
TODO
|
||||
|
||||
Syntax::
|
||||
|
||||
fields.many2many('other.object.name',
|
||||
'relation object',
|
||||
'actual.object.id',
|
||||
'other.object.id',
|
||||
'Field Name')
|
||||
|
||||
Where:
|
||||
- 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
|
||||
|
||||
Example::
|
||||
|
||||
'category_ids':
|
||||
fields.many2many(
|
||||
'res.partner.category',
|
||||
'res_partner_category_rel',
|
||||
'partner_id',
|
||||
'category_id',
|
||||
'Categories'),
|
||||
|
||||
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(
|
||||
'actual.object.name',
|
||||
'relation object',
|
||||
'actual.object.id',
|
||||
'other.object.id',
|
||||
'Other Field Name'),
|
||||
}
|
||||
other_object_name2()
|
||||
|
||||
Example::
|
||||
|
||||
class res_partner_category2(osv.osv):
|
||||
_inherit = 'res.partner.category'
|
||||
_columns = {
|
||||
'partner_ids': fields.many2many(
|
||||
'res.partner',
|
||||
'res_partner_category_rel',
|
||||
'category_id',
|
||||
'partner_id',
|
||||
'Partners'),
|
||||
}
|
||||
res_partner_category2()
|
||||
|
||||
:related:
|
||||
|
||||
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(
|
||||
'state_id',
|
||||
'country_id',
|
||||
type="many2one",
|
||||
relation="res.country",
|
||||
string="Country",
|
||||
store=False)
|
||||
|
||||
Where:
|
||||
- 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
|
||||
|
||||
where
|
||||
|
||||
* :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.
|
||||
|
||||
Example
|
||||
"""""""
|
||||
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'),
|
||||