Merge lp:~openerp-dev/openobject-addons/7.0-opw-589931-rgo into lp:openobject-addons

[Lithin T]

This fix is not traking when we deleting the records. So it should not be merged to the branch

[Lithin T (lithint-mail)]

review: Disapprove

[Naresh(OpenERP) (nch-openerp)]

Hello Lithin,

Please don't propose a merge proposal to its opposite source version. Here you proposed this to trunk source while it was intended for stable 7.0. Infact already a merge proposal was available for stable 7.0 https://code.launchpad.net/~openerp-dev/openobject-addons/7.0-opw-589931-rgo/+merge/156130 so there was no need to do this extra work.

Please keep this note for future reference. It will save time for all of us.

Thanks,

=== modified file 'audittrail/audittrail.py'
--- audittrail/audittrail.py	2013-03-29 14:37:20 +0000
+++ audittrail/audittrail.py	2013-10-16 08:27:50 +0000
@@ -284,6 +284,7 @@
         res_ids = []
         if args:
             res_ids = args[0]
+<<<<<<< TREE
             if isinstance(res_ids, (long, int)):
                 res_ids = [res_ids]
         if res_ids:
@@ -305,6 +306,88 @@
     This function simply read all the fields of the given res_ids, and also recurisvely on
     all records of a x2m fields read that need to be logged. Then it returns the result in
     convenient structure that will be used as comparison basis.
+=======
+            old_values = self.get_data(cr, uid_orig, pool, res_ids, model, method)
+            res = fct_src(cr, uid_orig, model.model, method, *args, **kw)
+        else: # method is write, action or workflow action
+            res_ids = []
+            if args:
+                res_ids = args[0]
+                if isinstance(res_ids, (long, int)):
+                    res_ids = [res_ids]
+            if res_ids:
+                # store the old values into a dictionary
+                old_values = self.get_data(cr, uid_orig, pool, res_ids, model, method)
+            # process the original function, workflow trigger...
+            res = fct_src(cr, uid_orig, model.model, method, *args, **kw)
+            if method == 'copy':
+                res_ids = [res]
+            if res_ids:
+                # check the new values and store them into a dictionary
+                new_values = self.get_data(cr, uid_orig, pool, res_ids, model, method)
+        # compare the old and new values and create audittrail log if needed
+        self.process_data(cr, uid_orig, pool, res_ids, model, method, old_values, new_values, field_list)
+        return res
+
+    def get_data(self, cr, uid, pool, res_ids, model, method):
+        """
+        This function simply read all the fields of the given res_ids, and also recurisvely on
+        all records of a x2m fields read that need to be logged. Then it returns the result in
+        convenient structure that will be used as comparison basis.
+
+            :param cr: the current row, from the database cursor,
+            :param uid: the current user’s ID. This parameter is currently not used as every
+                operation to get data is made as super admin. Though, it could be usefull later.
+            :param pool: current db's pooler object.
+            :param res_ids: Id's of resource to be logged/compared.
+            :param model: Object whose values are being changed
+            :param method: method to log: create, read, unlink, write, actions, workflow actions
+            :return: dict mapping a tuple (model_id, resource_id) with its value and textual value
+                { (model_id, resource_id): { 'value': ...
+                                             'textual_value': ...
+                                           },
+                }
+        """
+        data = {}
+        resource_pool = pool.get(model.model)
+        # read all the fields of the given resources in super admin mode
+        for resource in resource_pool.read(cr, SUPERUSER_ID, res_ids):
+            values = {}
+            values_text = {}
+            resource_id = resource['id']
+            # loop on each field on the res_ids we just have read
+            for field in resource:
+                if field in ('__last_update', 'id') or not resource_pool._all_columns.get(field):
+                    continue
+                values[field] = resource[field]
+                # get the textual value of that field for this record
+                values_text[field] = self.get_value_text(cr, SUPERUSER_ID, pool, resource_pool, method, field, resource[field])
+
+                field_obj = resource_pool._all_columns.get(field).column
+                if field_obj._type in ('one2many','many2many'):
+                    # check if an audittrail rule apply in super admin mode
+                    if self.check_rules(cr, SUPERUSER_ID, field_obj._obj, method):
+                        # check if the model associated to a *2m field exists, in super admin mode
+                        x2m_model_ids = pool.get('ir.model').search(cr, SUPERUSER_ID, [('model', '=', field_obj._obj)])
+                        x2m_model_id = x2m_model_ids and x2m_model_ids[0] or False
+                        assert x2m_model_id, _("'%s' Model does not exist..." %(field_obj._obj))
+                        x2m_model = pool.get('ir.model').browse(cr, SUPERUSER_ID, x2m_model_id)
+                        field_resource_ids = list(set(resource[field]))
+                        if model.model == x2m_model.model:
+                            # we need to remove current resource_id from the many2many to prevent an infinit loop
+                            if resource_id in field_resource_ids:
+                                field_resource_ids.remove(resource_id)
+                        data.update(self.get_data(cr, SUPERUSER_ID, pool, field_resource_ids, x2m_model, method))
+    
+            data[(model.id, resource_id)] = {'text':values_text, 'value': values}
+        return data
+
+    def prepare_audittrail_log_line(self, cr, uid, pool, model, resource_id, method, old_values, new_values, field_list=None):
+        """
+        This function compares the old data (i.e before the method was executed) and the new data
+        (after the method was executed) and returns a structure with all the needed information to
+        log those differences.
+>>>>>>> MERGE-SOURCE
 
         :param cr: the current row, from the database cursor,
         :param uid: the current user’s ID. This parameter is currently not used as every
@@ -346,6 +429,7 @@
                     field_resource_ids = list(set(resource[field]))
                     if model.model == x2m_model.model:
                         # we need to remove current resource_id from the many2many to prevent an infinit loop
+<<<<<<< TREE
                         if resource_id in field_resource_ids:
                             field_resource_ids.remove(resource_id)
                     data.update(get_data(cr, SUPERUSER_ID, pool, field_resource_ids, x2m_model, method))
@@ -502,6 +586,99 @@
                         return True
                     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', 'read_group', 'import_data'):
                         if rule['log_action']:
+=======
+                        if resource_id in res_ids:
+                            res_ids.remove(resource_id)
+                    for res_id in res_ids:
+                        lines.update(self.prepare_audittrail_log_line(cr, SUPERUSER_ID, pool, x2m_model, res_id, method, old_values, new_values, field_list))
+            # if the value value is different than the old value: record the change
+            if key not in old_values or key not in new_values or old_values[key]['value'][field_name] != new_values[key]['value'][field_name]:
+                data = {
+                      'name': field_name,
+                      'new_value': key in new_values and new_values[key]['value'].get(field_name),
+                      'old_value': key in old_values and old_values[key]['value'].get(field_name),
+                      'new_value_text': key in new_values and new_values[key]['text'].get(field_name),
+                      'old_value_text': key in old_values and old_values[key]['text'].get(field_name)
+                }
+                lines[key].append(data)
+        return lines
+
+    def process_data(self, cr, uid, pool, res_ids, model, method, old_values=None, new_values=None, field_list=None):
+        """
+        This function processes and iterates recursively to log the difference between the old
+        data (i.e before the method was executed) and the new data and creates audittrail log
+        accordingly.
+
+        :param cr: the current row, from the database cursor,
+        :param uid: the current user’s ID,
+        :param pool: current db's pooler object.
+        :param res_ids: Id's of resource to be logged/compared.
+        :param model: model object which values are being changed
+        :param method: method to log: create, read, unlink, write, actions, workflow actions
+        :param old_values: dict of values read before execution of the method
+        :param new_values: dict of values read after execution of the method
+        :param field_list: optional argument containing the list of fields to log. Currently only
+            used when performing a read, it could be usefull later on if we want to log the write
+            on specific fields only.
+        :return: True
+        """
+        if field_list is None:
+            field_list = []
+        # loop on all the given ids
+        for res_id in res_ids:
+            # compare old and new values and get audittrail log lines accordingly
+            lines = self.prepare_audittrail_log_line(cr, uid, pool, model, res_id, method, old_values, new_values, field_list)
+
+            # if at least one modification has been found
+            for model_id, resource_id in lines:
+                current_model = pool.get('ir.model').browse(cr, uid, model_id).model
+                if method == 'unlink':
+                    name = old_values[(model_id, resource_id)]['text'].get(pool.get(current_model)._rec_name)
+                else:
+                    name = pool.get(current_model).name_get(cr, uid, [resource_id])[0][1]
+                vals = {
+                    'method': method,
+                    'object_id': model_id,
+                    'user_id': uid,
+                    'res_id': resource_id,
+                    'name': name,
+                }
+                if (model_id, resource_id) not in old_values and method not in ('copy', 'read'):
+                    # the resource was not existing so we are forcing the method to 'create'
+                    # (because it could also come with the value 'write' if we are creating
+                    #  new record through a one2many field)
+                    vals.update({'method': 'create'})
+                if (model_id, resource_id) not in new_values and method not in ('copy', 'read'):
+                    # the resource is not existing anymore so we are forcing the method to 'unlink'
+                    # (because it could also come with the value 'write' if we are deleting the
+                    #  record through a one2many field)
+                    vals.update({'method': 'unlink'})
+                # create the audittrail log in super admin mode, only if a change has been detected
+                if lines[(model_id, resource_id)]:
+                    log_id = pool.get('audittrail.log').create(cr, SUPERUSER_ID, vals)
+                    model = pool.get('ir.model').browse(cr, uid, model_id)
+                    self.create_log_line(cr, SUPERUSER_ID, log_id, model, lines[(model_id, resource_id)])
+        return True
+
+    def check_rules(self, cr, uid, model, method):
+        """
+        Checks if auditrails is installed for that db and then if one rule match
+        @param cr: the current row, from the database cursor,
+        @param uid: the current user’s ID,
+        @param model: value of _name of the object which values are being changed
+        @param method: method to log: create, read, unlink,write,actions,workflow actions
+        @return: True or False
+        """
+        pool = pooler.get_pool(cr.dbname)
+        if 'audittrail.rule' in pool.models:
+            model_ids = pool.get('ir.model').search(cr, SUPERUSER_ID, [('model', '=', model)])
+            model_id = model_ids and model_ids[0] or False
+            if model_id:
+                rule_ids = pool.get('audittrail.rule').search(cr, SUPERUSER_ID, [('object_id', '=', model_id), ('state', '=', 'subscribed')])
+                for rule in pool.get('audittrail.rule').read(cr, SUPERUSER_ID, rule_ids, ['user_id','log_read','log_write','log_create','log_unlink','log_action','log_workflow']):
+                    if len(rule['user_id']) == 0 or uid in rule['user_id']:
+                        if rule.get('log_'+method,0):
+>>>>>>> MERGE-SOURCE
                             return True
 
 # Replace the openerp.service.model functions.