# encoding: utf-8
# The COPYRIGHT file at the top level of this repository contains the full
# copyright notices and license terms.
import datetime as mdatetime
import pytz
import logging
import os
import sys
import time
import unicodedata
import json
from sql import Null, Column
from sql.operators import Or
from datetime import datetime, timedelta
from collections import defaultdict
from io import BytesIO
from trytond.wizard import Wizard, StateView, StateAction, StateTransition, \
StateReport, Button
from trytond.model import ModelSQL, ModelView, fields, Unique, Check, \
sequence_ordered
from trytond.model.fields import depends
from trytond.pyson import If, Eval, Bool, PYSONEncoder, Id, In, Not, \
PYSONDecoder
from trytond.pool import Pool, PoolMeta
from trytond.transaction import Transaction
from trytond.tools import grouped_slice
from trytond.config import config as config_
from trytond import backend
from trytond.protocols.jsonrpc import JSONDecoder, JSONEncoder
from trytond.modules.html_report.html_report import HTMLReport
from .babi_eval import babi_eval
__all__ = ['Filter', 'Expression', 'Report', 'ReportGroup', 'Dimension',
'DimensionColumn', 'Measure', 'InternalMeasure', 'Order', 'ActWindow',
'Menu', 'Keyword', 'Model', 'OpenChartStart', 'OpenChart',
'ReportExecution', 'OpenExecutionSelect', 'OpenExecution',
'UpdateDataWizardStart', 'UpdateDataWizardUpdated',
'FilterParameter', 'CleanExecutionsStart', 'CleanExecutions',
'BabiHTMLReport']
FIELD_TYPES = [
('char', 'Char'),
('integer', 'Integer'),
('float', 'Float'),
('numeric', 'Numeric'),
('boolean', 'Boolean'),
('many2one', 'Many To One'),
]
AGGREGATE_TYPES = [
('avg', 'Average'),
('sum', 'Sum'),
('count', 'Count'),
('max', 'Max'),
('min', 'Min'),
]
SRC_CHARS = u""" .'"()/*-+?¿!&$[]{}@#`'^:;<>=~%,|\\"""
DST_CHARS = u"""__________________________________"""
BABI_CELERY = config_.getboolean('babi', 'celery', default=True)
BABI_RETENTION_DAYS = config_.getint('babi', 'retention_days', default=30)
BABI_CELERY_TASK = config_.get('babi', 'celery_task',
default='trytond.modules.babi.tasks.calculate_execution')
BABI_MAX_BD_COLUMN = config_.getint('babi', 'max_db_column', default=60)
try:
import celery
except ImportError:
celery = None
except AttributeError:
# If run from within frepple we will get
# AttributeError: 'module' object has no attribute 'argv'
pass
CELERY_CONFIG = config_.get('celery', 'config',
default='trytond.modules.babi.celeryconfig')
CELERY_BROKER = 'amqp://%(user)s:%(password)s@%(host)s:%(port)s/%(vhost)s' % {
'user': config_.get('celery', 'user', default='guest'),
'password': config_.get('celery', 'password', default='guest'),
'host': config_.get('celery', 'host', default='localhost'),
'port': config_.getint('celery', 'port', default=5672),
'vhost': config_.get('celery', 'vhost', default='/'),
}
logger = logging.getLogger(__name__)
def unaccent(text):
if not (isinstance(text, str) or isinstance(text, unicode)):
return str(text)
if isinstance(text, str) and bytes == str:
text = unicode(text, 'utf-8')
text = text.lower()
for c in xrange(len(SRC_CHARS)):
if c >= len(DST_CHARS):
break
text = text.replace(SRC_CHARS[c], DST_CHARS[c])
text = unicodedata.normalize('NFKD', text)
if bytes == str:
text = text.encode('ASCII', 'ignore')
return text
def _replace(x):
return x.replace("'", '')
class DynamicModel(ModelSQL, ModelView):
@classmethod
def __setup__(cls):
super(DynamicModel, cls).__setup__()
cls._error_messages.update({
'report_not_exists': ('Report "%s" no longer exists or you do '
'not have the rights to access it.'),
})
pool = Pool()
Execution = pool.get('babi.report.execution')
executions = Execution.search([
('babi_model.model', '=', cls.__name__),
])
if not executions or len(executions) > 1:
return
execution, = executions
try:
cls._order = execution.get_orders()
except AssertionError:
# An exception error is raisen on tests where Execution is not
# properly loaded in the pool
pass
@classmethod
def fields_view_get(cls, view_id=None, view_type='form'):
pool = Pool()
Execution = pool.get('babi.report.execution')
Dimension = pool.get('babi.dimension')
InternalMeasure = pool.get('babi.internal.measure')
model_name = '_'.join(cls.__name__.split('_')[0:2])
executions = Execution.search([
('babi_model.model', '=', cls.__name__),
], limit=1)
if not executions:
cls.raise_user_error('report_not_exists', cls.__name__)
context = Transaction().context
execution, = executions
with Transaction().set_context(_datetime=execution.create_date):
report = execution.report
view_type = context.get('view_type', view_type)
result = {}
result['type'] = view_type
result['view_id'] = view_id
result['field_childs'] = None
fields = []
if view_type == 'tree' or view_type == 'form':
keyword = ''
if view_type == 'tree':
keyword = 'keyword_open="1"'
fields.append('children')
xml = '<%s string="%s" %s>\n' % (view_type, report.model.name,
keyword)
for field in report.dimensions + execution.internal_measures:
# Avoid duplicated fields
if field.internal_name in fields:
continue
if view_type == 'form':
xml += '\n' % (field.internal_name)
xml += '\n' % (field.internal_name)
fields.append(field.internal_name)
xml += '\n' % (view_type)
result['arch'] = xml
if view_type == 'tree' and context.get('babi_tree_view'):
result['field_childs'] = 'children'
elif view_type == 'graph':
# TODO: Remove it on 3.6 as client autogenerates it
colors = ['#FF0000', '#0000FF', '#008000', '#FFFF00',
'#800080', '#FF00FF', '#FFA500', '#C0C0C0', '#000000']
model_name = context.get('model_name')
graph_type = context.get('graph_type')
measure_ids = context.get('measures')
legend = context.get('legend') and 1 or 0
interpolation = context.get('interpolation', 'linear')
dimension = Dimension(context.get('dimension'))
x_xml = '\n' % dimension.internal_name
fields.append(dimension.internal_name)
y_xml = ''
for i, measure in enumerate(InternalMeasure.browse(
measure_ids)):
color = colors[i % len(colors)]
y_xml += (' \n') % (measure.internal_name,
interpolation, color)
fields.append(measure.internal_name)
xml = '''
%(x_fields)s
%(y_fields)s
''' % {
'graph_type': graph_type,
'graph_name': model_name,
'legend': legend,
'x_fields': x_xml,
'y_fields': y_xml,
}
result['arch'] = xml
else:
assert False
result['fields'] = cls.fields_get(fields)
return result
def get_rec_name(self, name):
result = []
for field in self._babi_dimensions:
value = getattr(self, field)
if not value:
result.append('-')
elif isinstance(value, ModelSQL):
result.append(value.rec_name)
elif not isinstance(value, unicode):
result.append(unicode(value))
else:
result.append(value)
return ' / '.join(result)
def create_columns(name, ffields):
"Create fields of new model"
columns = {}
for field in ffields:
fname = field['name']
field_name = field['internal_name']
ttype = field['ttype']
if ttype == 'integer':
columns[field_name] = fields.Integer(fname)
elif ttype == 'float':
columns[field_name] = fields.Float(fname, digits=(16, 2))
elif ttype == 'numeric':
columns[field_name] = fields.Numeric(fname, digits=(16, 2))
elif ttype == 'char':
columns[field_name] = fields.Char(fname)
elif ttype == 'boolean':
columns[field_name] = fields.Boolean(fname)
elif ttype == 'many2one':
columns[field_name] = fields.Many2One(field['related_model'],
fname, ondelete='SET NULL')
else:
raise ValueError("Unknown type: %s" % ttype)
columns['babi_group'] = fields.Char('Group', size=500)
columns['parent'] = fields.Many2One(name, 'Parent', ondelete='CASCADE',
select=True, left='parent_left', right='parent_right')
columns['children'] = fields.One2Many(name, 'parent', 'Children')
columns['parent_left'] = fields.Integer('Parent Left', select=True)
columns['parent_right'] = fields.Integer('Parent Right', select=True)
return columns
def create_class(name, description, dimensions, measures):
"Create class, and make instance"
body = {
'__doc__': description,
'__name__': name,
# Used in get_rec_name()
'_defaults': {},
'_babi_dimensions': [x['internal_name'] for x in dimensions],
}
body.update(create_columns(name, dimensions + measures))
return type(name, (DynamicModel, ), body)
def register_class(internal_name, name, dimensions, measures):
"Register class an return model"
pool = Pool()
Model = pool.get('ir.model')
Class = create_class(internal_name, name, dimensions, measures)
Pool.register(Class, module='babi', type_='model')
Class.__setup__()
pool.add(Class, type='model')
Class.__post_setup__()
Class.__register__('babi')
model, = Model.search([
('model', '=', internal_name),
])
return model
def create_groups_access(model, groups):
"Creates group access for a given model"
pool = Pool()
ModelAccess = pool.get('ir.model.access')
to_create = []
for group in groups:
exists = ModelAccess.search([
('model', '=', model.id),
('group', '=', group.id),
])
if not exists:
to_create.append({
'model': model.id,
'group': group.id,
'perm_read': True,
'perm_create': True,
'perm_write': True,
'perm_delete': True,
})
if to_create:
ModelAccess.create(to_create)
class TimeoutException(Exception):
pass
class TimeoutChecker:
def __init__(self, timeout, callback):
self._timeout = timeout
self._callback = callback
self._start = datetime.now()
def check(self):
elapsed = (datetime.now() - self._start).seconds
if elapsed > self._timeout:
self._callback()
class DimensionIterator:
def __init__(self, values):
"""
values should be a dictionary where its values are
non-empty lists.
"""
self.values = values
self.keys = sorted(values.keys())
self.keys.reverse()
self.current = dict.fromkeys(values.keys(), 0)
self.current[self.keys[0]] = -1
def __iter__(self):
return self
def next(self):
for x in xrange(len(self.keys)):
key = self.keys[x]
if self.current[key] >= len(self.values[key]) - 1:
if x == len(self.keys) - 1:
raise StopIteration
self.current[key] = 0
else:
self.current[key] += 1
break
return self.current
class Filter(ModelSQL, ModelView):
"Filter"
__name__ = 'babi.filter'
_history = True
name = fields.Char('Name', required=True, translate=True)
model = fields.Many2One('ir.model', 'Model', required=True,
domain=[('babi_enabled', '=', True)])
model_name = fields.Function(fields.Char('Model Name'),
'on_change_with_model_name')
view_search = fields.Many2One('ir.ui.view_search', 'Search',
domain=[('model', '=', Eval('model_name'))],
depends=['model_name'])
domain = fields.Char('Domain')
python_expression = fields.Char('Python Expression',
help='The python expression introduced will be evaluated. If the '
'result is True the record will be included, it will be discarded '
'otherwise.')
parameters = fields.One2Many('babi.filter.parameter', 'filter',
'Parameters',
states={
'invisible': Not(Eval('context', {}).get('groups', []).contains(
Id('babi', 'group_babi_admin'))),
})
fields = fields.Function(fields.Many2Many('ir.model.field', None, None,
'Model Fields', depends=['model']),
'on_change_with_fields')
@depends('model')
def on_change_with_model_name(self, name=None):
return self.model.model if self.model else None
@depends('model')
def on_change_with_fields(self, name=None):
if not self.model:
return []
return [x.id for x in self.model.fields]
@depends('view_search')
def on_change_with_domain(self):
return self.view_search.domain if self.view_search else None
@depends('model_name', 'domain')
def on_change_with_view_search(self):
ViewSearch = Pool().get('ir.ui.view_search')
searches = ViewSearch.search([
('model', '=', self.model_name),
('domain', '=', self.domain),
])
if not searches:
return None
return searches[0].id
class FilterParameter(ModelSQL, ModelView):
"Filter Parameter"
__name__ = 'babi.filter.parameter'
_history = True
filter = fields.Many2One('babi.filter', 'Filter', required=True)
name = fields.Char('Name', required=True, translate=True, help='Name used '
'on the domain substitution')
ttype = fields.Selection(FIELD_TYPES + [('date', 'Date'),
('many2many', 'Many To Many')], 'Field Type', required=True)
related_model = fields.Many2One('ir.model', 'Related Model', states={
'required': Eval('ttype').in_(['many2one', 'many2many']),
'readonly': Not(Eval('ttype').in_(['many2one', 'many2many'])),
}, depends=['ttype'])
def create_keyword(self):
pool = Pool()
Action = pool.get('ir.action.wizard')
ModelData = pool.get('ir.model.data')
Keyword = pool.get('ir.action.keyword')
if self.ttype in ['many2one', 'many2many']:
action = Action(ModelData.get_id('babi', 'open_execution_wizard'))
keyword = Keyword()
keyword.keyword = 'form_relate'
keyword.model = '%s,-1' % self.related_model.model
keyword.action = action.action
keyword.babi_filter_parameter = self
keyword.save()
@classmethod
def __register__(cls, module_name):
super(FilterParameter, cls).__register__(module_name)
cursor = Transaction().connection.cursor()
sql_table = cls.__table__()
# Migration from int to integer
cursor.execute(*sql_table.update([Column(sql_table, 'ttype')],
['integer'], where=sql_table.ttype == 'int'))
# Migration from bool to boolean
cursor.execute(*sql_table.update([Column(sql_table, 'ttype')],
['boolean'], where=sql_table.ttype == 'bool'))
@classmethod
def __setup__(cls):
super(FilterParameter, cls).__setup__()
cls._error_messages.update({
'parameter_not_found': ('Parameter "%(parameter)s" not found '
'in Domain nor in Python Expression of filter '
'"%(filter)s".'),
})
def check_parameter_in_filter(self):
placeholder = '{%s}' % self.name
if ((self.filter.domain and placeholder not in self.filter.domain)
and (self.filter.python_expression
and placeholder not in self.filter.python_expression)):
self.raise_user_warning('babi_check_parameter_in_filter.{}'.format(
self.name), 'parameter_not_found', {
'parameter': self.rec_name,
'filter': self.filter.rec_name,
})
return False
return True
@classmethod
def create(cls, vlist):
filters = super(FilterParameter, cls).create(vlist)
for filter in filters:
filter.create_keyword()
return filters
@classmethod
def write(cls, *args):
pool = Pool()
Keyword = pool.get('ir.action.keyword')
super(FilterParameter, cls).write(*args)
actions = iter(args)
for filters, values in zip(actions, actions):
if 'related_model' in values:
filter_ids = [f.id for f in filters]
Keyword.delete(Keyword.search([
('babi_filter_parameter', 'in', filter_ids),
]))
for filter in filters:
filter.create_keyword()
@classmethod
def delete(cls, filters):
pool = Pool()
Keyword = pool.get('ir.action.keyword')
Keyword.delete(Keyword.search([
('babi_filter_parameter', 'in', [f.id for f in filters]),
]))
super(FilterParameter, cls).delete(filters)
class Expression(ModelSQL, ModelView):
"Expression"
__name__ = 'babi.expression'
_history = True
name = fields.Char('Name', required=True, translate=True)
model = fields.Many2One('ir.model', 'Model', required=True,
domain=[('babi_enabled', '=', True)])
expression = fields.Char('Expression', required=True,
help='Python expression that will return the value to be used.\n'
'The expression can include the following variables:\n\n'
'- "o": A reference to the current record being processed. For '
' example: "o.party.name"\n'
'\nAnd the following functions apply to dates and timestamps:\n\n'
'- "y()": Returns the year (as a string)\n'
'- "m()": Returns the month (as a string)\n'
'- "w()": Returns the week (as a string)\n'
'- "d()": Returns the day (as a string)\n'
'- "ym()": Returns the year-month (as a string)\n'
'- "ymd()": Returns the year-month-day (as a string).\n')
ttype = fields.Selection(FIELD_TYPES, 'Field Type', required=True)
related_model = fields.Many2One('ir.model', 'Related Model', states={
'required': Eval('ttype') == 'many2one',
'readonly': Eval('ttype') != 'many2one',
}, depends=['ttype'])
fields = fields.Function(fields.Many2Many('ir.model.field', None, None,
'Model Fields'), 'on_change_with_fields')
@classmethod
def __register__(cls, module_name):
super(Expression, cls).__register__(module_name)
cursor = Transaction().connection.cursor()
sql_table = cls.__table__()
# Migration from int to integer
cursor.execute(*sql_table.update([Column(sql_table, 'ttype')],
['integer'], where=sql_table.ttype == 'int'))
# Migration from bool to boolean
cursor.execute(*sql_table.update([Column(sql_table, 'ttype')],
['boolean'], where=sql_table.ttype == 'bool'))
@depends('model')
def on_change_with_fields(self, name=None):
if not self.model:
return []
return [x.id for x in self.model.fields]
class Report(ModelSQL, ModelView):
"Report"
__name__ = 'babi.report'
_history = True
name = fields.Char('Name', required=True, translate=True,
help='New virtual model name.')
model = fields.Many2One('ir.model', 'Model', required=True,
domain=[('babi_enabled', '=', True)], help='Model for data extraction')
model_name = fields.Function(fields.Char('Model Name'),
'on_change_with_model_name')
internal_name = fields.Function(fields.Char('Internal Name', states={
'invisible': Not(Eval('context', {}).get('groups', []
).contains(Id('babi', 'group_babi_admin'))),
}),
'get_internal_name')
filter = fields.Many2One('babi.filter', 'Filter',
domain=[('model', '=', Eval('model'))], depends=['model'])
dimensions = fields.One2Many('babi.dimension', 'report',
'Dimensions')
columns = fields.One2Many('babi.dimension.column', 'report',
'Dimensions on Columns')
measures = fields.One2Many('babi.measure', 'report', 'Measures')
order = fields.One2Many('babi.order', 'report', 'Order', order=[
('sequence', 'ASC')
])
groups = fields.Many2Many('babi.report-res.group', 'report', 'group',
'Groups', help='User groups that will be able to see use this report.')
parent_menu = fields.Many2One('ir.ui.menu', 'Parent Menu',
required=True)
menus = fields.One2Many('ir.ui.menu', 'babi_report', 'Menus',
readonly=True,
states={
'invisible': Not(Eval('context', {}).get('groups', []).contains(
Id('babi', 'group_babi_admin'))),
})
actions = fields.One2Many('ir.action.act_window', 'babi_report',
'Actions', readonly=True,
states={
'invisible': Not(Eval('context', {}).get('groups', []).contains(
Id('babi', 'group_babi_admin'))),
})
keywords = fields.One2Many('ir.action.keyword', 'babi_report', 'Keywords',
readonly=True,
states={
'invisible': Not(Eval('context', {}).get('groups', []).contains(
Id('babi', 'group_babi_admin'))),
})
timeout = fields.Integer('Timeout', required=True, help='If report '
'calculation should take more than the specified timeout (in seconds) '
'the process will be stopped automatically.')
executions = fields.One2Many('babi.report.execution', 'report',
'Executions', readonly=True, order=[('date', 'DESC')],
states={
'invisible': Not(Eval('context', {}).get('groups', []).contains(
Id('babi', 'group_babi_admin'))),
})
last_execution = fields.Function(fields.Many2One('babi.report.execution',
'Last Executions', readonly=True), 'get_last_execution')
crons = fields.One2Many('ir.cron', 'babi_report', 'Schedulers',
context={'babi_report': Eval('id')})
report_cell_level = fields.Integer('Cell Level',
help='Start cell level that not has indentation')
@classmethod
def __setup__(cls):
super(Report, cls).__setup__()
cls._error_messages.update({
'no_dimensions': ('Report "%s" has no dimensions. At least '
'one is needed.'),
'no_measures': ('Report "%s" has no measures. At least one '
'is needed.'),
'timeout_exception': ('Report calculation exceeded timeout '
'limit.')
})
cls._buttons.update({
'calculate': {},
'create_menus': {},
'remove_menus': {},
})
@staticmethod
def default_timeout():
Config = Pool().get('babi.configuration')
config = Config(1)
return config.default_timeout
@staticmethod
def default_report_cell_level():
Config = Pool().get('babi.configuration')
config = Config(1)
return config.report_cell_level or 3
@depends('model')
def on_change_with_model_name(self, name=None):
return self.model.model if self.model else None
def get_internal_name(self, name):
return 'babi_report_%d' % self.id
def get_last_execution(self, name):
if self.executions:
for execution in self.executions:
if execution.state == 'calculated' and not execution.filtered:
return execution.id
@classmethod
def write(cls, *args):
actions = iter(args)
to_update = []
for reports, values in zip(actions, actions):
if 'name' in values:
for report in reports:
if report.name != values['name']:
to_update.append(report)
if to_update:
cls.remove_menus(to_update)
return super(Report, cls).write(*args)
@classmethod
def delete(cls, reports):
cls.remove_menus(reports)
cls.remove_crons(reports)
with Transaction().set_context(babi_order_force=True):
super(Report, cls).delete(reports)
@classmethod
def copy(cls, reports, default=None):
if default is None:
default = {}
default = default.copy()
if 'order' not in default:
default['order'] = None
default['actions'] = None
default['keywords'] = None
default['menus'] = None
default['executions'] = None
if 'name' not in default:
result = []
for report in reports:
default['name'] = '%s (2)' % report.name
result.extend(super(Report, cls).copy([report], default))
return result
return super(Report, cls).copy(reports, default)
@classmethod
def remove_crons(cls, reports):
pool = Pool()
Cron = pool.get('ir.cron')
Cron.delete([c for r in reports for c in r.crons])
@classmethod
def remove_menus(cls, reports):
"Remove all menus and actions created"
pool = Pool()
ActWindow = pool.get('ir.action.act_window')
Menu = pool.get('ir.ui.menu')
actions = []
menus = []
for report in reports:
actions += report.actions
menus += report.menus
ActWindow.delete(actions)
Menu.delete(menus)
def create_tree_view_menu(self, langs):
pool = Pool()
ActWindow = pool.get('ir.action.act_window')
Action = pool.get('ir.action.wizard')
Menu = pool.get('ir.ui.menu')
ModelData = pool.get('ir.model.data')
encoder = PYSONEncoder()
# This action is needed for the wizard to open the data
action = ActWindow()
action.name = self.name
action.res_model = 'babi.report'
action.domain = encoder.encode([('parent', '=', None)])
action.babi_report = self
action.groups = self.groups
action.context = encoder.encode({'babi_tree_view': True})
action.save()
wizard = Action(ModelData.get_id('babi', 'open_execution_wizard'))
menu = Menu()
menu.name = self.name
menu.parent = self.parent_menu
menu.babi_report = self
menu.action = str(wizard)
menu.icon = 'tryton-tree'
menu.groups = self.groups
menu.babi_type = 'tree'
menu.save()
if langs:
for lang in langs:
with Transaction().set_context(language=lang.code,
fuzzy_translation=False):
data, = self.read([self], fields_names=['name'])
Menu.write([menu], data)
return menu.id
def create_list_view_menu(self, parent, langs):
"Create list view and action to open"
pool = Pool()
ActWindow = pool.get('ir.action.act_window')
Action = pool.get('ir.action.wizard')
ModelData = pool.get('ir.model.data')
Menu = pool.get('ir.ui.menu')
# This action is needed for the wizard to open the data
action = ActWindow()
action.name = self.name
action.res_model = 'babi.report'
action.babi_report = self
action.groups = self.groups
action.save()
wizard = Action(ModelData.get_id('babi', 'open_execution_wizard'))
menu = Menu()
menu.name = self.name
menu.parent = parent
menu.babi_report = self
menu.action = str(wizard)
menu.icon = 'tryton-list'
menu.groups = self.groups
menu.babi_type = 'list'
menu.save()
if langs:
for lang in langs:
with Transaction().set_context(language=lang.code,
fuzzy_translation=False):
data, = self.read([self], fields_names=['name'])
Menu.write([menu], data)
return menu.id
def create_update_wizard_menu(self, parent):
pool = Pool()
Menu = pool.get('ir.ui.menu')
Action = pool.get('ir.action.wizard')
ModelData = pool.get('ir.model.data')
action = Action(ModelData.get_id('babi', 'open_execution_wizard'))
menu = Menu(ModelData.get_id('babi', 'menu_update_data'))
menu, = Menu.copy([menu], {
'parent': parent,
'babi_report': self.id,
'icon': 'tryton-executable',
'groups': [x.id for x in self.groups],
'babi_type': 'wizard',
'active': True,
})
menu.action = str(action)
menu.save()
def create_history_menu(self, parent):
pool = Pool()
Action = pool.get('ir.action.wizard')
ModelData = pool.get('ir.model.data')
Menu = pool.get('ir.ui.menu')
action = Action(ModelData.get_id('babi', 'open_execution_wizard'))
menu = Menu(ModelData.get_id('babi', 'menu_historical_data'))
menu, = Menu.copy([menu], {
'parent': parent,
'babi_report': self.id,
'icon': 'tryton-executable',
'groups': [x.id for x in self.groups],
'babi_type': 'history',
'active': True,
})
menu.action = str(action)
menu.save()
@classmethod
def create_menus(cls, reports):
"""Regenerates all actions and menu entries"""
pool = Pool()
Lang = pool.get('ir.lang')
langs = Lang.search([
('translatable', '=', True),
])
cls.remove_menus(reports)
for report in reports:
menu = report.create_tree_view_menu(langs)
report.create_list_view_menu(menu, langs)
report.create_update_wizard_menu(menu)
report.create_history_menu(menu)
return 'reload menu'
def get_dimensions(self, with_columns=False):
dimensions = []
for dimension in self.dimensions:
dimensions.append(dimension.get_dimension_data())
if with_columns:
for dimension in self.columns:
dimensions.append(dimension.get_dimension_data())
return dimensions
def get_execution_data(self):
return {
'report': self.id,
'timeout': self.timeout,
'company': Transaction().context.get('company'),
}
@classmethod
def calculate_babi_report(cls, args=None):
"""This method is intended to be called from ir.cron"""
if not args:
args = []
reports = cls.search([('id', '=', args)])
return cls.calculate(reports)
def execute(self, execution):
Execution = Pool().get('babi.report.execution')
transaction = Transaction()
user = transaction.user
database_name = transaction.database.name
logger.info('Babi execution %s (report "%s")' % (
execution.id, self.rec_name))
if celery and BABI_CELERY:
os.system(
'%s/celery call %s '
'--broker=%s --args=[%d,%d] --config="%s" --queue=%s' % (
os.path.dirname(sys.executable),
BABI_CELERY_TASK,
CELERY_BROKER,
execution.id,
user,
CELERY_CONFIG,
database_name))
else:
# Fallback to synchronous mode if celery is not available
Execution.calculate([execution])
@classmethod
def calculate(cls, reports):
Execution = Pool().get('babi.report.execution')
for report in reports:
if not report.measures:
cls.raise_user_error('no_measures', report.rec_name)
if not report.dimensions:
cls.raise_user_error('no_dimensions', report.rec_name)
execution, = Execution.create([report.get_execution_data()])
Transaction().commit()
report.execute(execution)
class ReportExecution(ModelSQL, ModelView):
"Report Execution"
__name__ = 'babi.report.execution'
report = fields.Many2One('babi.report', 'Report', required=True,
readonly=True, ondelete='CASCADE')
date = fields.DateTime('Execution Date', required=True, readonly=True)
internal_name = fields.Function(fields.Char('Internal Name'),
'get_internal_name')
report_model = fields.Function(fields.Many2One('ir.model', 'Report Model'),
'on_change_with_report_model')
babi_model = fields.Many2One('ir.model', 'BI Model', readonly=True,
help='Link to new model instance')
state = fields.Selection([
('pending', 'Pending'),
('in_progress', 'In progress'),
('calculated', 'Calculated'),
('timeout', 'Timeout'),
('failed', 'Failed'),
('canceled', 'Canceled'),
], 'State', required=True, readonly=True)
timeout = fields.Integer('Timeout', required=True, readonly=True,
help='If report calculation should take more than the specified '
'timeout (in seconds) the process will be stopped automatically.')
duration = fields.Float('Duration', readonly=True,
help='Number of seconds the calculation took.')
filtered = fields.Boolean('Filtered', help='Used to mark executions with '
'parameter filters evaluated', readonly=True)
filter_values = fields.Text('Filter Values', readonly=True)
internal_measures = fields.One2Many('babi.internal.measure',
'execution', 'Internal Measures', readonly=True)
pid = fields.Integer('Pid', readonly=True)
company = fields.Many2One('company.company', 'Company', required=True,
domain=[
('id', If(Eval('context', {}).contains('company'), '=', '!='),
Eval('context', {}).get('company', -1)),
],
select=True)
@classmethod
def __setup__(cls):
super(ReportExecution, cls).__setup__()
cls._order.insert(0, ('date', 'DESC'))
cls._error_messages.update({
'filter_parameters': ('Execution "%s" has filter parameters '
' and you did not provide any of them. Please execute it '
' from the menu.'),
'no_dimensions': ('Execution "%s" has no dimensions. At least '
'one is needed.'),
'no_measures': ('Execution "%s" has no measures. At least one '
'is needed.'),
})
cls._buttons.update({
'open': {
'invisible': Eval('state') != 'calculated',
},
'cancel': {
'invisible': ((Eval('state') != 'in_progress') &
~Eval('pid', False)),
},
})
@staticmethod
def default_date():
return datetime.now()
@staticmethod
def default_state():
return 'pending'
@staticmethod
def default_filtered():
return False
@staticmethod
def default_timeout():
Config = Pool().get('babi.configuration')
config = Config(1)
return config.default_timeout
@staticmethod
def default_company():
return Transaction().context.get('company')
def get_rec_name(self, name):
Company = Pool().get('company.company')
company_id = Transaction().context.get('company')
date = self.date
if company_id:
company = Company(company_id)
if company.timezone:
timezone = pytz.timezone(company.timezone)
date = timezone.localize(self.date)
date = self.date + date.utcoffset()
return '%s (%s)' % (self.report.rec_name, date)
def get_internal_name(self, name):
return 'babi_execution_%d' % self.id
def get_measures(self):
measures = []
for measure in self.internal_measures:
measures.append(measure.get_measure_data())
return measures
def get_orders(self):
order = []
with Transaction().set_context(_datetime=self.date):
for record in self.report.order:
if record.dimension:
field = record.dimension.internal_name
order.append((field, record.order))
else:
for measure in record.measure.internal_measures:
if measure.execution == self:
field = measure.internal_name
order.append((field, record.order))
return order
@depends('report')
def on_change_with_report_model(self, name=None):
if self.report:
return self.report.model.id
@classmethod
@ModelView.button_action('babi.open_execution_wizard')
def open(cls, executions):
pass
@classmethod
@ModelView.button
def cancel(cls, executions):
for execution in executions:
if execution.state != 'in_progress':
continue
if not execution.pid:
continue
os.kill(execution.pid, 15)
execution.state = 'canceled'
execution.save()
@classmethod
def delete(cls, executions):
Model = Pool().get('ir.model')
Model.delete([x.babi_model for x in executions if x.babi_model])
cls.remove_data(executions)
cls.remove_keywords(executions)
to_delete = set([e.internal_name for e in executions])
super(ReportExecution, cls).delete(executions)
# We should remove the classes from the pool so when removing related
# records it doesn't fail checking unexisting models
pool = Pool()
with pool.lock:
for name in to_delete:
try:
del pool._pool[pool.database_name]['model'][name]
except KeyError:
# The model may not be registered on the pool
continue
@classmethod
def remove_keywords(cls, executions):
pool = Pool()
Keyword = pool.get('ir.action.keyword')
models = ['%s,-1' % e.babi_model.model for e in executions
if e.babi_model]
keywords = Keyword.search([('model', 'in', models)])
Keyword.delete(keywords)
@classmethod
def clean(cls, date=None):
pool = Pool()
Date = pool.get('ir.date')
if date is None:
date = Date.today() - timedelta(days=BABI_RETENTION_DAYS)
date = datetime.combine(date, mdatetime.time.min)
executions = cls.search([('date', '<', date)])
cls.delete(executions)
return True
@classmethod
def remove_data(cls, executions):
TableHandler = backend.get('TableHandler')
cursor = Transaction().connection.cursor()
# Add a transaction for each 200 executions otherwise locks are not
# released on Postgresql and a exception is raised about too many locks
for sub_executions in grouped_slice(executions, 200):
for execution in sub_executions:
table = execution.internal_name
if not TableHandler.table_exist(table):
continue
# Table and model are the same.
TableHandler.drop_table(table, table)
# There is no method to remove sequence in table
# handler, so we must remove them manually
try:
# SQLite doesn't have sequences
cursor.execute("DROP SEQUENCE IF EXISTS %s_id_seq"
% table)
except:
pass
Transaction().commit()
def validate_model(self, with_columns=False):
"makes model available on Tryton and pool instance"
dimensions = self.report.get_dimensions(with_columns)
measures = self.get_measures()
model = register_class(self.internal_name, self.report.name,
dimensions, measures)
if not self.babi_model:
self.babi_model = model
self.save()
create_groups_access(model, self.report.groups)
# Commit transaction to avoid locks
Transaction().commit()
def timeout_exception(self):
raise TimeoutException
@staticmethod
def save_state(execution_id, state, exception=False):
" Save state in a new transaction"
DatabaseOperationalError = backend.get('DatabaseOperationalError')
Transaction().rollback()
with Transaction().new_transaction() as new_transaction:
try:
pool = Pool()
Execution = pool.get('babi.report.execution')
Model = pool.get('ir.model')
new_instances = Execution.browse([execution_id])
to_write = {'state': state}
if state == 'in_progress':
to_write['pid'] = os.getpid()
Execution.write(new_instances, to_write)
if exception:
Execution.remove_data(new_instances)
Model.delete([e.babi_model for e in new_instances])
new_transaction.commit()
except DatabaseOperationalError:
new_transaction.rollback()
@classmethod
def calculate(cls, executions):
transaction = Transaction()
for execution in executions:
execution.save_state(execution.id, 'in_progress')
date = execution.create_date
with transaction.set_context(_datetime=date):
execution.validate_model()
with transaction.set_user(0):
execution.create_keywords()
try:
execution.create_data()
except TimeoutException:
execution.save_state(execution.id, 'timeout',
exception=True)
cls.raise_user_error('timeout_exception')
except Exception:
execution.save_state(execution.id, 'failed',
exception=True)
execution.save()
raise
def replace_parameters(self, expression):
if self.report.filter and self.report.filter.parameters:
if not self.filter_values:
self.raise_user_error('filter_parameters', self.rec_name)
filter_data = json.loads(self.filter_values.encode('utf-8'),
object_hook=JSONDecoder())
parameters = dict((p.id, p.name) for p in
self.report.filter.parameters)
values = {}
for key, value in filter_data.iteritems():
filter_name = parameters[int(key.split('_')[-1:][0])]
if not value or filter_name not in expression:
continue
values[filter_name] = value
expression = expression.format(**values)
return expression
def get_python_filter(self):
if self.report.filter and self.report.filter.python_expression:
return self.replace_parameters(
self.report.filter.python_expression)
def get_domain_filter(self):
domain = '[]'
if self.report.filter and self.report.filter.domain:
domain = self.report.filter.domain
if '__' in domain:
domain = str(PYSONDecoder().decode(domain))
domain = self.replace_parameters(domain)
# TODO: Use a PYSON domain?
return eval(domain, {
'datetime': mdatetime,
'false': False,
'true': True,
})
def create_keywords(self):
pool = Pool()
Action = pool.get('ir.action.wizard')
ModelData = pool.get('ir.model.data')
Keyword = pool.get('ir.action.keyword')
action = Action(ModelData.get_id('babi', 'open_chart_wizard'))
keyword = Keyword()
keyword.keyword = 'tree_open'
keyword.model = '%s,-1' % self.babi_model.model
keyword.action = action.action
keyword.babi_report = self.report
keyword.groups = self.report.groups
keyword.save()
def create_data(self):
"Creates data for this execution"
pool = Pool()
Model = pool.get(self.report.model.model)
transaction = Transaction()
cursor = transaction.connection.cursor()
BIModel = pool.get(self.babi_model.model)
checker = TimeoutChecker(self.timeout, self.timeout_exception)
logger.info('Updating Data of report: %s' % self.rec_name)
update_start = time.time()
model = self.report.model.model
if not self.report.measures:
self.raise_user_error('no_measures', self.rec_name)
if not self.report.dimensions:
self.raise_user_error('no_dimensions', self.rec_name)
domain = self.get_domain_filter()
start = datetime.today()
self.update_internal_measures()
with_columns = len(self.report.columns) > 0
self.validate_model(with_columns=with_columns)
dimension_names = [x.internal_name for x in self.report.dimensions]
dimension_expressions = [(x.expression.expression,
'' if x.expression.ttype == 'many2one'
else 'empty') for x in
self.report.dimensions]
measure_names = [x.internal_name for x in
self.internal_measures]
measure_expressions = [x.expression for x in
self.internal_measures]
if self.report.columns:
dimension_names.extend([x.internal_name for x in
self.report.columns])
dimension_expressions.extend([(x.expression.expression,
'' if x.expression.ttype == 'many2one'
else 'empty') for x in self.report.columns])
columns = (['create_date', 'create_uid'] + dimension_names +
measure_names)
columns = ['"%s"' % x for x in columns]
# Some older versions of psycopg do not allow column names
# to be of type unicode
columns = [str(x) for x in columns]
uid = transaction.user
python_filter = self.get_python_filter()
table = BIModel._table
if self.report.columns:
table = BIModel._table + '_tmp'
# Save data to a temporally table:
cursor.execute('CREATE TEMP TABLE %s AS SELECT * FROM %s WHERE '
' 0 = 1' % (table, BIModel._table))
# Process records
offset = 2000
index = 0
def sanitanize(x):
if (isinstance(x, basestring) or isinstance(x, str)
or isinstance(x, unicode)):
x = x.replace('|', '-')
if not isinstance(x, unicode) and isinstance(x, str):
return unicode(x.decode('utf-8'))
else:
return unicode(x)
with transaction.set_context(_datetime=None):
records = Model.search(domain, offset=index * offset, limit=offset)
while records:
checker.check()
logger.info('Calculated %s, %s records in %s seconds'
% (model, index * offset, datetime.today() - start))
to_create = '' if bytes == str else b''
# var o it's used on expression!!
# Don't rename var
# chunk = records[index * offset:(index + 1) * offset]
for record in records:
if python_filter:
if not babi_eval(python_filter, record,
convert_none=False):
continue
vals = ['now()', str(uid)]
vals += [sanitanize(babi_eval(x[0], record, convert_none=x[1]))
for x in dimension_expressions]
vals += [sanitanize(babi_eval(x, record, convert_none='zero'))
for x in measure_expressions]
record = '|'.join(vals).replace('\n', ' ')
record.replace('\\', '')
record += '\n'
record = record.encode('utf-8')
to_create += record
if to_create:
data = BytesIO(to_create)
if hasattr(cursor, 'copy_from'):
cursor.copy_from(data, table, sep='|', null='',
columns=columns)
data.close()
else:
base_query = 'INSERT INTO %s (' % table
base_query += ','.join([unicode(x) for x in columns])
base_query += ' ) VALUES '
for line in data.readlines():
if len(line) == 0:
continue
if bytes != str:
line = line.decode('utf-8')
query = base_query + '(now(),'
query += ','.join(["'%s'" % unicode(x)
for x in line.split('|')[1:]])
query += ')'
cursor.execute(query)
index += 1
with transaction.set_context(_datetime=None):
records = Model.search(domain, offset=index * offset,
limit=offset)
if self.report.columns:
distincts = self.distinct_dimension_columns(cursor, table)
self.update_internal_measures(distincts)
self.validate_model()
query = 'INSERT INTO %s ('
query += ','.join([unicode(x) for x in columns])
query += ',' + ','.join([unicode(x.internal_name) for x in
self.internal_measures])
query += ') SELECT '
query += ','.join([unicode(x) for x in columns])
query += ',' + ','.join([unicode(x.expression) for x in
self.internal_measures])
query += ' FROM %s '
cursor.execute(query % (BIModel._table, table))
cursor.execute('DROP TABLE %s ' % (table))
self.update_measures(checker)
logger.info('Calc all %s records in %s seconds'
% (model, datetime.today() - start))
self.state = 'calculated'
self.duration = time.time() - update_start
self.save()
logger.info('End Update Data of report: %s' % self.rec_name)
def distinct_dimension_columns(self, cursor, tablename):
distincts = {}
for dimension in self.report.columns:
cursor.execute('SELECT %s from %s group by 1 order by 1' % (
dimension.internal_name, tablename))
distincts[dimension.id] = [unicode(x[0]) for x in
cursor.fetchall()]
return distincts
def update_internal_measures(self, distincts=None):
InternalMeasure = Pool().get('babi.internal.measure')
to_create = []
if distincts is None:
distincts = {}
for key in distincts.keys():
# TODO: Make translatable
distincts[key] = ['(all)'] + sorted(list(distincts[key]))
columns = {}
for column in self.report.columns:
columns[column.id] = column
InternalMeasure.delete(self.internal_measures)
sequence = 0
for measure in self.report.measures:
sequence += 1
related_model_id = None
if measure.expression.ttype == 'many2one':
related_model_id = measure.expression.related_model.id
if distincts:
iterator = DimensionIterator(distincts)
else:
iterator = [None]
for combination in iterator:
name = []
internal_names = []
expression = measure.expression.expression
if combination:
for key, index in combination.iteritems():
dimension = columns[key]
value = distincts[key][index]
name.append(dimension.name + ' ' + value)
internal_names.append(
dimension.internal_name + '_' + unaccent(value))
# Zero will always be the '(all)' entry added above
if index > 0:
expression = ('CASE WHEN "%s" = \'%s\' THEN "%s"'
'END') % (dimension.internal_name,
_replace(value), measure.internal_name)
else:
expression = "%s" % (measure.internal_name)
name.append(measure.name)
internal_names.append(measure.internal_name)
name = '/'.join(name)
# PSQL default column name max characters
if ((len(internal_names) > 1)
and (len('_'.join(internal_names)) > BABI_MAX_BD_COLUMN)):
measure_len = len(measure.internal_name)
max_len = BABI_MAX_BD_COLUMN - measure_len
combination_name = internal_names.pop(0)[:max_len]
internal_names.insert(0, combination_name)
to_create.append({
'execution': self.id,
'measure': measure.id,
'sequence': sequence,
'name': name,
'internal_name': '_'.join(internal_names),
'aggregate': measure.aggregate,
'expression': expression,
'ttype': measure.expression.ttype,
'related_model': related_model_id,
})
if to_create:
InternalMeasure.create(to_create)
def update_measures(self, checker):
# Mapping from types to their null values
types_null = defaultdict(int)
types_null['bool'] = False
types_null['char'] = "''"
def query_inserts(table_name, measures, select_group, group,
extra=None):
"""Inserts a group record"""
transaction = Transaction()
cursor = transaction.connection.cursor()
babi_group = ""
if group:
babi_group = ",MAX('%s') as babi_group" % group
local_measures = measures + babi_group
if extra_data:
local_measures += ", %s" % extra_data
select_query = "SELECT %s FROM %s where babi_group IS NULL" % (
local_measures, table_name)
if select_group:
select_query += " GROUP BY %s" % select_group
if extra_data:
select_query += ", %s" % extra_data
fields = []
for measure in local_measures.split(','):
if ' as ' in measure:
measure = measure.split(' as ')[-1]
measure = measure.replace('"', '').strip()
fields.append(unaccent(measure))
query = "INSERT INTO %s(%s)" % (table_name, ','.join(fields))
if not transaction.database.has_returning():
previous_id = 0
cursor.execute('SELECT MAX(id) FROM %s' % table_name)
row = cursor.fetchone()
if row:
previous_id = row[0] or 0
query += select_query
cursor.execute(query)
cursor.execute('SELECT id from %s WHERE id > %s ' % (
table_name, previous_id))
else:
query += " %s RETURNING id" % select_query
cursor.execute(query)
return [x[0] for x in cursor.fetchall()]
def update_parent(table_name, parent_id, group, group_by,
group_by_types):
sql_query = []
for group_item in group_by:
values = {
'item': group_item,
'def': types_null[group_by_types[group_item]],
'table': table_name,
'parent_id': parent_id,
}
# Values should be coalesce to avoid parent errors when null
group_query = ('Coalesce("%(item)s", %(def)s)=(select '
'Coalesce("%(item)s", %(def)s) from %(table)s '
'where id = %(parent_id)d)') % values
sql_query.append(group_query)
sql_query = u' AND '.join(sql_query)
sql_query[:-5]
query = """
UPDATE """ + table_name + """ set parent=%s
WHERE
parent IS NULL AND
id != %s AND
babi_group = '%s'
""" % (parent_id, parent_id, group)
if sql_query:
query += 'AND %s' % sql_query
cursor.execute(query)
pool = Pool()
BIModel = pool.get(self.babi_model.model)
if not self.internal_measures:
return
group_by_types = dict([(x.internal_name, x.expression.ttype)
for x in self.report.dimensions if x.group_by])
group_by = [x.internal_name for x in self.report.dimensions
if x.group_by]
extra_data = ",".join([x.internal_name for x in self.report.dimensions
if not x.group_by])
table_name = Pool().get(self.babi_model.model)._table
cursor = Transaction().connection.cursor()
group_by_iterator = group_by[:]
aggregate = None
current_group = None
while group_by_iterator:
checker.check()
group = ['"%s"' % x for x in group_by_iterator]
measures = ['%s("%s") as %s' % (
x.aggregate == 'count' and aggregate or x.aggregate,
x.internal_name,
x.internal_name,
) for x in self.internal_measures] + group
measures = ','.join(measures)
group = ','.join(group)
logger.info('SELECT table_name %s, measures %s, groups %s' % (
table_name, measures, group))
child_group = current_group
current_group = group_by[len(group_by_iterator) - 1]
parent_ids = query_inserts(table_name, measures, group,
current_group, extra_data)
if group_by != group_by_iterator:
for parent_id in parent_ids:
update_parent(table_name, parent_id, child_group,
group_by_iterator, group_by_types)
child_group = current_group
group_by_iterator.pop()
extra_data = None
# ROOT
measures = ",".join(['%s("%s") as %s' % (
x.aggregate == 'count' and aggregate or x.aggregate,
x.internal_name, x.internal_name) for x in
self.internal_measures])
group = None
parent_id = query_inserts(table_name, measures, None, None)[0]
# TODO: Translate '(all)'
if group_by_types[group_by[0]] != 'many2one':
cursor.execute("UPDATE " + table_name + " SET \"" + group_by[0] +
"\"='" + '(all)' + "' WHERE id=%s" % parent_id)
update_parent(table_name, parent_id, child_group, group_by_iterator,
group_by_types)
delete = 'DELETE FROM %s WHERE babi_group IS NULL' % (table_name)
cursor.execute(delete + ' and id != %s ' % parent_id)
# Update parent_left, parent_right
BIModel._rebuild_tree('parent', None, 0)
class OpenExecutionSelect(ModelView):
"Open Report Execution - Select Values"
__name__ = 'babi.report.execution.open.select'
# TODO: Add domain for validating report permisions
report = fields.Many2One('babi.report', 'Report', required=True,
states={
'readonly': Bool(Eval('report_readonly')),
}, depends=['report_readonly'])
execution = fields.Many2One('babi.report.execution', 'Execution',
required=True, domain=[
('report', '=', Eval('report')),
('state', '=', 'calculated'),
],
states={
'readonly': Bool(Eval('execution_readonly')),
}, depends=['report', 'execution_readonly'])
view_type = fields.Selection([
('tree', 'Tree'),
('list', 'List'),
], 'View type', required=True)
report_readonly = fields.Boolean('Report Readonly')
execution_readonly = fields.Boolean('Execution Readonly')
@classmethod
def view_attributes(cls):
return super(OpenExecutionSelect, cls).view_attributes() + [(
'/form/group[@id="labels"]', 'states',
{'invisible': Eval('graph_type') != 'report'})]
@classmethod
def default_get(cls, fields, with_rec_name=True):
pool = Pool()
Execution = pool.get('babi.report.execution')
Menu = pool.get('ir.ui.menu')
result = super(OpenExecutionSelect, cls).default_get(fields,
with_rec_name)
active_id = Transaction().context.get('active_id')
model_name = Transaction().context.get('active_model')
if model_name == 'babi.report.execution':
execution = Execution(active_id)
result.update({
'execution': execution.id,
'report': execution.report.id,
'view_type': 'tree',
'report_readonly': True,
'execution_readonly': True,
})
elif model_name == 'ir.ui.menu':
menu = Menu(active_id)
result.update({
'report': menu.babi_report.id,
'view_type': 'tree',
'report_readonly': True,
})
if menu.babi_type == 'filtered':
result.update({
'execution_readonly': True,
})
return result
@depends('report')
def on_change_report(self):
if not self.report:
self.execution = None
class OpenExecutionFiltered(StateView):
def __init__(self):
buttons = [
Button('Cancel', 'end', 'tryton-cancel'),
Button('Open', 'create_execution', 'tryton-ok', True),
]
super(OpenExecutionFiltered, self).__init__('babi.report', 0, buttons)
def get_view(self, wizard, state_name):
pool = Pool()
Menu = pool.get('ir.ui.menu')
Report = pool.get('babi.report')
Execution = pool.get('babi.report.execution')
Parameter = pool.get('babi.filter.parameter')
context = Transaction().context
model = context.get('active_model')
execution_definitions = Execution.fields_get(fields_names=[
'report', 'report_model'])
report_definition = execution_definitions['report']
report_definition['required'] = True
result = {}
result['type'] = 'form'
result['view_id'] = None
result['model'] = 'babi.report.execution'
result['field_childs'] = None
fields = {}
parameter2report = {}
if model == 'ir.ui.menu':
menu = Menu(context.get('active_id'))
filter = menu.babi_report.filter
report_definition['readonly'] = True
parameters = Parameter.search([('filter', '=', filter)])
else:
# TODO: Report definition add domain for groups
parameters = Parameter.search([
('related_model.model', '=',
context.get('active_model'))],
)
report_definition['readonly'] = False
reports = Report.search([('filter', 'in',
[p.filter for p in parameters])])
for report in reports:
key = report.filter.id
if key in parameter2report:
parameter2report[key].append(report.id)
else:
parameter2report[key] = [report.id]
report_definition['domain'] = ['id', 'in', [r.id for r in reports]]
parameters_to_remove = []
for parameter in parameters:
if not parameter.check_parameter_in_filter():
parameters_to_remove.append(parameter)
for parameter in parameters_to_remove:
parameters.remove(parameter)
xml = '\n'
result['arch'] = xml
result['fields'] = fields
return result
def get_defaults(self, wizard, state_name, fields):
pool = Pool()
Menu = pool.get('ir.ui.menu')
Parameter = pool.get('babi.filter.parameter')
context = Transaction().context
model = context.get('active_model')
defaults = {}
if model == 'ir.ui.menu':
menu = Menu(context.get('active_id'))
defaults['report'] = menu.babi_report.id
else:
parameters = Parameter.search([
('related_model.model', '=', model)]
)
for parameter in parameters:
name = '%s_%d' % (parameter.name, parameter.id)
defaults[name] = context.get('active_id')
return defaults
class CustomDict(dict):
def __getattr__(self, name):
return {}
def __setattr__(self, name, value):
self[name] = value
class UpdateDataWizardStart(ModelView):
"Update Data Wizard Start"
__name__ = 'babi.update_data.wizard.start'
class UpdateDataWizardUpdated(ModelView):
"Update Data Wizard Done"
__name__ = 'babi.update_data.wizard.done'
class OpenExecution(Wizard):
'Open Report Execution'
__name__ = 'babi.report.execution.open'
start = StateTransition()
update_start = StateView('babi.update_data.wizard.start',
'babi.update_data_wizard_start_form_view', [
Button('Cancel', 'end', 'tryton-cancel'),
Button('Ok', 'update', 'tryton-ok', default=True),
])
filtered = OpenExecutionFiltered()
create_execution = StateTransition()
select = StateView('babi.report.execution.open.select',
'babi.open_execution_select_view_form', [
Button('Cancel', 'end', 'tryton-cancel'),
Button('Open', 'open_view', 'tryton-ok', True),
])
open_view = StateAction('babi.open_execution_wizard')
update = StateTransition()
update_done = StateView('babi.update_data.wizard.done',
'babi.update_data_wizard_done_form_view', [
Button('Ok', 'end', 'tryton-ok', default=True),
])
@classmethod
def __setup__(cls):
super(OpenExecution, cls).__setup__()
cls._error_messages.update({
'no_menus': ('No menus found for report %s. In order to view '
'it\'s data you must create menu entries.'),
'no_report': ('No report found for current execution'),
'no_execution': ('No execution found for current record. '
'Execute the update data wizard in order to create one.'),
})
def __getattribute__(self, name):
if name == 'filtered':
if not hasattr(self, 'filter_values'):
self.filter_values = CustomDict()
name = 'filter_values'
return super(OpenExecution, self).__getattribute__(name)
def transition_start(self):
pool = Pool()
Menu = pool.get('ir.ui.menu')
context = Transaction().context
model_name = context.get('active_model')
if model_name == 'babi.report.execution':
return 'select'
elif model_name == 'ir.ui.menu':
menu = Menu(context.get('active_id'))
if menu.babi_report.filter and \
len(menu.babi_report.filter.parameters) > 0:
return 'filtered'
if menu.babi_type == 'history':
return 'select'
if menu.babi_type == 'wizard':
return 'update_start'
return 'open_view'
else:
return 'filtered'
def transition_create_execution(self):
pool = Pool()
Report = pool.get('babi.report')
Execution = pool.get('babi.report.execution')
report = self.filter_values.pop('report', None)
if not report:
self.raise_user_error('no_report_found')
data = {}
for key, value in self.filter_values.iteritems():
# Fields has id of the field appendend, so it must be removed.
new_key = '_'.join(key.split('_')[:-1])
data[new_key] = value
report = Report(report)
execution = report.get_execution_data()
data = json.dumps(self.filter_values, cls=JSONEncoder)
execution['filter_values'] = data
execution['filtered'] = True
execution, = Execution.create([execution])
Transaction().commit()
Execution.calculate([execution])
context = Transaction().context
context.update({
'filtered_execution': execution.id,
})
return 'open_view'
def transition_update(self):
pool = Pool()
Menu = pool.get('ir.ui.menu')
Report = pool.get('babi.report')
menu = Menu(Transaction().context['active_id'])
Report.calculate([menu.babi_report])
return 'update_done'
def do_open_view(self, action):
pool = Pool()
Action = pool.get('ir.action')
ActionWindow = pool.get('ir.action.act_window')
Menu = pool.get('ir.ui.menu')
Execution = pool.get('babi.report.execution')
transaction = Transaction()
context = transaction.context
model_name = context.get('active_model')
if model_name == 'ir.ui.menu':
menu = Menu(context.get('active_id'))
if menu.babi_type == 'history':
report = self.select.report
execution = self.select.execution
view_type = self.select.view_type
else:
report = menu.babi_report
if 'filtered_execution' in context:
execution = Execution(context.get('filtered_execution'))
else:
execution = report.last_execution
view_type = menu.babi_type
else:
report = self.select.report
execution = self.select.execution
view_type = self.select.view_type
if not execution:
self.raise_user_error('no_execution', report.rec_name)
with transaction.set_context(_datetime=execution.date):
execution.validate_model()
domain = [
('babi_report', '=', report.id),
]
if view_type == 'tree':
domain.append(('context', 'ilike', "%%babi_tree_view%%"))
else:
domain.append(('context', 'not ilike', "%%babi_tree_view%%"))
try:
action, = ActionWindow.search(domain, limit=1)
action = Action.get_action_values(action.type, [action.id])[0]
except ValueError:
self.raise_user_error('no_menus', report.rec_name)
action['res_model'] = execution.babi_model.model
action['name'] = execution.rec_name
action['context_model'] = None
return action, {}
class ReportGroup(ModelSQL):
"Report - Group"
__name__ = 'babi.report-res.group'
report = fields.Many2One('babi.report', 'Report', required=True,
ondelete='CASCADE')
group = fields.Many2One('res.group', 'Group', required=True)
@classmethod
def __setup__(cls):
super(ReportGroup, cls).__setup__()
t = cls.__table__()
cls._sql_constraints += [
('report_group_uniq', Unique(t, t.report, t.group),
'Report and Group must be unique.'),
]
class DimensionMixin:
report = fields.Many2One('babi.report', 'Report', required=True,
ondelete='CASCADE')
sequence = fields.Integer('Sequence')
name = fields.Char('Name', required=True, translate=True)
internal_name = fields.Function(fields.Char('Internal Name'),
'get_internal_name')
expression = fields.Many2One('babi.expression', 'Expression',
required=True, domain=[
('model', '=', Eval('_parent_report', {}).get('model', 0)),
])
group_by = fields.Boolean('Group By This Dimension')
width = fields.Integer('Width',
help='Width report columns (%)')
def get_internal_name(self, name):
return 'babi_dimension_%d' % self.id
@staticmethod
def order_sequence(tables):
table, _ = tables[None]
return [table.sequence == Null, table.sequence]
@staticmethod
def default_group_by():
return True
@depends('expression')
def on_change_with_name(self):
return self.expression.name if self.expression else None
def get_dimension_data(self):
return {
'name': self.name,
'internal_name': self.internal_name,
'expression': self.expression.expression,
'ttype': self.expression.ttype,
'related_model': (self.expression.related_model
and self.expression.related_model.model),
}
class Dimension(ModelSQL, ModelView, DimensionMixin):
"Dimension"
__name__ = 'babi.dimension'
_history = True
@classmethod
def __setup__(cls):
super(Dimension, cls).__setup__()
t = cls.__table__()
cls._order.insert(0, ('sequence', 'ASC'))
cls._sql_constraints += [
('report_and_name_unique', Unique(t, t.report, t.name),
'Dimension name must be unique per report.'),
]
@classmethod
def update_order(cls, dimensions):
Order = Pool().get('babi.order')
cursor = Transaction().connection.cursor()
dimension_ids = [x.id for x in dimensions if x.group_by]
orders = Order.search([
('dimension', 'in', dimension_ids),
])
existing = [x.dimension.id for x in orders]
missing = set(dimension_ids) - set(existing)
to_create = []
for dimension in cls.browse(list(missing)):
cursor.execute('SELECT MAX(sequence) FROM babi_order WHERE '
'report=%s' % dimension.report.id)
sequence = cursor.fetchone()[0] or 0
to_create.append({
'report': dimension.report.id,
'sequence': sequence + 10,
'dimension': dimension.id,
})
with Transaction().set_context({'babi_order_force': True}):
Order.create(to_create)
@classmethod
def create(cls, values):
dimensions = super(Dimension, cls).create(values)
cls.update_order(dimensions)
return dimensions
@classmethod
def write(cls, *args):
actions = iter(args)
to_update = []
for dimensions, _ in zip(actions, actions):
to_update += dimensions
cls.update_order(to_update)
return super(Dimension, cls).write(*args)
@classmethod
def delete(cls, dimensions):
Order = Pool().get('babi.order')
orders = Order.search([
('dimension', 'in', [x.id for x in dimensions]),
])
if orders:
with Transaction().set_context({'babi_order_force': True}):
Order.delete(orders)
return super(Dimension, cls).delete(dimensions)
class DimensionColumn(ModelSQL, ModelView, DimensionMixin):
"Column Dimension"
__name__ = 'babi.dimension.column'
_history = True
@classmethod
def __setup__(cls):
super(DimensionColumn, cls).__setup__()
cls._order.insert(0, ('sequence', 'ASC'))
def get_internal_name(self, name):
return 'babi_dimension_column_%d' % self.id
class Measure(ModelSQL, ModelView):
"Measure"
__name__ = 'babi.measure'
_history = True
report = fields.Many2One('babi.report', 'Report', required=True,
ondelete='CASCADE')
sequence = fields.Integer('Sequence')
name = fields.Char('Name', required=True, translate=True)
internal_name = fields.Function(fields.Char('Internal Name'),
'get_internal_name')
expression = fields.Many2One('babi.expression', 'Expression',
required=True, domain=[
('model', '=', Eval('_parent_report', {}).get('model', 0)),
])
aggregate = fields.Selection(AGGREGATE_TYPES, 'Aggregate', required=True)
internal_measures = fields.One2Many('babi.internal.measure',
'measure', 'Internal Measures')
width = fields.Integer('Width',
help='Width report columns (%)')
@classmethod
def __setup__(cls):
super(Measure, cls).__setup__()
t = cls.__table__()
cls._order.insert(0, ('sequence', 'ASC'))
cls._sql_constraints += [
('report_and_name_unique', Unique(t, t.report, t.name),
'Measure name must be unique per report.'),
]
@staticmethod
def order_sequence(tables):
table, _ = tables[None]
return [table.sequence == Null, table.sequence]
@staticmethod
def default_aggregate():
return 'sum'
@depends('expression')
def on_change_with_name(self):
return self.expression.name if self.expression else None
def get_internal_name(self, name):
return 'babi_measure_%d' % (self.id)
def get_measure_data(self):
return {
'name': self.name,
'internal_name': self.internal_name,
'expression': self.expression,
'ttype': self.ttype,
'related_model': (self.related_model and
self.related_model.model),
}
@classmethod
def update_order(cls, measures):
Order = Pool().get('babi.order')
cursor = Transaction().connection.cursor()
measure_ids = [x.id for x in measures]
orders = Order.search([
('measure', 'in', measure_ids),
])
existing_ids = [x.measure.id for x in orders]
missing_ids = set(measure_ids) - set(existing_ids)
to_create = []
for measure in cls.browse(list(missing_ids)):
cursor.execute('SELECT MAX(sequence) FROM babi_order WHERE '
'report=%s' % measure.report.id)
sequence = cursor.fetchone()[0] or 0
to_create.append({
'report': measure.report.id,
'sequence': sequence + 1,
'measure': measure.id,
})
with Transaction().set_context({'babi_order_force': True}):
Order.create(to_create)
@classmethod
def create(cls, values):
measures = super(Measure, cls).create(values)
cls.update_order(measures)
return measures
@classmethod
def write(cls, *args):
actions = iter(args)
to_update = []
for measures, _ in zip(actions, actions):
to_update += measures
cls.update_order(to_update)
return super(Measure, cls).write(*args)
@classmethod
def delete(cls, measures):
Order = Pool().get('babi.order')
to_remove = []
for measure in measures:
orders = Order.search([
('measure', '=', measure.id),
])
to_remove += orders
if to_remove:
with Transaction().set_context({'babi_order_force': True}):
Order.delete(to_remove)
return super(Measure, cls).delete(measures)
class InternalMeasure(ModelSQL, ModelView):
"Internal Measure"
__name__ = 'babi.internal.measure'
execution = fields.Many2One('babi.report.execution', 'Report Execution',
required=True, ondelete='CASCADE')
measure = fields.Many2One('babi.measure', 'Measure', required=True,
ondelete='CASCADE')
sequence = fields.Integer('Sequence', required=True)
name = fields.Char('Name', required=True)
internal_name = fields.Char('Internal Name', required=True)
expression = fields.Char('Expression')
aggregate = fields.Selection(AGGREGATE_TYPES, 'Aggregate', required=True)
ttype = fields.Selection(FIELD_TYPES, 'Field Type',
required=True)
related_model = fields.Many2One('ir.model', 'Related Model')
@classmethod
def __setup__(cls):
super(InternalMeasure, cls).__setup__()
cls._order.insert(0, ('sequence', 'ASC'))
@classmethod
def __register__(cls, module_name):
TableHandler = backend.get('TableHandler')
super(InternalMeasure, cls).__register__(module_name)
cursor = Transaction().connection.cursor()
sql_table = cls.__table__()
# Migration from 3.0: no more relation with reports.
table = TableHandler(cls, module_name)
if table.column_exist('report'):
table.not_null_action('report', action='remove')
# Migration from int to integer
cursor.execute(*sql_table.update([Column(sql_table, 'ttype')],
['integer'], where=sql_table.ttype == 'int'))
# Migration from bool to boolean
cursor.execute(*sql_table.update([Column(sql_table, 'ttype')],
['boolean'], where=sql_table.ttype == 'bool'))
def get_measure_data(self):
return {
'name': self.name,
'internal_name': self.internal_name,
'expression': self.expression,
'ttype': self.ttype,
'related_model': (self.related_model and
self.related_model.model),
}
class Order(ModelSQL, ModelView, sequence_ordered()):
"Order"
__name__ = 'babi.order'
_history = True
report = fields.Many2One('babi.report', 'Report', required=True,
ondelete='CASCADE')
dimension = fields.Many2One('babi.dimension', 'Dimension', readonly=True)
measure = fields.Many2One('babi.measure', 'Measure', readonly=True)
order = fields.Selection([
('ASC', 'Ascending'),
('DESC', 'Descending'),
], 'Order', required=True)
@staticmethod
def default_order():
return 'ASC'
@classmethod
def __setup__(cls):
super(Order, cls).__setup__()
t = cls.__table__()
cls._error_messages.update({
'cannot_create_order_entry': ('Order entries are created '
'automatically'),
'cannot_remove_order_entry': ('Order entries are deleted '
'automatically'),
})
cls._sql_constraints += [
('report_and_dimension_unique', Unique(t, t.report, t.dimension),
'Dimension must be unique per report.'),
('report_and_measure_unique', Unique(t, t.report, t.measure),
'Measure must be unique per report.'),
('dimension_or_measure', Check(t, Or((
(t.dimension == Null) & (t.measure != Null),
(t.dimension != Null) & (t.measure == Null)
))),
'Only dimension or measure can be set.'),
]
@classmethod
def create(cls, values):
if not Transaction().context.get('babi_order_force'):
cls.raise_user_error('cannot_create_order_entry')
return super(Order, cls).create(values)
@classmethod
def delete(cls, orders):
if not Transaction().context.get('babi_order_force'):
cls.raise_user_error('cannot_remove_order_entry')
return super(Order, cls).delete(orders)
class ActWindow:
__metaclass__ = PoolMeta
__name__ = 'ir.action.act_window'
babi_report = fields.Many2One('babi.report', 'BABI Report')
class Menu:
__metaclass__ = PoolMeta
__name__ = 'ir.ui.menu'
babi_report = fields.Many2One('babi.report', 'BABI Report')
babi_type = fields.Selection([
(None, ''),
('tree', 'Tree'),
('list', 'List'),
('history', 'History'),
('wizard', 'Wizard'),
], 'BABI Type', readonly=True)
class Keyword:
__metaclass__ = PoolMeta
__name__ = 'ir.action.keyword'
babi_report = fields.Many2One('babi.report', 'BABI Report')
babi_filter_parameter = fields.Many2One('babi.filter.parameter',
'BABI Filter Parameter')
class Model:
__metaclass__ = PoolMeta
__name__ = 'ir.model'
babi_enabled = fields.Boolean('BI Enabled', help='Check if you want '
'this model to be available in Business Intelligence reports.')
class OpenChartStart(ModelView):
"Open Chart Start"
__name__ = 'babi.open_chart.start'
graph_type = fields.Selection([
('vbar', 'Vertical Bars'),
('hbar', 'Horizontal Bars'),
('line', 'Line'),
('pie', 'Pie'),
('report', 'Report'),
], 'Graph', required=True, sort=False)
interpolation = fields.Selection([
('linear', 'Linear'),
('constant-center', 'Constant Center'),
('constant-left', 'Constant Left'),
('constant-right', 'Constant Right'),
], 'Interpolation',
states={
'required': Eval('graph_type') == 'line',
'invisible': Eval('graph_type').in_(['line', 'report']),
}, depends=['graph_type'], sort=False)
show_legend = fields.Boolean('Show Legend',
states={
'invisible': (Eval('graph_type') == 'report'),
}, depends=['graph_type'])
report = fields.Many2One('babi.report', 'Report',
states={
'invisible': (Eval('graph_type') == 'report'),
}, depends=['graph_type'])
execution = fields.Many2One('babi.report.execution', 'Execution',
states={
'invisible': (Eval('graph_type') == 'report'),
}, depends=['graph_type'])
execution_date = fields.DateTime('Execution Time',
states={
'invisible': (Eval('graph_type') == 'report'),
}, depends=['graph_type'])
dimension = fields.Many2One('babi.dimension', 'Dimension',
domain=[
('report', '=', Eval('report')),
],
context={
'_datetime': Eval('execution_date'),
},
states={
'required': Eval('graph_type') == 'line',
'invisible': Eval('graph_type').in_(['line', 'report']),
}, depends=['report', 'execution_date', 'graph_type'])
measures = fields.Many2Many('babi.internal.measure', None, None,
'Measures', required=True,
domain=[
('execution', '=', Eval('execution')),
],
states={
'invisible': (Eval('graph_type') == 'report'),
},
depends=['execution', 'graph_type'])
@classmethod
def default_get(cls, fields, with_rec_name=True):
pool = Pool()
Execution = pool.get('babi.report.execution')
model_name = Transaction().context.get('active_model')
executions = Execution.search([
('babi_model.model', '=', model_name),
], limit=1)
result = super(OpenChartStart, cls).default_get(fields, with_rec_name)
if len(executions) != 1:
return result
execution, = executions
report = execution.report
Model = pool.get(model_name)
active_id, = Transaction().context.get('active_ids')
record = Model(active_id)
with Transaction().set_context(_datetime=execution.create_date):
fields = []
found = False
for x in report.dimensions:
if found:
fields.append(x.id)
continue
if x.internal_name == str(record.babi_group):
found = True
if not fields:
# If it was not found it means user clicked on 'root'
# babi_group
fields = [x.id for x in report.dimensions]
return {
'report': execution.report.id,
'execution': execution.id,
'execution_date': execution.date,
'model': execution.babi_model.id,
'dimension': fields[0] if fields else None,
'measures': [x.id for x in execution.internal_measures],
'graph_type': 'vbar',
'show_legend': True,
'interpolation': 'linear',
}
class EmptyStateAction(StateAction):
def __init__(self):
super(EmptyStateAction, self).__init__(None)
def get_action(self):
return {}
class OpenChart(Wizard):
"Open Chart"
__name__ = 'babi.open_chart'
start = StateView('babi.open_chart.start',
'babi.open_chart_start_form_view', [
Button('Cancel', 'end', 'tryton-cancel'),
Button('Print', 'print_', 'tryton-ok',
states={
'invisible': (Eval('graph_type') != 'report'),
},
),
Button('Open', 'open_', 'tryton-ok', default=True,
states={
'invisible': (Eval('graph_type') == 'report'),
},
),
])
open_ = EmptyStateAction()
print_ = StateReport('babi.report.execution')
@classmethod
def __setup__(cls):
super(OpenChart, cls).__setup__()
cls._error_messages.update({
'one_measure_in_pie_charts': ('Only one measure can be used '
'in pie charts.'),
})
def do_open_(self, action):
pool = Pool()
context = Transaction().context
model_name = context.get('active_model')
active_ids = context.get('active_ids')
Model = pool.get(model_name)
if len(self.start.measures) > 1 and self.start.graph_type == 'pie':
self.raise_user_error('one_measure_in_pie_charts')
group_name = self.start.dimension.internal_name
records = Model.search([
('babi_group', '=', group_name),
('parent', 'child_of', active_ids),
])
domain = [('id', 'in', [x.id for x in records])]
domain = json.dumps(domain)
context = {}
context['view_type'] = 'graph'
context['graph_type'] = self.start.graph_type
context['dimension'] = self.start.dimension.id
context['measures'] = [x.id for x in self.start.measures]
context['legend'] = self.start.show_legend
context['interpolation'] = self.start.interpolation
context['model_name'] = model_name
context = json.dumps(context)
action = {
'id': -1,
'name': '%s - %s Chart' % (self.start.execution.rec_name,
self.start.dimension.rec_name),
'model': model_name,
'res_model': model_name,
'type': 'ir.action.act_window',
'context_model': None,
'pyson_domain': domain,
'pyson_context': context,
'pyson_order': '[]',
'pyson_search_value': '[]',
'domains': [],
}
return action, {}
def do_print_(self, action):
context = Transaction().context
model_name = context.get('active_model')
active_ids = context.get('active_ids')
report = self.start.report
data = {
'model_name': model_name,
'report_name': report.name,
'records': active_ids,
'headers': [{d.internal_name: {
'name': d.name,
'width': d.width or '',
'text-align': 'right' if d.expression.ttype in [
'float', 'numeric'] else 'left',
}} for d in report.dimensions],
'cell_level': report.report_cell_level or 3,
}
if (self.start.graph_type == 'report'):
if self.start.measures:
data['headers'] += [{m.internal_name: {
'name': m.name,
'width': '',
'text-align': 'right',
}} for m in self.start.measures]
else:
data['headers'] += [{m.internal_name: {
'name': m.name,
'width': m.width or '',
'text-align': 'right' if m.expression.ttype in [
'float', 'numeric'] else 'left',
}} for m in report.measures]
return action, data
def transition_print_(self):
return 'end'
class CleanExecutionsStart(ModelView):
'Clean Execution Start'
__name__ = 'babi.clean_executions.start'
date = fields.Date('Date', required=True)
class CleanExecutions(Wizard):
'Clean Executions'
__name__ = 'babi.clean_executions'
start = StateView('babi.clean_executions.start',
'babi.clean_executions_start_form_view', [
Button('Cancel', 'end', 'tryton-cancel'),
Button('Ok', 'clean', 'tryton-ok', default=True),
])
clean = StateTransition()
def transition_clean(self):
pool = Pool()
Execution = pool.get('babi.report.execution')
Execution.clean(self.start.date)
return 'end'
class BabiHTMLReport(HTMLReport):
__name__ = 'babi.report.execution'
@classmethod
def prepare(cls, ids, data):
Model = Pool().get(data['model_name'])
records = []
parameters = {}
def get_childs(record):
childs = []
for r in Model.search([
# ('babi_group', '=', group_name),
('parent', '=', record.id),
]):
childs.append(get_childs(r))
return {
'record': record,
'childs': childs,
}
for record in Model.search([
('id', 'in', data['records']),
]):
records.append(get_childs(record))
return records, parameters
@classmethod
def execute(cls, ids, data):
context = Transaction().context
context['report_lang'] = Transaction().language
context['report_translations'] = os.path.join(
os.path.dirname(__file__), 'report', 'translations')
columns = []
for header in data['headers']:
columns += header.keys()
with Transaction().set_context(**context):
records, parameters = cls.prepare(ids, data)
return super(BabiHTMLReport, cls).execute(data['records'], {
'name': 'babi.report.execution',
'model': data['model_name'],
'headers': data['headers'],
'columns': columns,
'report_name': data['report_name'],
'records': records,
'parameters': parameters,
'output_format': 'pdf',
'report_options': {
'now': datetime.now(),
'cell_level': data['cell_level'],
}
})