[ADD] Rebased BI Tool (8.0)

bi_view_editor/models/bve_view.py

@@ -0,0 +1,300 @@
+# -*- coding: utf-8 -*-
+# © 2015-2016 ONESTEiN BV (<http://www.onestein.eu>)
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
+
+import json
+
+from openerp import tools
+from openerp import SUPERUSER_ID
+from openerp import models, fields, api
+from openerp.exceptions import Warning
+from openerp.tools.translate import _
+
+
+class BveView(models.Model):
+    _name = 'bve.view'
+
+    @api.depends('group_ids')
+    @api.one
+    def _compute_users(self):
+        if self.sudo().group_ids:
+            self.user_ids = self.env['res.users'].sudo().browse(
+                list(set([u.id for group in self.sudo().group_ids
+                          for u in group.users])))
+        else:
+            self.user_ids = self.env['res.users'].sudo().search([])
+
+    name = fields.Char(size=128, string="Name", required=True)
+    model_name = fields.Char(size=128, string="Model Name")
+
+    note = fields.Text(string="Notes")
+
+    state = fields.Selection(
+        [('draft', 'Draft'),
+         ('created', 'Created')],
+        string="State",
+        default="draft")
+    data = fields.Text(
+        string="Data",
+        help="Use the special Onestein query builder to define the query "
+             "to generate your report dataset. "
+             "NOTE: Te be edited, the query should be in 'Draft' status.")
+
+    action_id = fields.Many2one('ir.actions.act_window', string="Action")
+    view_id = fields.Many2one('ir.ui.view', string="View")
+
+    group_ids = fields.Many2many(
+        'res.groups',
+        string="Groups",
+        help="User groups allowed to see the generated report; "
+             "if NO groups are specified the report will be public "
+             "for everyone.")
+
+    user_ids = fields.Many2many(
+        'res.users',
+        string="Users",
+        compute=_compute_users,
+        store=True)
+
+    _sql_constraints = [
+        ('name_uniq',
+         'unique(name)',
+         'Custom BI View names must be unique!'),
+    ]
+
+    @api.multi
+    def unlink(self):
+        for view in self:
+            if view.state == 'created':
+                raise Warning(
+                    _('Error'),
+                    _('You cannot delete a created view! '
+                      'Reset the view to draft first.'))
+
+        super(BveView, self).unlink()
+
+    @api.multi
+    def action_edit_query(self):
+        return {
+            'type': 'ir.actions.client',
+            'tag': 'bi_view_editor.open',
+            'target': 'new',
+            'params': {'bve_view_id': self.id}
+        }
+
+    @api.multi
+    def action_reset(self):
+        if self.action_id:
+            if self.action_id.view_id:
+                self.action_id.view_id.sudo().unlink()
+            self.action_id.sudo().unlink()
+
+        self.env['ir.model'].sudo().search(
+            [('model', '=', self.model_name)]).unlink()
+
+        table_name = self.model_name.replace(".", "_")
+        tools.drop_view_if_exists(self.env.cr, table_name)
+
+        self.write({
+            'state': 'draft'
+        })
+        return True
+
+    def _create_graph_view(self):
+        fields_info = json.loads(self.data)
+        return ["""<field name="x_{}" type="{}" />""".format(
+            field_info['name'],
+            (field_info['row'] and 'row') or
+            (field_info['column'] and 'col') or
+            (field_info['measure'] and 'measure'))
+                for field_info in fields_info if field_info['row'] or
+                field_info['column'] or field_info['measure']]
+
+    @api.multi
+    def action_create(self):
+
+        def _get_fields_info(fields_data):
+            fields_info = []
+            for field_data in fields_data:
+                field = self.env['ir.model.fields'].browse(field_data["id"])
+                vals = {
+                    "table": self.env[field.model_id.model]._table,
+                    "table_alias": field_data["table_alias"],
+                    "select_field": field.name,
+                    "as_field": "x_" + field_data["name"],
+                    "join": False,
+                    "model": field.model_id.model
+                }
+                if field_data.get("join_node"):
+                    vals.update({"join": field_data["join_node"]})
+                fields_info.append(vals)
+            return fields_info
+
+        def _build_query():
+
+            info = _get_fields_info(json.loads(self.data))
+            fields = [("{}.{}".format(f["table_alias"],
+                       f["select_field"]),
+                       f["as_field"]) for f in info if 'join_node' not in f]
+            tables = set([(f["table"], f["table_alias"]) for f in info])
+            join_nodes = [
+                (f["table_alias"],
+                 f["join"],
+                 f["select_field"]) for f in info if f["join"] is not False]
+
+            table_name = self.model_name.replace(".", "_")
+            tools.drop_view_if_exists(self.env.cr, table_name)
+
+            basic_fields = [
+                ("t0.id", "id"),
+                ("t0.write_uid", "write_uid"),
+                ("t0.write_date", "write_date"),
+                ("t0.create_uid", "create_uid"),
+                ("t0.create_date", "create_date")
+            ]
+
+            q = """CREATE or REPLACE VIEW %s as (
+                SELECT %s
+                FROM  %s
+                WHERE %s
+                )""" % (table_name, ','.join(
+                ["{} AS {}".format(f[0], f[1])
+                 for f in basic_fields + fields]), ','.join(
+                ["{} AS {}".format(t[0], t[1])
+                 for t in list(tables)]), " AND ".join(
+                ["{}.{} = {}.id".format(j[0], j[2], j[1])
+                 for j in join_nodes] + ["TRUE"]))
+
+            self.env.cr.execute(q)
+
+        def _prepare_field(field_data):
+            if not field_data["custom"]:
+                field = self.env['ir.model.fields'].browse(field_data["id"])
+                vals = {
+                    "name": "x_" + field_data["name"],
+                    "complete_name": field.complete_name,
+                    'model': self.model_name,
+                    'relation': field.relation,
+                    "field_description": field_data.get(
+                        "description", field.field_description),
+                    "ttype": field.ttype,
+                    "selection": field.selection,
+                    "size": field.size,
+                    'state': "manual"
+                }
+                if field.ttype == 'selection' and not field.selection:
+                    model_obj = self.env[field.model_id.model]
+                    selection = model_obj._columns[field.name].selection
+                    selection_domain = str(selection)
+                    vals.update({"selection": selection_domain})
+                return vals
+
+        def _prepare_object():
+            return {
+                'name': self.name,
+                'model': self.model_name,
+                'field_id': [
+                    (0, 0, _prepare_field(field))
+                    for field in json.loads(self.data)
+                    if 'join_node' not in field]
+            }
+
+        def _build_object():
+            res_id = self.env['ir.model'].sudo().create(_prepare_object())
+            return res_id
+
+        # read access
+        def group_ids_with_access(model_name, access_mode):
+            self.env.cr.execute('''SELECT
+                  g.id
+                FROM
+                  ir_model_access a
+                  JOIN ir_model m ON (a.model_id=m.id)
+                  JOIN res_groups g ON (a.group_id=g.id)
+                  LEFT JOIN ir_module_category c ON (c.id=g.category_id)
+                WHERE
+                  m.model=%s AND
+                  a.active IS True AND
+                  a.perm_''' + access_mode, (model_name,))
+            return [x[0] for x in self.env.cr.fetchall()]
+
+        def _build_access_rules(obj):
+            info = json.loads(self.data)
+            models = list(set([f["model"] for f in info]))
+            read_groups = set.intersection(*[set(
+                group_ids_with_access(model, 'read')) for model in models])
+
+            for group in read_groups:
+                self.env['ir.model.access'].sudo().create({
+                    'name': 'read access to ' + self.model_name,
+                    'model_id': obj.id,
+                    'group_id': group,
+                    'perm_read': True,
+                })
+
+            # edit access
+            for group in self.group_ids:
+                self.env['ir.model.access'].sudo().create({
+                    'name': 'read access to ' + self.model_name,
+                    'model_id': obj.id,
+                    'group_id': group.id,
+                    'perm_read': True,
+                    'perm_write': True,
+                })
+
+            return
+
+        self.model_name = "x_bve." + ''.join(
+            [x for x in self.name.lower()
+             if x.isalnum()]).replace("_", ".").replace(" ", ".")
+
+        _build_query()
+        obj = _build_object()
+        _build_access_rules(obj)
+        self.env.cr.commit()
+
+        from openerp.modules.registry import RegistryManager
+        self.env.registry = RegistryManager.new(self.env.cr.dbname)
+        self.pool = self.env.registry
+
+        view_id = self.pool.get('ir.ui.view').create(
+            self.env.cr, SUPERUSER_ID,
+            {'name': "Analysis",
+             'type': 'graph',
+             'model': self.model_name,
+             'priority': 16,
+             'arch': """<?xml version="1.0"?>
+                        <graph string="Analysis"
+                               type="pivot"
+                               stacked="True"> {} </graph>
+                     """.format("".join(self._create_graph_view()))
+             }, context={})
+        view_ids = [view_id]
+
+        action_vals = {'name': self.name,
+                       'res_model': self.model_name,
+                       'type': 'ir.actions.act_window',
+                       'view_type': 'form',
+                       'view_mode': 'graph',
+                       'view_id': view_ids and view_ids[0] or 0,
+                       'context': "{'service_name': '%s'}" % self.name,
+                       }
+        act_window = self.env['ir.actions.act_window']
+        action_id = act_window.sudo().create(action_vals)
+
+        self.write({
+            'action_id': action_id.id,
+            'view_id': view_id,
+            'state': 'created'
+        })
+
+        return True
+
+    @api.multi
+    def open_view(self):
+        return {
+            'type': 'ir.actions.act_window',
+            'res_model': self.model_name,
+            'view_type': 'graph',
+            'view_mode': 'graph',
+        }