Naresh(OpenERP) has proposed merging
lp:~openerp-dev/openobject-addons/trunk-bug-832635-nch into
lp:openobject-addons.
Requested reviews:
Vo Minh Thu (OpenERP) (vmt-openerp)
Olivier Dony (OpenERP) (odo-openerp)
For more details, see:
https://code.launchpad.net/~openerp-dev/openobject-addons/trunk-bug-832635-nch/+merge/74416
Hello,
This merge proposal contains fix for the linked bug as well as refactoring and
improvement of the audit trail module.
please provide your feedback,
Thanks,
--
https://code.launchpad.net/~openerp-dev/openobject-addons/trunk-bug-832635-nch/+merge/74416
Your team OpenERP R&D Team is subscribed to branch
lp:~openerp-dev/openobject-addons/trunk-bug-832635-nch.
=== modified file 'audittrail/audittrail.py'
--- audittrail/audittrail.py 2011-06-15 13:23:47 +0000
+++ audittrail/audittrail.py 2011-09-07 12:42:35 +0000
@@ -187,55 +187,6 @@
class audittrail_objects_proxy(object_proxy):
""" Uses Object proxy for auditing changes on object of subscribed Rules"""
- def get_value_text(self, cr, uid, field_name, values, model, context=None):
- """
- Gets textual values for the fields
- e.g.: For field of type many2one it gives its name value instead of id
-
- @param cr: the current row, from the database cursor,
- @param uid: the current userâs ID for security checks,
- @param field_name: List of fields for text values
- @param values: Values for field to be converted into textual values
- @return: values: List of textual values for given fields
- """
- if not context:
- context = {}
- if field_name in('__last_update','id'):
- return values
- pool = pooler.get_pool(cr.dbname)
- field_pool = pool.get('ir.model.fields')
- model_pool = pool.get('ir.model')
- obj_pool = pool.get(model.model)
- if obj_pool._inherits:
- inherits_ids = model_pool.search(cr, uid, [('model', '=', obj_pool._inherits.keys()[0])])
- field_ids = field_pool.search(cr, uid, [('name', '=', field_name), ('model_id', 'in', (model.id, inherits_ids[0]))])
- else:
- field_ids = field_pool.search(cr, uid, [('name', '=', field_name), ('model_id', '=', model.id)])
- field_id = field_ids and field_ids[0] or False
- assert field_id, _("'%s' field does not exist in '%s' model" %(field_name, model.model))
-
- field = field_pool.read(cr, uid, field_id)
- relation_model = field['relation']
- relation_model_pool = relation_model and pool.get(relation_model) or False
-
- if field['ttype'] == 'many2one':
- res = False
- relation_id = False
- if values and type(values) == tuple:
- relation_id = values[0]
- if relation_id and relation_model_pool:
- relation_model_object = relation_model_pool.read(cr, uid, relation_id, [relation_model_pool._rec_name])
- res = relation_model_object[relation_model_pool._rec_name]
- return res
-
- elif field['ttype'] in ('many2many','one2many'):
- res = []
- for relation_model_object in relation_model_pool.read(cr, uid, values, [relation_model_pool._rec_name]):
- res.append(relation_model_object[relation_model_pool._rec_name])
- return res
-
- return values
-
def create_log_line(self, cr, uid, log_id, model, lines=[]):
"""
Creates lines for changed fields with its old and new values
@@ -250,49 +201,71 @@
model_pool = pool.get('ir.model')
field_pool = pool.get('ir.model.fields')
log_line_pool = pool.get('audittrail.log.line')
- #start Loop
for line in lines:
- if line['name'] in('__last_update','id'):
- continue
+ field_obj = obj_pool._all_columns.get(line['name'])
+ assert field_obj, _("'%s' field does not exist in '%s' model" %(line['name'], model.model))
+ field_obj = field_obj.column
+ old_value = line.get('old_value', '')
+ new_value = line.get('new_value', '')
+ old_value_text = line.get('old_value_text', '')
+ new_value_text = line.get('new_value_text', '')
+ search_models = [ model.id ]
if obj_pool._inherits:
- inherits_ids = model_pool.search(cr, uid, [('model', '=', obj_pool._inherits.keys()[0])])
- field_ids = field_pool.search(cr, uid, [('name', '=', line['name']), ('model_id', 'in', (model.id, inherits_ids[0]))])
- else:
- field_ids = field_pool.search(cr, uid, [('name', '=', line['name']), ('model_id', '=', model.id)])
- field_id = field_ids and field_ids[0] or False
- assert field_id, _("'%s' field does not exist in '%s' model" %(line['name'], model.model))
-
- field = field_pool.read(cr, uid, field_id)
- old_value = 'old_value' in line and line['old_value'] or ''
- new_value = 'new_value' in line and line['new_value'] or ''
- old_value_text = 'old_value_text' in line and line['old_value_text'] or ''
- new_value_text = 'new_value_text' in line and line['new_value_text'] or ''
-
+ search_models += model_pool.search(cr, uid, [('model', 'in', obj_pool._inherits.keys())])
+ field_id = field_pool.search(cr, uid, [('name', '=', line['name']), ('model_id', 'in', search_models)])
if old_value_text == new_value_text:
continue
- if field['ttype'] == 'many2one':
- if type(old_value) == tuple:
- old_value = old_value[0]
- if type(new_value) == tuple:
- new_value = new_value[0]
+ if field_obj._type == 'many2one':
+ old_value = old_value and old_value[0] or old_value
+ new_value = new_value and new_value[0] or new_value
vals = {
"log_id": log_id,
- "field_id": field_id,
+ "field_id": field_id and field_id[0] or False,
"old_value": old_value,
"new_value": new_value,
"old_value_text": old_value_text,
"new_value_text": new_value_text,
- "field_description": field['field_description']
+ "field_description": field_obj.string
}
line_id = log_line_pool.create(cr, uid, vals)
cr.commit()
- #End Loop
- return True
-
-
+ return True
+
+ def get_value_text(self, cr, db, uid, pool, resource_pool, method, field, value, recursive=True):
+ field_obj = (resource_pool._all_columns.get(field)).column
+ if field_obj._type in ('one2many','many2many'):
+ if recursive:
+ self.log_fct(db, uid, field_obj._obj, method, None, value, 'child_relation_log')
+ data = pool.get(field_obj._obj).name_get(cr, uid, value)
+ return map(lambda x:x[1], data)
+ elif field_obj._type == 'many2one':
+ return value and value[1] or value
+ return False
+
+ def start_log_process(self, cr, db, user_id, model, method, resource_data, pool, resource_pool):
+ key1 = '%s_value'%(method == 'create' and 'new' or 'old')
+ key2 = '%s_value_text'%(method == 'create' and 'new' or 'old')
+ uid = 1
+ vals = { 'method': method, 'object_id': model.id,'user_id': user_id}
+ for resource, fields in resource_data.iteritems():
+ vals.update({'res_id': resource})
+ log_id = pool.get('audittrail.log').create(cr, uid, vals)
+ lines = []
+ for field_key, value in fields.iteritems():
+ if field_key in ('__last_update', 'id'):continue
+ ret_val = self.get_value_text(cr, db, uid, pool, resource_pool, method, field_key, value, method != 'read')
+ line = {
+ 'name': field_key,
+ key1: value,
+ key2: ret_val and ret_val or value
+ }
+ lines.append(line)
+ self.create_log_line(cr, uid, log_id, model, lines)
+ return True
+
def log_fct(self, db, uid, model, method, fct_src, *args):
"""
- Logging function: This function is performs logging oprations according to method
+ Logging function: This function is performs logging operations according to method
@param db: the current database
@param uid: the current userâs ID for security checks,
@param object: Object who's values are being changed
@@ -303,105 +276,45 @@
"""
uid_orig = uid
uid = 1
- res2 = args
pool = pooler.get_pool(db)
cr = pooler.get_db(db).cursor()
resource_pool = pool.get(model)
log_pool = pool.get('audittrail.log')
- model_pool = pool.get('ir.model')
-
- model_ids = model_pool.search(cr, uid, [('model', '=', model)])
- model_id = model_ids and model_ids[0] or False
- assert model_id, _("'%s' Model does not exist..." %(model))
- model = model_pool.browse(cr, uid, model_id)
-
- if method in ('create'):
- res_id = fct_src(db, uid_orig, model.model, method, *args)
- cr.commit()
- resource = resource_pool.read(cr, uid, res_id, args[0].keys())
- vals = {
- "method": method,
- "object_id": model.id,
- "user_id": uid_orig,
- "res_id": resource['id'],
- }
- if 'id' in resource:
- del resource['id']
- log_id = log_pool.create(cr, uid, vals)
- lines = []
- for field in resource:
- line = {
- 'name': field,
- 'new_value': resource[field],
- 'new_value_text': self.get_value_text(cr, uid, field, resource[field], model)
- }
- lines.append(line)
- self.create_log_line(cr, uid, log_id, model, lines)
-
+ model = self.check_rule_subscription(cr, uid, pool, model, False)
+ assert model, _("'%s' Model does not exist..." %(model))
+
+ relational_table_log = args and args[-1] == 'child_relation_log' or False
+ if method == 'create':
+ resource_data = {}
+ fields_to_read = []
+ if relational_table_log:
+ res_id = args[0]
+ else:
+ res_id = fct_src(db, uid_orig, model.model, method, *args)
+ cr.commit()
+ fields_to_read = args[0].keys()
+ if res_id:
+ resource = resource_pool.read(cr, uid, res_id, fields_to_read)
+ if not isinstance(resource,list):
+ resource = [resource]
+ map(lambda x: resource_data.setdefault(x['id'], x), resource)
+ self.start_log_process(cr, db, uid_orig, model, method, resource_data, pool, resource_pool)
cr.commit()
cr.close()
return res_id
- elif method in ('read'):
+ elif method in('read', 'unlink'):
res_ids = args[0]
old_values = {}
- res = fct_src(db, uid_orig, model.model, method, *args)
- if type(res) == list:
- for v in res:
- old_values[v['id']] = v
+ if method == 'read':
+ res = fct_src(db, uid_orig, model.model, method, *args)
+ map(lambda x: old_values.setdefault(x['id'], x), res)
else:
- old_values[res['id']] = res
- for res_id in old_values:
- vals = {
- "method": method,
- "object_id": model.id,
- "user_id": uid_orig,
- "res_id": res_id,
-
- }
- log_id = log_pool.create(cr, uid, vals)
- lines = []
- for field in old_values[res_id]:
- line = {
- 'name': field,
- 'old_value': old_values[res_id][field],
- 'old_value_text': self.get_value_text(cr, uid, field, old_values[res_id][field], model)
- }
- lines.append(line)
-
- self.create_log_line(cr, uid, log_id, model, lines)
- cr.commit()
- cr.close()
- return res
-
- elif method in ('unlink'):
- res_ids = args[0]
- old_values = {}
- for res_id in res_ids:
- old_values[res_id] = resource_pool.read(cr, uid, res_id)
-
- for res_id in res_ids:
- vals = {
- "method": method,
- "object_id": model.id,
- "user_id": uid_orig,
- "res_id": res_id,
-
- }
- log_id = log_pool.create(cr, uid, vals)
- lines = []
- for field in old_values[res_id]:
- if field in ('id'):
- continue
- line = {
- 'name': field,
- 'old_value': old_values[res_id][field],
- 'old_value_text': self.get_value_text(cr, uid, field, old_values[res_id][field], model)
- }
- lines.append(line)
-
- self.create_log_line(cr, uid, log_id, model, lines)
- res = fct_src(db, uid_orig, model.model, method, *args)
+ res = resource_pool.read(cr, uid, res_ids)
+ map(lambda x:old_values.setdefault(x['id'], x), res)
+ self.start_log_process(cr, db, uid_orig, model, method, old_values, pool, resource_pool)
+ if not relational_table_log and method == 'unlink':
+ res = fct_src(db, uid_orig, model.model, method, *args)
cr.commit()
cr.close()
return res
@@ -412,152 +325,133 @@
res_ids = args[0]
old_values = {}
fields = []
- if len(args)>1 and type(args[1]) == dict:
+ if len(args) > 1 and isinstance(args[1], dict):
fields = args[1].keys()
- if type(res_ids) in (long, int):
+ if isinstance(res_ids, (long, int)):
res_ids = [res_ids]
if res_ids:
- for resource in resource_pool.read(cr, uid, res_ids):
- resource_id = resource['id']
- if 'id' in resource:
- del resource['id']
- old_values_text = {}
- old_value = {}
- for field in resource.keys():
- old_value[field] = resource[field]
- old_values_text[field] = self.get_value_text(cr, uid, field, resource[field], model)
- old_values[resource_id] = {'text':old_values_text, 'value': old_value}
-
+ x2m_old_values = {}
+ old_values = {}
+ def inline_process_old_data(res_ids, model, model_id=False):
+ resource_pool = pool.get(model)
+ resource_data = resource_pool.read(cr, uid, res_ids)
+ _old_values = {}
+ for resource in resource_data:
+ _old_values_text = {}
+ _old_value = {}
+ resource_id = resource['id']
+ for field in resource.keys():
+ if field in ('__last_update', 'id'):continue
+ field_obj = (resource_pool._all_columns.get(field)).column
+ if field_obj._type in ('one2many','many2many'):
+ x2m_rule_ids, x2m_model = self.check_rule_subscription(cr, uid, pool, field_obj._obj)
+ if x2m_rule_ids:
+ x2m_old_values.update(inline_process_old_data(resource[field], field_obj._obj, x2m_model))
+ ret_val = self.get_value_text(cr, db, uid, pool, resource_pool, method, field, resource[field], False)
+ _old_value[field] = resource[field]
+ _old_values_text[field] = ret_val and ret_val or resource[field]
+ _old_values[resource_id] = {'text':_old_values_text, 'value': _old_value}
+ if model_id:
+ _old_values[resource_id].update({'model_id':model_id})
+ return _old_values
+ old_values.update(inline_process_old_data(res_ids, model.model))
res = fct_src(db, uid_orig, model.model, method, *args)
cr.commit()
-
if res_ids:
- for resource in resource_pool.read(cr, uid, res_ids):
- resource_id = resource['id']
- if 'id' in resource:
- del resource['id']
- vals = {
- "method": method,
- "object_id": model.id,
- "user_id": uid_orig,
- "res_id": resource_id,
- }
-
-
- log_id = log_pool.create(cr, uid, vals)
- lines = []
- for field in resource.keys():
- line = {
- 'name': field,
- 'new_value': resource[field],
- 'old_value': old_values[resource_id]['value'][field],
- 'new_value_text': self.get_value_text(cr, uid, field, resource[field], model),
- 'old_value_text': old_values[resource_id]['text'][field]
- }
- lines.append(line)
-
- self.create_log_line(cr, uid, log_id, model, lines)
+ def inline_process_new_data(res_ids, model, dict_to_use={}):
+ resource_pool = pool.get(model.model)
+ resource_data = resource_pool.read(cr, uid, res_ids)
+ vals = {'method': method,'object_id': model.id,'user_id': uid_orig }
+ for resource in resource_data:
+ resource_id = resource['id']
+ vals.update({'res_id': resource_id})
+ log_id = log_pool.create(cr, uid, vals)
+ lines = []
+ for field in resource.keys():
+ if field in ('__last_update', 'id'):continue
+ field_obj = (resource_pool._all_columns.get(field)).column
+ if field_obj._type in ('one2many','many2many'):
+ x2m_rule_ids, x2m_model = self.check_rule_subscription(cr, uid, pool, field_obj._obj)
+ if x2m_rule_ids:
+ inline_process_new_data(resource[field], x2m_model, x2m_old_values)
+ ret_val = self.get_value_text(cr, db, uid, pool, resource_pool, method, field, resource[field], False)
+ line = {
+ 'name': field,
+ 'new_value': resource[field],
+ 'old_value': resource_id in dict_to_use and dict_to_use[resource_id]['value'].get(field),
+ 'new_value_text': ret_val and ret_val or resource[field],
+ 'old_value_text': resource_id in dict_to_use and dict_to_use[resource_id]['text'].get(field)
+ }
+ lines.append(line)
+ self.create_log_line(cr, uid, log_id, model, lines)
+ return True
+ inline_process_new_data(res_ids, model, old_values)
cr.commit()
cr.close()
return res
return True
-
-
-
- def execute(self, db, uid, model, method, *args, **kw):
+
+ def check_rule_subscription(self, cr, uid, pool, model, rule_check=True):
+ '''
+ Test if the model has been subscribed to the audit rule
+ if yes then return the rule_ids also return the model browse_record object.
+ '''
+ model_ids = pool.get('ir.model').search(cr, uid, [('model', '=', model)])
+ model_obj = model_ids and model_ids[0] and pool.get('ir.model').browse(cr, uid, model_ids[0]) or False
+ if rule_check:
+ rule_ids = pool.get('audittrail.rule').search(cr, uid, [('object_id', '=', model_obj.id), ('state', '=', 'subscribed')])
+ return rule_ids, model_obj
+ return model_obj
+
+ def audit_log_call(self, db, uid, model, method, action_type, *args, **argv):
"""
Overrides Object Proxy execute method
@param db: the current database
@param uid: the current user's ID for security checks,
@param object: Object who's values are being changed
@param method: get any method and create log
-
+ @param action_type: either 'execute' or 'workflow'
@return: Returns result as per method of Object proxy
"""
uid_orig = uid
uid = 1
pool = pooler.get_pool(db)
- model_pool = pool.get('ir.model')
- rule_pool = pool.get('audittrail.rule')
+ logged_uids = []
cr = pooler.get_db(db).cursor()
cr.autocommit(True)
- logged_uids = []
- fct_src = super(audittrail_objects_proxy, self).execute
-
- def my_fct(db, uid, model, method, *args):
- rule = False
- model_ids = model_pool.search(cr, uid, [('model', '=', model)])
- model_id = model_ids and model_ids[0] or False
-
- for model_name in pool.obj_list():
- if model_name == 'audittrail.rule':
- rule = True
- if not rule:
- return fct_src(db, uid_orig, model, method, *args)
- if not model_id:
- return fct_src(db, uid_orig, model, method, *args)
-
- rule_ids = rule_pool.search(cr, uid, [('object_id', '=', model_id), ('state', '=', 'subscribed')])
- if not rule_ids:
- return fct_src(db, uid_orig, model, method, *args)
-
- for thisrule in rule_pool.browse(cr, uid, rule_ids):
- for user in thisrule.user_id:
- logged_uids.append(user.id)
+ if action_type == 'execute':
+ ignore_methods = ['default_get','read','fields_view_get','fields_get','search',
+ 'search_count','name_search','name_get','get','request_get',
+ 'get_sc', 'unlink', 'write', 'create']
+ fct_src = super(audittrail_objects_proxy, self).execute
+ else:
+ fct_src = super(audittrail_objects_proxy, self).exec_workflow
+ try:
+ rule_ids, model_obj = self.check_rule_subscription(cr, uid, pool, model)
+ if not ('audittrail.rule' in pool.obj_list() and model_obj and rule_ids):
+ return fct_src(db, uid_orig, model, method, *args, **argv)
+ for model_rule in pool.get('audittrail.rule').browse(cr, uid, rule_ids):
+ logged_uids += map(lambda x:x.id, model_rule.user_id)
if not logged_uids or uid in logged_uids:
- if method in ('read', 'write', 'create', 'unlink'):
- if getattr(thisrule, 'log_' + method):
- return self.log_fct(db, uid_orig, model, method, fct_src, *args)
-
- elif method not in ('default_get','read','fields_view_get','fields_get','search','search_count','name_search','name_get','get','request_get', 'get_sc', 'unlink', 'write', 'create'):
- if thisrule.log_action:
- return self.log_fct(db, uid_orig, model, method, fct_src, *args)
-
- return fct_src(db, uid_orig, model, method, *args)
- try:
- res = my_fct(db, uid, model, method, *args)
- return res
+ if action_type == 'execute':
+ if method in ('read', 'write', 'create', 'unlink'):
+ if getattr(model_rule, 'log_' + method):
+ return self.log_fct(db, uid_orig, model, method, fct_src, *args)
+ elif method not in ignore_methods:
+ if model_rule.log_action:
+ return self.log_fct(db, uid_orig, model, method, fct_src, *args)
+ else:
+ if model_rule.log_workflow:
+ return self.log_fct(db, uid_orig, model, method, fct_src, *args)
+ return fct_src(db, uid_orig, model, method, *args, **argv)
finally:
cr.close()
+ def execute(self, db, uid, model, method, *args, **argv):
+ return self.audit_log_call(db, uid, model, method, 'execute', *args, **argv)
+
def exec_workflow(self, db, uid, model, method, *args, **argv):
- uid_orig = uid
- uid = 1
-
- pool = pooler.get_pool(db)
- logged_uids = []
- fct_src = super(audittrail_objects_proxy, self).exec_workflow
- field = method
- rule = False
- model_pool = pool.get('ir.model')
- rule_pool = pool.get('audittrail.rule')
- cr = pooler.get_db(db).cursor()
- cr.autocommit(True)
- try:
- model_ids = model_pool.search(cr, uid, [('model', '=', model)])
- for obj_name in pool.obj_list():
- if obj_name == 'audittrail.rule':
- rule = True
- if not rule:
- return super(audittrail_objects_proxy, self).exec_workflow(db, uid_orig, model, method, *args, **argv)
- if not model_ids:
- return super(audittrail_objects_proxy, self).exec_workflow(db, uid_orig, model, method, *args, **argv)
-
- rule_ids = rule_pool.search(cr, uid, [('object_id', 'in', model_ids), ('state', '=', 'subscribed')])
- if not rule_ids:
- return super(audittrail_objects_proxy, self).exec_workflow(db, uid_orig, model, method, *args, **argv)
-
- for thisrule in rule_pool.browse(cr, uid, rule_ids):
- for user in thisrule.user_id:
- logged_uids.append(user.id)
- if not logged_uids or uid in logged_uids:
- if thisrule.log_workflow:
- return self.log_fct(db, uid_orig, model, method, fct_src, *args)
- return super(audittrail_objects_proxy, self).exec_workflow(db, uid_orig, model, method, *args, **argv)
-
- return True
- finally:
- cr.close()
+ return self.audit_log_call(db, uid, model, method, 'workflow', *args, **argv)
audittrail_objects_proxy()
_______________________________________________
Mailing list: https://launchpad.net/~openerp-dev-gtk
Post to : [email protected]
Unsubscribe : https://launchpad.net/~openerp-dev-gtk
More help : https://help.launchpad.net/ListHelp
