From a4a9c2941f95cbd229171adf9d23c977485a1804 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20Delavall=C3=A9e?= Date: Tue, 17 Apr 2012 10:43:15 +0200 Subject: [PATCH 01/15] [REF] Moved nex features merges from api to revisions. bzr revid: tde@openerp.com-20120417084315-omitzsd21sq3mby0 --- doc/index.rst | 31 +++----------------- doc/index.rst.inc | 12 ++++---- doc/{api => revisions}/need_action_specs.rst | 0 doc/{api => revisions}/user_img_specs.rst | 0 4 files changed, 10 insertions(+), 33 deletions(-) rename doc/{api => revisions}/need_action_specs.rst (100%) rename doc/{api => revisions}/user_img_specs.rst (100%) diff --git a/doc/index.rst b/doc/index.rst index 815633aed54..51162354913 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -1,29 +1,6 @@ -.. OpenERP Web documentation master file, created by - sphinx-quickstart on Fri Mar 18 16:31:55 2011. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. +:orphan: -Welcome to OpenERP Web's documentation! -======================================= +OpenERP Server Developers Documentation +======================================== -Contents: - -.. toctree:: - :maxdepth: 2 - - search-view - - getting-started - production - widgets - addons - development - project - old-version - -Indices and tables -================== - -* :ref:`genindex` -* :ref:`modindex` -* :ref:`search` +.. include:: index.rst.inc diff --git a/doc/index.rst.inc b/doc/index.rst.inc index 80873a696ec..da37481785f 100644 --- a/doc/index.rst.inc +++ b/doc/index.rst.inc @@ -1,17 +1,17 @@ -OpenERP Server -'''''''''''''' +OpenERP Server Documentation +''''''''''''''''''''''''''''' .. toctree:: :maxdepth: 1 test-framework -New feature merges -++++++++++++++++++ +Main revisions and new features +++++++++++++++++++++++++++++++++ .. toctree:: :maxdepth: 1 - api/user_img_specs - api/need_action_specs + revisions/user_img_specs + revisions/need_action_specs diff --git a/doc/api/need_action_specs.rst b/doc/revisions/need_action_specs.rst similarity index 100% rename from doc/api/need_action_specs.rst rename to doc/revisions/need_action_specs.rst diff --git a/doc/api/user_img_specs.rst b/doc/revisions/user_img_specs.rst similarity index 100% rename from doc/api/user_img_specs.rst rename to doc/revisions/user_img_specs.rst From 05cbf324d405716eef963984eff530e27c55a02a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20Delavall=C3=A9e?= Date: Tue, 17 Apr 2012 11:21:34 +0200 Subject: [PATCH 02/15] [REN] Renamed test-framework to 99_test_framework (temp modification to include dev book) bzr revid: tde@openerp.com-20120417092134-rpmk8rd14svdgde2 --- doc/99_test_framework.rst | 100 ++++++++++++++++++++++++++++++++++++++ doc/index.rst.inc | 3 +- 2 files changed, 102 insertions(+), 1 deletion(-) create mode 100644 doc/99_test_framework.rst diff --git a/doc/99_test_framework.rst b/doc/99_test_framework.rst new file mode 100644 index 00000000000..56951b1a8e1 --- /dev/null +++ b/doc/99_test_framework.rst @@ -0,0 +1,100 @@ +.. _test-framework: + +Test framework +============== + +In addition to the YAML-based tests, OpenERP uses the unittest2_ testing +framework to test both the core ``openerp`` package and its addons. For the +core and each addons, tests are divided between three (overlapping) sets: + +1. A test suite that comprises all the tests that can be run right after the + addons is installed (or, for the core, right after a database is created). + That suite is called ``fast_suite`` and must contain only tests that can be run + frequently. Actually most of the tests should be considered fast enough to be + included in that ``fast_suite`` list and only tests that take a long time to run + (e.g. more than a minute) should not be listed. Those long tests should come up + pretty rarely. + +2. A test suite called ``checks`` provides sanity checks. These tests are + invariants that must be full-filled at any time. They are expected to always + pass: obviously they must pass right after the module is installed (i.e. just + like the ``fast_suite`` tests), but they must also pass after any other module is + installed, after a migration, or even after the database was put in production + for a few months. + +3. The third suite is made of all the tests: those provided by the two above + suites, but also tests that are not explicitely listed in ``fast_suite`` or + ``checks``. They are not explicitely listed anywhere and are discovered + automatically. + +As the sanity checks provide stronger guarantees about the code and database +structure, new tests must be added to the ``checks`` suite whenever it is +possible. Said with other words: one should try to avoid writing tests that +assume a freshly installed/unaltered module or database. + +It is possible to have tests that are not listed in ``fast_suite`` or +``checks``. This is useful if a test takes a lot of time. By default, when +using the testing infrastructure, tests should run fast enough so that people +can use them frequently. One can also use that possiblity for tests that +require some complex setup before they can be successfuly run. + +As a rule of thumb when writing a new test, try to add it to the ``checks`` +suite. If it really needs that the module it belongs to is freshly installed, +add it to ``fast_suite``. Finally, if it can not be run in an acceptable time +frame, don't add it to any explicit list. + +Writing tests +------------- + +The tests must be developed under ``.tests`` (or ``openerp.tests`` +for the core). For instance, with respect to the tests, a module ``foo`` +should be organized as follow:: + + foo/ + __init__.py # does not import .tests + tests/ + __init__.py # import some of the tests sub-modules, and + # list them in fast_suite or checks + test_bar.py # contains unittest2 classes + test_baz.py # idem + ... and so on ... + +The two explicit lists of tests are thus the variables ``foo.tests.fast_suite`` +and ``foo.tests.checks``. As an example, you can take a look at the +``openerp.tests`` module (which follows exactly the same conventions even if it +is not an addons). + +Note that the ``fast_suite`` and ``checks`` variables are really lists of +module objects. They could be directly unittest2 suite objects if necessary in +the future. + +Running the tests +----------------- + +To run the tests (see :ref:`above ` to learn how tests are +organized), the simplest way is to use the ``oe`` command (provided by the +``openerp-command`` project). + +:: + + > oe run-tests # will run all the fast_suite tests + > oe run-tests -m openerp # will run all the fast_suite tests defined in `openerp.tests` + > oe run-tests -m sale # will run all the fast_suite tests defined in `openerp.addons.sale.tests` + > oe run-tests -m foo.test_bar # will run the tests defined in `openerp.addons.foo.tests.test_bar` + +In addition to the above possibilities, when invoked with a non-existing module +(or module.sub-module) name, oe will reply with a list of available test +sub-modules. + +Depending on the unittest2_ class that is used to write the tests (see +``openerp.tests.common`` for some helper classes that you can re-use), a database +may be created before the test is run, and the module providing the test will +be installed on that database. + +Because creating a database, installing modules, and then dropping it is +expensive, it is possible to interleave the run of the ``fast_suite`` tests +with the initialization of a new database: the dabase is created, and after +each requested module is installed, its fast_suite tests are run. The database +is thus created and dropped (and the modules installed) only once. + +.. _unittest2: http://pypi.python.org/pypi/unittest2 diff --git a/doc/index.rst.inc b/doc/index.rst.inc index da37481785f..e36bccd79d5 100644 --- a/doc/index.rst.inc +++ b/doc/index.rst.inc @@ -5,7 +5,8 @@ OpenERP Server Documentation .. toctree:: :maxdepth: 1 - test-framework + 01_getting_started + 99_test_framework Main revisions and new features ++++++++++++++++++++++++++++++++ From efa85ca0809d109f377adef17fa209d6c81e4e7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20Delavall=C3=A9e?= Date: Tue, 17 Apr 2012 11:22:05 +0200 Subject: [PATCH 03/15] [REF] Added first chapter from dev book: getting started. Rewrote the installation guide. bzr revid: tde@openerp.com-20120417092205-5mfvukv35qysj6h6 --- doc/01_getting_started.rst | 279 +++++++++++++++++++++++++++++++++++++ doc/test-framework.rst | 100 ------------- 2 files changed, 279 insertions(+), 100 deletions(-) create mode 100644 doc/01_getting_started.rst delete mode 100644 doc/test-framework.rst diff --git a/doc/01_getting_started.rst b/doc/01_getting_started.rst new file mode 100644 index 00000000000..e7bd882305a --- /dev/null +++ b/doc/01_getting_started.rst @@ -0,0 +1,279 @@ +========================================= +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 client + drwxrwxr-x 3 openerp openerp 4096 2012-04-17 11:10 client-web + drwxrwxr-x 2 openerp openerp 4096 2012-04-17 11:10 dump + 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 + 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/ + +Configuration +============= + +.. _getrting_started_configuration-link: + +Two configuration files are available: + + * one for the client: ~/.openerprc + * one for the server: ~/.openerp_serverrc + +Those files follow the convention used by python's ConfigParser module. + +Lines beginning with "#" or ";" are comments. + +The client configuration file is automatically generated upon the first start. The one of the server can automatically be created using the command: :: + + openerp-server.py -s + +If they are not found, the server and the client will start with the default configuration. + + +**Server Configuration File** + +The server configuration file .openerp_serverrc is used to save server startup options. Here is the list of the available options: + +:interface: + Address to which the server will be bound + +:port: + Port the server will listen on + +:database: + Name of the database to use + +:user: + Username used when connecting to the database + +:translate_in: + File used to translate OpenERP to your language + +:translate_out: + File used to export the language OpenERP use + +:language: + Use this language as the language of the server. This must be specified as an ISO country code, as specified by the W3C. + +:verbose: + Enable debug output + +:init: + init a module (use "all" for all modules) + +:update: + update a module (use "all" for all modules) + +:upgrade: + Upgrade/install/uninstall modules + +:db_name: + specify the database name + +:db_user: + specify the database user name + +:db_password: + specify the database password + +:pg_path: + specify the pg executable path + +:db_host: + specify the database host + +:db_port: + specify the database port + +:translate_modules: + Specify modules to export. Use in combination with --i18n-export + + +You can create your own configuration file by specifying -s or --save on the server command line. If you would like to write an alternative configuration file, use -c or --config= +Here is a basic configuration for a server:: + + [options] + verbose = False + xmlrpc = True + database = terp + update = {} + port = 8069 + init = {} + interface = 127.0.0.1 + reportgz = False + +Full Example for Server V5.0 :: + + [printer] + path = none + softpath_html = none + preview = True + softpath = none + + [logging] + output = stdout + logger = + verbose = True + level = error + + [help] + index = http://www.openerp.com/documentation/user-manual/ + context = http://www.openerp.com/scripts/context_index.php + + [form] + autosave = False + toolbar = True + + [support] + recipient = support@openerp.com + support_id = + + [tip] + position = 0 + autostart = False + + [client] + lang = en_US + default_path = /home/user + filetype = {} + theme = none + toolbar = icons + form_tab_orientation = 0 + form_tab = top + + [survey] + position = 3 + + [path] + pixmaps = /usr/share/pixmaps/openerp-client/ + share = /usr/share/openerp-client/ + + [login] + db = eo2 + login = admin + protocol = http:// + port = 8069 + server = localhost + + +Command line options +==================== + +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 + --net_interface=NETINTERFACE + specify the TCP IP address for netrpc + --net_port=NETPORT specify the TCP port for netrpc + --no-netrpc disable netrpc + --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 version 6. For example, ``price_accuracy`` is now +configured through the :ref:`decimal_accuracy` screen. + diff --git a/doc/test-framework.rst b/doc/test-framework.rst deleted file mode 100644 index 56951b1a8e1..00000000000 --- a/doc/test-framework.rst +++ /dev/null @@ -1,100 +0,0 @@ -.. _test-framework: - -Test framework -============== - -In addition to the YAML-based tests, OpenERP uses the unittest2_ testing -framework to test both the core ``openerp`` package and its addons. For the -core and each addons, tests are divided between three (overlapping) sets: - -1. A test suite that comprises all the tests that can be run right after the - addons is installed (or, for the core, right after a database is created). - That suite is called ``fast_suite`` and must contain only tests that can be run - frequently. Actually most of the tests should be considered fast enough to be - included in that ``fast_suite`` list and only tests that take a long time to run - (e.g. more than a minute) should not be listed. Those long tests should come up - pretty rarely. - -2. A test suite called ``checks`` provides sanity checks. These tests are - invariants that must be full-filled at any time. They are expected to always - pass: obviously they must pass right after the module is installed (i.e. just - like the ``fast_suite`` tests), but they must also pass after any other module is - installed, after a migration, or even after the database was put in production - for a few months. - -3. The third suite is made of all the tests: those provided by the two above - suites, but also tests that are not explicitely listed in ``fast_suite`` or - ``checks``. They are not explicitely listed anywhere and are discovered - automatically. - -As the sanity checks provide stronger guarantees about the code and database -structure, new tests must be added to the ``checks`` suite whenever it is -possible. Said with other words: one should try to avoid writing tests that -assume a freshly installed/unaltered module or database. - -It is possible to have tests that are not listed in ``fast_suite`` or -``checks``. This is useful if a test takes a lot of time. By default, when -using the testing infrastructure, tests should run fast enough so that people -can use them frequently. One can also use that possiblity for tests that -require some complex setup before they can be successfuly run. - -As a rule of thumb when writing a new test, try to add it to the ``checks`` -suite. If it really needs that the module it belongs to is freshly installed, -add it to ``fast_suite``. Finally, if it can not be run in an acceptable time -frame, don't add it to any explicit list. - -Writing tests -------------- - -The tests must be developed under ``.tests`` (or ``openerp.tests`` -for the core). For instance, with respect to the tests, a module ``foo`` -should be organized as follow:: - - foo/ - __init__.py # does not import .tests - tests/ - __init__.py # import some of the tests sub-modules, and - # list them in fast_suite or checks - test_bar.py # contains unittest2 classes - test_baz.py # idem - ... and so on ... - -The two explicit lists of tests are thus the variables ``foo.tests.fast_suite`` -and ``foo.tests.checks``. As an example, you can take a look at the -``openerp.tests`` module (which follows exactly the same conventions even if it -is not an addons). - -Note that the ``fast_suite`` and ``checks`` variables are really lists of -module objects. They could be directly unittest2 suite objects if necessary in -the future. - -Running the tests ------------------ - -To run the tests (see :ref:`above ` to learn how tests are -organized), the simplest way is to use the ``oe`` command (provided by the -``openerp-command`` project). - -:: - - > oe run-tests # will run all the fast_suite tests - > oe run-tests -m openerp # will run all the fast_suite tests defined in `openerp.tests` - > oe run-tests -m sale # will run all the fast_suite tests defined in `openerp.addons.sale.tests` - > oe run-tests -m foo.test_bar # will run the tests defined in `openerp.addons.foo.tests.test_bar` - -In addition to the above possibilities, when invoked with a non-existing module -(or module.sub-module) name, oe will reply with a list of available test -sub-modules. - -Depending on the unittest2_ class that is used to write the tests (see -``openerp.tests.common`` for some helper classes that you can re-use), a database -may be created before the test is run, and the module providing the test will -be installed on that database. - -Because creating a database, installing modules, and then dropping it is -expensive, it is possible to interleave the run of the ``fast_suite`` tests -with the initialization of a new database: the dabase is created, and after -each requested module is installed, its fast_suite tests are run. The database -is thus created and dropped (and the modules installed) only once. - -.. _unittest2: http://pypi.python.org/pypi/unittest2 From 8624a85a20be8c77c3d7ab118cf2f21e01e7163b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20Delavall=C3=A9e?= Date: Tue, 17 Apr 2012 13:09:40 +0200 Subject: [PATCH 04/15] [DOC] getting_started: improved content bzr revid: tde@openerp.com-20120417110940-b8mq1sqone0wpycp --- doc/01_getting_started.rst | 547 ++++++++++++++++++++++++------------- 1 file changed, 355 insertions(+), 192 deletions(-) diff --git a/doc/01_getting_started.rst b/doc/01_getting_started.rst index e7bd882305a..d126c4ccb82 100644 --- a/doc/01_getting_started.rst +++ b/doc/01_getting_started.rst @@ -1,14 +1,14 @@ -========================================= +======================================== Getting started with OpenERP development -========================================= +======================================== .. toctree:: - :maxdepth: 1 + :maxdepth: 1 Installation from sources -++++++++++++++++++++++++++ +========================== -.._getting_started_installation_source-link: +.. _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. @@ -45,8 +45,14 @@ This will create the following structure inside your ``source`` directory, and f 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 - python-imaging python-matplotlib + sudo apt-get install graphviz ghostscript postgresql-client + + sudo apt-get install 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-zsi python-imaging python-matplotlib Next step is to initialize the database. This will create a new openerp role:: @@ -61,189 +67,46 @@ Testing your installation can be done on http://localhost:8069/ . You should see .. _Launchpad: https://launchpad.net/ .. _Bazaar: http://bazaar.canonical.com/en/ -Configuration -============= - -.. _getrting_started_configuration-link: - -Two configuration files are available: - - * one for the client: ~/.openerprc - * one for the server: ~/.openerp_serverrc - -Those files follow the convention used by python's ConfigParser module. - -Lines beginning with "#" or ";" are comments. - -The client configuration file is automatically generated upon the first start. The one of the server can automatically be created using the command: :: - - openerp-server.py -s - -If they are not found, the server and the client will start with the default configuration. - - -**Server Configuration File** - -The server configuration file .openerp_serverrc is used to save server startup options. Here is the list of the available options: - -:interface: - Address to which the server will be bound - -:port: - Port the server will listen on - -:database: - Name of the database to use - -:user: - Username used when connecting to the database - -:translate_in: - File used to translate OpenERP to your language - -:translate_out: - File used to export the language OpenERP use - -:language: - Use this language as the language of the server. This must be specified as an ISO country code, as specified by the W3C. - -:verbose: - Enable debug output - -:init: - init a module (use "all" for all modules) - -:update: - update a module (use "all" for all modules) - -:upgrade: - Upgrade/install/uninstall modules - -:db_name: - specify the database name - -:db_user: - specify the database user name - -:db_password: - specify the database password - -:pg_path: - specify the pg executable path - -:db_host: - specify the database host - -:db_port: - specify the database port - -:translate_modules: - Specify modules to export. Use in combination with --i18n-export - - -You can create your own configuration file by specifying -s or --save on the server command line. If you would like to write an alternative configuration file, use -c or --config= -Here is a basic configuration for a server:: - - [options] - verbose = False - xmlrpc = True - database = terp - update = {} - port = 8069 - init = {} - interface = 127.0.0.1 - reportgz = False - -Full Example for Server V5.0 :: - - [printer] - path = none - softpath_html = none - preview = True - softpath = none - - [logging] - output = stdout - logger = - verbose = True - level = error - - [help] - index = http://www.openerp.com/documentation/user-manual/ - context = http://www.openerp.com/scripts/context_index.php - - [form] - autosave = False - toolbar = True - - [support] - recipient = support@openerp.com - support_id = - - [tip] - position = 0 - autostart = False - - [client] - lang = en_US - default_path = /home/user - filetype = {} - theme = none - toolbar = icons - form_tab_orientation = 0 - form_tab = top - - [survey] - position = 3 - - [path] - pixmaps = /usr/share/pixmaps/openerp-client/ - share = /usr/share/openerp-client/ - - [login] - db = eo2 - login = admin - protocol = http:// - port = 8069 - server = localhost - - Command line options ==================== -General Options ---------------- +Using the command :: - --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 - --net_interface=NETINTERFACE - specify the TCP IP address for netrpc - --net_port=NETPORT specify the TCP port for netrpc - --no-netrpc disable netrpc - --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: -------------------------- + ./openerp-server --help + +gives you the available command line options. For OpenERP server at revision 4133, an output example is given in the `Command line options example`_. Here are a few interesting command line options. + +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 + --net_interface=NETINTERFACE specify the TCP IP address for netrpc + --net_port=NETPORT specify the TCP port for netrpc + --no-netrpc disable netrpc + --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 @@ -254,11 +117,10 @@ Database related options: --db_host=DB_HOST specify the database host --db_port=DB_PORT specify the database port -Internationalization options: ------------------------------ +Internationalization options +++++++++++++++++++++++++++++ - Use these options to translate OpenERP to another language.See i18n - section of the user manual. Option '-l' is mandatory. +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 @@ -272,8 +134,309 @@ Internationalization options: specify modules to export. Use in combination with --i18n-export -Options from previous versions: -------------------------------- -Some options were removed in version 6. For example, ``price_accuracy`` is now +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 + +An example of server configuration file for + +Appendix +======== + +Command line options example +++++++++++++++++++++++++++++ + +Usage: openerp-server [options] + +**Options**:: + + --version show program's version number and exit + -h, --help show this help message and exit + +**Common options**:: + + -c CONFIG, --config=CONFIG + specify alternate config file + -s, --save save configuration to ~/.openerp_serverrc + -i INIT, --init=INIT + install one or more modules (comma-separated list, use + "all" for all modules), requires -d + -u UPDATE, --update=UPDATE + update one or more modules (comma-separated list, use + "all" for all modules). Requires -d. + --without-demo=WITHOUT_DEMO + disable loading demo data for modules to be installed + (comma-separated, use "all" for all modules). Requires + -d and -i. Default is none + -P IMPORT_PARTIAL, --import-partial=IMPORT_PARTIAL + Use this for big data importation, if it crashes you + will be able to continue at the current state. Provide + a filename to store intermediate importation states. + --pidfile=PIDFILE file where the server pid will be stored + --addons-path=ADDONS_PATH + specify additional addons paths (separated by commas). + --load=SERVER_WIDE_MODULES + Comma-separated list of server-wide modules + default=web + +**XML-RPC Configuration**:: + + --xmlrpc-interface=XMLRPC_INTERFACE + Specify the TCP IP address for the XML-RPC protocol. + The empty string binds to all interfaces. + --xmlrpc-port=XMLRPC_PORT + specify the TCP port for the XML-RPC protocol + --no-xmlrpc disable the XML-RPC protocol + --proxy-mode Enable correct behavior when behind a reverse proxy + +**XML-RPC Secure Configuration**:: + + --xmlrpcs-interface=XMLRPCS_INTERFACE + Specify the TCP IP address for the XML-RPC Secure + protocol. The empty string binds to all interfaces. + --xmlrpcs-port=XMLRPCS_PORT + specify the TCP port for the XML-RPC Secure protocol + --no-xmlrpcs disable the XML-RPC Secure protocol + --cert-file=SECURE_CERT_FILE + specify the certificate file for the SSL connection + --pkey-file=SECURE_PKEY_FILE + specify the private key file for the SSL connection + +**NET-RPC Configuration**:: + + --netrpc-interface=NETRPC_INTERFACE + specify the TCP IP address for the NETRPC protocol + --netrpc-port=NETRPC_PORT + specify the TCP port for the NETRPC protocol + --no-netrpc disable the NETRPC protocol + +**Web interface Configuration**:: + + --db-filter=REGEXP Filter listed database + +**Static HTTP service**:: + + --static-http-enable + enable static HTTP service for serving plain HTML + files + --static-http-document-root=STATIC_HTTP_DOCUMENT_ROOT + specify the directory containing your static HTML + files (e.g '/var/www/') + --static-http-url-prefix=STATIC_HTTP_URL_PREFIX + specify the URL root prefix where you want web + browsers to access your static HTML files (e.g '/') + +**Testing Configuration**:: + + --test-file=TEST_FILE + Launch a YML test file. + --test-report-directory=TEST_REPORT_DIRECTORY + If set, will save sample of all reports in this + directory. + --test-enable Enable YAML and unit tests. + --test-commit Commit database changes performed by YAML or XML + tests. + +**Logging Configuration**:: + + --logfile=LOGFILE file where the server log will be stored + --no-logrotate do not rotate the logfile + --syslog Send the log to the syslog server + --log-handler=PREFIX:LEVEL + setup a handler at LEVEL for a given PREFIX. An empty + PREFIX indicates the root logger. This option can be + repeated. Example: "openerp.orm:DEBUG" or + "werkzeug:CRITICAL" (default: ":INFO") + --log-request shortcut for --log- + handler=openerp.netsvc.rpc.request:DEBUG + --log-response shortcut for --log- + handler=openerp.netsvc.rpc.response:DEBUG + --log-web shortcut for --log- + handler=openerp.addons.web.common.http:DEBUG + --log-sql shortcut for --log-handler=openerp.sql_db:DEBUG + --log-level=LOG_LEVEL + specify the level of the logging. Accepted values: + ['info', 'debug_rpc', 'warn', 'test', 'critical', + 'debug_sql', 'error', 'debug', 'debug_rpc_answer', + 'notset'] (deprecated option). + +**SMTP Configuration**:: + + --email-from=EMAIL_FROM + specify the SMTP email address for sending email + --smtp=SMTP_SERVER specify the SMTP server for sending email + --smtp-port=SMTP_PORT + specify the SMTP port + --smtp-ssl specify the SMTP server support SSL or not + --smtp-user=SMTP_USER + specify the SMTP username for sending email + --smtp-password=SMTP_PASSWORD + specify the SMTP password for sending email + +**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 + --db_maxconn=DB_MAXCONN + specify the the maximum number of physical connections + to posgresql + --db-template=DB_TEMPLATE + specify a custom database template to create a new + database + +**Internationalisation options**:: + + Use these options to translate OpenERP to another language.See i18n + section of the user manual. Option '-d' is mandatory.Option '-l' is + mandatory in case of importation + + --load-language=LOAD_LANGUAGE + specifies the languages for the translations you want + to be loaded + -l LANGUAGE, --language=LANGUAGE + specify the language of the translation file. Use it + with --i18n-export or --i18n-import + --i18n-export=TRANSLATE_OUT + export all sentences to be translated to a CSV file, a + PO file or a TGZ archive and exit + --i18n-import=TRANSLATE_IN + import a CSV or a PO file with translations and exit. + The '-l' option is required. + --i18n-overwrite overwrites existing translation terms on updating a + module or importing a CSV or a PO file. + --modules=TRANSLATE_MODULES + specify modules to export. Use in combination with + --i18n-export + +**Security-related options**:: + + --no-database-list disable the ability to return the list of databases + +**Advanced options**:: + + --cache-timeout=CACHE_TIMEOUT + set the timeout for the cache system + --debug enable debug mode + --stop-after-init stop the server after its initialization + -t TIMEZONE, --timezone=TIMEZONE + specify reference timezone for the server (e.g. + Europe/Brussels + --osv-memory-count-limit=OSV_MEMORY_COUNT_LIMIT + Force a limit on the maximum number of records kept in + the virtual osv_memory tables. The default is False, + which means no count-based limit. + --osv-memory-age-limit=OSV_MEMORY_AGE_LIMIT + Force a limit on the maximum age of records kept in + the virtual osv_memory tables. This is a decimal value + expressed in hours, and the default is 1 hour. + --max-cron-threads=MAX_CRON_THREADS + Maximum number of threads processing concurrently cron + jobs. + --virtual-memory-limit=VIRTUAL_MEMORY_LIMIT + Maximum allowed virtual memory per Gunicorn process. + When the limit is reached, any memory allocation will + fail. + --virtual-memory-reset=VIRTUAL_MEMORY_RESET + Maximum allowed virtual memory per Gunicorn process. + When the limit is reached, the worker will be reset + after the current request. + --cpu-time-limit=CPU_TIME_LIMIT + Maximum allowed CPU time per Gunicorn process. When + the limit is reached, an exception is raised. + --unaccent Use the unaccent function provided by the database + when available. + +Server configuration file ++++++++++++++++++++++++++ + +:: + + [options] + addons_path = /home/openerp/workspace/openerp-dev/addons/trunk,/home/openerp/workspace/openerp-dev/web/trunk/addons + admin_passwd = admin + cache_timeout = 100000 + cpu_time_limit = 60 + csv_internal_sep = , + db_host = False + db_maxconn = 64 + db_name = False + db_password = False + db_port = False + db_template = template0 + db_user = openerp + dbfilter = .* + debug_mode = False + demo = {} + email_from = False + import_partial = + list_db = True + log_handler = [':INFO'] + log_level = info + logfile = False + login_message = False + logrotate = True + max_cron_threads = 4 + netrpc = True + netrpc_interface = + netrpc_port = 8070 + osv_memory_age_limit = 1.0 + osv_memory_count_limit = False + pg_path = None + pidfile = False + proxy_mode = False + reportgz = False + secure_cert_file = server.cert + secure_pkey_file = server.pkey + server_wide_modules = None + smtp_password = False + smtp_port = 25 + smtp_server = localhost + smtp_ssl = False + smtp_user = False + static_http_document_root = None + static_http_enable = False + static_http_url_prefix = None + syslog = False + test_commit = False + test_enable = False + test_file = False + test_report_directory = False + timezone = False + translate_modules = ['all'] + unaccent = False + virtual_memory_limit = 805306368 + virtual_memory_reset = 671088640 + without_demo = False + xmlrpc = True + xmlrpc_interface = + xmlrpc_port = 8069 + xmlrpcs = True + xmlrpcs_interface = + xmlrpcs_port = 8071 From 6d16d56970f1f01a5e360916e792c640bd127655 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20Delavall=C3=A9e?= Date: Tue, 17 Apr 2012 13:10:16 +0200 Subject: [PATCH 05/15] [DOC] [ADD] Added architecture chapter. bzr revid: tde@openerp.com-20120417111016-nnjncznndlcchyrg --- doc/02_architecture.rst | 569 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 569 insertions(+) create mode 100644 doc/02_architecture.rst diff --git a/doc/02_architecture.rst b/doc/02_architecture.rst new file mode 100644 index 00000000000..867d5be7c15 --- /dev/null +++ b/doc/02_architecture.rst @@ -0,0 +1,569 @@ +======================================== +Architecture +======================================== + +MVC architecture +================ + +According to `Wikipedia `_, "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:: images/MVCDiagram.png + :scale: 100 + :align: center + + MVC 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. + +MVC Model in OpenERP +-------------------- + +In OpenERP, we can apply this model-view-controller semantic with + + * model : The PostgreSQL tables. + * view : views are defined in XML files in OpenERP. + * controller : The objects of OpenERP. + + +MVCSQL +------ + +Example 1 ++++++++++ + +Suppose sale is a variable on a record of the sale.order object related to the 'sale_order' table. You can acquire such a variable doing this.:: + + sale = self.browse(cr, uid, ID) + +(where cr is the current row, from the database cursor, uid is the current user's ID for security checks, and ID is the sale order's ID or list of IDs if we want more than one) + +Suppose you want to get: the country name of the first contact of a partner related to the ID sale order. You can do the following in OpenERP:: + + country_name = sale.partner_id.address[0].country_id.name + +If you want to write the same thing in traditional SQL development, it will be in python: (we suppose cr is the cursor on the database, with psycopg) + +.. code-block:: python + + cr.execute('select partner_id from sale_order where id=%d', (ID,)) + partner_id = cr.fetchone()[0] + cr.execute('select country_id from res_partner_address where partner_id=%d', (partner_id,)) + country_id = cr.fetchone()[0] + cr.execute('select name from res_country where id=%d', (country_id,)) + del partner_id + del country_id + country_name = cr.fetchone()[0] + +Of course you can do better if you develop smartly in SQL, using joins or subqueries. But you have to be smart and most of the time you will not be able to make such improvements: + + * Maybe some parts are in others functions + * There may be a loop in different elements + * You have to use intermediate variables like country_id + +The first operation as an object call is much better for several reasons: + + * It uses objects facilities and works with modules inheritances, overload, ... + * It's simpler, more explicit and uses less code + * It's much more efficient as you will see in the following examples + * Some fields do not directly correspond to a SQL field (e.g.: function fields in Python) + + +Prefetching ++++++++++++ + +Suppose that later in the code, in another function, you want to access the name of the partner associated to your sale order. You can use this:: + + partner_name = sale.partner_id.name + +And this will not generate any SQL query as it has been prefetched by the object relational mapping engine of OpenERP. + + +Loops and special fields +++++++++++++++++++++++++ + +Suppose now that you want to compute the totals of 10 sales order by countries. You can do this in OpenERP within a OpenERP object: + +.. code-block:: python + + def get_totals(self, cr, uid, ids): + countries = {} + for sale in self.browse(cr, uid, ids): + country = sale.partner_invoice_id.country + countries.setdefault(country, 0.0) + countries[country] += sale.amount_untaxed + return countries + +And, to print them as a good way, you can add this on your object: + +.. code-block:: python + + def print_totals(self, cr, uid, ids): + result = self.get_totals(cr, uid, ids) + for country in result.keys(): + print '[%s] %s: %.2f' (country.code, country.name, result[country]) + +The 2 functions will generate 4 SQL queries in total ! This is due to the SQL engine of OpenERP that does prefetching, works on lists and uses caching methods. The 3 queries are: + + 1. Reading the sale.order to get ID's of the partner's address + 2. Reading the partner's address for the countries + 3. Calling the amount_untaxed function that will compute a total of the sale order lines + 4. Reading the countries info (code and name) + +That's great because if you run this code on 1000 sales orders, you have the guarantee to only have 4 SQL queries. + +Notes: + + * IDS is the list of the 10 ID's: [12,15,18,34, ...,99] + * The arguments of a function are always the same: + + - cr: the cursor database (from psycopg) + - uid: the user id (for security checks) + * If you run this code on 5000 sales orders, you may have 8 SQL queries because as SQL queries are not allowed to take too much memory, it may have to do two separate readings. + + +Complex example ++++++++++++++++ + +Here is a complete example, from the OpenERP official distribution, of the function that does bill of material explosion and computation of associated routings: + +.. code-block:: python + + class mrp_bom(osv.osv): + ... + def _bom_find(self, cr, uid, product_id, product_uom, properties=[]): + bom_result = False + # Why searching on BoM without parent ? + cr.execute('select id from mrp_bom where product_id=%d and bom_id is null + order by sequence', (product_id,)) + ids = map(lambda x: x[0], cr.fetchall()) + max_prop = 0 + result = False + for bom in self.pool.get('mrp.bom').browse(cr, uid, ids): + prop = 0 + for prop_id in bom.property_ids: + if prop_id.id in properties: + prop+=1 + if (prop>max_prop) or ((max_prop==0) and not result): + result = bom.id + max_prop = prop + return result + + def _bom_explode(self, cr, uid, bom, factor, properties, addthis=False, level=10): + factor = factor / (bom.product_efficiency or 1.0) + factor = rounding(factor, bom.product_rounding) + if factor`_, +`three-tier architecture +`_. +The application tier itself is written as a core, multiple additional +modules can be installed to create a particular configuration of +OpenERP. + +The core of OpenERP and its modules are written in `Python +`_. The functionality of a module is exposed through +XML-RPC (and/or NET-RPC depending on the server's configuration)[#]. Modules +typically make use of OpenERP's ORM to persist their data in a relational +database (PostgreSQL). Modules can insert data in the database during +installation by providing XML, CSV, or YML files. + +.. figure:: images/client_server.png + :scale: 85 + :align: center + +.. [#] JSON-RPC is planned for OpenERP v6.1. + +The 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. The salient features are a flexible ORM, +a MVC architecture, extensible data models and views, different report engines, +all tied together in a coherent, network-accessible framework. + +From a developer perspective, the server acts both as a library which brings +the above benefits while hiding the low-level, nitty-gritty details, and as a +simple way to install, configure and run the written applications. + +Modules +------- + +By itself, the OpenERP server is not very useful. For any enterprise, the value +of OpenERP lies in its different modules. It is the role of the modules to +implement any business needs. The server is only the necessary machinery to run +the modules. A lot of modules already exist. Any official OpenERP release +includes about 170 of them, and hundreds of modules are available through the +community. Examples of modules are Account, CRM, HR, Marketing, MRP, Sale, etc. + +A module is usually composed of data models, together with some initial data, +views definitions (i.e. how data from specific data models should be displayed +to the user), wizards (specialized screens to help the user for specific +interactions), workflows definitions, and reports. + +Clients +------- + +Clients can communicate with an OpenERP server using XML-RPC. A custom, faster +protocol called NET-RPC is also provided but will shortly disappear, replaced +by JSON-RPC. XML-RPC, as JSON-RPC in the future, makes it possible to write +clients for OpenERP in a variety of programming languages. OpenERP S.A. +develops two different clients: a desktop client, written with the widely used +`GTK+ `_ graphical toolkit, and a web client that should +run in any modern web browser. + +As the logic of OpenERP should entirely reside on the server, the client is +conceptually very simple; it issues a request to the server and display the result +(e.g. a list of customers) in different manners (as forms, lists, calendars, +...). Upon user actions, it will send modified data to the server. + +Relational database server and ORM +---------------------------------- + +The data tier of OpenERP is provided by a PostgreSQL relational database. While +direct SQL queries can be executed from OpenERP modules, most database access +to the relational database is done through the `Object-Relational Mapping +`_. + +The ORM is one of the salient features mentioned above. The data models are +described in Python and OpenERP creates the underlying database tables. All the +benefits of RDBMS (unique constraints, relational integrity, efficient +querying, ...) are used when possible 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 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 reaction can only happen if the ORM is used to create that data. + +Models +------ + +To define data models and otherwise pursue any work with the associated data, +OpenERP as many ORMs uses the concept of 'model'. A model is the authoritative +specification of how some data are structured, constrained, and manipulated. In +practice, a model is written as a Python class. The class encapsulates anything +there is to know about the model: the different fields composing the model, +default values to be used when creating new records, constraints, and so on. It +also holds the dynamic aspect of the data it controls: methods on the class can +be written to implement any business needs (for instance, what to do upon user +action, or upon workflow transitions). + +There are two different models. One is simply called 'model', and the second is +called 'transient model'. The two models provide the same capabilities with a +single difference: transient models are automatically cleared from the +database (they can be cleaned when some limit on the number of records is +reached, or when they are untouched for some time). + +To describe the data model per se, OpenERP offers a range of different kind of +fields. There are basic fields such as integer, or text fields. There are +relational fields to implement one-to-many, many-to-one, and many-to-many +relationships. There are so-called function fields, which are dynamically +computed and are not necessarily available in database, and more. + +Access to data is controlled by OpenERP and configured by different mechanisms. +This ensures that different users can have read and/or write access to only the +relevant data. Access can be controlled with respect to user groups and rules +based on the value of the data themselves. + +Modules +------- + +OpenERP supports a modular approach both from a development perspective and a +deployment point of view. In essence, a module groups everything related to a +single concern in one meaningful entity. It is comprised of models, views, +workflows, and wizards. + +Services and WSGI +----------------- + +Everything in OpenERP, and models 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. + +While not mandatory, the services can make use of the `WSGI +`_ 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, but +also to use OpenERP to host a WSGI application. + +A striking example of this possibility is the OpenERP Web project. OpenERP Web +is the server-side counter part to the web clients. It is OpenERP Web which +provides the web pages to the browser and manages web sessions. OpenERP Web is +a WSGI-compliant application. As such, it can be run as a stand-alone HTTP +server or embedded inside OpenERP. + +XML-RPC, JSON-RPC +----------------- + +The access to the models makes also use of the WSGI stack. This can be done +using the XML-RPC protocol, and JSON-RPC will be added soon. + + +Explanation of modules: + +**Server - Base distribution** + +We use a distributed communication mechanism inside the OpenERP server. Our engine supports most commonly distributed patterns: request/reply, publish/subscribe, monitoring, triggers/callback, ... + +Different business objects can be in different computers or the same objects can be on multiple computers to perform load-balancing. + +**Server - Object Relational Mapping (ORM)** + +This layer provides additional object functionality on top of PostgreSQL: + + * Consistency: powerful validity checks, + * Work with objects (methods, references, ...) + * Row-level security (per user/group/role) + * Complex actions on a group of resources + * Inheritance + +**Server - Web-Services** + +The web-service module offer a common interface for all web-services + + * SOAP + * XML-RPC + * NET-RPC + +Business objects can also be accessed via the distributed object mechanism. They can all be modified via the client interface with contextual views. + +**Server - Workflow Engine** + +Workflows are graphs represented by business objects that describe the dynamics of the company. Workflows are also used to track processes that evolve over time. + +An example of workflow used in OpenERP: + +A sales order generates an invoice and a shipping order + +**Server - Report Engine** + +Reports in OpenERP can be rendered in different ways: + + * Custom reports: those reports can be directly created via the client interface, no programming required. Those reports are represented by business objects (ir.report.custom) + * High quality personalized reports using openreport: no programming required but you have to write 2 small XML files: + + - a template which indicates the data you plan to report + - an XSL:RML stylesheet + * Hard coded reports + * OpenOffice Writer templates + +Nearly all reports are produced in PDF. + +**Server - Business Objects** + +Almost everything is a business object in OpenERP, they describe all data of the program (workflows, invoices, users, customized reports, ...). Business objects are described using the ORM module. They are persistent and can have multiple views (described by the user or automatically calculated). + +Business objects are structured in the /module directory. + +**Client - Wizards** + +Wizards are graphs of actions/windows that the user can perform during a session. + +**Client - Widgets** + +Widgets are probably, although the origin of the term seems to be very difficult to trace, "WIndow gaDGETS" in the IT world, which mean they are gadgets before anything, which implement elementary features through a portable visual tool. + +All common widgets are supported: + + * entries + * textboxes + * floating point numbers + * dates (with calendar) + * checkboxes + * ... + +And also all special widgets: + + * buttons that call actions + * references widgets + + - one2one + + - many2one + + - many2many + + - one2many in list + + - ... + +Widget have different appearances in different views. For example, the date widget in the search dialog represents two normal dates for a range of date (from...to...). + +Some widgets may have different representations depending on the context. For example, the one2many widget can be represented as a form with multiple pages or a multi-columns list. + +Events on the widgets module are processed with a callback mechanism. A callback mechanism is a process whereby an element defines the type of events he can handle and which methods should be called when this event is triggered. Once the event is triggered, the system knows that the event is bound to a specific method, and calls that method back. Hence callback. + + +Module Integrations +=================== + +The are many different modules available for OpenERP and suited for different business models. Nearly all of these are optional (except ModulesAdminBase), making it easy to customize OpenERP to serve specific business needs. All the modules are in a directory named addons/ on the server. You simply need to copy or delete a module directory in order to either install or delete the module on the OpenERP platform. + +Some modules depend on other modules. See the file addons/module/__openerp__.py for more information on the dependencies. + +Here is an example of __openerp__.py: + +.. code-block:: python + + { + "name" : "Open TERP Accounting", + "version" : "1.0", + "author" : "Bob Gates - Not So Tiny", + "website" : "http://www.openerp.com/", + "category" : "Generic Modules/Others", + "depends" : ["base"], + "description" : """A + Multiline + Description + """, + "init_xml" : ["account_workflow.xml", "account_data.xml", "account_demo.xml"], + "demo_xml" : ["account_demo.xml"], + "update_xml" : ["account_view.xml", "account_report.xml", "account_wizard.xml"], + "active": False, + "installable": True + } + +When initializing a module, the files in the init_xml list are evaluated in turn and then the files in the update_xml list are evaluated. When updating a module, only the files from the **update_xml** list are evaluated. + + +Inheritance +=========== + +Traditional Inheritance +----------------------- + +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. + +Inheritance by Delegation +------------------------- + + **Syntax :**:: + + class tiny_object(osv.osv) + _name = 'tiny.object' + _table = 'tiny_object' + _inherits = { 'tiny.object_a' : 'name_col_a', 'tiny.object_b' : 'name_col_b', + ..., 'tiny.object_n' : 'name_col_n' } + (...) + + +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 *'name_col_a' 'name_col_b' ... 'name_col_n'* 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. From 597a2877235c88750b5441d4e5325b4561977f80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20Delavall=C3=A9e?= Date: Tue, 17 Apr 2012 14:52:42 +0200 Subject: [PATCH 06/15] [DOC] [REF] Refactored architecture chapter. bzr revid: tde@openerp.com-20120417125242-5xy4tugaa9fd7e4q --- doc/02_architecture.rst | 727 +++++++++++----------------------------- doc/index.rst.inc | 3 +- 2 files changed, 196 insertions(+), 534 deletions(-) diff --git a/doc/02_architecture.rst b/doc/02_architecture.rst index 867d5be7c15..bf1b3192e37 100644 --- a/doc/02_architecture.rst +++ b/doc/02_architecture.rst @@ -2,568 +2,229 @@ Architecture ======================================== -MVC architecture -================ +OpenERP as a multitenant three-tiers architecture +================================================= -According to `Wikipedia `_, "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. +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. -.. figure:: images/MVCDiagram.png - :scale: 100 +OpenERP is a `multitenant `_, `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, which allow users to access OpenERP. Two clients exist, a + desktop GTK client and a browser-based client + + - the GTK client access directly to the OpenERP Server + - users can also use standard web browsers to access OpenERP. In that + case, an OpenERP application is loaded. It handles communications between + the browser and the Web layer of the server. + +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 - MVC Diagram +The next subsections give details about the different tiers of the OpenERP +architecture. -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 : +PostgreSQL database ++++++++++++++++++++ - * 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. +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. -MVC Model in OpenERP --------------------- +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. -In OpenERP, we can apply this model-view-controller semantic with - - * model : The PostgreSQL tables. - * view : views are defined in XML files in OpenERP. - * controller : The objects of OpenERP. - - -MVCSQL ------- - -Example 1 -+++++++++ - -Suppose sale is a variable on a record of the sale.order object related to the 'sale_order' table. You can acquire such a variable doing this.:: - - sale = self.browse(cr, uid, ID) - -(where cr is the current row, from the database cursor, uid is the current user's ID for security checks, and ID is the sale order's ID or list of IDs if we want more than one) - -Suppose you want to get: the country name of the first contact of a partner related to the ID sale order. You can do the following in OpenERP:: - - country_name = sale.partner_id.address[0].country_id.name - -If you want to write the same thing in traditional SQL development, it will be in python: (we suppose cr is the cursor on the database, with psycopg) - -.. code-block:: python - - cr.execute('select partner_id from sale_order where id=%d', (ID,)) - partner_id = cr.fetchone()[0] - cr.execute('select country_id from res_partner_address where partner_id=%d', (partner_id,)) - country_id = cr.fetchone()[0] - cr.execute('select name from res_country where id=%d', (country_id,)) - del partner_id - del country_id - country_name = cr.fetchone()[0] - -Of course you can do better if you develop smartly in SQL, using joins or subqueries. But you have to be smart and most of the time you will not be able to make such improvements: - - * Maybe some parts are in others functions - * There may be a loop in different elements - * You have to use intermediate variables like country_id - -The first operation as an object call is much better for several reasons: - - * It uses objects facilities and works with modules inheritances, overload, ... - * It's simpler, more explicit and uses less code - * It's much more efficient as you will see in the following examples - * Some fields do not directly correspond to a SQL field (e.g.: function fields in Python) - - -Prefetching -+++++++++++ - -Suppose that later in the code, in another function, you want to access the name of the partner associated to your sale order. You can use this:: - - partner_name = sale.partner_id.name - -And this will not generate any SQL query as it has been prefetched by the object relational mapping engine of OpenERP. - - -Loops and special fields -++++++++++++++++++++++++ - -Suppose now that you want to compute the totals of 10 sales order by countries. You can do this in OpenERP within a OpenERP object: - -.. code-block:: python - - def get_totals(self, cr, uid, ids): - countries = {} - for sale in self.browse(cr, uid, ids): - country = sale.partner_invoice_id.country - countries.setdefault(country, 0.0) - countries[country] += sale.amount_untaxed - return countries - -And, to print them as a good way, you can add this on your object: - -.. code-block:: python - - def print_totals(self, cr, uid, ids): - result = self.get_totals(cr, uid, ids) - for country in result.keys(): - print '[%s] %s: %.2f' (country.code, country.name, result[country]) - -The 2 functions will generate 4 SQL queries in total ! This is due to the SQL engine of OpenERP that does prefetching, works on lists and uses caching methods. The 3 queries are: - - 1. Reading the sale.order to get ID's of the partner's address - 2. Reading the partner's address for the countries - 3. Calling the amount_untaxed function that will compute a total of the sale order lines - 4. Reading the countries info (code and name) - -That's great because if you run this code on 1000 sales orders, you have the guarantee to only have 4 SQL queries. - -Notes: - - * IDS is the list of the 10 ID's: [12,15,18,34, ...,99] - * The arguments of a function are always the same: - - - cr: the cursor database (from psycopg) - - uid: the user id (for security checks) - * If you run this code on 5000 sales orders, you may have 8 SQL queries because as SQL queries are not allowed to take too much memory, it may have to do two separate readings. - - -Complex example -+++++++++++++++ - -Here is a complete example, from the OpenERP official distribution, of the function that does bill of material explosion and computation of associated routings: - -.. code-block:: python - - class mrp_bom(osv.osv): - ... - def _bom_find(self, cr, uid, product_id, product_uom, properties=[]): - bom_result = False - # Why searching on BoM without parent ? - cr.execute('select id from mrp_bom where product_id=%d and bom_id is null - order by sequence', (product_id,)) - ids = map(lambda x: x[0], cr.fetchall()) - max_prop = 0 - result = False - for bom in self.pool.get('mrp.bom').browse(cr, uid, ids): - prop = 0 - for prop_id in bom.property_ids: - if prop_id.id in properties: - prop+=1 - if (prop>max_prop) or ((max_prop==0) and not result): - result = bom.id - max_prop = prop - return result - - def _bom_explode(self, cr, uid, bom, factor, properties, addthis=False, level=10): - factor = factor / (bom.product_efficiency or 1.0) - factor = rounding(factor, bom.product_rounding) - if factor`_, -`three-tier architecture -`_. -The application tier itself is written as a core, multiple additional -modules can be installed to create a particular configuration of -OpenERP. - -The core of OpenERP and its modules are written in `Python -`_. The functionality of a module is exposed through -XML-RPC (and/or NET-RPC depending on the server's configuration)[#]. Modules -typically make use of OpenERP's ORM to persist their data in a relational -database (PostgreSQL). Modules can insert data in the database during -installation by providing XML, CSV, or YML files. - -.. figure:: images/client_server.png - :scale: 85 - :align: center - -.. [#] JSON-RPC is planned for OpenERP v6.1. - -The OpenERP server ------------------- +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. The salient features are a flexible ORM, -a MVC architecture, extensible data models and views, different report engines, -all tied together in a coherent, network-accessible framework. +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, nitty-gritty details, and as a -simple way to install, configure and run the written applications. +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. -Modules -------- +**Server - ORM** -By itself, the OpenERP server is not very useful. For any enterprise, the value -of OpenERP lies in its different modules. It is the role of the modules to -implement any business needs. The server is only the necessary machinery to run -the modules. A lot of modules already exist. Any official OpenERP release -includes about 170 of them, and hundreds of modules are available through the -community. Examples of modules are Account, CRM, HR, Marketing, MRP, Sale, etc. +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. -A module is usually composed of data models, together with some initial data, -views definitions (i.e. how data from specific data models should be displayed -to the user), wizards (specialized screens to help the user for specific -interactions), workflows definitions, and reports. +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 layer relies on CherryPy for the routing +layer of communications, especially for session and cookies management. + +**Modules** + +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. Clients -------- ++++++++ -Clients can communicate with an OpenERP server using XML-RPC. A custom, faster -protocol called NET-RPC is also provided but will shortly disappear, replaced -by JSON-RPC. XML-RPC, as JSON-RPC in the future, makes it possible to write -clients for OpenERP in a variety of programming languages. OpenERP S.A. -develops two different clients: a desktop client, written with the widely used -`GTK+ `_ graphical toolkit, and a web client that should -run in any modern web browser. +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. -As the logic of OpenERP should entirely reside on the server, the client is -conceptually very simple; it issues a request to the server and display the result -(e.g. a list of customers) in different manners (as forms, lists, calendars, -...). Upon user actions, it will send modified data to the server. +Two clients can be used for user access to OpenERP, a GTK client and a +browser-based client. The GTK client communicates directly with the server. +Using the GTK client requires the client to be installed on the workstation +of each user. -Relational database server and ORM ----------------------------------- +The browser-based client holds an OpenERP application that handles communications +between the browser and the Web layer of the server. The static code of the web +application is minimal. It consists of a minimal flow of HTML that is in charge +of loading the application code in Javascript. This client-side OpenERP application +sends user requests to the server, and gets data back. Data management is +done dynamically in this client. Using this client is therefore easy for +users, but also for administrators because it does not require any software +installation on the user machine. -The data tier of OpenERP is provided by a PostgreSQL relational database. While -direct SQL queries can be executed from OpenERP modules, most database access -to the relational database is done through the `Object-Relational Mapping -`_. -The ORM is one of the salient features mentioned above. The data models are -described in Python and OpenERP creates the underlying database tables. All the -benefits of RDBMS (unique constraints, relational integrity, efficient -querying, ...) are used when possible 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[#]. +MVC architecture in OpenERP +=========================== -.. [#] It is important to understand the ORM responsibility before attempting to by-pass it and 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 reaction can only happen if the ORM is used to create that data. +According to `Wikipedia `_, +"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. -Models ------- +.. _`Figure 3`: +.. figure:: _static/02_mvc_diagram.png + :width: 35% + :alt: Model-View-Controller diagram + :align: center + + Model-View-Controller diagram -To define data models and otherwise pursue any work with the associated data, -OpenERP as many ORMs uses the concept of 'model'. A model is the authoritative -specification of how some data are structured, constrained, and manipulated. In -practice, a model is written as a Python class. The class encapsulates anything -there is to know about the model: the different fields composing the model, -default values to be used when creating new records, constraints, and so on. It -also holds the dynamic aspect of the data it controls: methods on the class can -be written to implement any business needs (for instance, what to do upon user -action, or upon workflow transitions). +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 : -There are two different models. One is simply called 'model', and the second is -called 'transient model'. The two models provide the same capabilities with a -single difference: transient models are automatically cleared from the -database (they can be cleaned when some limit on the number of records is -reached, or when they are untouched for some time). + - 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. -To describe the data model per se, OpenERP offers a range of different kind of -fields. There are basic fields such as integer, or text fields. There are -relational fields to implement one-to-many, many-to-one, and many-to-many -relationships. There are so-called function fields, which are dynamically -computed and are not necessarily available in database, and more. +OpenERP follows the MVC semantic with -Access to data is controlled by OpenERP and configured by different mechanisms. -This ensures that different users can have read and/or write access to only the -relevant data. Access can be controlled with respect to user groups and rules -based on the value of the data themselves. + - model : The PostgreSQL tables. + - view : views are defined in XML files in OpenERP. + - controller : The objects of OpenERP. -Modules -------- -OpenERP supports a modular approach both from a development perspective and a -deployment point of view. In essence, a module groups everything related to a -single concern in one meaningful entity. It is comprised of models, views, -workflows, and wizards. +Network communications +====================== + +GTK clients communicate with the OpenERP server using XML-RPC protocol by +default. However, using a secured version XML-RPCS is possible when configurating +your OpenERP instance. In previous versions of OpenERP, a custom protocol +called NET-RPC was used. It was a binary version of the XML-RPC protocol, +allowing faster communications. However, this protocol will no longer be +used in OpenERP. The use of JSON-RPC is also planned for the 6.1 version +of OpenERP. + +Web-based clients communicate using HTTP protocol. As for XML-RPC, it is +possible to configure OpenERP to use secured HTTPS connections. Services and WSGI ------------------ - -Everything in OpenERP, and models 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. - -While not mandatory, the services can make use of the `WSGI -`_ 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, but -also to use OpenERP to host a WSGI application. - -A striking example of this possibility is the OpenERP Web project. OpenERP Web -is the server-side counter part to the web clients. It is OpenERP Web which -provides the web pages to the browser and manages web sessions. OpenERP Web is -a WSGI-compliant application. As such, it can be run as a stand-alone HTTP -server or embedded inside OpenERP. - -XML-RPC, JSON-RPC ------------------ - -The access to the models makes also use of the WSGI stack. This can be done -using the XML-RPC protocol, and JSON-RPC will be added soon. - - -Explanation of modules: - -**Server - Base distribution** - -We use a distributed communication mechanism inside the OpenERP server. Our engine supports most commonly distributed patterns: request/reply, publish/subscribe, monitoring, triggers/callback, ... - -Different business objects can be in different computers or the same objects can be on multiple computers to perform load-balancing. - -**Server - Object Relational Mapping (ORM)** - -This layer provides additional object functionality on top of PostgreSQL: - - * Consistency: powerful validity checks, - * Work with objects (methods, references, ...) - * Row-level security (per user/group/role) - * Complex actions on a group of resources - * Inheritance - -**Server - Web-Services** - -The web-service module offer a common interface for all web-services - - * SOAP - * XML-RPC - * NET-RPC - -Business objects can also be accessed via the distributed object mechanism. They can all be modified via the client interface with contextual views. - -**Server - Workflow Engine** - -Workflows are graphs represented by business objects that describe the dynamics of the company. Workflows are also used to track processes that evolve over time. - -An example of workflow used in OpenERP: - -A sales order generates an invoice and a shipping order - -**Server - Report Engine** - -Reports in OpenERP can be rendered in different ways: - - * Custom reports: those reports can be directly created via the client interface, no programming required. Those reports are represented by business objects (ir.report.custom) - * High quality personalized reports using openreport: no programming required but you have to write 2 small XML files: - - - a template which indicates the data you plan to report - - an XSL:RML stylesheet - * Hard coded reports - * OpenOffice Writer templates - -Nearly all reports are produced in PDF. - -**Server - Business Objects** - -Almost everything is a business object in OpenERP, they describe all data of the program (workflows, invoices, users, customized reports, ...). Business objects are described using the ORM module. They are persistent and can have multiple views (described by the user or automatically calculated). - -Business objects are structured in the /module directory. - -**Client - Wizards** - -Wizards are graphs of actions/windows that the user can perform during a session. - -**Client - Widgets** - -Widgets are probably, although the origin of the term seems to be very difficult to trace, "WIndow gaDGETS" in the IT world, which mean they are gadgets before anything, which implement elementary features through a portable visual tool. - -All common widgets are supported: - - * entries - * textboxes - * floating point numbers - * dates (with calendar) - * checkboxes - * ... - -And also all special widgets: - - * buttons that call actions - * references widgets - - - one2one - - - many2one - - - many2many - - - one2many in list - - - ... - -Widget have different appearances in different views. For example, the date widget in the search dialog represents two normal dates for a range of date (from...to...). - -Some widgets may have different representations depending on the context. For example, the one2many widget can be represented as a form with multiple pages or a multi-columns list. - -Events on the widgets module are processed with a callback mechanism. A callback mechanism is a process whereby an element defines the type of events he can handle and which methods should be called when this event is triggered. Once the event is triggered, the system knows that the event is bound to a specific method, and calls that method back. Hence callback. - - -Module Integrations -=================== - -The are many different modules available for OpenERP and suited for different business models. Nearly all of these are optional (except ModulesAdminBase), making it easy to customize OpenERP to serve specific business needs. All the modules are in a directory named addons/ on the server. You simply need to copy or delete a module directory in order to either install or delete the module on the OpenERP platform. - -Some modules depend on other modules. See the file addons/module/__openerp__.py for more information on the dependencies. - -Here is an example of __openerp__.py: - -.. code-block:: python - - { - "name" : "Open TERP Accounting", - "version" : "1.0", - "author" : "Bob Gates - Not So Tiny", - "website" : "http://www.openerp.com/", - "category" : "Generic Modules/Others", - "depends" : ["base"], - "description" : """A - Multiline - Description - """, - "init_xml" : ["account_workflow.xml", "account_data.xml", "account_demo.xml"], - "demo_xml" : ["account_demo.xml"], - "update_xml" : ["account_view.xml", "account_report.xml", "account_wizard.xml"], - "active": False, - "installable": True - } - -When initializing a module, the files in the init_xml list are evaluated in turn and then the files in the update_xml list are evaluated. When updating a module, only the files from the **update_xml** list are evaluated. - - -Inheritance -=========== - -Traditional Inheritance ------------------------ - -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. - -Inheritance by Delegation -------------------------- - - **Syntax :**:: - - class tiny_object(osv.osv) - _name = 'tiny.object' - _table = 'tiny_object' - _inherits = { 'tiny.object_a' : 'name_col_a', 'tiny.object_b' : 'name_col_b', - ..., 'tiny.object_n' : 'name_col_n' } - (...) - - -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 *'name_col_a' 'name_col_b' ... 'name_col_n'* 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. +================= + +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. + +While not mandatory, the services can make use of the `WSGI +`_ 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. diff --git a/doc/index.rst.inc b/doc/index.rst.inc index e36bccd79d5..670ffd7f53d 100644 --- a/doc/index.rst.inc +++ b/doc/index.rst.inc @@ -3,9 +3,10 @@ OpenERP Server Documentation ''''''''''''''''''''''''''''' .. toctree:: - :maxdepth: 1 + :maxdepth: 2 01_getting_started + 02_architecture 99_test_framework Main revisions and new features From 7ceabb818d266458c4e52502e40ce03bca67c961 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Thibault=20Delavall=C3=A9e?= Date: Tue, 17 Apr 2012 15:40:34 +0200 Subject: [PATCH 07/15] [DOC] [ADD] Added module development chapter from developer book. bzr revid: tde@openerp.com-20120417134034-dqrgog0nxhz3d10e --- doc/03_module_dev.rst | 12 + doc/03_module_dev_01.rst | 597 ++++++++++++++++ doc/03_module_dev_02.rst | 959 +++++++++++++++++++++++++ doc/03_module_dev_03.rst | 1428 ++++++++++++++++++++++++++++++++++++++ doc/03_module_dev_04.rst | 365 ++++++++++ doc/03_module_dev_05.rst | 91 +++ doc/api/startup.rst | 1 - doc/index.rst | 1 + doc/index.rst.inc | 15 +- 9 files changed, 3466 insertions(+), 3 deletions(-) create mode 100644 doc/03_module_dev.rst create mode 100644 doc/03_module_dev_01.rst create mode 100644 doc/03_module_dev_02.rst create mode 100644 doc/03_module_dev_03.rst create mode 100644 doc/03_module_dev_04.rst create mode 100644 doc/03_module_dev_05.rst diff --git a/doc/03_module_dev.rst b/doc/03_module_dev.rst new file mode 100644 index 00000000000..a019af94601 --- /dev/null +++ b/doc/03_module_dev.rst @@ -0,0 +1,12 @@ +======= +Modules +======= + +.. toctree:: + :maxdepth: 2 + + 03_module_dev_01 + 03_module_dev_02 + 03_module_dev_03 + 03_module_dev_04 + 03_module_dev_05 diff --git a/doc/03_module_dev_01.rst b/doc/03_module_dev_01.rst new file mode 100644 index 00000000000..2da148fe1ca --- /dev/null +++ b/doc/03_module_dev_01.rst @@ -0,0 +1,597 @@ +Module development +================== + +Module Structure ++++++++++++++++++ + +All the modules are located in the source/addons directory. The following +steps are necessary to create a new module: + + * create a subdirectory in the source/addons directory + * create the import **__init__.py** file + * create a module description file: **__openerp__.py** + * create the **Python** file containing the **objects** + * create **.xml files** that create the data (views, menu entries, demo data, ...) + * optionally create **reports**, **wizards** or **workflows**. + +Python Module Descriptor File __init__.py +----------------------------------------- + +The ``__init__.py`` file is, like any Python module, executed at the start +of the program. It needs to import the Python files that need to be loaded. + +So, if you create a "module.py" file, containing the description of your +objects, you have to write one line in __init__.py:: + + import module + +OpenERP Module Descriptor File __openerp__.py +--------------------------------------------- + +In the created module directory, you must add a **__openerp__.py** file. +This file, which must be in Python format, 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. + +This file must contain a Python dictionary with the following values: + +**name** + + The (Plain English) name of the module. + +**version** + + The version of the module. + +**description** + + The module description (text). + +**author** + + The author of the module. + +**website** + + The website of the module. + +**license** + + The license of the module (default:GPL-2). + +**depends** + + List of modules on which this module depends. The base module must + almost always be in the dependencies because some necessary data for + the views, reports, ... are in the base module. + +**init_xml** + + List of .xml files to load when the server is launched with the "--init=module" + argument. Filepaths must be relative to the directory where the module is. + OpenERP XML File Format is detailed in this section. + +**update_xml** + + List of .xml files to load when the server is launched with the "--update=module" + launched. Filepaths must be relative to the directory where the module is. + OpenERP XML File Format is detailed in this section. The files in **update_xml** + concern: views, reports and wizards. + +**installable** + + True or False. Determines if the module is installable or not. + +**active** + + True or False (default: False). Determines the modules that are installed + on the database creation. + +**Example** + +Here is an example of __openerp__.py file for the product module + +.. code-block:: python + + { + "name" : "Products & Pricelists", + "version" : "1.1", + "author" : "Open", + "category" : "Generic Modules/Inventory Control", + "depends" : ["base", "account"], + "init_xml" : [], + "demo_xml" : ["product_demo.xml"], + "update_xml" : ["product_data.xml", "product_report.xml", "product_wizard.xml", + "product_view.xml", "pricelist_view.xml"], + "installable": True, + "active": True + } + +The files that must be placed in init_xml are the ones that relate to the +workflow definition, data to load at the installation of the software and +the data for the demonstrations. + + +XML Files ++++++++++ + +XML files located in the module directory are used to modify the structure of +the database. They are used for many purposes, among which we can cite : + + * initialization and demonstration data declaration, + * views declaration, + * reports declaration, + * wizards 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. + + +Objects ++++++++ + +All OpenERP resources are objects: menus, actions, reports, invoices, partners, ... OpenERP is based on an object relational mapping of a database to control the information. 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. + +Other advantages of an ORM; + + * simpler relations : invoice.partner.address[0].city + * objects have properties and methods: invoice.pay(3400 EUR), + * inheritance, high level constraints, ... + +It is easier to manipulate one object (example, a partner) than several tables (partner address, categories, events, ...) + + +.. figure:: images/pom_3_0_3.png + :scale: 50 + :align: center + + *The Physical Objects Model of [OpenERP version 3.0.3]* + + +PostgreSQL and ORM +------------------ + +The ORM of OpenERP is constructed over PostgreSQL. It is thus possible to +query the object used by OpenERP using the object interface 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. + +.. note:: + + The Physical Database Model of OpenERP + +Pre-Installed Data +------------------ + +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 + + + + + + + "field1 content" + + + "field2 content" + + (...) + + + (...) + + (...) + + + +Fields content are strings that must be encoded as *UTF-8* in XML files. + +Let's review an example taken from the OpenERP source (base_demo.xml in the base module): + +.. code-block:: xml + + + Tiny sprl + + + + +.. code-block:: xml + + + admin + admin + Administrator + Administrator + + + + + + + +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 + + + +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 + + + +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. + +Record Tag +////////// + +**Description** + +The addition of new data is made with the record tag. This one takes a mandatory attribute : model. Model is the object name where the insertion has to be done. The tag record can also take an optional attribute: id. If this attribute is given, a variable of this name can be used later on, in the same file, to make reference to the newly created resource ID. + +A record tag may contain field tags. They indicate the record's fields value. If a field is not specified the default value will be used. + +**Example** + +.. code-block:: xml + + + account.invoice + Invoices List + account.invoice.list + account/report/invoice.xsl + account/report/invoice.xml + + +Field tag +///////// + +The attributes for the field tag are the following: + +name : mandatory + the field name + +eval : optional + python expression that indicating the value to add + +ref + reference to an id defined in this file + +model + model to be looked up in the search + +search + a query + +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 + + + +Getitem tag +/////////// + +Takes a subset of the evaluation of the last child node of the tag. + +type : mandatory + int or list + +index : mandatory + int or string (a key of a dictionary) + +**Example** + +Evaluates to the first element of the list of ids returned by the function node + +.. code-block:: xml + + + + + +i18n +"""" + +Improving Translations +////////////////////// + +.. describe:: Translating in launchpad + +Translations are managed by +the `Launchpad Web interface `_. Here, you'll +find the list of translatable projects. + +Please read the `FAQ `_ before asking questions. + +.. describe:: Translating your own module + +.. versionchanged:: 5.0 + +Contrary to the 4.2.x version, the translations are now done by module. So, +instead of an unique ``i18n`` folder for the whole application, 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. OpenERP can also +generate a .tgz archive containing well organised ``.po`` files for each selected +module. + +.. [#f_po] http://www.gnu.org/software/autoconf/manual/gettext/PO-Files.html#PO-Files + +Process +""""""" + +Defining the process +//////////////////// + +Through the interface and module recorder. +Then, put the generated XML in your own module. + +Views +""""" + +Technical Specifications - Architecture - 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 `_ chapter. + +Wizards +""""""" + +Here's an example of a .XML file that declares a wizard. + +.. code-block:: xml + + + + + + + + +A wizard is declared using a wizard tag. See "Add A New Wizard" for more information about wizard XML. + +also you can add wizard in menu using following xml entry + +.. code-block:: xml + + + + + + + + + +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 + + +Profile Module +++++++++++++++ + +The purpose of a profile is to initialize OpenERP with a set of modules directly after the database has been created. A profile is a special kind of module that contains no code, only *dependencies on other modules*. + +In order to create a profile, you only have to create a new directory in server/addons (you *should* call this folder profile_modulename), in which you put an *empty* __init__.py file (as every directory Python imports must contain an __init__.py file), and a __openerp__.py whose structure is as follows : + +.. code-block:: python + + { + "name":"''Name of the Profile'', + "version":"''Version String''", + "author":"''Author Name''", + "category":"Profile", + "depends":[''List of the modules to install with the profile''], + "demo_xml":[], + "update_xml":[], + "active":False, + "installable":True, + } + +Here's the code of the file source/addons/profile_tools/__openerp__.py, +which corresponds to the tools profile in OpenERP. + +.. code-block:: python + + { + "name" : "Miscellaneous Tools", + "version" : "1.0", + "depends" : ["base", "base_setup"], + "author" : "OpenERP SA", + "category" : "Hidden/Dependency", + 'complexity': "easy", + "description": """ + Installer for extra Hidden like lunch, survey, idea, share, etc. + ================================================================ + + Makes the Extra Hidden Configuration available from where you can install + modules like share, lunch, pad, idea, survey and subscription. + """, + 'website': 'http://www.openerp.com', + 'init_xml': [], + 'update_xml': [ + ], + 'demo_xml': [], + 'installable': True, + 'auto_install': False, + 'certificate' : '00557100228403879621', + 'images': ['images/config_extra_Hidden.jpeg'], + } + + + + + +Action creation +--------------- + +Linking events to action +++++++++++++++++++++++++ + +The available type of events are: + + * **client_print_multi** (print from a list or form) + * **client_action_multi** (action from a list or form) + * **tree_but_open** (double click on the item of a tree, like the menu) + * **tree_but_action** (action on the items of a tree) + +To map an events to an action: + +.. code-block:: xml + + + tree_but_open + account.journal.period + Open Journal + + + + +If you double click on a journal/period (object: account.journal.period), this will open the selected wizard. (id="action_move_journal_line_form_select"). + +You can use a res_id field to allow this action only if the user click on a specific object. + +.. code-block:: xml + + + tree_but_open + account.journal.period + Open Journal + + + + + +The action will be triggered if the user clicks on the account.journal.period n°3. + +When you declare wizard, report or menus, the ir.values creation is automatically made with these tags: + + * + * + * + +So you usually do not need to add the mapping by yourself. diff --git a/doc/03_module_dev_02.rst b/doc/03_module_dev_02.rst new file mode 100644 index 00000000000..c7075a8f7ae --- /dev/null +++ b/doc/03_module_dev_02.rst @@ -0,0 +1,959 @@ +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 ` 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` + (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` + (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. + + +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'), + } + hr_contract() + +If we want to add a field that retrieves the function of an employee by looking its current contract, we use a functional field. The object hr_employee is inherited this way: + +.. code-block:: python + + class hr_employee(osv.osv): + _name = "hr.employee" + _description = "Employee" + _inherit = "hr.employee" + _columns = { + 'contract_ids' : fields.one2many('hr.contract', 'employee_id', 'Contracts'), + 'function' : fields.function( + _get_cur_function_id, + type='many2one', + obj="res.partner.function", + method=True, + string='Contract Function'), + } + hr_employee() + +.. note:: three points + + * :guilabel:`type` ='many2one' is because the function field must create + a many2one field; function is declared as a many2one in hr_contract also. + * :guilabel:`obj` ="res.partner.function" is used to specify that the + object to use for the many2one field is res.partner.function. + * We called our method :guilabel:`_get_cur_function_id` because its role + is to return a dictionary whose keys are ids of employees, and whose + corresponding values are ids of the function of those employees. The + code of this method is: + +.. code-block:: python + + def _get_cur_function_id(self, cr, uid, ids, field_name, arg, context): + for i in ids: + #get the id of the current function of the employee of identifier "i" + sql_req= """ + SELECT f.id AS func_id + FROM hr_contract c + LEFT JOIN res_partner_function f ON (f.id = c.function) + WHERE + (c.employee_id = %d) + """ % (i,) + + cr.execute(sql_req) + sql_res = cr.dictfetchone() + + if sql_res: #The employee has one associated contract + res[i] = sql_res['func_id'] + else: + #res[i] must be set to False and not to None because of XML:RPC + # "cannot marshal None unless allow_none is enabled" + res[i] = False + return res + +The id of the function is retrieved using a SQL query. Note that if the query +returns no result, the value of sql_res['func_id'] will be None. We force the +False value in this case value because XML:RPC (communication between the server +and the client) doesn't allow to transmit this value. + +store Parameter +""""""""""""""" +It will calculate the field and store the result in the table. The field will be +recalculated when certain fields are changed on other objects. It uses the +following syntax: + +.. code-block:: python + + store = { + 'object_name': ( + function_name, + ['field_name1', 'field_name2'], + priority) + } + +It will call function function_name when any changes are written to fields in the +list ['field1','field2'] on object 'object_name'. The function should have the +following signature:: + + def function_name(self, cr, uid, ids, context=None): + +Where `ids` will be the ids of records in the other object's table that have +changed values in the watched fields. The function should return a list of ids +of records in its own table that should have the field recalculated. That list +will be sent as a parameter for the main function of the field. + +Here's an example from the membership module: + +.. code-block:: python + + 'membership_state': + fields.function( + _membership_state, + method=True, + string='Current membership state', + type='selection', + selection=STATE, + store={ + 'account.invoice': (_get_invoice_partner, ['state'], 10), + 'membership.membership_line': (_get_partner_id,['state'], 10), + 'res.partner': ( + lambda self, cr, uid, ids, c={}: ids, + ['free_member'], + 10) + }), + +Property Fields ++++++++++++++++ + +.. describe:: Declaring a property + +A property is a special field: fields.property. + +.. code-block:: python + + class res_partner(osv.osv): + _name = "res.partner" + _inherit = "res.partner" + _columns = { + 'property_product_pricelist': + fields.property( + 'product.pricelist', + type='many2one', + relation='product.pricelist', + string="Sale Pricelist", + method=True, + view_load=True, + group_name="Pricelists Properties"), + } + + +Then you have to create the default value in a .XML file for this property: + +.. code-block:: xml + + + property_product_pricelist + + + + +.. + +.. tip:: + + if the default value points to a resource from another module, you can use the ref function like this: + + + +**Putting properties in forms** + +To add properties in forms, just put the tag in your form. This will automatically add all properties fields that are related to this object. The system will add properties depending on your rights. (some people will be able to change a specific property, others won't). + +Properties are displayed by section, depending on the group_name attribute. (It is rendered in the client like a separator tag). + +**How does this work ?** + +The fields.property class inherits from fields.function and overrides the read and write method. The type of this field is many2one, so in the form a property is represented like a many2one function. + +But the value of a property is stored in the ir.property class/table as a complete record. The stored value is a field of type reference (not many2one) because each property may point to a different object. If you edit properties values (from the administration menu), these are represented like a field of type reference. + +When you read a property, the program gives you the property attached to the instance of object you are reading. If this object has no value, the system will give you the default property. + +The definition of a property is stored in the ir.model.fields class like any other fields. In the definition of the property, you can add groups that are allowed to change to property. + +**Using properties or normal fields** + +When you want to add a new feature, you will have to choose to implement it as a property or as normal field. Use a normal field when you inherit from an object and want to extend this object. Use a property when the new feature is not related to the object but to an external concept. + + +Here are a few tips to help you choose between a normal field or a property: + +Normal fields extend the object, adding more features or data. + +A property is a concept that is attached to an object and have special features: + +* Different value for the same property depending on the company +* Rights management per field +* It's a link between resources (many2one) + +**Example 1: Account Receivable** + +The default "Account Receivable" for a specific partner is implemented as a property because: + + * This is a concept related to the account chart and not to the partner, so it is an account property that is visible on a partner form. Rights have to be managed on this fields for accountants, these are not the same rights that are applied to partner objects. So you have specific rights just for this field of the partner form: only accountants may change the account receivable of a partner. + + * This is a multi-company field: the same partner may have different account receivable values depending on the company the user belongs to. In a multi-company system, there is one account chart per company. The account receivable of a partner depends on the company it placed the sale order. + + * The default account receivable is the same for all partners and is configured from the general property menu (in administration). + +.. note:: + One interesting thing is that properties avoid "spaghetti" code. The account module depends on the partner (base) module. But you can install the partner (base) module without the accounting module. If you add a field that points to an account in the partner object, both objects will depend on each other. It's much more difficult to maintain and code (for instance, try to remove a table when both tables are pointing to each others.) + +**Example 2: Product Times** + +The product expiry module implements all delays related to products: removal date, product usetime, ... This module is very useful for food industries. + +This module inherits from the product.product object and adds new fields to it: + +.. code-block:: python + + class product_product(osv.osv): + + _inherit = 'product.product' + _name = 'product.product' + _columns = { + + 'life_time': fields.integer('Product lifetime'), + 'use_time': fields.integer('Product usetime'), + 'removal_time': fields.integer('Product removal time'), + 'alert_time': fields.integer('Product alert time'), + } + + product_product() + +.. + +This module adds simple fields to the product.product object. We did not use properties because: + + * We extend a product, the life_time field is a concept related to a product, not to another object. + * We do not need a right management per field, the different delays are managed by the same people that manage all products. + + +ORM methods +----------- + +Keeping the context in ORM methods +++++++++++++++++++++++++++++++++++ + +In OpenObject, the context holds very important data such as the language in +which a document must be written, whether function field needs updating or not, +etc. + +When calling an ORM method, you will probably already have a context - for +example the framework will provide you with one as a parameter of almost +every method. +If you do have a context, it is very important that you always pass it through +to every single method you call. + +This rule also applies to writing ORM methods. You should expect to receive a +context as parameter, and always pass it through to every other method you call.. diff --git a/doc/03_module_dev_03.rst b/doc/03_module_dev_03.rst new file mode 100644 index 00000000000..975ebbb3064 --- /dev/null +++ b/doc/03_module_dev_03.rst @@ -0,0 +1,1428 @@ +Views and Events +================ + +Introduction to Views +--------------------- + +As all data of the program is stored in objects, as explained in the Objects section, how are these objects exposed to the user ? We will try to answer this question in this section. + +First of all, let's note that every resource type uses its own interface. For example, the screen to modify a partner's data is not the same as the one to modify an invoice. + +Then, you have to know that the OpenERP user interface is dynamic, it means that it is not described "statically" by some code, but dynamically built from XML descriptions of the client screens. + +From now on, we will call these screen descriptions views. + +A notable characteristic of these views is that they can be edited at any moment (even during the program execution). After a modification to a displayed view has occurred, you simply need to close the tab corresponding to that 'view' and re-open it for the changes to appear. + +Views principles +++++++++++++++++ + +Views describe how each object (type of resource) is displayed. More precisely, for each object, we can define one (or several) view(s) to describe which fields should be drawn and how. + +There are two types of views: + + #. form views + #. tree views + +.. note:: Since OpenERP 4.1, form views can also contain graphs. + + +Form views +---------- + +The field disposition in a form view always follows the same principle. Fields are distributed on the screen following the rules below: + + * By default, each field is preceded by a label, with its name. + * Fields are placed on the screen from left to right, and from top to bottom, according to the order in which they are declared in the view. + * Every screen is divided into 4 columns, each column being able to contain either a label, or an "edition" field. As every edition field is preceded (by default) by a label with its name, there will be two fields (and their respective labels) on each line of the screen. The green and red zones on the screen-shot below, illustrate those 4 columns. They designate respectively the labels and their corresponding fields. + +.. figure:: images/sale_order.png + :scale: 50 + :align: center + + +Views also support more advanced placement options: + + * A view field can use several columns. For example, on the screen-shot below, the zone in the blue frame is, in fact, the only field of a "one to many". We will come back later on this note, but let's note that it uses the whole width of the screen and not only one column. + + .. figure:: images/sale_order_sale_order_lines.png + :scale: 50 + :align: center + + * We can also make the opposite operation: take a columns group and divide it in as many columns as desired. The surrounded green zones of the screen above are good examples. Precisely, the green framework up and on the right side takes the place of two columns, but contains 4 columns. + +As we can see below in the purple zone of the screen, there is also a way to distribute the fields of an object on different tabs. + +.. figure:: images/sale_order_notebook.png + :scale: 50 + :align: center + + +Tree views +----------- + +These views are used when we work in list mode (in order to visualize several resources at once) and in the search screen. These views are simpler than the form views and thus have less options. + +.. figure:: images/tree_view.png + :scale: 50 + :align: center + +Graph views +-------------- + +A graph is a new mode of view for all views of type form. If, for example, a sale order line must be visible as list or as graph, define it like this in the action that open this sale order line. Do not set the view mode as "tree,form,graph" or "form,graph" - it must be "graph,tree" to show the graph first or "tree,graph" to show the list first. (This view mode is extra to your "form,tree" view and should have a separate menu item): + +.. code-block:: xml + + form + tree,graph + +view_type:: + + tree = (tree with shortcuts at the left), form = (switchable view form/list) + +view_mode:: + + tree,graph : sequences of the views when switching + +Then, the user will be able to switch from one view to the other. Unlike forms and trees, OpenERP is not able to automatically create a view on demand for the graph type. So, you must define a view for this graph: + + +.. code-block:: xml + + + sale.order.line.graph + sale.order.line + graph + + + + + + + + + +The graph view + +A view of type graph is just a list of fields for the graph. + +Graph tag +++++++++++ + +The default type of the graph is a pie chart - to change it to a barchart change **** to **** You also may change the orientation. + +:Example : + +.. code-block:: xml + + + +Field tag ++++++++++ + +The first field is the X axis. The second one is the Y axis and the optional third one is the Z axis for 3 dimensional graphs. You can apply a few attributes to each field/axis: + + * **group**: if set to true, the client will group all item of the same value for this field. For each other field, it will apply an operator + * **operator**: the operator to apply is another field is grouped. By default it's '+'. Allowed values are: + + + +: addition + + \*: multiply + + \**: exponent + + min: minimum of the list + + max: maximum of the list + +:Defining real statistics on objects: + +The easiest method to compute real statistics on objects is: + + 1. Define a statistic object which is a postgresql view + 2. Create a tree view and a graph view on this object + +You can get en example in all modules of the form: report\_.... Example: report_crm. + + +Search views +-------------- + +Search views are a new feature of OpenERP supported as of version 6.0 +It creates a customized search panel, and is declared quite similarly to a form view, +except that the view type and root element change to ``search`` instead of ``form``. + +.. image:: images/search.png + :scale: 50 + :align: center + +Following is the list of new elements and features supported in search views. + +Group tag ++++++++++ + +Unlike form group elements, search view groups support unlimited number of widget(fields or filters) +in a row (no automatic line wrapping), and only use the following attributes: + + + ``expand``: turns on the expander icon on the group (1 for expanded by default, 0 for collapsed) + + ``string``: label for the group + +.. code-block:: xml + + + + + + + + +In the screenshot above the green area is an expandable group. + +Filter tag ++++++++++++ +Filters are displayed as a toggle button on search panel +Filter elements can add new values in the current domain or context of the search view. +Filters can be added as a child element of field too, to indicate that they apply specifically +to that field (in this case the button's icon will smaller) + +In the picture above the red area contains filters at the top of the form while +the blue area highlights a field and it's child filter. + +.. code-block:: xml + + + + + + +Group By +++++++++ + +.. code-block:: xml + + + +Above filters groups records sharing the same ``project_id`` value. Groups are loaded +lazily, so the inner records are only loaded when the group is expanded. +The group header lines contain the common values for all records in that group, and all numeric +fields currently displayed in the view are replaced by the sum of the values in that group. + +It is also possible to group on multiple values by specifying a list of fields instead of a single string. +In this case nested groups will be displayed:: + + + +Fields +++++++ + +Field elements in search views are used to get user-provided values +for searches. As a result, as for group elements, they are quite +different than form view's fields: + +* a search field can contain filters, which generally indicate that + both field and filter manage the same field and are related. + + Those inner filters are rendered as smaller buttons, right next to + the field, and *must not* have a ``string`` attribute. + +* a search field really builds a domain composed of ``[(field_name, + operator, field_value)]``. This domain can be overridden in two + ways: + + * ``@operator`` replaces the default operator for the field (which + depends on its type) + + * ``@filter_domain`` lets you provide a fully custom domain, which + will replace the default domain creation + +* a search field does not create a context by default, but you can + provide an ``@context`` which will be evaluated and merged into the + wider context (as with a ``filter`` element). + +To get the value of the field in your ``@context`` or +``@filter_domain``, you can use the variable ``self``: + +.. code-block:: xml + + + +or + +.. code-block:: xml + + + +Range fields (date, datetime, time) +""""""""""""""""""""""""""""""""""" + +The range fields are composed of two input widgets (from and two) +instead of just one. + +This leads to peculiarities (compared to non-range search fields): + +* It is not possible to override the operator of a range field via + ``@operator``, as the domain is built of two sections and each + section uses a different operator. + +* Instead of being a simple value (integer, string, float) ``self`` + for use in ``@filter_domain`` and ``@context`` is a ``dict``. + + Because each input widget of a range field can be empty (and the + field itself will still be valid), care must be taken when using + ``self``: it has two string keys ``"from"`` and ``"to"``, but any of + these keys can be either missing entirely or set to the value + ``False``. + +Actions for Search view ++++++++++++++++++++++++ + +After declaring a search view, it will be used automatically for all tree views on the same model. +If several search views exist for a single model, the one with the highest priority (lowest sequence) will +be used. Another option is to explicitly select the search view you want to use, by setting the +``search_view_id`` field of the action. + +In addition to being able to pass default form values in the context of the action, OpenERP 6.0 now +supports passing initial values for search views too, via the context. The context keys need to match the +``search_default_XXX`` format. ``XXX`` may refer to the ``name`` of a ```` or ```` +in the search view (as the ``name`` attribute is not required on filters, this only works for filters that have +an explicit ``name`` set). The value should be either the initial value for search fields, or +simply a boolean value for filters, to toggle them + +.. code-block:: xml + + + Tasks + project.task + form + tree,form,calendar,gantt,graph + + + {"search_default_current":1,"search_default_user_id":uid} + + + +Custom Filters +++++++++++++++ + +As of v6.0, all search views also features custom search filters, as show below. +Users can define their own custom filters using any of the fields available on the current model, +combining them with AND/OR operators. It is also possible to save any search context (the combination +of all currently applied domain and context values) as a personal filter, which can be recalled +at any time. Filters can also be turned into Shortcuts directly available in the User's homepage. + +.. image:: images/filter.png + :scale: 50 + :align: center + + +In above screenshot we filter Partner where Salesman = Demo user and Country = Belgium, +We can save this search criteria as a Shortcut or save as Filter. + +Filters are user specific and can be modified via the Manage Filters option in the filters drop-down. + + +Calendar Views +-------------- + +Calendar view provides timeline/schedule view for the data. + +View Specification +++++++++++++++++++ + +Here is an example view: + +.. code-block:: xml + + + + + + +Here is the list of supported attributes for ``calendar`` tag: + + ``string`` + The title string for the view. + + ``date_start`` + A ``datetime`` field to specify the starting date for the calendar item. This + attribute is required. + + ``date_stop`` + A ``datetime`` field to specify the end date. Ignored if ``date_delay`` + attribute is specified. + + ``date_delay`` + A ``numeric`` field to specify time in hours for a record. This attribute + will get preference over ``date_stop`` and ``date_stop`` will be ignored. + + ``day_length`` + An ``integer`` value to specify working day length. Default is ``8`` hours. + + ``color`` + A field, generally ``many2one``, to colorize calendar/gantt items. + + ``mode`` + A string value to set default view/zoom mode. For ``calendar`` view, this can be + one of following (default is ``month``): + + * ``day`` + * ``week`` + * ``month`` + +Screenshots ++++++++++++ + +Month Calendar: + +.. figure:: images/calendar_month.png + :scale: 50% + :align: center + +Week Calendar: + +.. figure:: images/calendar_week.png + :scale: 50% + :align: center + + +Gantt Views +----------- + +Gantt view provides timeline view for the data. Generally, it can be used to display +project tasks and resource allocation. + +A Gantt chart is a graphical display of all the tasks that a project is composed of. +Each bar on the chart is a graphical representation of the length of time the task is +planned to take. + +A resource allocation summary bar is shown on top of all the grouped tasks, +representing how effectively the resources are allocated among the tasks. + +Color coding of the summary bar is as follows: + + * `Gray` shows that the resource is not allocated to any task at that time + * `Blue` shows that the resource is fully allocated at that time. + * `Red` shows that the resource is overallocated + +View Specification +++++++++++++++++++ + +Here is an example view: + +.. code-block:: xml + + + + + + + +The ``attributes`` accepted by the ``gantt`` tag are similar to ``calendar`` view tag. The +``level`` tag is used to group the records by some ``many2one`` field. Currently, only +one level is supported. + +Here is the list of supported attributes for ``gantt`` tag: + + ``string`` + The title string for the view. + + ``date_start`` + A ``datetime`` field to specify the starting date for the gantt item. This + attribute is required. + + ``date_stop`` + A ``datetime`` field to specify the end date. Ignored if ``date_delay`` + attribute is specified. + + ``date_delay`` + A ``numeric`` field to specify time in hours for a record. This attribute + will get preference over ``date_stop`` and ``date_stop`` will be ignored. + + ``day_length`` + An ``integer`` value to specify working day length. Default is ``8`` hours. + + ``color`` + A field, generally ``many2one``, to colorize calendar/gantt items. + + ``mode`` + A string value to set default view/zoom mode. For ``gantt`` view, this can be + one of following (default is ``month``): + + * ``day`` + * ``3days`` + * ``week`` + * ``3weeks`` + * ``month`` + * ``3months`` + * ``year`` + * ``3years`` + * ``5years`` + +The ``level`` tag supports following attributes: + + ``object`` + An openerp object having many2one relationship with view object. + + ``link`` + The field name in current object that links to the given ``object``. + + ``domain`` + The domain to be used to filter the given ``object`` records. + +Drag and Drop ++++++++++++++ + +The left side pane displays list of the tasks grouped by the given ``level`` field. +You can reorder or change the group of any records by dragging them. + +The main content pane displays horizontal bars plotted on a timeline grid. A group +of bars are summarized with a top summary bar displaying resource allocation of all +the underlying tasks. + +You can change the task start time by dragging the tasks horizontally. While +end time can be changed by dragging right end of a bar. + +.. note:: + + The time is calculated considering ``day_length`` so a bar will span more + then one day if total time for a task is greater then ``day_length`` value. + +Screenshots ++++++++++++ + +.. figure:: images/gantt.png + :scale: 50% + :align: center + + +Design Elements +--------------- + +The files describing the views are of the form: + +:Example: + +.. code-block:: xml + + + + + [view definitions] + + + +The view definitions contain mainly three types of tags: + + * **** tags with the attribute model="ir.ui.view", which contain the view definitions themselves + * **** tags with the attribute model="ir.actions.act_window", which link actions to these views + * **** tags, which create entries in the menu, and link them with actions + +New : You can specify groups for whom the menu is accessible using the groups +attribute in the `menuitem` tag. + +New : You can now add shortcut using the `shortcut` tag. + +:Example: + +.. code-block:: xml + + + +Note that you should add an id attribute on the `menuitem` which is referred by +menu attribute. + +.. code-block:: xml + + + sale.order.form + sale.order + + +
+ ......... +
+ + + +Default value for the priority field : 16. When not specified the system will use the view with the lower priority. + +View Types +++++++++++ + +Tree View +""""""""" +You can specify the columns to include in the list, along with some details of +the list's appearance. The search fields aren't specified here, they're +specified by the `select` attribute in the form view fields. + +.. code-block:: xml + + + stock.location.tree + stock.location + tree + + + + + + + + + + + + +That example is just a flat list, but you can also display a real tree structure +by specifying a `field_parent`. The name is a bit misleading, though; the field +you specify must contain a list of all **child** entries. + +.. code-block:: xml + + + stock.location.tree + stock.location + tree + child_ids + + + + + + + + +On the `tree` element, the following attributes are supported: + +colors + Conditions for applying different colors to items in the list. The default + is black. +toolbar + Set this to 1 if you want a tree structure to list the top level entries + in a separate toolbar area. When you click on an entry in the toolbar, all + its descendants will be displayed in the main tree. The value is ignored + for flat lists. + +Grouping Elements ++++++++++++++++++ + +Separator +""""""""" + +Adds a separator line + +:Example: + +.. code-block:: xml + + + +The string attribute defines its label and the colspan attribute defines his horizontal size (in number of columns). + +Notebook +"""""""" + +: With notebooks you can distribute the view fields on different tabs (each one defined by a page tag). You can use the tabpos properties to set tab at: up, down, left, right. + +:Example: + +.. code-block:: xml + + .... + +Group +""""" + +: groups several columns and split the group in as many columns as desired. + + * **colspan**: the number of columns to use + * **rowspan**: the number of rows to use + * **expand**: if we should expand the group or not + * **col**: the number of columns to provide (to its children) + * **string**: (optional) If set, a frame will be drawn around the group of fields, with a label containing the string. Otherwise, the frame will be invisible. + +:Example: + +.. code-block:: xml + + + +