Join the social network of Tech Nerds, increase skill rank, get work, manage projects...
 
  • How administrator track every user operation on all the objects of the system in OpenERP(Odoo)?

    • 0
    • 0
    • 0
    • 0
    • 0
    • 0
    • 0
    • 0
    • 935
    Comment on it

    Step-1 Install Audit Trail module
    Step-2 After that custmozie .py(Python file) file: In below example, I have custmozied .py file. You can directly copy the below python code in your .py file:-

    from openerp.osv import fields, osv
    from openerp.osv.osv import object_proxy
    from openerp.tools.translate import _
    from openerp import pooler
    import time
    from openerp import tools
    from openerp import SUPERUSER_ID
    
    class audittrail_rule(osv.osv):
        """
        For Auddittrail Rule
        """
        _name = 'audittrail.rule'
        _description = "Audittrail Rule"
        _columns = {
            "name": fields.char("Rule Name", size=32, required=True),
            "object_id": fields.many2one('ir.model', 'Object', required=True, help="Select object for which you want to generate log."),
            "user_id": fields.many2many('res.users', 'audittail_rules_users',
                                                'user_id', 'rule_id', 'Users', help="if  User is not added then it will applicable for all users"),
            "log_read": fields.boolean("Log Reads", help="Select this if you want to keep track of read/open on any record of the object of this rule"),
            "log_write": fields.boolean("Log Writes", help="Select this if you want to keep track of modification on any record of the object of this rule"),
            "log_unlink": fields.boolean("Log Deletes", help="Select this if you want to keep track of deletion on any record of the object of this rule"),
            "log_create": fields.boolean("Log Creates",help="Select this if you want to keep track of creation on any record of the object of this rule"),
            "log_action": fields.boolean("Log Action",help="Select this if you want to keep track of actions on the object of this rule"),
            "log_workflow": fields.boolean("Log Workflow",help="Select this if you want to keep track of workflow on any record of the object of this rule"),
            "state": fields.selection((("draft", "Draft"), ("subscribed", "Subscribed")), "Status", required=True),
            "action_id": fields.many2one('ir.actions.act_window', "Action ID"),
        }
        _defaults = {
            'state': 'draft',
            'log_create': 1,
            'log_unlink': 1,
            'log_write': 1,
        }
        _sql_constraints = [
            ('model_uniq', 'unique (object_id)', """There is already a rule defined on this object\n You cannot define another: please edit the existing one.""")
        ]
        __functions = {}
    
        def subscribe(self, cr, uid, ids, *args):
            """
            Subscribe Rule for auditing changes on object and apply shortcut for logs on that object.
            @param cr: the current row, from the database cursor,
            @param uid: the current users ID for security checks,
            @param ids: List of Auddittrail Rules IDs.
            @return: True
            """
            obj_action = self.pool.get('ir.actions.act_window')
            obj_model = self.pool.get('ir.model.data')
            #start Loop
            for thisrule in self.browse(cr, uid, ids):
                obj = self.pool.get(thisrule.object_id.model)
                if not obj:
                    raise osv.except_osv(
                            _('WARNING: audittrail is not part of the pool'),
                            _('Change audittrail depends -- Setting rule as DRAFT'))
                    self.write(cr, uid, [thisrule.id], {"state": "draft"})
                val = {
                     "name": 'View Log',
                     "res_model": 'audittrail.log',
                     "src_model": thisrule.object_id.model,
                     "domain": "[('object_id','=', " + str(thisrule.object_id.id) + "), ('res_id', '=', active_id)]"
    
                }
                action_id = obj_action.create(cr, SUPERUSER_ID, val)
                self.write(cr, uid, [thisrule.id], {"state": "subscribed", "action_id": action_id})
                keyword = 'client_action_relate'
                value = 'ir.actions.act_window,' + str(action_id)
                res = obj_model.ir_set(cr, SUPERUSER_ID, 'action', keyword, 'View_log_' + thisrule.object_id.model, [thisrule.object_id.model], value, replace=True, isobject=True, xml_id=False)
                #End Loop
            return True
    
        def unsubscribe(self, cr, uid, ids, *args):
            """
            Unsubscribe Auditing Rule on object
            @param cr: the current row, from the database cursor,
            @param uid: the current users ID for security checks,
            @param ids: List of Auddittrail Rules IDs.
            @return: True
            """
            obj_action = self.pool.get('ir.actions.act_window')
            ir_values_obj = self.pool.get('ir.values')
            value=''
            #start Loop
            for thisrule in self.browse(cr, uid, ids):
                if thisrule.id in self.__functions:
                    for function in self.__functions[thisrule.id]:
                        setattr(function[0], function[1], function[2])
                w_id = obj_action.search(cr, uid, [('name', '=', 'View Log'), ('res_model', '=', 'audittrail.log'), ('src_model', '=', thisrule.object_id.model)])
                if w_id:
                    obj_action.unlink(cr, SUPERUSER_ID, w_id)
                    value = "ir.actions.act_window" + ',' + str(w_id[0])
                val_id = ir_values_obj.search(cr, uid, [('model', '=', thisrule.object_id.model), ('value', '=', value)])
                if val_id:
                    ir_values_obj = pooler.get_pool(cr.dbname).get('ir.values')
                    res = ir_values_obj.unlink(cr, uid, [val_id[0]])
                self.write(cr, uid, [thisrule.id], {"state": "draft"})
            #End Loop
            return True
    
    class audittrail_log(osv.osv):
        """
        For Audittrail Log
        """
        _name = 'audittrail.log'
        _description = "Audittrail Log"
    
        def _name_get_resname(self, cr, uid, ids, *args):
            data = {}
            for resname in self.browse(cr, uid, ids,[]):
                model_object = resname.object_id
                res_id = resname.res_id
                if model_object and res_id:
                    model_pool = self.pool.get(model_object.model)
                    res = model_pool.read(cr, uid, res_id, ['name'])
                    data[resname.id] = res['name']
                else:
                     data[resname.id] = False
            return data
    
        _columns = {
            "name": fields.char("Resource Name",size=64),
            "object_id": fields.many2one('ir.model', 'Object'),
            "user_id": fields.many2one('res.users', 'User'),
            "method": fields.char("Method", size=64),
            "timestamp": fields.datetime("Date"),
            "res_id": fields.integer('Resource Id'),
            "line_ids": fields.one2many('audittrail.log.line', 'log_id', 'Log lines'),
        }
    
        _defaults = {
            "timestamp": lambda *a: time.strftime("%Y-%m-%d %H:%M:%S")
        }
        _order = "timestamp desc"
    
    class audittrail_log_line(osv.osv):
        """
        Audittrail Log Line.
        """
        _name = 'audittrail.log.line'
        _description = "Log Line"
        _columns = {
              'field_id': fields.many2one('ir.model.fields', 'Fields', required=True),
              'log_id': fields.many2one('audittrail.log', 'Log'),
              'log': fields.integer("Log ID"),
              'old_value': fields.text("Old Value"),
              'new_value': fields.text("New Value"),
              'old_value_text': fields.text('Old value Text'),
              'new_value_text': fields.text('New value Text'),
              'field_description': fields.char('Field Description', size=64),
            }
    
    class audittrail_objects_proxy(object_proxy):
        """ Uses Object proxy for auditing changes on object of subscribed Rules"""
    
        def get_value_text(self, cr, uid, pool, resource_pool, method, field, value):
            """
            Gets textual values for the fields.
                If the field is a many2one, it returns the name.
                If it's a one2many or a many2many, it returns a list of name.
                In other cases, it just returns the value.
            :param cr: the current row, from the database cursor,
            :param uid: the current users ID for security checks,
            :param pool: current db's pooler object.
            :param resource_pool: pooler object of the model which values are being changed.
            :param field: for which the text value is to be returned.
            :param value: value of the field.
            :param recursive: True or False, True will repeat the process recursively
            :return: string value or a list of values(for O2M/M2M)
            """
    
            field_obj = (resource_pool._all_columns.get(field)).column
            if field_obj._type in ('one2many','many2many'):
                data = pool.get(field_obj._obj).name_get(cr, uid, value)
                #return the modifications on x2many fields as a list of names
                res = map(lambda x:x[1], data)
            elif field_obj._type == 'many2one':
                #return the modifications on a many2one field as its value returned by name_get()
                res = value and value[1] or value
            else:
                res = value
            return res

 0 Comment(s)

Sign In
                           OR                           
                           OR                           
Register

Sign up using

                           OR                           
Forgot Password
Fill out the form below and instructions to reset your password will be emailed to you:
Reset Password
Fill out the form below and reset your password: