mirror of
https://github.com/OCA/reporting-engine.git
synced 2025-02-16 16:30:38 +02:00
[ADD] Rebased BI Tool (8.0)
This commit is contained in:
astirpe
6
bi_view_editor/models/__init__.py
Normal file
6
bi_view_editor/models/__init__.py
Normal file
@@ -0,0 +1,6 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# © 2015-2016 ONESTEiN BV (<http://www.onestein.eu>)
|
||||
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
|
||||
|
||||
from . import bve_view
|
||||
from . import ir_model
|
||||
300
bi_view_editor/models/bve_view.py
Normal file
300
bi_view_editor/models/bve_view.py
Normal file
@@ -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',
|
||||
}
|
||||
219
bi_view_editor/models/ir_model.py
Normal file
219
bi_view_editor/models/ir_model.py
Normal file
@@ -0,0 +1,219 @@
|
||||
# -*- coding: utf-8 -*-
|
||||
# © 2015-2016 ONESTEiN BV (<http://www.onestein.eu>)
|
||||
# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html).
|
||||
|
||||
from openerp import models, api
|
||||
from openerp.modules.registry import RegistryManager
|
||||
|
||||
NO_BI_MODELS = [
|
||||
"temp.range",
|
||||
"account.statement.operation.template",
|
||||
"fetchmail.server"
|
||||
]
|
||||
|
||||
NO_BI_FIELDS = [
|
||||
"id",
|
||||
"create_uid",
|
||||
"create_date",
|
||||
"write_uid",
|
||||
"write_date"
|
||||
]
|
||||
|
||||
|
||||
def dict_for_field(field):
|
||||
return {
|
||||
"id": field.id,
|
||||
"name": field.name,
|
||||
"description": field.field_description,
|
||||
"type": field.ttype,
|
||||
"relation": field.relation,
|
||||
"custom": False,
|
||||
|
||||
"model_id": field.model_id.id,
|
||||
"model": field.model_id.model,
|
||||
"model_name": field.model_id.name
|
||||
}
|
||||
|
||||
|
||||
def dict_for_model(model):
|
||||
return {
|
||||
"id": model.id,
|
||||
"name": model.name,
|
||||
"model": model.model
|
||||
}
|
||||
|
||||
|
||||
class IrModel(models.Model):
|
||||
_inherit = 'ir.model'
|
||||
|
||||
def _filter_bi_fields(self, ir_model_field_obj):
|
||||
name = ir_model_field_obj.name
|
||||
model = ir_model_field_obj.model_id
|
||||
model_name = model.model
|
||||
if name in self.env[model_name]._columns:
|
||||
f = self.env[model_name]._columns[name]
|
||||
return f._classic_write
|
||||
return False
|
||||
|
||||
@api.model
|
||||
def _filter_bi_models(self, model):
|
||||
model_name = model["model"]
|
||||
if model_name in NO_BI_MODELS or \
|
||||
model_name.startswith("workflow") or \
|
||||
model_name.startswith("ir.") or \
|
||||
model["name"] == "Unknow" or \
|
||||
"report" in model_name or \
|
||||
model_name.startswith("base_") or \
|
||||
"_" in model_name or \
|
||||
"." in model["name"] or \
|
||||
"mail" in model_name or \
|
||||
"edi." in model_name:
|
||||
return False
|
||||
return self.env['ir.model.access'].check(
|
||||
model["model"], 'read', False)
|
||||
|
||||
@api.model
|
||||
def get_related_fields(self, model_ids):
|
||||
""" Return list of field dicts for all fields that can be
|
||||
joined with models in model_ids
|
||||
"""
|
||||
model_names = dict([(model.id, model.model)
|
||||
for model in self.env['ir.model'].sudo().search(
|
||||
[('id', 'in', model_ids.values())])])
|
||||
filter_bi_fields = self._filter_bi_fields
|
||||
if filter_bi_fields:
|
||||
rfields = [
|
||||
dict(dict_for_field(field),
|
||||
join_node=-1,
|
||||
table_alias=model[0])
|
||||
for field in filter(
|
||||
filter_bi_fields,
|
||||
self.env['ir.model.fields'].sudo().search(
|
||||
[('model_id', 'in', model_ids.values()),
|
||||
('ttype', 'in', ['many2one'])]))
|
||||
for model in model_ids.items()
|
||||
if model[1] == field.model_id.id
|
||||
]
|
||||
|
||||
lfields = [
|
||||
dict(dict_for_field(field),
|
||||
join_node=model[0],
|
||||
table_alias=-1)
|
||||
for field in filter(
|
||||
filter_bi_fields,
|
||||
self.env['ir.model.fields'].sudo().search(
|
||||
[('relation', 'in', model_names.values()),
|
||||
('ttype', 'in', ['many2one'])]))
|
||||
for model in model_ids.items()
|
||||
if model_names[model[1]] == field['relation']
|
||||
]
|
||||
|
||||
return [dict(field, join_node=model[0])
|
||||
for field in lfields
|
||||
if model_names[model[1]] == field['relation']] + [
|
||||
dict(field, table_alias=model[0])
|
||||
for model in model_ids.items()
|
||||
for field in rfields if model[1] == field['model_id']]
|
||||
|
||||
@api.model
|
||||
def get_related_models(self, model_ids):
|
||||
""" Return list of model dicts for all models that can be
|
||||
joined with models in model_ids
|
||||
"""
|
||||
related_fields = self.get_related_fields(model_ids)
|
||||
return sorted(filter(
|
||||
self._filter_bi_models,
|
||||
[{"id": model.id, "name": model.name, "model": model.model}
|
||||
for model in self.env['ir.model'].sudo().search(
|
||||
['|',
|
||||
('id', 'in', model_ids.values() + [
|
||||
f['model_id']
|
||||
for f in related_fields if f['table_alias'] == -1]),
|
||||
('model', 'in', [
|
||||
f['relation']
|
||||
for f in related_fields if f['join_node'] == -1])])]),
|
||||
key=lambda x: x['name'])
|
||||
|
||||
@api.model
|
||||
def get_models(self):
|
||||
""" Return list of model dicts for all available models.
|
||||
"""
|
||||
models_domain = [('osv_memory', '=', False)]
|
||||
return sorted(filter(
|
||||
self._filter_bi_models,
|
||||
[dict_for_model(model)
|
||||
for model in self.search(models_domain)]),
|
||||
key=lambda x: x['name'])
|
||||
|
||||
@api.model
|
||||
def get_join_nodes(self, field_data, new_field):
|
||||
""" Return list of field dicts of join nodes
|
||||
|
||||
Return all possible join nodes to add new_field to the query
|
||||
containing model_ids.
|
||||
"""
|
||||
model_ids = dict([(field['table_alias'],
|
||||
field['model_id']) for field in field_data])
|
||||
keys = [(field['table_alias'], field['id'])
|
||||
for field in field_data if field.get('join_node', -1) != -1]
|
||||
join_nodes = ([{'table_alias': alias}
|
||||
for alias, model_id in model_ids.items()
|
||||
if model_id == new_field['model_id']] + [
|
||||
d for d in self.get_related_fields(model_ids)
|
||||
if (d['relation'] == new_field['model'] and
|
||||
d['join_node'] == -1) or
|
||||
(d['model_id'] == new_field['model_id'] and
|
||||
d['table_alias'] == -1)])
|
||||
return filter(
|
||||
lambda x: 'id' not in x or
|
||||
(x['table_alias'], x['id']) not in keys, join_nodes)
|
||||
|
||||
@api.model
|
||||
def get_fields(self, model_id):
|
||||
bi_field_domain = [
|
||||
('model_id', '=', model_id),
|
||||
("name", "not in", NO_BI_FIELDS),
|
||||
('ttype', 'not in', [
|
||||
'many2many', "one2many", "html", "binary", "reference"])
|
||||
]
|
||||
filter_bi_fields = self._filter_bi_fields
|
||||
fields_obj = self.env['ir.model.fields']
|
||||
fields = filter(filter_bi_fields,
|
||||
fields_obj.sudo().search(bi_field_domain))
|
||||
return sorted([{"id": field.id,
|
||||
"model_id": model_id,
|
||||
"name": field.name,
|
||||
"description": field.field_description,
|
||||
"type": field.ttype,
|
||||
"custom": False,
|
||||
"model": field.model_id.model,
|
||||
"model_name": field.model_id.name}
|
||||
for field in fields], key=lambda x: x['description'],
|
||||
reverse=True)
|
||||
|
||||
def create(self, cr, user, vals, context=None):
|
||||
if context is None:
|
||||
context = {}
|
||||
if context and context.get('bve'):
|
||||
vals['state'] = 'base'
|
||||
res = super(IrModel, self).create(cr, user, vals, context)
|
||||
if vals.get('state', 'base') == 'bve':
|
||||
vals['state'] = 'manual'
|
||||
|
||||
# add model in registry
|
||||
self.instanciate(cr, user, vals['model'], context)
|
||||
self.pool.setup_models(cr, partial=(not self.pool.ready))
|
||||
|
||||
# update database schema
|
||||
# model = self.pool[vals['model']]
|
||||
# ctx = dict(
|
||||
# context,
|
||||
# field_name=vals['name'],
|
||||
# field_state='manual',
|
||||
# select=vals.get('select_level', '0'),
|
||||
# update_custom_fields=True)
|
||||
RegistryManager.signal_registry_change(cr.dbname)
|
||||
|
||||
self.write(cr, user, [res], {'state': 'manual'})
|
||||
|
||||
return res
|
||||
Reference in New Issue
Block a user