import tools
from tools.safe_eval import safe_eval as eval
-regex_order = re.compile('^(([a-z0-9_]+|"[a-z0-9_]+")( *desc| *asc)?( *, *|))+$', re.I)
+# List of etree._Element subclasses that we choose to ignore when parsing XML.
+from tools import SKIPPED_ELEMENT_TYPES
+regex_order = re.compile('^(([a-z0-9_]+|"[a-z0-9_]+")( *desc| *asc)?( *, *|))+$', re.I)
POSTGRES_CONFDELTYPES = {
'RESTRICT': 'r',
'SET DEFAULT': 'd',
}
-# List of etree._Element subclasses that we choose to ignore when parsing view architecture.
-# We include the *Base ones just in case, currently they seem to be subclasses of the _* ones.
-SKIPPED_ELEMENT_TYPES = (etree._Comment, etree._ProcessingInstruction, etree.CommentBase, etree.PIBase)
-
def last_day_of_current_month():
today = datetime.date.today()
last_day = str(calendar.monthrange(today.year, today.month)[1])
# read the results
field_names = map(lambda x: x[0], fields_to_fetch)
field_values = self._table.read(self._cr, self._uid, ids, field_names, context=self._context, load="_classic_write")
+
+ # TODO: improve this, very slow for reports
if self._fields_process:
lang = self._context.get('lang', 'en_US') or 'en_US'
lang_obj_ids = self.pool.get('res.lang').search(self._cr, self._uid, [('code', '=', lang)])
# testing to be sure we got the right
# object and not the parent one.
if not isinstance(value, browse_record):
+ if obj is None:
+ # In some cases the target model is not available yet, so we must ignore it,
+ # which is safe in most cases, this value will just be loaded later when needed.
+ # This situation can be caused by custom fields that connect objects with m2o without
+ # respecting module dependencies, causing relationships to be connected to soon when
+ # the target is not loaded yet.
+ continue
new_data[field_name] = browse_record(self._cr,
self._uid, value, obj, self._cache,
context=self._context,
self._data[result_line['id']].update(new_data)
if not name in self._data[self._id]:
- #how did this happen?
+ # How did this happen? Could be a missing model due to custom fields used too soon, see above.
self.logger.notifyChannel("browse_record", netsvc.LOG_ERROR,
"Fields to fetch: %s, Field values: %s"%(field_names, field_values))
self.logger.notifyChannel("browse_record", netsvc.LOG_ERROR,
model_id = cr.fetchone()[0]
if 'module' in context:
name_id = 'model_'+self._name.replace('.', '_')
- cr.execute('select * from ir_model_data where name=%s and res_id=%s and module=%s', (name_id, model_id, context['module']))
+ cr.execute('select * from ir_model_data where name=%s and module=%s', (name_id, context['module']))
if not cr.rowcount:
cr.execute("INSERT INTO ir_model_data (name,date_init,date_update,module,model,res_id) VALUES (%s, now(), now(), %s, %s, %s)", \
(name_id, context['module'], 'ir.model', model_id)
'readonly': (f.readonly and 1) or 0,
'required': (f.required and 1) or 0,
'selectable': (f.selectable and 1) or 0,
+ 'translate': (f.translate and 1) or 0,
'relation_field': (f._type=='one2many' and isinstance(f, fields.one2many)) and f._fields_id or '',
}
+
# When its a custom field,it does not contain f.select
if context.get('field_state', 'base') == 'manual':
if context.get('field_name', '') == k:
vals['id'] = id
cr.execute("""INSERT INTO ir_model_fields (
id, model_id, model, name, field_description, ttype,
- relation,view_load,state,select_level,relation_field
+ relation,view_load,state,select_level,relation_field, translate
) VALUES (
- %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s
+ %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s
)""", (
id, vals['model_id'], vals['model'], vals['name'], vals['field_description'], vals['ttype'],
vals['relation'], bool(vals['view_load']), 'base',
- vals['select_level'], vals['relation_field']
+ vals['select_level'], vals['relation_field'], bool(vals['translate'])
))
if 'module' in context:
name1 = 'field_' + self._table + '_' + k
cr.commit()
cr.execute("""UPDATE ir_model_fields SET
model_id=%s, field_description=%s, ttype=%s, relation=%s,
- view_load=%s, select_level=%s, readonly=%s ,required=%s, selectable=%s, relation_field=%s
+ view_load=%s, select_level=%s, readonly=%s ,required=%s, selectable=%s, relation_field=%s, translate=%s
WHERE
model=%s AND name=%s""", (
vals['model_id'], vals['field_description'], vals['ttype'],
vals['relation'], bool(vals['view_load']),
- vals['select_level'], bool(vals['readonly']), bool(vals['required']), bool(vals['selectable']), vals['relation_field'], vals['model'], vals['name']
+ vals['select_level'], bool(vals['readonly']), bool(vals['required']), bool(vals['selectable']), vals['relation_field'], bool(vals['translate']), vals['model'], vals['name']
))
break
cr.commit()
self._table = self._name.replace('.', '_')
def browse(self, cr, uid, select, context=None, list_class=None, fields_process=None):
- """
- Fetch records as objects allowing to use dot notation to browse fields and relations
+ """Fetch records as objects allowing to use dot notation to browse fields and relations
:param cr: database cursor
:param user: current user id
if not data[fpos]:
dt = ''
for rr in r:
- if isinstance(rr.name, browse_record):
- rr = rr.name
+ name_relation = self.pool.get(rr._table_name)._rec_name
+ if isinstance(rr[name_relation], browse_record):
+ rr = rr[name_relation]
rr_name = self.pool.get(rr._table_name).name_get(cr, uid, [rr.id], context=context)
rr_name = rr_name and rr_name[0] and rr_name[0][1] or ''
dt += tools.ustr(rr_name or '') + ','
:param filename: optional file to store partial import state for recovery
:rtype: tuple
- This method is used when importing data via client menu
+ This method is used when importing data via client menu.
+
+ Example of fields to import for a sale.order::
+ .id, (=database_id)
+ partner_id, (=name_search)
+ order_line/.id, (=database_id)
+ order_line/name,
+ order_line/product_id/id, (=xml id)
+ order_line/price_unit,
+ order_line/product_uom_qty,
+ order_line/product_uom/id (=xml_id)
"""
if not context:
context = {}
- fields = map(lambda x: x.split('/'), fields)
+ def _replace_field(x):
+ x = re.sub('([a-z0-9A-Z_])\\.id$', '\\1/.id', x)
+ return x.replace(':id','/id').split('/')
+ fields = map(_replace_field, fields)
logger = netsvc.Logger()
ir_model_data_obj = self.pool.get('ir.model.data')
-
-
-
-
-
- def _check_db_id(self, model_name, db_id):
- obj_model = self.pool.get(model_name)
- ids = obj_model.search(cr, uid, [('id', '=', int(db_id))])
- if not len(ids):
- raise Exception(_("Database ID doesn't exist: %s : %s") %(model_name, db_id))
- return True
-
- def process_liness(self, datas, prefix, current_module, model_name, fields_def, position=0):
+ # mode: id (XML id) or .id (database id) or False for name_get
+ def _get_id(model_name, id, current_module=False, mode='id'):
+ if mode=='.id':
+ id = int(id)
+ obj_model = self.pool.get(model_name)
+ dom = [('id', '=', id)]
+ if obj_model._columns.get('active'):
+ dom.append(('active', 'in', ['True','False']))
+ ids = obj_model.search(cr, uid, dom, context=context)
+ if not len(ids):
+ raise Exception(_("Database ID doesn't exist: %s : %s") %(model_name, id))
+ elif mode=='id':
+ if '.' in id:
+ module, xml_id = id.rsplit('.', 1)
+ else:
+ module, xml_id = current_module, id
+ record_id = ir_model_data_obj._get_id(cr, uid, module, xml_id)
+ ir_model_data = ir_model_data_obj.read(cr, uid, [record_id], ['res_id'], context=context)
+ if not ir_model_data:
+ raise ValueError('No references to %s.%s' % (module, xml_id))
+ id = ir_model_data[0]['res_id']
+ else:
+ obj_model = self.pool.get(model_name)
+ ids = obj_model.name_search(cr, uid, id, operator='=', context=context)
+ if not ids:
+ raise ValueError('No record found for %s' % (id,))
+ id = ids[0][0]
+ return id
+
+ # IN:
+ # datas: a list of records, each record is defined by a list of values
+ # prefix: a list of prefix fields ['line_ids']
+ # position: the line to process, skip is False if it's the first line of the current record
+ # OUT:
+ # (res, position, warning, res_id) with
+ # res: the record for the next line to process (including it's one2many)
+ # position: the new position for the next line
+ # res_id: the ID of the record if it's a modification
+ def process_liness(self, datas, prefix, current_module, model_name, fields_def, position=0, skip=0):
line = datas[position]
row = {}
- translate = {}
- todo = []
warning = []
- data_id = False
data_res_id = False
- is_xml_id = False
- is_db_id = False
- ir_model_data_obj = self.pool.get('ir.model.data')
- #
- # Import normal fields
- #
+ xml_id = False
+ nbrmax = position+1
+
+ done = {}
for i in range(len(fields)):
+ res = False
if i >= len(line):
raise Exception(_('Please check that all your lines have %d columns.') % (len(fields),))
- if not line[i]:
- continue
field = fields[i]
- if prefix and not prefix[0] in field:
+ if field[:len(prefix)] <> prefix:
+ if line[i] and skip:
+ return False
continue
- if (len(field)==len(prefix)+1) and field[len(prefix)].endswith('.id') and (field[len(prefix)]<>'.id'):
- # Database ID
- res = False
- if line[i]:
- field_name = field[0].split('.')[0]
- model_rel = fields_def[field_name]['relation']
-
- if fields_def[field[len(prefix)][:-3]]['type'] == 'many2many':
- res_id = []
- for db_id in line[i].split(config.get('csv_internal_sep')):
- try:
- _check_db_id(self, model_rel, db_id)
- res_id.append(db_id)
- except Exception, e:
- warning += [tools.exception_to_unicode(e)]
- logger.notifyChannel("import", netsvc.LOG_ERROR,
- tools.exception_to_unicode(e))
- if len(res_id):
- res = [(6, 0, res_id)]
- else:
- try:
- _check_db_id(self, model_rel, line[i])
- res = line[i]
- except Exception, e:
- warning += [tools.exception_to_unicode(e)]
- logger.notifyChannel("import", netsvc.LOG_ERROR,
- tools.exception_to_unicode(e))
- row[field_name] = res or False
- continue
-
- if (len(field)==len(prefix)+1) and field[len(prefix)].endswith(':id'):
- res_id = False
- if line[i]:
- if fields_def[field[len(prefix)][:-3]]['type'] == 'many2many':
- res_id = []
- for word in line[i].split(config.get('csv_internal_sep')):
- if '.' in word:
- module, xml_id = word.rsplit('.', 1)
- else:
- module, xml_id = current_module, word
- id = ir_model_data_obj._get_id(cr, uid, module,
- xml_id)
- res_id2 = ir_model_data_obj.read(cr, uid, [id],
- ['res_id'])[0]['res_id']
- if res_id2:
- res_id.append(res_id2)
- if len(res_id):
- res_id = [(6, 0, res_id)]
- else:
- if '.' in line[i]:
- module, xml_id = line[i].rsplit('.', 1)
- else:
- module, xml_id = current_module, line[i]
- record_id = ir_model_data_obj._get_id(cr, uid, module, xml_id)
- ir_model_data = ir_model_data_obj.read(cr, uid, [record_id], ['res_id'])
- if ir_model_data:
- res_id = ir_model_data[0]['res_id']
- else:
- raise ValueError('No references to %s.%s' % (module, xml_id))
- row[field[-1][:-3]] = res_id or False
+ # ID of the record using a XML ID
+ if field[len(prefix)]=='id':
+ try:
+ data_res_id = _get_id(model_name, line[i], current_module, 'id')
+ except ValueError, e:
+ pass
+ xml_id = line[i]
continue
- if (len(field) == len(prefix)+1) and \
- len(field[len(prefix)].split(':lang=')) == 2:
- f, lang = field[len(prefix)].split(':lang=')
- translate.setdefault(lang, {})[f] = line[i] or False
+
+ # ID of the record using a database ID
+ elif field[len(prefix)]=='.id':
+ data_res_id = _get_id(model_name, line[i], current_module, '.id')
continue
- if (len(field) == len(prefix)+1) and \
- (prefix == field[0:len(prefix)]):
- if field[len(prefix)] == "id":
- # XML ID
- db_id = False
- is_xml_id = data_id = line[i]
- d = data_id.split('.')
- module = len(d) > 1 and d[0] or ''
- name = len(d) > 1 and d[1] or d[0]
- data_ids = ir_model_data_obj.search(cr, uid, [('module', '=', module), ('model', '=', model_name), ('name', '=', name)])
- if len(data_ids):
- d = ir_model_data_obj.read(cr, uid, data_ids, ['res_id'])[0]
- db_id = d['res_id']
- if is_db_id and not db_id:
- data_ids = ir_model_data_obj.search(cr, uid, [('module', '=', module), ('model', '=', model_name), ('res_id', '=', is_db_id)])
- if not len(data_ids):
- ir_model_data_obj.create(cr, uid, {'module': module, 'model': model_name, 'name': name, 'res_id': is_db_id})
- db_id = is_db_id
- if is_db_id and int(db_id) != int(is_db_id):
- warning += [_("Id is not the same than existing one: %s") % (is_db_id)]
- logger.notifyChannel("import", netsvc.LOG_ERROR,
- _("Id is not the same than existing one: %s") % (is_db_id))
- data_res_id = db_id
+
+ # recursive call for getting children and returning [(0,0,{})] or [(1,ID,{})]
+ if fields_def[field[len(prefix)]]['type']=='one2many':
+ if field[len(prefix)] in done:
continue
+ done[field[len(prefix)]] = True
+ relation_obj = self.pool.get(fields_def[field[len(prefix)]]['relation'])
+ newfd = relation_obj.fields_get(cr, uid, context=context)
+ pos = position
+ res = []
+ first = 0
+ while pos < len(datas):
+ res2 = process_liness(self, datas, prefix + [field[len(prefix)]], current_module, relation_obj._name, newfd, pos, first)
+ if not res2:
+ break
+ (newrow, pos, w2, data_res_id2, xml_id2) = res2
+ nbrmax = max(nbrmax, pos)
+ warning += w2
+ first += 1
+ if (not newrow) or not reduce(lambda x, y: x or y, newrow.values(), 0):
+ break
+ res.append( (data_res_id2 and 1 or 0, data_res_id2 or 0, newrow) )
- if field[len(prefix)] == ".id":
- # Database ID
- try:
- _check_db_id(self, model_name, line[i])
- data_res_id = is_db_id = int(line[i])
- except Exception, e:
- warning += [tools.exception_to_unicode(e)]
- logger.notifyChannel("import", netsvc.LOG_ERROR,
- tools.exception_to_unicode(e))
- continue
- data_ids = ir_model_data_obj.search(cr, uid, [('model', '=', model_name), ('res_id', '=', line[i])])
- if len(data_ids):
- d = ir_model_data_obj.read(cr, uid, data_ids, ['name', 'module'])[0]
- data_id = d['name']
- if d['module']:
- data_id = '%s.%s' % (d['module'], d['name'])
- else:
- data_id = d['name']
- if is_xml_id and not data_id:
- data_id = is_xml_id
- if is_xml_id and is_xml_id != data_id:
- warning += [_("Id is not the same than existing one: %s") % (line[i])]
- logger.notifyChannel("import", netsvc.LOG_ERROR,
- _("Id is not the same than existing one: %s") % (line[i]))
+ elif fields_def[field[len(prefix)]]['type']=='many2one':
+ relation = fields_def[field[len(prefix)]]['relation']
+ if len(field) == len(prefix)+1:
+ mode = False
+ else:
+ mode = field[len(prefix)+1]
+ res = line[i] and _get_id(relation, line[i], current_module, mode) or False
- continue
- if fields_def[field[len(prefix)]]['type'] == 'integer':
- res = line[i] and int(line[i])
- elif fields_def[field[len(prefix)]]['type'] == 'boolean':
- res = line[i].lower() not in ('0', 'false', 'off')
- elif fields_def[field[len(prefix)]]['type'] == 'float':
- res = line[i] and float(line[i])
- elif fields_def[field[len(prefix)]]['type'] == 'selection':
- res = False
- if isinstance(fields_def[field[len(prefix)]]['selection'],
- (tuple, list)):
- sel = fields_def[field[len(prefix)]]['selection']
- else:
- sel = fields_def[field[len(prefix)]]['selection'](self,
- cr, uid, context)
- for key, val in sel:
- if line[i] in [tools.ustr(key), tools.ustr(val)]: #Acepting key or value for selection field
- res = key
- break
- if line[i] and not res:
- logger.notifyChannel("import", netsvc.LOG_WARNING,
- _("key '%s' not found in selection field '%s'") % \
- (line[i], field[len(prefix)]))
-
- warning += [_("Key/value '%s' not found in selection field '%s'") % (line[i], field[len(prefix)])]
-
- elif fields_def[field[len(prefix)]]['type'] == 'many2one':
- res = False
- if line[i]:
- relation = fields_def[field[len(prefix)]]['relation']
- res2 = self.pool.get(relation).name_search(cr, uid,
- line[i], [], operator='=', context=context)
- res = (res2 and res2[0][0]) or False
- if not res:
- warning += [_("Relation not found: %s on '%s'") % (line[i], relation)]
- logger.notifyChannel("import", netsvc.LOG_WARNING,
- _("Relation not found: %s on '%s'") % (line[i], relation))
- elif fields_def[field[len(prefix)]]['type'] == 'many2many':
- res = []
- if line[i]:
- relation = fields_def[field[len(prefix)]]['relation']
- for word in line[i].split(config.get('csv_internal_sep')):
- res2 = self.pool.get(relation).name_search(cr,
- uid, word, [], operator='=', context=context)
- res3 = (res2 and res2[0][0]) or False
- if not res3:
- warning += [_("Relation not found: %s on '%s'") % (word, relation)]
- logger.notifyChannel("import",
- netsvc.LOG_WARNING,
- _("Relation not found: %s on '%s'") % (word, relation))
- else:
- res.append(res3)
- if len(res):
- res = [(6, 0, res)]
+ elif fields_def[field[len(prefix)]]['type']=='many2many':
+ relation = fields_def[field[len(prefix)]]['relation']
+ if len(field) == len(prefix)+1:
+ mode = False
else:
- res = line[i] or False
- row[field[len(prefix)]] = res
- elif (prefix==field[0:len(prefix)]):
- if field[0] not in todo:
- todo.append(field[len(prefix)])
- #
- # Import one2many, many2many fields
- #
- nbrmax = 1
- for field in todo:
- relation_obj = self.pool.get(fields_def[field]['relation'])
- newfd = relation_obj.fields_get(
- cr, uid, context=context)
- res = process_liness(self, datas, prefix + [field], current_module, relation_obj._name, newfd, position)
- (newrow, max2, w2, translate2, data_id2, data_res_id2) = res
- nbrmax = max(nbrmax, max2)
- warning = warning + w2
- reduce(lambda x, y: x and y, newrow)
- row[field] = newrow and (reduce(lambda x, y: x or y, newrow.values()) and \
- [(data_res_id2 and 1 or 0, data_res_id2 or 0, newrow)]) or []
- i = max2
- while (position+i) < len(datas):
- ok = True
- for j in range(len(fields)):
- field2 = fields[j]
- if (len(field2) <= (len(prefix)+1)) and datas[position+i][j]:
- ok = False
- if not ok:
- break
+ mode = field[len(prefix)+1]
+
+ # TODO: improve this by using csv.csv_reader
+ res = []
+ if line[i]:
+ for db_id in line[i].split(config.get('csv_internal_sep')):
+ res.append( _get_id(relation, db_id, current_module, mode) )
+ res = [(6,0,res)]
+
+ elif fields_def[field[len(prefix)]]['type'] == 'integer':
+ res = line[i] and int(line[i]) or 0
+ elif fields_def[field[len(prefix)]]['type'] == 'boolean':
+ res = line[i].lower() not in ('0', 'false', 'off')
+ elif fields_def[field[len(prefix)]]['type'] == 'float':
+ res = line[i] and float(line[i]) or 0.0
+ elif fields_def[field[len(prefix)]]['type'] == 'selection':
+ for key, val in fields_def[field[len(prefix)]]['selection']:
+ if line[i] in [tools.ustr(key), tools.ustr(val)]:
+ res = key
+ break
+ if line[i] and not res:
+ logger.notifyChannel("import", netsvc.LOG_WARNING,
+ _("key '%s' not found in selection field '%s'") % \
+ (line[i], field[len(prefix)]))
+ warning += [_("Key/value '%s' not found in selection field '%s'") % (line[i], field[len(prefix)])]
+ else:
+ res = line[i]
- (newrow, max2, w2, translate2, data_id2, data_res_id2) = process_liness(
- self, datas, prefix+[field], current_module, relation_obj._name, newfd, position+i)
- warning = warning + w2
- if newrow and reduce(lambda x, y: x or y, newrow.values()):
- row[field].append((data_res_id2 and 1 or 0, data_res_id2 or 0, newrow))
- i += max2
- nbrmax = max(nbrmax, i)
-
- if len(prefix) == 0:
- for i in range(max(nbrmax, 1)):
- #if datas:
- datas.pop(0)
- result = (row, nbrmax, warning, translate, data_id, data_res_id)
+ row[field[len(prefix)]] = res or False
+
+ result = (row, nbrmax, warning, data_res_id, xml_id)
return result
fields_def = self.fields_get(cr, uid, context=context)
- done = 0
- initial_size = len(datas)
if config.get('import_partial', False) and filename:
data = pickle.load(file(config.get('import_partial')))
original_value = data.get(filename, 0)
- counter = 0
- while len(datas):
- counter += 1
+
+ position = 0
+ while position<len(datas):
res = {}
- #try:
- (res, other, warning, translate, data_id, res_id) = \
- process_liness(self, datas, [], current_module, self._name, fields_def)
+
+ (res, position, warning, res_id, xml_id) = \
+ process_liness(self, datas, [], current_module, self._name, fields_def, position=position)
if len(warning):
cr.rollback()
- return (-1, res, 'Line ' + str(counter) +' : ' + '!\n'.join(warning), '')
+ return (-1, res, 'Line ' + str(position) +' : ' + '!\n'.join(warning), '')
try:
id = ir_model_data_obj._update(cr, uid, self._name,
- current_module, res, xml_id=data_id, mode=mode,
+ current_module, res, mode=mode, xml_id=xml_id,
noupdate=noupdate, res_id=res_id, context=context)
except Exception, e:
- import psycopg2
- import osv
- cr.rollback()
- if isinstance(e, psycopg2.IntegrityError):
- msg = _('Insertion Failed! ')
- for key in self.pool._sql_error.keys():
- if key in e[0]:
- msg = self.pool._sql_error[key]
- if hasattr(msg, '__call__'):
- msg = msg(cr, uid, [res_id,], context=context)
- else:
- msg = _(msg)
- break
- return (-1, res, 'Line ' + str(counter) +' : ' + msg, '')
- if isinstance(e, osv.orm.except_orm):
- msg = _('Insertion Failed! ' + e[1])
- return (-1, res, 'Line ' + str(counter) +' : ' + msg, '')
- #Raising Uncaught exception
- return (-1, res, 'Line ' + str(counter) +' : ' + str(e), '')
-
- for lang in translate:
- context2 = context.copy()
- context2['lang'] = lang
- self.write(cr, uid, [id], translate[lang], context2)
- if config.get('import_partial', False) and filename and (not (counter%100)):
+ return (-1, res, 'Line ' + str(position) +' : ' + tools.ustr(e), '')
+
+ if config.get('import_partial', False) and filename and (not (position%100)):
data = pickle.load(file(config.get('import_partial')))
- data[filename] = initial_size - len(datas) + original_value
+ data[filename] = position
pickle.dump(data, file(config.get('import_partial'), 'wb'))
if context.get('defer_parent_store_computation'):
self._parent_store_compute(cr)
cr.commit()
- #except Exception, e:
- # logger.notifyChannel("import", netsvc.LOG_ERROR, e)
- # cr.rollback()
- # try:
- # return (-1, res, e[0], warning)
- # except:
- # return (-1, res, e[0], '')
- done += 1
- #
- # TODO: Send a request with the result and multi-thread !
- #
if context.get('defer_parent_store_computation'):
self._parent_store_compute(cr)
- return (done, 0, 0, 0)
+ return (position, 0, 0, 0)
def read(self, cr, user, ids, fields=None, context=None, load='_classic_read'):
"""
elif view_type == 'tree':
_rec_name = self._rec_name
if _rec_name not in self._columns:
- _rec_name = self._columns.keys()[0]
+ if len(self._columns.keys()):
+ _rec_name = self._columns.keys()[0]
+ else:
+ _rec_name = 'id'
xml = '<?xml version="1.0" encoding="utf-8"?>' \
'<tree string="%s"><field name="%s"/></tree>' \
- % (self._description, self._rec_name)
+ % (self._description, _rec_name)
elif view_type == 'calendar':
xml = self.__get_default_calendar_view()
def copy(self, cr, uid, id, default=None, context=None):
raise NotImplementedError(_('The copy method is not implemented on this object !'))
- def exists(self, cr, uid, id, context=None):
+ def exists(self, cr, uid, ids, context=None):
raise NotImplementedError(_('The exists method is not implemented on this object !'))
def read_string(self, cr, uid, id, langs, fields=None, context=None):
# override defaults with the provided values, never allow the other way around
defaults = self.default_get(cr, uid, missing_defaults, context)
for dv in defaults:
- if (dv in self._columns and self._columns[dv]._type == 'many2many') \
- or (dv in self._inherit_fields and self._inherit_fields[dv][2]._type == 'many2many') \
+ if ((dv in self._columns and self._columns[dv]._type == 'many2many') \
+ or (dv in self._inherit_fields and self._inherit_fields[dv][2]._type == 'many2many')) \
and defaults[dv] and isinstance(defaults[dv][0], (int, long)):
defaults[dv] = [(6, 0, defaults[dv])]
- if dv in self._columns and self._columns[dv]._type == 'one2many' \
- or (dv in self._inherit_fields and self._inherit_fields[dv][2]._type == 'one2many') \
- and isinstance(defaults[dv], (list, tuple)) and isinstance(defaults[dv][0], dict):
+ if (dv in self._columns and self._columns[dv]._type == 'one2many' \
+ or (dv in self._inherit_fields and self._inherit_fields[dv][2]._type == 'one2many')) \
+ and isinstance(defaults[dv], (list, tuple)) and defaults[dv] and isinstance(defaults[dv][0], dict):
defaults[dv] = [(0, 0, x) for x in defaults[dv]]
defaults.update(values)
values = defaults
_protected = ['read', 'write', 'create', 'default_get', 'perm_read', 'unlink', 'fields_get', 'fields_view_get', 'search', 'name_get', 'distinct_field_get', 'name_search', 'copy', 'import_data', 'search_count', 'exists']
_inherit_fields = {}
- _max_count = 200
- _max_hours = 1
+ _max_count = config.get('osv_memory_count_limit')
+ _max_hours = config.get('osv_memory_age_limit')
_check_time = 20
def __init__(self, cr):
if uid != 1 and self.datas[object_id]['internal.create_uid'] != uid:
raise except_orm(_('AccessError'), '%s access is only allowed on your own records for osv_memory objects except for the super-user' % mode.capitalize())
- def vaccum(self, cr, uid):
+ def vaccum(self, cr, uid, force=False):
+ """Run the vaccuum cleaning system, expiring and removing old records from the
+ virtual osv_memory tables if the "max count" or "max age" conditions are enabled
+ and have been reached. This method can be called very often (e.g. everytime a record
+ is created), but will only actually trigger the cleanup process once out of
+ "_check_time" times (by default once out of 20 calls)."""
self.check_id += 1
- if self.check_id % self._check_time:
+ if (not force) and (self.check_id % self._check_time):
return True
tounlink = []
- max = time.time() - self._max_hours * 60 * 60
- for id in self.datas:
- if self.datas[id]['internal.date_access'] < max:
- tounlink.append(id)
- self.unlink(cr, 1, tounlink)
- if len(self.datas) > self._max_count:
- sorted = map(lambda x: (x[1]['internal.date_access'], x[0]), self.datas.items())
- sorted.sort()
- ids = map(lambda x: x[1], sorted[:len(self.datas)-self._max_count])
- self.unlink(cr, uid, ids)
+
+ # Age-based expiration
+ if self._max_hours:
+ max = time.time() - self._max_hours * 60 * 60
+ for k,v in self.datas.iteritems():
+ if v['internal.date_access'] < max:
+ tounlink.append(k)
+ self.unlink(cr, 1, tounlink)
+
+ # Count-based expiration
+ if self._max_count and len(self.datas) > self._max_count:
+ # sort by access time to remove only the first/oldest ones in LRU fashion
+ records = self.datas.items()
+ records.sort(key=lambda x:x[1]['internal.date_access'])
+ self.unlink(cr, 1, [x[0] for x in records[:len(self.datas)-self._max_count]])
+
return True
def read(self, cr, user, ids, fields_to_read=None, context=None, load='_classic_read'):
result.append(r)
if id in self.datas:
self.datas[id]['internal.date_access'] = time.time()
+ # all non inherited fields for which the attribute whose name is in load is False
fields_post = filter(lambda x: x in self._columns and not getattr(self._columns[x], load), fields_to_read)
+ todo = {}
for f in fields_post:
- res2 = self._columns[f].get_memory(cr, self, ids, f, user, context=context, values=result)
- for record in result:
- record[f] = res2[record['id']]
+ todo.setdefault(self._columns[f]._multi, [])
+ todo[self._columns[f]._multi].append(f)
+ for key, val in todo.items():
+ if key:
+ res2 = self._columns[val[0]].get_memory(cr, self, ids, val, user, context=context, values=result)
+ for pos in val:
+ for record in result:
+ if isinstance(res2[record['id']], str): res2[record['id']] = eval(res2[record['id']]) #TOCHECK : why got string instend of dict in python2.6
+ multi_fields = res2.get(record['id'],{})
+ if multi_fields:
+ record[pos] = multi_fields.get(pos,[])
+ else:
+ for f in val:
+ res2 = self._columns[f].get_memory(cr, self, ids, f, user, context=context, values=result)
+ for record in result:
+ if res2:
+ record[f] = res2[record['id']]
+ else:
+ record[f] = []
+
if isinstance(ids_orig, (int, long)):
return result[0]
return result
return self.datas.keys()
res = []
- counter = 0
+ counter = 1
#Find the value of dict
f = False
if result:
for id, data in self.datas.items():
- counter = counter + 1
data['id'] = id
- if limit and (counter > int(limit)):
+ if limit and (counter > int(limit) + int(offset)):
break
f = True
for arg in result:
val = eval('data[arg[0]]'+arg[1] +' arg[2]', locals())
elif arg[1] in ['ilike']:
val = (str(data[arg[0]]).find(str(arg[2]))!=-1)
-
f = f and val
-
if f:
- res.append(id)
+ if counter > offset:
+ res.append(id)
+ counter += 1
if count:
return len(res)
return res or []
# nothing to check in memory...
pass
- def exists(self, cr, uid, id, context=None):
- return id in self.datas
+ def exists(self, cr, uid, ids, context=None):
+ if isinstance(ids, (int,long)):
+ ids = [ids]
+ return all(( id in self.datas for id in ids ))
class orm(orm_template):
_sql_constraints = []
_table = None
+ _all_columns = {}
_protected = ['read', 'write', 'create', 'default_get', 'perm_read', 'unlink', 'fields_get', 'fields_view_get', 'search', 'name_get', 'distinct_field_get', 'name_search', 'copy', 'import_data', 'search_count', 'exists']
__logger = logging.getLogger('orm')
__schema = logging.getLogger('orm.schema')
# Take care of adding join(s) if groupby is an '_inherits'ed field
groupby_list = groupby
+ qualified_groupby_field = groupby
if groupby:
if isinstance(groupby, list):
groupby = groupby[0]
- self._inherits_join_calc(groupby, query)
+ qualified_groupby_field = self._inherits_join_calc(groupby, query)
if groupby:
assert not groupby or groupby in fields, "Fields in 'groupby' must appear in the list of fields to read (perhaps it's missing in the list view?)"
groupby_def = self._columns.get(groupby) or (self._inherit_fields.get(groupby) and self._inherit_fields.get(groupby)[2])
assert groupby_def and groupby_def._classic_write, "Fields in 'groupby' must be regular database-persisted fields (no function or related fields), or function fields with store=True"
- fget = self.fields_get(cr, uid, fields)
+ fget = self.fields_get(cr, uid, fields, context=context)
float_int_fields = filter(lambda x: fget[x]['type'] in ('float', 'integer'), fields)
flist = ''
group_count = group_by = groupby
if groupby:
if fget.get(groupby):
- if fget[groupby]['type'] in ('date', 'datetime'):
- flist = "to_char(%s,'yyyy-mm') as %s " % (groupby, groupby)
- groupby = "to_char(%s,'yyyy-mm')" % (groupby)
+ groupby_type = fget[groupby]['type']
+ if groupby_type in ('date', 'datetime'):
+ qualified_groupby_field = "to_char(%s,'yyyy-mm')" % qualified_groupby_field
+ flist = "%s as %s " % (qualified_groupby_field, groupby)
+ elif groupby_type == 'boolean':
+ qualified_groupby_field = "coalesce(%s,false)" % qualified_groupby_field
+ flist = "%s as %s " % (qualified_groupby_field, groupby)
else:
- flist = groupby
+ flist = qualified_groupby_field
else:
# Don't allow arbitrary values, as this would be a SQL injection vector!
raise except_orm(_('Invalid group_by'),
if f not in ['id', 'sequence']:
group_operator = fget[f].get('group_operator', 'sum')
if flist:
- flist += ','
- flist += group_operator+'('+f+') as '+f
+ flist += ', '
+ qualified_field = '"%s"."%s"' % (self._table, f)
+ flist += "%s(%s) AS %s" % (group_operator, qualified_field, f)
- gb = groupby and (' GROUP BY '+groupby) or ''
+ gb = groupby and (' GROUP BY ' + qualified_groupby_field) or ''
from_clause, where_clause, where_clause_params = query.get_sql()
where_clause = where_clause and ' WHERE ' + where_clause
while field in current_table._inherit_fields and not field in current_table._columns:
parent_model_name = current_table._inherit_fields[field][0]
parent_table = self.pool.get(parent_model_name)
- self._inherits_join_add(parent_model_name, query)
+ current_table._inherits_join_add(parent_model_name, query)
current_table = parent_table
return '"%s".%s' % (current_table._table, field)
# add the NOT NULL constraint
cr.commit()
try:
- cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" SET NOT NULL' % (self._table, k))
+ cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" SET NOT NULL' % (self._table, k), log_exceptions=False)
cr.commit()
self.__schema.debug("Table '%s': column '%s': added NOT NULL constraint",
self._table, k)
cr.execute('DROP INDEX "%s_%s_index"' % (self._table, k))
cr.commit()
msg = "Table '%s': dropping index for column '%s' of type '%s' as it is not required anymore"
- self.__schema.warn(msg, self._table, k, f._type)
+ self.__schema.debug(msg, self._table, k, f._type)
if isinstance(f, fields.many2one):
ref = self.pool.get(f._obj)._table
if f.required:
try:
cr.commit()
- cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" SET NOT NULL' % (self._table, k))
+ cr.execute('ALTER TABLE "%s" ALTER COLUMN "%s" SET NOT NULL' % (self._table, k), log_exceptions=False)
self.__schema.debug("Table '%s': column '%s': added a NOT NULL constraint",
self._table, k)
except Exception:
f = self._columns[store_field]
if hasattr(f, 'digits_change'):
f.digits_change(cr)
+ def not_this_field(stored_func):
+ x, y, z, e, f, l = stored_func
+ return x != self._name or y != store_field
+ self.pool._store_function[self._name] = filter(not_this_field, self.pool._store_function.get(self._name, []))
if not isinstance(f, fields.function):
continue
if not f.store:
continue
- if self._columns[store_field].store is True:
+ sm = f.store
+ if sm is True:
sm = {self._name: (lambda self, cr, uid, ids, c={}: ids, None, 10, None)}
- else:
- sm = self._columns[store_field].store
for object, aa in sm.items():
if len(aa) == 4:
(fnct, fields2, order, length) = aa
raise except_orm('Error',
('Invalid function definition %s in object %s !\nYou must use the definition: store={object:(fnct, fields, priority, time length)}.' % (store_field, self._name)))
self.pool._store_function.setdefault(object, [])
- ok = True
- for x, y, z, e, f, l in self.pool._store_function[object]:
- if (x==self._name) and (y==store_field) and (e==fields2):
- if f == order:
- ok = False
- if ok:
- self.pool._store_function[object].append( (self._name, store_field, fnct, fields2, order, length))
- self.pool._store_function[object].sort(lambda x, y: cmp(x[4], y[4]))
+ self.pool._store_function[object].append((self._name, store_field, fnct, tuple(fields2) if fields2 else None, order, length))
+ self.pool._store_function[object].sort(lambda x, y: cmp(x[4], y[4]))
for (key, _, msg) in self._sql_constraints:
self.pool._sql_error[self._table+'_'+key] = msg
'string': field['field_description'],
'required': bool(field['required']),
'readonly': bool(field['readonly']),
- 'domain': field['domain'] or None,
+ 'domain': eval(field['domain']) if field['domain'] else None,
'size': field['size'],
'ondelete': field['on_delete'],
'translate': (field['translate']),
+ 'manual': True,
#'select': int(field['select_level'])
}
for table in self._inherits:
res.update(self.pool.get(table)._inherit_fields)
for col in self.pool.get(table)._columns.keys():
- res[col] = (table, self._inherits[table], self.pool.get(table)._columns[col])
+ res[col] = (table, self._inherits[table], self.pool.get(table)._columns[col], table)
for col in self.pool.get(table)._inherit_fields.keys():
- res[col] = (table, self._inherits[table], self.pool.get(table)._inherit_fields[col][2])
+ res[col] = (table, self._inherits[table], self.pool.get(table)._inherit_fields[col][2], self.pool.get(table)._inherit_fields[col][3])
self._inherit_fields = res
+ self._all_columns = self._get_column_infos()
self._inherits_reload_src()
+ def _get_column_infos(self):
+ """Returns a dict mapping all fields names (direct fields and
+ inherited field via _inherits) to a ``column_info`` struct
+ giving detailed columns """
+ result = {}
+ for k, (parent, m2o, col, original_parent) in self._inherit_fields.iteritems():
+ result[k] = fields.column_info(k, col, parent, m2o, original_parent)
+ for k, col in self._columns.iteritems():
+ result[k] = fields.column_info(k, col)
+ return result
+
def _inherits_check(self):
for table, field_name in self._inherits.items():
if field_name not in self._columns:
context = {}
self.pool.get('ir.model.access').check(cr, user, self._name, 'read', context=context)
if not fields:
- fields = self._columns.keys() + self._inherit_fields.keys()
+ fields = list(set(self._columns.keys() + self._inherit_fields.keys()))
if isinstance(ids, (int, long)):
select = [ids]
else:
for table in self._inherits:
col = self._inherits[table]
- cols = intersect(self._inherit_fields.keys(), set(fields_to_read) - set(self._columns.keys()))
+ cols = [x for x in intersect(self._inherit_fields.keys(), fields_to_read) if x not in self._columns.keys()]
if not cols:
continue
res2 = self.pool.get(table).read(cr, user, [x[col] for x in res], cols, context, load)
for group in groups:
module = group.split(".")[0]
grp = group.split(".")[1]
- cr.execute("select count(*) from res_groups_users_rel where gid IN (select res_id from ir_model_data where name=%s and module=%s and model=%s) and uid=%s" \
+ cr.execute("select count(*) from res_groups_users_rel where gid IN (select res_id from ir_model_data where name=%s and module=%s and model=%s) and uid=%s", \
(grp, module, 'res.groups', user))
readonly = cr.fetchall()
if readonly[0][0] >= 1:
self.check_access_rule(cr, uid, ids, 'unlink', context=context)
+ pool_model_data = self.pool.get('ir.model.data')
+ pool_ir_values = self.pool.get('ir.values')
for sub_ids in cr.split_for_in_conditions(ids):
cr.execute('delete from ' + self._table + ' ' \
'where id IN %s', (sub_ids,))
+
+ # Removing the ir_model_data reference if the record being deleted is a record created by xml/csv file,
+ # as these are not connected with real database foreign keys, and would be dangling references.
+ # Step 1. Calling unlink of ir_model_data only for the affected IDS.
+ referenced_ids = pool_model_data.search(cr, uid, [('res_id','in',list(sub_ids)),('model','=',self._name)], context=context)
+ # Step 2. Marching towards the real deletion of referenced records
+ pool_model_data.unlink(cr, uid, referenced_ids, context=context)
+
+ # For the same reason, removing the record relevant to ir_values
+ ir_value_ids = pool_ir_values.search(cr, uid,
+ ['|',('value','in',['%s,%s' % (self._name, sid) for sid in sub_ids]),'&',('res_id','in',list(sub_ids)),('model','=',self._name)],
+ context=context)
+ if ir_value_ids:
+ pool_ir_values.unlink(cr, uid, ir_value_ids, context=context)
+
for order, object, store_ids, fields in result_store:
if object != self._name:
obj = self.pool.get(object)
rids = map(lambda x: x[0], cr.fetchall())
if rids:
obj._store_set_values(cr, uid, rids, fields, context)
+
return True
#
clause, params = '%s=%%s' % (self._parent_name,), (parent_val,)
else:
clause, params = '%s IS NULL' % (self._parent_name,), ()
- cr.execute('SELECT parent_right, id FROM %s WHERE %s ORDER BY %s' % (self._table, clause, order), params)
- parents = cr.fetchall()
for id in parents_changed:
cr.execute('SELECT parent_left, parent_right FROM %s WHERE id=%%s' % (self._table,), (id,))
pleft, pright = cr.fetchone()
distance = pright - pleft + 1
+ # Positions of current siblings, to locate proper insertion point;
+ # this can _not_ be fetched outside the loop, as it needs to be refreshed
+ # after each update, in case several nodes are sequentially inserted one
+ # next to the other (i.e computed incrementally)
+ cr.execute('SELECT parent_right, id FROM %s WHERE %s ORDER BY %s' % (self._table, clause, order), params)
+ parents = cr.fetchall()
+
# Find Position of the element
position = None
for (parent_pright, parent_id) in parents:
result.sort()
done = {}
- for order, object, ids, fields in result:
- key = (object, tuple(fields))
+ for order, object, ids_to_update, fields_to_recompute in result:
+ key = (object, tuple(fields_to_recompute))
done.setdefault(key, {})
# avoid to do several times the same computation
todo = []
- for id in ids:
+ for id in ids_to_update:
if id not in done[key]:
done[key][id] = True
todo.append(id)
- self.pool.get(object)._store_set_values(cr, user, todo, fields, context)
+ self.pool.get(object)._store_set_values(cr, user, todo, fields_to_recompute, context)
wf_service = netsvc.LocalService("workflow")
for id in ids:
upd_todo = []
for v in vals.keys():
if v in self._inherit_fields:
- (table, col, col_detail) = self._inherit_fields[v]
+ (table, col, col_detail, original_parent) = self._inherit_fields[v]
tocreate[table][v] = vals[v]
del vals[v]
else:
del vals[self._inherits[table]]
record_id = tocreate[table].pop('id', None)
-
+
+ # When linking/creating parent records, force context without 'no_store_function' key that
+ # defers stored functions computing, as these won't be computed in batch at the end of create().
+ parent_context = dict(context)
+ parent_context.pop('no_store_function', None)
+
if record_id is None or not record_id:
- record_id = self.pool.get(table).create(cr, user, tocreate[table], context=context)
+ record_id = self.pool.get(table).create(cr, user, tocreate[table], context=parent_context)
else:
- self.pool.get(table).write(cr, user, [record_id], tocreate[table], context=context)
+ self.pool.get(table).write(cr, user, [record_id], tocreate[table], context=parent_context)
upd0 += ',' + self._inherits[table]
upd1 += ',%s'
return id_new
def _store_get_values(self, cr, uid, ids, fields, context):
+ """Returns an ordered list of fields.functions to call due to
+ an update operation on ``fields`` of records with ``ids``,
+ obtained by calling the 'store' functions of these fields,
+ as setup by their 'store' attribute.
+
+ :return: [(priority, model_name, [record_ids,], [function_fields,])]
+ """
+ # FIXME: rewrite, cleanup, use real variable names
+ # e.g.: http://pastie.org/1222060
result = {}
fncts = self.pool._store_function.get(self._name, [])
for fnct in range(len(fncts)):
return result2
def _store_set_values(self, cr, uid, ids, fields, context):
+ """Calls the fields.function's "implementation function" for all ``fields``, on records with ``ids`` (taking care of
+ respecting ``multi`` attributes), and stores the resulting values in the database directly."""
if not ids:
return True
field_flag = False
domain = domain[:]
# if the object has a field named 'active', filter out all inactive
# records unless they were explicitely asked for
- if 'active' in self._columns and (active_test and context.get('active_test', True)):
+ if 'active' in (self._columns.keys() + self._inherit_fields.keys()) and (active_test and context.get('active_test', True)):
if domain:
active_in_args = False
for a in domain:
# _order is complex, can't use it here, so we default to _rec_name
m2o_order = dest_model._rec_name
else:
- # extract the first field name, to be able to qualify it and add desc/asc
- m2o_order = m2o_order.split(",",1)[0].strip().split(" ",1)[0]
+ # extract the field names, to be able to qualify them and add desc/asc
+ m2o_order_list = []
+ for order_part in m2o_order.split(","):
+ m2o_order_list.append(order_part.strip().split(" ",1)[0].strip())
+ m2o_order = m2o_order_list
# Join the dest m2o table if it's not joined yet. We use [LEFT] OUTER join here
# as we don't want to exclude results that have NULL values for the m2o
src_table, src_field = qualified_field.replace('"','').split('.', 1)
query.join((src_table, dest_model._table, src_field, 'id'), outer=True)
- return '"%s"."%s"' % (dest_model._table, m2o_order)
+ qualify = lambda field: '"%s"."%s"' % (dest_model._table, field)
+ return map(qualify, m2o_order) if isinstance(m2o_order, list) else qualify(m2o_order)
def _generate_order_by(self, order_spec, query):
order_field = order_split[0].strip()
order_direction = order_split[1].strip() if len(order_split) == 2 else ''
inner_clause = None
- if order_field in self._columns:
+ if order_field == 'id':
+ inner_clause = '"%s"."%s"' % (self._table, order_field)
+ elif order_field in self._columns:
order_column = self._columns[order_field]
if order_column._classic_read:
inner_clause = '"%s"."%s"' % (self._table, order_field)
elif order_column._type == 'many2one':
inner_clause = self._generate_m2o_order_by(order_field, query)
else:
- continue # ignore non-readable or "non-joignable" fields
+ continue # ignore non-readable or "non-joinable" fields
elif order_field in self._inherit_fields:
- parent_obj = self.pool.get(self._inherit_fields[order_field][0])
+ parent_obj = self.pool.get(self._inherit_fields[order_field][3])
order_column = parent_obj._columns[order_field]
if order_column._classic_read:
inner_clause = self._inherits_join_calc(order_field, query)
elif order_column._type == 'many2one':
inner_clause = self._generate_m2o_order_by(order_field, query)
else:
- continue # ignore non-readable or "non-joignable" fields
+ continue # ignore non-readable or "non-joinable" fields
if inner_clause:
- order_by_elements.append("%s %s" % (inner_clause, order_direction))
+ if isinstance(inner_clause, list):
+ for clause in inner_clause:
+ order_by_elements.append("%s %s" % (clause, order_direction))
+ else:
+ order_by_elements.append("%s %s" % (inner_clause, order_direction))
if order_by_elements:
order_by_clause = ",".join(order_by_elements)
for parent_column in ['parent_left', 'parent_right']:
data.pop(parent_column, None)
- for v in self._inherits:
- del data[self._inherits[v]]
+ # remove _inherits field's from data recursively, missing parents will
+ # be created by create() (so that copy() copy everything).
+ def remove_ids(inherits_dict):
+ for parent_table in inherits_dict:
+ del data[inherits_dict[parent_table]]
+ remove_ids(self.pool.get(parent_table)._inherits)
+ remove_ids(self._inherits)
return data
def copy_translations(self, cr, uid, old_id, new_id, context=None):
return False
return True
+ def _get_xml_ids(self, cr, uid, ids, *args, **kwargs):
+ """Find out the XML ID(s) of any database record.
+
+ **Synopsis**: ``_get_xml_ids(cr, uid, ids) -> { 'id': ['module.xml_id'] }``
+
+ :return: map of ids to the list of their fully qualified XML IDs
+ (empty list when there's none).
+ """
+ model_data_obj = self.pool.get('ir.model.data')
+ data_ids = model_data_obj.search(cr, uid, [('model', '=', self._name), ('res_id', 'in', ids)])
+ data_results = model_data_obj.read(cr, uid, data_ids, ['module', 'name', 'res_id'])
+ result = {}
+ for id in ids:
+ # can't use dict.fromkeys() as the list would be shared!
+ result[id] = []
+ for record in data_results:
+ result[record['res_id']].append('%(module)s.%(name)s' % record)
+ return result
+
def get_xml_id(self, cr, uid, ids, *args, **kwargs):
"""Find out the XML ID of any database record, if there
is one. This method works as a possible implementation
for a function field, to be able to add it to any
model object easily, referencing it as ``osv.osv.get_xml_id``.
+ When multiple XML IDs exist for a record, only one
+ of them is returned (randomly).
+
**Synopsis**: ``get_xml_id(cr, uid, ids) -> { 'id': 'module.xml_id' }``
- :return: the fully qualified XML ID of the given object,
+ :return: map of ids to their fully qualified XML ID,
defaulting to an empty string when there's none
(to be usable as a function field).
"""
- result = dict.fromkeys(ids, '')
- model_data_obj = self.pool.get('ir.model.data')
- data_ids = model_data_obj.search(cr, uid,
- [('model', '=', self._name), ('res_id', 'in', ids)])
- data_results = model_data_obj.read(cr, uid, data_ids,
- ['name', 'module', 'res_id'])
- for record in data_results:
- result[record['res_id']] = '%(module)s.%(name)s' % record
- return result
+ results = self._get_xml_ids(cr, uid, ids)
+ for k, v in results.items():
+ if results[k]:
+ results[k] = v[0]
+ else:
+ results[k] = ''
+ return results
# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
projects / odoo / odoo.git / blobdiff