OpenERP Developments

Welcome to BACON:CONSULT‎ > ‎Services‎ > ‎odoo‎ > ‎

OpenERP Module Development

This section touches on some aspects of OpenERP module development, with some code snippets I've found quite useful. The codes is based on OpenERP version 6.1-1.

Contents

1 OpenERP Module Development
1. 1.1 Method A - Defining a domain in a many2one field
2. 1.2 Method B - Using a selection field

Filling many2one selection field with values based on associate fields

An often discussed challenge is how to create a drop-down menu that contains records, based on a selection from another field. I've desribed two approaches in this section which I used for a client project.

Method A is simpler solution than Method B. The examples are based on display of a Bill of Materials (BOM) and to display all child components of a selected BOM.

The object used is MRP.BOM which has the following details:

Object Fields:

The following fields were used in the object:

id:the id of the master bom record

bom_id: the BOM id (not the same as the product_id)

bom_line:the id of all child components

name: name of the product

product_id: Parent Record

openerp object - mrp.bom

When creating new functions in OpenERP, I normally test the logic directly in python using IDLE . For me this is a quick technique for debugging. I setup an XML-RFC connection to the OpenERP database on the server. In most cases if you can get the logic working in IDLE then it should work OK in OpenERP...but in some case this is not always the case.

Python Code - XML-RPC

import xmlrpclib

sock = xmlrpclib.ServerProxy('http://<your ip address of Openerp server>:8069/xmlrpc/object')

uid = 1

pwd = 'admin' (normally the default user is 1 with password admin)

dbname ='<the name of the OpenERP database>'

# find all products with a BOM i.e. where bom field != blank

args = [('bom_lines', '!=', '')] #query clause

ids = sock.execute(dbname, uid, pwd, 'mrp.bom', 'search', args)

ids=sorted(ids)

# Print these records ids

print 'The following BOM Records have a BOM ID of = ',ids

# Get the details of the child for each master bom record

# Field Product ID returns the product ID and name of the product in tht product.product table

# Which is useful to retrieve all details of the parent and child BOM too.

bom_fields = ('name', 'product_id','bom_lines' )

for i in range(len(ids)):

bom_id1 = sock.execute(dbname, uid, pwd, ('mrp.bom'), 'read', ids[i], bom_fields)

print '----------------------------------'

print 'Main BOM=', ids[i], bom_id1, bom_id1['bom_lines']

# get childs boms and show these too

for child1 in bom_id1['bom_lines']:

bom_child1 = sock.execute(dbname, uid, pwd, ('mrp.bom'), 'read', child1, bom_fields)

# Extract the parent BOM ID of this child to see if this also has a BOM

anewlist = bom_child1 ['product_id']

#print 'Child=',bom_child1,

print '*******Child1 =',child1, ',',bom_child1 ['name'], ',', anewlist [0] , ',', bom_child1 ['bom_lines']

#print '..........',anewlist [0] # extract the id of the parent bom

#bom_id2 = sock.execute(dbname, uid, pwd, ('mrp.bom'), 'read', anewlist [0], bom_fields)

# get any BOMs of childs boms and show these too (this part needs finishing)

A list of all BOMS and child components will be printed out as follows:

Text Box

Main BOM= 46 {'product_id': [30, '[SHE100] Shelf of 100cm'], 'id': 46, 'name': 'Default BOM for Shelf of 100cm', 'bom_lines': [47, 48, 49, 50]} [47, 48, 49, 50]

*******Child1 = 47 , Side Panel , 42 , []

*******Child1 = 48 , Assembly Section , 45 , []

*******Child1 = 49 , Rear panel SHE100 , 40 , []

*******Child1 = 50 , RCK100 , 43 , []

----------------------------------

Main BOM= 51 {'product_id': [43, '[RCK100] Rack 100cm'], 'id': 51, 'name': 'RCK100', 'bom_lines': [52, 53]} [52, 53]

*******Child1 = 52 , SPAN100 , 32 , []

*******Child1 = 53 , METC000 , 47 , []

----------------------------------

Main BOM= 54 {'product_id': [32, '[SPAN100] Shelf Panel'], 'id': 54, 'name': 'SPAN100', 'bom_lines': [55]} [55]

*******Child1 = 55 , WOOD010 , 35 , []

----------------------------------

Main BOM= 56 {'product_id': [45, '[PROFIL] Assembly Section'], 'id': 56, 'name': 'Assembly Section', 'bom_lines': [57]} [57]

*******Child1 = 57 , Wood Lintel 0.25m , 46 , []

----------------------------------

Main BOM= 58 {'product_id': [40, '[RPAN100] Rear Panel SHE100'], 'id': 58, 'name': 'Rear panel SHE100', 'bom_lines': [59]} [59]

*******Child1 = 59 , WOOD002 0.25m , 33 , []

----------------------------------

Main BOM= 60 {'product_id': [31, '[SHE200] Shelf of 200cm'], 'id': 60, 'name': 'Default BOM for Shelf of 200cm', 'bom_lines': [61, 62, 63, 64, 65]} [61, 62, 63, 64, 65]

*******Child1 = 61 , Rear panel SHE200 , 41 , []

*******Child1 = 62 , Assembly Section , 45 , []

*******Child1 = 63 , Side Panel , 42 , []

*******Child1 = 64 , Shelf 200 , 44 , []

*******Child1 = 65 , Metal Cleats , 47 , []

----------------------------------

Main BOM= 66 {'product_id': [49, '[SHE100KIT] KIT Shelf of 100cm'], 'id': 66, 'name': 'Default BOM for KIT Shelf of 100cm', 'bom_lines': [67, 68]} [67, 68]

*******Child1 = 67 , Assembly Section , 45 , []

*******Child1 = 68 , Side Panel , 42 , []

----------------------------------

Main BOM= 69 {'product_id': [53, 'Orange Juice'], 'id': 69, 'name': 'Orange Juice', 'bom_lines': [70, 71, 72]} [70, 71, 72]

*******Child1 = 70 , Orange , 54 , []

*******Child1 = 71 , Sugar , 55 , []

*******Child1 = 72 , Water , 56 , []

----------------------------------

Main BOM= 73 {'product_id': [57, 'Shirt'], 'id': 73, 'name': 'Shirt', 'bom_lines': [74, 75]} [74, 75]

*******Child1 = 74 , Cloth , 58 , []

*******Child1 = 75 , Shirt Buttons , 59 , []

Method A - Defining a domain in a many2one field

This is useful if you want to restrict certain selections into a drop down list and then further restrict the selection based on the first selection.

Notice there is an icon on the right side of the fields for search, create, etc.

Screen Shots

field 'bom_select_list' (BOM Master)

This list shows all products that have has a bom defined

field bom_select_list4 (BOM Childs)

This list only shows the bom components related the previous selection

.py file

The following fields were defined into an inherited view.

_columns = {

'bom_select_list' : fields.many2one("mrp.bom", 'BOM Master', domain="[('bom_lines','!=','')]"),

If you understand SQL, then this is equivalent to:: select * from mrp.bom where bom_lines <> ""

This creates a new many2one drop down list which is populated as for the previous field, but the filter is based on the record select in the previous field: ' bom_select_list:

'bom_select_list2' : fields.many2one("mrp.bom",'Bom Child', domain="[('bom_id','=',bom_select_list)]"),

This is equivalent to following SQL statement select * from mrp.bom where bom_id = bom_select_list

XML file

The field for 1st level selection:

The field for 2nd level selection:

Comments

This is a quick method of achieving drop down fields. No further functions or methods need to be defined

Method B - Using a selection field

Screen Shots

This shows two fields. The first field 'Master Bom' is a many2one field with pre-filitered records of all products with a BOM defined. The changing of the field triggers and on-change event that then finds all component products related to the selected BOM master. The results is a direct dump from the dictionary. Some additional text formating would produce a tidy list.

Note: that the pull-down field has a different icon, compared to method A above. With this method it's not possible to create or search for additional records as all records are shown in the drop-down menu. If the list is long, then it could affect performance.

Note that in the BOM child field the appropriate child boms are automatically displayed.

.py file

Functions:

def _get_bom_selection(self, cr, uid, context=None):

obj = self.pool.get('mrp.bom')

args = [('bom_lines', '!=', '')] #set filter

ids = obj.search(cr, uid, args) #filters all BOMs with childs

bom_fields = ('name', 'id', 'product_id','bom_lines' )

res = obj.read(cr, uid, ids, bom_fields, context) #filters all BOMs with childs

res = [( r['id'],r['name'], r['bom_lines'],r['product_id'] ) for r in res]

return res

def onchange_get_childbom_selection(self, cr, uid, ids, bom_select_list1_example_b, context=None):

#get the table

a_child_list =[] #clear the bom child list

result = []

child_list2 = []

obj = self.pool.get('mrp.bom')

bom_select_list1_example_b = str(bom_select_list1_example_b)

print '>>> BOM Master: %s' %bom_select_list1_example_b

print '>>> obj: %s' % obj

#finds that one BOMs in the complete BOM table

bom_fields = ('name', 'bom_lines' ) #determine all field that will returned in the results

bom_id1 = obj.read(cr, uid,[bom_select_list1_example_b],bom_fields, context)

print '>>> bom_id1:',bom_id1[0]['bom_lines']

a_value4 = [] #read the record and extract the bom_lines field

child_list = bom_id1[0]['bom_lines']

for child1 in child_list:

bom_child1 = obj.read(cr, uid, child1, ['name'], context)

a_value1 = str(bom_child1['id']) + ' '

a_value2 = str(bom_child1['name'])

a_value3 = a_value1 + a_value2 + '\n'

a_value4 = str(a_value4) + str(a_value3)

print '.........', a_value3 #Debug Message

res = {'value': {'bom_results_list_example_b': a_value4}}

return res

*the red values are the fields from/to which the values are retrieved / returned from / to

The . py fields

The 1st field is of type 'selection' which can be used to trigger a function. The function _get_bom_selection fills the selection list with records before making the result available in the XML view.

When a record in the XML view is changed the on_change event is triggered and this function called onchange_get_childbom_selection from within the XML view. This on_change trigger is done on the XLM record (see below). Note how the value in field 'bom_select_list1_exampleb' is passed to the function, merely by using the field name.

_columns = {

'bom_select_list1_example_b' : fields.selection(_get_bom_selection,'Master BOM:'),

'bom_results_list_example_b' : fields.text('Bom Child'),

}

XML file

This a selection field that is pre-loaded with records (see field declaration above) When a selection is made the onchange_get_childbom_selection method is triggered. The function searches mrp.bom for child bom records associated with the other field. The results are merely written to the text field

Subpages (2): OpenERP Processes xwPython

Comments