Merge pull request #409 from yvaucher/9.0-record_archiver

[PORT] [9.0] record_archiver

record_archiver/README.rst

@@ -0,0 +1,71 @@
+.. image:: https://img.shields.io/badge/licence-AGPL--3-blue.svg
+   :target: http://www.gnu.org/licenses/agpl-3.0-standalone.html
+   :alt: License: AGPL-3
+
+================
+Records Archiver
+================
+
+Create a cron job that deactivates old records in order to optimize
+performance.
+
+Records are deactivated based on their last activity (write_date).
+
+Configuration
+=============
+
+You can configure lifespan of each type of record in
+`Settings -> Configuration -> Records Archiver`
+
+A different lifespan can be configured for each model.
+
+Usage
+=====
+
+Once the lifespans are configured, the cron will automatically
+deactivate the old records.
+
+Known issues / Roadmap
+======================
+
+The default behavior is to archive all records having a ``write_date`` <
+lifespan and with a state being ``done`` or ``cancel``. If these rules
+need to be modified for a model (e.g. change the states to archive), the
+hook ``RecordLifespan._archive_domain`` can be extended.
+
+Bug Tracker
+===========
+
+Bugs are tracked on `GitHub Issues
+<https://github.com/OCA/server-tools/issues>`_.  In case of trouble, please
+check there if your issue has already been reported.  If you spotted it first,
+help us smashing it by providing a detailed and welcomed `feedback
+<https://github.com/OCA/
+server-tools/issues/new?body=module:%20
+record_archiver%0Aversion:%20
+9.0%0A%0A**Steps%20to%20reproduce**%0A-%20...%0A%0A**Current%20behavior**%0A%0A**Expected%20behavior**>`_.
+
+
+Credits
+=======
+
+Contributors
+------------
+
+* Yannick Vaucher <yannick.vaucher@camptocamp.com>
+* Guewen Baconnier <guewen.baconnier@camptocamp.com>
+
+Maintainer
+----------
+
+.. image:: https://odoo-community.org/logo.png
+   :alt: Odoo Community Association
+   :target: https://odoo-community.org
+
+This module is maintained by the OCA.
+
+OCA, or the Odoo Community Association, is a nonprofit organization whose
+mission is to support the collaborative development of Odoo features and
+promote its widespread use.
+
+To contribute to this module, please visit http://odoo-community.org.

record_archiver/__init__.py

@@ -0,0 +1 @@
+from . import models

record_archiver/__openerp__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+# © 2015 Yannick Vaucher (Camptocamp SA)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+{'name': 'Records Archiver',
+ 'version': '9.0.1.0.0',
+ 'author': 'Camptocamp,Odoo Community Association (OCA)',
+ 'license': 'AGPL-3',
+ 'category': 'misc',
+ 'depends': ['base'],
+ 'website': 'www.camptocamp.com',
+ 'data': ['views/record_lifespan_view.xml',
+          'data/cron.xml',
+          'security/ir.model.access.csv',
+          ],
+ 'installable': True,
+ 'auto_install': False,
+ }

record_archiver/data/cron.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<openerp>
+  <data noupdate="1">
+
+    <record forcecreate="True" id="ir_cron_record_archiver" model="ir.cron">
+      <field name="name">Records Archiver</field>
+      <field eval="True" name="active"/>
+      <field name="user_id" ref="base.user_root"/>
+      <field name="interval_number">1</field>
+      <field name="interval_type">months</field>
+      <field name="numbercall">-1</field>
+      <field eval="False" name="doall"/>
+      <field eval="'record.lifespan'" name="model"/>
+      <field eval="'_scheduler_archive_records'" name="function"/>
+      <field eval="'()'" name="args"/>
+    </record>
+
+  </data>
+</openerp>

record_archiver/i18n/record_archiver.pot

@@ -0,0 +1,99 @@
+# Translation of OpenERP Server.
+# This file contains the translation of the following modules:
+#	* record_archiver
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: OpenERP Server 7.0\n"
+"Report-Msgid-Bugs-To: \n"
+"POT-Creation-Date: 2015-07-01 12:35+0000\n"
+"PO-Revision-Date: 2015-07-01 12:35+0000\n"
+"Last-Translator: <>\n"
+"Language-Team: \n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: \n"
+"Plural-Forms: \n"
+
+#. module: record_archiver
+#: model:ir.actions.act_window,help:record_archiver.action_record_lifespan_view
+msgid "<p class=\"oe_view_nocontent_create\">\n"
+"          Click to define a new lifespan for a type of records.\n"
+"        </p><p>\n"
+"          Every record of model with a lifespan will be set to inactive\n"
+"          after the the defined months are elapsed. The lifespan is\n"
+"          based on the last write on a record.\n"
+"        </p>\n"
+"      "
+msgstr ""
+
+#. module: record_archiver
+#: code:addons/record_archiver/models/record_lifespan.py:104
+#: code:addons/record_archiver/models/record_lifespan.py:108
+#, python-format
+msgid "Error"
+msgstr ""
+
+#. module: record_archiver
+#: field:ir.model,has_an_active_field:0
+msgid "Has an active field"
+msgstr ""
+
+#. module: record_archiver
+#: field:record.lifespan,model_id:0
+msgid "Model"
+msgstr ""
+
+#. module: record_archiver
+#: code:addons/record_archiver/models/record_lifespan.py:109
+#, python-format
+msgid "Model %s has no active field"
+msgstr ""
+
+#. module: record_archiver
+#: code:addons/record_archiver/models/record_lifespan.py:105
+#, python-format
+msgid "Model %s not found"
+msgstr ""
+
+#. module: record_archiver
+#: field:record.lifespan,model:0
+msgid "Model Name"
+msgstr ""
+
+#. module: record_archiver
+#: code:_description:0
+#: model:ir.model,name:record_archiver.model_ir_model
+#, python-format
+msgid "Models"
+msgstr ""
+
+#. module: record_archiver
+#: field:record.lifespan,months:0
+msgid "Months"
+msgstr ""
+
+#. module: record_archiver
+#: sql_constraint:record.lifespan:0
+msgid "Months must be a value greater than 0"
+msgstr ""
+
+#. module: record_archiver
+#: help:record.lifespan,months:0
+msgid "Number of month after which the records will be set to inactive based on their write date"
+msgstr ""
+
+#. module: record_archiver
+#: model:ir.actions.act_window,name:record_archiver.action_record_lifespan_view
+#: model:ir.ui.menu,name:record_archiver.menu_record_lifespan_config
+#: view:record.lifespan:0
+msgid "Records Archiver Lifespans"
+msgstr ""
+
+#. module: record_archiver
+#: code:_description:0
+#: model:ir.model,name:record_archiver.model_record_lifespan
+#, python-format
+msgid "record.lifespan"
+msgstr ""
+

record_archiver/models/__init__.py

@@ -0,0 +1,2 @@
+from . import ir_model
+from . import record_lifespan

record_archiver/models/ir_model.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# © 2015 Guewen Baconnier (Camptocamp SA)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from openerp import api, fields, models
+
+
+class IrModel(models.Model):
+    _inherit = 'ir.model'
+
+    @api.multi
+    def _compute_has_an_active_field(self):
+        for model in self:
+            active_fields = self.env['ir.model.fields'].search(
+                [('model_id', '=', model.id),
+                 ('name', '=', 'active'),
+                 ],
+                limit=1)
+            model.has_an_active_field = bool(active_fields)
+
+    @api.model
+    def _search_has_an_active_field(self,  operator, value):
+        if operator not in ['=', '!=']:
+            raise AssertionError('operator %s not allowed' % operator)
+        fields_model = self.env['ir.model.fields']
+        domain = []
+        active_fields = fields_model.search(
+            [('name', '=', 'active')])
+        models = active_fields.mapped('model_id')
+        if operator == '=' and value or operator == '!=' and not value:
+            domain.append(('id', 'in', models.ids))
+        else:
+            domain.append(('id', 'not in', models.ids))
+        return domain
+
+    has_an_active_field = fields.Boolean(
+        compute=_compute_has_an_active_field,
+        search=_search_has_an_active_field,
+        string='Has an active field',
+    )

record_archiver/models/record_lifespan.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+# © 2015-2016 Yannick Vaucher (Camptocamp SA)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+import logging
+
+from datetime import datetime
+from dateutil.relativedelta import relativedelta
+
+from openerp import api, exceptions, fields, models
+from openerp.tools.translate import _
+
+_logger = logging.getLogger(__name__)
+
+
+class RecordLifespan(models.Model):
+    """ Configure records lifespans per model
+
+    After the lifespan is expired (compared to the `write_date` of the
+    records), the records are deactivated.
+    """
+    _name = 'record.lifespan'
+    _order = 'model'
+
+    model_id = fields.Many2one(
+        'ir.model',
+        string='Model',
+        required=True,
+        domain=[('has_an_active_field', '=', True)],
+    )
+    model = fields.Char(
+        related='model_id.model',
+        string='Model Name',
+        store=True,
+    )
+    months = fields.Integer(
+        required=True,
+        help="Number of month after which the records will be set to inactive "
+             "based on their write date"
+    )
+
+    _sql_constraints = [
+        ('months_gt_0', 'check (months > 0)',
+         "Months must be a value greater than 0"),
+    ]
+
+    @api.model
+    def _scheduler_archive_records(self):
+        lifespans = self.search([])
+        _logger.info('Records archiver starts archiving records')
+        for lifespan in lifespans:
+            try:
+                lifespan.archive_records()
+            except exceptions.UserError as e:
+                _logger.error("Archiver error:\n%s", e[1])
+        _logger.info('Rusty Records now rest in peace')
+        return True
+
+    @api.multi
+    def _archive_domain(self, expiration_date):
+        """ Returns the domain used to find the records to archive.
+
+        Can be inherited to change the archived records for a model.
+        """
+        model = self.env[self.model_id.model]
+        domain = [('write_date', '<', expiration_date)]
+        if 'state' in model._columns:
+            domain += [('state', 'in', ('done', 'cancel'))]
+        return domain
+
+    @api.multi
+    def _archive_lifespan_records(self):
+        """ Archive the records for a lifespan, so for a model.
+
+        Can be inherited to customize the archive strategy.
+        The default strategy is to change the field ``active`` to False
+        on the records having a ``write_date`` older than the lifespan.
+        Only done and canceled records will be deactivated.
+
+        """
+        self.ensure_one()
+        today = datetime.today()
+        model_name = self.model_id.model
+        model = self.env[model_name]
+        if not isinstance(model, models.Model):
+            raise exceptions.UserError(
+                _('Model %s not found') % model_name)
+        if 'active' not in model._columns:
+            raise exceptions.UserError(
+                _('Model %s has no active field') % model_name)
+
+        delta = relativedelta(months=self.months)
+        expiration_date = fields.Datetime.to_string(today - delta)
+
+        domain = self._archive_domain(expiration_date)
+        recs = model.search(domain)
+        if not recs:
+            return
+
+        # use a SQL query to bypass tracking always messages on write for
+        # object inheriting mail.thread
+        query = ("UPDATE %s SET active = FALSE WHERE id in %%s"
+                 ) % model._table
+        self.env.cr.execute(query, (tuple(recs.ids),))
+        recs.invalidate_cache()
+        _logger.info(
+            'Archived %s %s older than %s',
+            len(recs.ids), model_name, expiration_date)
+
+    @api.multi
+    def archive_records(self):
+        """ Call the archiver for several record lifespans """
+        for lifespan in self:
+            lifespan._archive_lifespan_records()
+        return True

record_archiver/security/ir.model.access.csv

@@ -0,0 +1,2 @@
+id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
+access_record_lifespan,Record Lifespan,record_archiver.model_record_lifespan,base.group_no_one,1,1,1,1

record_archiver/tests/__init__.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+from . import test_active_search
+from . import test_archive

record_archiver/tests/test_active_search.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# © 2015 Guewen Baconnier (Camptocamp SA)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+import openerp.tests.common as common
+
+
+class TestActiveSearch(common.TransactionCase):
+
+    def test_model_with_active_field(self):
+        IrModel = self.env['ir.model']
+        partner_model = IrModel.search([('model', '=', 'res.partner')],
+                                       limit=1)
+        self.assertTrue(partner_model.has_an_active_field)
+        self.assertIn(partner_model,
+                      IrModel.search([('has_an_active_field', '=', True)]))
+        self.assertIn(partner_model,
+                      IrModel.search([('has_an_active_field', '!=', False)]))
+        self.assertNotIn(partner_model,
+                         IrModel.search([('has_an_active_field', '!=', True)]))
+        self.assertNotIn(partner_model,
+                         IrModel.search([('has_an_active_field', '=', False)]))
+
+    def test_model_without_active_field(self):
+        IrModel = self.env['ir.model']
+        country_model = IrModel.search([('model', '=', 'res.country')],
+                                       limit=1)
+        self.assertFalse(country_model.has_an_active_field)
+        self.assertIn(country_model,
+                      IrModel.search([('has_an_active_field', '!=', True)]))
+        self.assertIn(country_model,
+                      IrModel.search([('has_an_active_field', '=', False)]))
+        self.assertNotIn(country_model,
+                         IrModel.search([('has_an_active_field', '=', True)]))
+        self.assertNotIn(country_model,
+                         IrModel.search([('has_an_active_field', '!=', False)])
+                         )

record_archiver/tests/test_archive.py

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+# © 2015 Guewen Baconnier (Camptocamp SA)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+from datetime import datetime, timedelta
+import openerp.tests.common as common
+
+
+class TestArchive(common.TransactionCase):
+
+    def setUp(self):
+        super(TestArchive, self).setUp()
+        Partner = self.env['res.partner']
+        self.partner1 = Partner.create(
+            {'name': 'test user 1'})
+        self.partner2 = Partner.create(
+            {'name': 'test user 2'})
+        self.partner3 = Partner.create(
+            {'name': 'test user 3'})
+        old_date = datetime.now() - timedelta(days=365)
+        self.env.cr.execute(
+            'UPDATE res_partner SET write_date = %s '
+            'WHERE id IN %s', (old_date, tuple([self.partner2.id,
+                                                self.partner3.id]))
+        )
+        self.Lifespan = self.env['record.lifespan']
+        self.model_id = self.ref('base.model_res_partner')
+
+    @common.at_install(False)
+    @common.post_install(True)
+    def test_lifespan(self):
+        lifespan = self.Lifespan.create(
+            {'model_id': self.model_id,
+             'months': 3,
+             })
+        lifespan.archive_records()
+        self.assertTrue(self.partner1.active)
+        self.assertFalse(self.partner2.active)
+        self.assertFalse(self.partner3.active)
+
+    @common.at_install(False)
+    @common.post_install(True)
+    def test_scheduler(self):
+        self.Lifespan.create(
+            {'model_id': self.model_id,
+             'months': 3,
+             })
+        self.Lifespan._scheduler_archive_records()
+        self.assertTrue(self.partner1.active)
+        self.assertFalse(self.partner2.active)
+        self.assertFalse(self.partner3.active)

record_archiver/views/record_lifespan_view.xml

@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<openerp>
+  <data>
+
+    <record id="view_record_lifespan_tree" model="ir.ui.view">
+      <field name="name">record.lifespan.tree</field>
+      <field name="model">record.lifespan</field>
+      <field name="arch" type="xml">
+        <tree string="Records Archiver Lifespans" editable="bottom">
+          <field name="model_id"/>
+          <field name="months"/>
+        </tree>
+      </field>
+    </record>
+
+    <record id="view_record_lifespan_search" model="ir.ui.view">
+      <field name="name">record.lifespan.search</field>
+      <field name="model">record.lifespan</field>
+      <field name="arch" type="xml">
+        <search string="Records Archiver Lifespans">
+          <field name="model_id"/>
+        </search>
+      </field>
+    </record>
+
+    <record model="ir.actions.act_window" id="action_record_lifespan_view">
+      <field name="name">Records Archiver Lifespans</field>
+      <field name="type">ir.actions.act_window</field>
+      <field name="res_model">record.lifespan</field>
+      <field name="view_type">form</field>
+      <field name="view_mode">tree</field>
+      <field name="search_view_id" ref="view_record_lifespan_search"/>
+      <field name="help" type="html">
+        <p class="oe_view_nocontent_create">
+          Click to define a new lifespan for a type of records.
+        </p><p>
+          Every record of model with a lifespan will be set to inactive
+          after the the defined months are elapsed. The lifespan is
+          based on the last write on a record.
+        </p>
+      </field>
+    </record>
+
+    <menuitem id="menu_record_archiver"
+      name="Record Archiver"
+      parent="base.menu_administration"
+      sequence="10"/>
+
+    <menuitem id="menu_record_lifespan_config"
+      name="Lifespans"
+      parent="menu_record_archiver"
+      sequence="20"
+      action="action_record_lifespan_view"/>
+
+  </data>
+</openerp>