You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

519 lines
22 KiB

9 years ago
9 years ago
9 years ago
  1. # -*- coding: utf-8 -*-
  2. ##############################################################################
  3. #
  4. # OpenERP, Open Source Management Solution
  5. # Copyright (C) 2013 ABF OSIELL (<http://osiell.com>).
  6. #
  7. # This program is free software: you can redistribute it and/or modify
  8. # it under the terms of the GNU Affero General Public License as
  9. # published by the Free Software Foundation, either version 3 of the
  10. # License, or (at your option) any later version.
  11. #
  12. # This program is distributed in the hope that it will be useful,
  13. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  15. # GNU Affero General Public License for more details.
  16. #
  17. # You should have received a copy of the GNU Affero General Public License
  18. # along with this program. If not, see <http://www.gnu.org/licenses/>.
  19. #
  20. ##############################################################################
  21. from openerp import models, fields, api, modules, _, SUPERUSER_ID, sql_db
  22. FIELDS_BLACKLIST = [
  23. 'id', 'create_uid', 'create_date', 'write_uid', 'write_date',
  24. 'display_name', '__last_update',
  25. ]
  26. # Used for performance, to avoid a dictionary instanciation when we need an
  27. # empty dict to simplify algorithms
  28. EMPTY_DICT = {}
  29. class DictDiffer(object):
  30. """Calculate the difference between two dictionaries as:
  31. (1) items added
  32. (2) items removed
  33. (3) keys same in both but changed values
  34. (4) keys same in both and unchanged values
  35. """
  36. def __init__(self, current_dict, past_dict):
  37. self.current_dict, self.past_dict = current_dict, past_dict
  38. self.set_current = set(current_dict)
  39. self.set_past = set(past_dict)
  40. self.intersect = self.set_current.intersection(self.set_past)
  41. def added(self):
  42. return self.set_current - self.intersect
  43. def removed(self):
  44. return self.set_past - self.intersect
  45. def changed(self):
  46. return set(o for o in self.intersect
  47. if self.past_dict[o] != self.current_dict[o])
  48. def unchanged(self):
  49. return set(o for o in self.intersect
  50. if self.past_dict[o] == self.current_dict[o])
  51. class AuditlogRule(models.Model):
  52. _name = 'auditlog.rule'
  53. _description = "Auditlog - Rule"
  54. name = fields.Char(u"Name", size=32, required=True)
  55. model_id = fields.Many2one(
  56. 'ir.model', u"Model", required=True,
  57. help=u"Select model for which you want to generate log.")
  58. user_ids = fields.Many2many(
  59. 'res.users',
  60. 'audittail_rules_users',
  61. 'user_id', 'rule_id',
  62. string=u"Users",
  63. help=u"if User is not added then it will applicable for all users")
  64. log_read = fields.Boolean(
  65. u"Log Reads",
  66. help=(u"Select this if you want to keep track of read/open on any "
  67. u"record of the model of this rule"))
  68. log_write = fields.Boolean(
  69. u"Log Writes", default=True,
  70. help=(u"Select this if you want to keep track of modification on any "
  71. u"record of the model of this rule"))
  72. log_unlink = fields.Boolean(
  73. u"Log Deletes", default=True,
  74. help=(u"Select this if you want to keep track of deletion on any "
  75. u"record of the model of this rule"))
  76. log_create = fields.Boolean(
  77. u"Log Creates", default=True,
  78. help=(u"Select this if you want to keep track of creation on any "
  79. u"record of the model of this rule"))
  80. # log_action = fields.Boolean(
  81. # "Log Action",
  82. # help=("Select this if you want to keep track of actions on the "
  83. # "model of this rule"))
  84. # log_workflow = fields.Boolean(
  85. # "Log Workflow",
  86. # help=("Select this if you want to keep track of workflow on any "
  87. # "record of the model of this rule"))
  88. state = fields.Selection(
  89. [('draft', "Draft"), ('subscribed', "Subscribed")],
  90. string=u"State", required=True, default='draft')
  91. action_id = fields.Many2one(
  92. 'ir.actions.act_window', string="Action")
  93. _sql_constraints = [
  94. ('model_uniq', 'unique(model_id)',
  95. ("There is already a rule defined on this model\n"
  96. "You cannot define another: please edit the existing one."))
  97. ]
  98. def _register_hook(self, cr, ids=None):
  99. """Get all rules and apply them to log method calls."""
  100. super(AuditlogRule, self)._register_hook(cr)
  101. if not hasattr(self.pool, '_auditlog_field_cache'):
  102. self.pool._auditlog_field_cache = {}
  103. if not hasattr(self.pool, '_auditlog_model_cache'):
  104. self.pool._auditlog_model_cache = {}
  105. if ids is None:
  106. ids = self.search(cr, SUPERUSER_ID, [('state', '=', 'subscribed')])
  107. return self._patch_methods(cr, SUPERUSER_ID, ids)
  108. @api.multi
  109. def _patch_methods(self):
  110. """Patch ORM methods of models defined in rules to log their calls."""
  111. updated = False
  112. model_cache = self.pool._auditlog_model_cache
  113. for rule in self:
  114. if rule.state != 'subscribed':
  115. continue
  116. if not self.pool.get(rule.model_id.model):
  117. # ignore rules for models not loadable currently
  118. continue
  119. model_cache[rule.model_id.model] = rule.model_id.id
  120. model_model = self.env[rule.model_id.model]
  121. # CRUD
  122. # -> create
  123. check_attr = 'auditlog_ruled_create'
  124. if getattr(rule, 'log_create') \
  125. and not hasattr(model_model, check_attr):
  126. model_model._patch_method('create', self._make_create())
  127. setattr(model_model, check_attr, True)
  128. updated = True
  129. # -> read
  130. check_attr = 'auditlog_ruled_read'
  131. if getattr(rule, 'log_read') \
  132. and not hasattr(model_model, check_attr):
  133. model_model._patch_method('read', self._make_read())
  134. setattr(model_model, check_attr, True)
  135. updated = True
  136. # -> write
  137. check_attr = 'auditlog_ruled_write'
  138. if getattr(rule, 'log_write') \
  139. and not hasattr(model_model, check_attr):
  140. model_model._patch_method('write', self._make_write())
  141. setattr(model_model, check_attr, True)
  142. updated = True
  143. # -> unlink
  144. check_attr = 'auditlog_ruled_unlink'
  145. if getattr(rule, 'log_unlink') \
  146. and not hasattr(model_model, check_attr):
  147. model_model._patch_method('unlink', self._make_unlink())
  148. setattr(model_model, check_attr, True)
  149. updated = True
  150. return updated
  151. @api.multi
  152. def _revert_methods(self):
  153. """Restore original ORM methods of models defined in rules."""
  154. updated = False
  155. for rule in self:
  156. model_model = self.env[rule.model_id.model]
  157. for method in ['create', 'read', 'write', 'unlink']:
  158. if getattr(rule, 'log_%s' % method) and hasattr(
  159. getattr(model_model, method), 'origin'):
  160. model_model._revert_method(method)
  161. updated = True
  162. if updated:
  163. modules.registry.RegistryManager.signal_registry_change(
  164. self.env.cr.dbname)
  165. # Unable to find a way to declare the `create` method with the new API,
  166. # errors occurs with the `_register_hook()` BaseModel method.
  167. def create(self, cr, uid, vals, context=None):
  168. """Update the registry when a new rule is created."""
  169. res_id = super(AuditlogRule, self).create(
  170. cr, uid, vals, context=context)
  171. if self._register_hook(cr, [res_id]):
  172. modules.registry.RegistryManager.signal_registry_change(cr.dbname)
  173. return res_id
  174. # Unable to find a way to declare the `write` method with the new API,
  175. # errors occurs with the `_register_hook()` BaseModel method.
  176. def write(self, cr, uid, ids, vals, context=None):
  177. """Update the registry when existing rules are updated."""
  178. if isinstance(ids, (int, long)):
  179. ids = [ids]
  180. super(AuditlogRule, self).write(cr, uid, ids, vals, context=context)
  181. if self._register_hook(cr, ids):
  182. modules.registry.RegistryManager.signal_registry_change(cr.dbname)
  183. return True
  184. @api.multi
  185. def unlink(self):
  186. """Unsubscribe rules before removing them."""
  187. self.unsubscribe()
  188. return super(AuditlogRule, self).unlink()
  189. def _make_create(self):
  190. """Instanciate a create method that log its calls."""
  191. @api.model
  192. @api.returns('self', lambda value: value.id)
  193. def create(self, vals, **kwargs):
  194. self = self.with_context(auditlog_disabled=True)
  195. rule_model = self.env['auditlog.rule']
  196. new_record = create.origin(self, vals, **kwargs)
  197. new_values = dict(
  198. (d['id'], d) for d in new_record.sudo().read(
  199. list(self._fields)))
  200. rule_model.sudo().create_logs(
  201. self.env.uid, self._name, new_record.ids,
  202. 'create', None, new_values)
  203. return new_record
  204. return create
  205. def _make_read(self):
  206. """Instanciate a read method that log its calls."""
  207. def read(self, *args, **kwargs):
  208. result = read.origin(self, *args, **kwargs)
  209. # Sometimes the result is not a list but a dictionary
  210. # Also, we can not modify the current result as it will break calls
  211. result2 = result
  212. if not isinstance(result2, list):
  213. result2 = [result]
  214. read_values = dict((d['id'], d) for d in result2)
  215. # Old API
  216. if args and isinstance(args[0], sql_db.Cursor):
  217. cr, uid, ids = args[0], args[1], args[2]
  218. if isinstance(ids, (int, long)):
  219. ids = [ids]
  220. # If the call came from auditlog itself, skip logging:
  221. # avoid logs on `read` produced by auditlog during internal
  222. # processing: read data of relevant records, 'ir.model',
  223. # 'ir.model.fields'... (no interest in logging such operations)
  224. if kwargs.get('context', {}).get('auditlog_disabled'):
  225. return result
  226. env = api.Environment(cr, uid, {'auditlog_disabled': True})
  227. rule_model = env['auditlog.rule']
  228. rule_model.sudo().create_logs(
  229. env.uid, self._name, ids,
  230. 'read', read_values)
  231. # New API
  232. else:
  233. # If the call came from auditlog itself, skip logging:
  234. # avoid logs on `read` produced by auditlog during internal
  235. # processing: read data of relevant records, 'ir.model',
  236. # 'ir.model.fields'... (no interest in logging such operations)
  237. if self.env.context.get('auditlog_disabled'):
  238. return result
  239. self = self.with_context(auditlog_disabled=True)
  240. rule_model = self.env['auditlog.rule']
  241. rule_model.sudo().create_logs(
  242. self.env.uid, self._name, self.ids,
  243. 'read', read_values)
  244. return result
  245. return read
  246. def _make_write(self):
  247. """Instanciate a write method that log its calls."""
  248. @api.multi
  249. def write(self, vals, **kwargs):
  250. self = self.with_context(auditlog_disabled=True)
  251. rule_model = self.env['auditlog.rule']
  252. old_values = dict(
  253. (d['id'], d) for d in self.sudo().read(list(self._fields)))
  254. result = write.origin(self, vals, **kwargs)
  255. new_values = dict(
  256. (d['id'], d) for d in self.sudo().read(list(self._fields)))
  257. rule_model.sudo().create_logs(
  258. self.env.uid, self._name, self.ids,
  259. 'write', old_values, new_values)
  260. return result
  261. return write
  262. def _make_unlink(self):
  263. """Instanciate an unlink method that log its calls."""
  264. @api.multi
  265. def unlink(self, **kwargs):
  266. self = self.with_context(auditlog_disabled=True)
  267. rule_model = self.env['auditlog.rule']
  268. old_values = dict(
  269. (d['id'], d) for d in self.sudo().read(list(self._fields)))
  270. rule_model.sudo().create_logs(
  271. self.env.uid, self._name, self.ids, 'unlink', old_values)
  272. return unlink.origin(self, **kwargs)
  273. return unlink
  274. def create_logs(self, uid, res_model, res_ids, method,
  275. old_values=None, new_values=None,
  276. additional_log_values=None):
  277. """Create logs. `old_values` and `new_values` are dictionnaries, e.g:
  278. {RES_ID: {'FIELD': VALUE, ...}}
  279. """
  280. if old_values is None:
  281. old_values = EMPTY_DICT
  282. if new_values is None:
  283. new_values = EMPTY_DICT
  284. log_model = self.env['auditlog.log']
  285. http_request_model = self.env['auditlog.http.request']
  286. http_session_model = self.env['auditlog.http.session']
  287. for res_id in res_ids:
  288. model_model = self.env[res_model]
  289. name = model_model.browse(res_id).name_get()
  290. res_name = name and name[0] and name[0][1]
  291. vals = {
  292. 'name': res_name,
  293. 'model_id': self.pool._auditlog_model_cache[res_model],
  294. 'res_id': res_id,
  295. 'method': method,
  296. 'user_id': uid,
  297. 'http_request_id': http_request_model.current_http_request(),
  298. 'http_session_id': http_session_model.current_http_session(),
  299. }
  300. vals.update(additional_log_values or {})
  301. log = log_model.create(vals)
  302. diff = DictDiffer(
  303. new_values.get(res_id, EMPTY_DICT),
  304. old_values.get(res_id, EMPTY_DICT))
  305. if method is 'create':
  306. self._create_log_line_on_create(log, diff.added(), new_values)
  307. elif method is 'read':
  308. self._create_log_line_on_read(
  309. log, old_values.get(res_id, EMPTY_DICT).keys(), old_values)
  310. elif method is 'write':
  311. self._create_log_line_on_write(
  312. log, diff.changed(), old_values, new_values)
  313. def _get_field(self, model, field_name):
  314. cache = self.pool._auditlog_field_cache
  315. if field_name not in cache.get(model.model, {}):
  316. cache.setdefault(model.model, {})
  317. # - we use 'search()' then 'read()' instead of the 'search_read()'
  318. # to take advantage of the 'classic_write' loading
  319. # - search the field in the current model and those it inherits
  320. field_model = self.env['ir.model.fields']
  321. all_model_ids = [model.id]
  322. all_model_ids.extend(model.inherited_model_ids.ids)
  323. field = field_model.search(
  324. [('model_id', 'in', all_model_ids), ('name', '=', field_name)])
  325. # The field can be a dummy one, like 'in_group_X' on 'res.users'
  326. # As such we can't log it (field_id is required to create a log)
  327. if not field:
  328. cache[model.model][field_name] = False
  329. else:
  330. field_data = field.read(load='_classic_write')[0]
  331. cache[model.model][field_name] = field_data
  332. return cache[model.model][field_name]
  333. def _create_log_line_on_read(
  334. self, log, fields_list, read_values):
  335. """Log field filled on a 'read' operation."""
  336. log_line_model = self.env['auditlog.log.line']
  337. for field_name in fields_list:
  338. if field_name in FIELDS_BLACKLIST:
  339. continue
  340. field = self._get_field(log.model_id, field_name)
  341. # not all fields have an ir.models.field entry (ie. related fields)
  342. if field:
  343. log_vals = self._prepare_log_line_vals_on_read(
  344. log, field, read_values)
  345. log_line_model.create(log_vals)
  346. def _prepare_log_line_vals_on_read(self, log, field, read_values):
  347. """Prepare the dictionary of values used to create a log line on a
  348. 'read' operation.
  349. """
  350. vals = {
  351. 'field_id': field['id'],
  352. 'log_id': log.id,
  353. 'old_value': read_values[log.res_id][field['name']],
  354. 'old_value_text': read_values[log.res_id][field['name']],
  355. 'new_value': False,
  356. 'new_value_text': False,
  357. }
  358. if field['relation'] and '2many' in field['ttype']:
  359. old_value_text = self.env[field['relation']].browse(
  360. vals['old_value']).name_get()
  361. vals['old_value_text'] = old_value_text
  362. return vals
  363. def _create_log_line_on_write(
  364. self, log, fields_list, old_values, new_values):
  365. """Log field updated on a 'write' operation."""
  366. log_line_model = self.env['auditlog.log.line']
  367. for field_name in fields_list:
  368. if field_name in FIELDS_BLACKLIST:
  369. continue
  370. field = self._get_field(log.model_id, field_name)
  371. # not all fields have an ir.models.field entry (ie. related fields)
  372. if field:
  373. log_vals = self._prepare_log_line_vals_on_write(
  374. log, field, old_values, new_values)
  375. log_line_model.create(log_vals)
  376. def _prepare_log_line_vals_on_write(
  377. self, log, field, old_values, new_values):
  378. """Prepare the dictionary of values used to create a log line on a
  379. 'write' operation.
  380. """
  381. vals = {
  382. 'field_id': field['id'],
  383. 'log_id': log.id,
  384. 'old_value': old_values[log.res_id][field['name']],
  385. 'old_value_text': old_values[log.res_id][field['name']],
  386. 'new_value': new_values[log.res_id][field['name']],
  387. 'new_value_text': new_values[log.res_id][field['name']],
  388. }
  389. # for *2many fields, log the name_get
  390. if field['relation'] and '2many' in field['ttype']:
  391. # Filter IDs to prevent a 'name_get()' call on deleted resources
  392. existing_ids = self.env[field['relation']]._search(
  393. [('id', 'in', vals['old_value'])])
  394. old_value_text = []
  395. if existing_ids:
  396. existing_values = self.env[field['relation']].browse(
  397. existing_ids).name_get()
  398. old_value_text.extend(existing_values)
  399. # Deleted resources will have a 'DELETED' text representation
  400. deleted_ids = set(vals['old_value']) - set(existing_ids)
  401. for deleted_id in deleted_ids:
  402. old_value_text.append((deleted_id, 'DELETED'))
  403. vals['old_value_text'] = old_value_text
  404. new_value_text = self.env[field['relation']].browse(
  405. vals['new_value']).name_get()
  406. vals['new_value_text'] = new_value_text
  407. return vals
  408. def _create_log_line_on_create(
  409. self, log, fields_list, new_values):
  410. """Log field filled on a 'create' operation."""
  411. log_line_model = self.env['auditlog.log.line']
  412. for field_name in fields_list:
  413. if field_name in FIELDS_BLACKLIST:
  414. continue
  415. field = self._get_field(log.model_id, field_name)
  416. # not all fields have an ir.models.field entry (ie. related fields)
  417. if field:
  418. log_vals = self._prepare_log_line_vals_on_create(
  419. log, field, new_values)
  420. log_line_model.create(log_vals)
  421. def _prepare_log_line_vals_on_create(self, log, field, new_values):
  422. """Prepare the dictionary of values used to create a log line on a
  423. 'create' operation.
  424. """
  425. vals = {
  426. 'field_id': field['id'],
  427. 'log_id': log.id,
  428. 'old_value': False,
  429. 'old_value_text': False,
  430. 'new_value': new_values[log.res_id][field['name']],
  431. 'new_value_text': new_values[log.res_id][field['name']],
  432. }
  433. if field['relation'] and '2many' in field['ttype']:
  434. new_value_text = self.env[field['relation']].browse(
  435. vals['new_value']).name_get()
  436. vals['new_value_text'] = new_value_text
  437. return vals
  438. @api.multi
  439. def subscribe(self):
  440. """Subscribe Rule for auditing changes on model and apply shortcut
  441. to view logs on that model.
  442. """
  443. act_window_model = self.env['ir.actions.act_window']
  444. model_data_model = self.env['ir.model.data']
  445. for rule in self:
  446. # Create a shortcut to view logs
  447. domain = "[('model_id', '=', %s), ('res_id', '=', active_id)]" % (
  448. rule.model_id.id)
  449. vals = {
  450. 'name': _(u"View logs"),
  451. 'res_model': 'auditlog.log',
  452. 'src_model': rule.model_id.model,
  453. 'domain': domain,
  454. }
  455. act_window = act_window_model.sudo().create(vals)
  456. rule.write({'state': 'subscribed', 'action_id': act_window.id})
  457. keyword = 'client_action_relate'
  458. value = 'ir.actions.act_window,%s' % act_window.id
  459. model_data_model.sudo().ir_set(
  460. 'action', keyword, 'View_log_' + rule.model_id.model,
  461. [rule.model_id.model], value, replace=True,
  462. isobject=True, xml_id=False)
  463. return True
  464. @api.multi
  465. def unsubscribe(self):
  466. """Unsubscribe Auditing Rule on model."""
  467. act_window_model = self.env['ir.actions.act_window']
  468. ir_values_model = self.env['ir.values']
  469. # Revert patched methods
  470. self._revert_methods()
  471. for rule in self:
  472. # Remove the shortcut to view logs
  473. act_window = act_window_model.search(
  474. [('name', '=', 'View Log'),
  475. ('res_model', '=', 'auditlog.log'),
  476. ('src_model', '=', rule.model_id.model)])
  477. if act_window:
  478. value = 'ir.actions.act_window,%s' % act_window.id
  479. act_window.unlink()
  480. ir_value = ir_values_model.search(
  481. [('model', '=', rule.model_id.model),
  482. ('value', '=', value)])
  483. if ir_value:
  484. ir_value.unlink()
  485. self.write({'state': 'draft'})
  486. return True