540 lines
18 KiB
Python
540 lines
18 KiB
Python
# -*- coding: utf-8 -*-
|
|
# This file is part of the cashbook-module from m-ds for Tryton.
|
|
# The COPYRIGHT file at the top level of this repository contains the
|
|
# full copyright notices and license terms.
|
|
|
|
from sql.conditionals import Case
|
|
from trytond.model import ModelView, ModelSQL, fields, sequence_ordered
|
|
from trytond.pyson import Eval, Bool
|
|
from trytond.transaction import Transaction
|
|
from trytond.pool import Pool
|
|
from trytond.i18n import gettext
|
|
from trytond.exceptions import UserError
|
|
from .colors import sel_color as sel_bgcolor
|
|
from .templates import (
|
|
template_view_graph, template_view_line, cashbook_types,
|
|
category_types, booktype_types, currency_types)
|
|
|
|
|
|
sel_chart = [
|
|
('vbar', 'Vertical Bars'),
|
|
('hbar', 'Horizontal Bars'),
|
|
('pie', 'Pie'),
|
|
('line', 'Line'),
|
|
]
|
|
|
|
|
|
sel_maincolor = [
|
|
('default', 'Default'),
|
|
('red', 'Red'),
|
|
('green', 'Green'),
|
|
('grey', 'Grey'),
|
|
('black', 'Black'),
|
|
('darkcyan', 'Dark Cyan'),
|
|
]
|
|
|
|
|
|
class Evaluation(sequence_ordered(), ModelSQL, ModelView):
|
|
'Evaluation'
|
|
__name__ = 'cashbook_report.evaluation'
|
|
|
|
company = fields.Many2One(
|
|
string='Company', model_name='company.company',
|
|
required=True, ondelete="RESTRICT")
|
|
name = fields.Char(string='Name', required=True)
|
|
|
|
# max. 5x data tyypes to show
|
|
dtype1 = fields.Selection(
|
|
string='Data type 1', required=True, sort=True,
|
|
selection='get_sel_etype', help='Type of data displayed')
|
|
dtype1_string = dtype1.translated('dtype1')
|
|
dtype2 = fields.Selection(
|
|
string='Data type 2', sort=True,
|
|
selection='get_sel_etype2', help='Type of data displayed',
|
|
states={
|
|
'invisible': ~Bool(Eval('dtype1', '')),
|
|
}, depends=['dtype1'])
|
|
dtype2_string = dtype2.translated('dtype2')
|
|
dtype3 = fields.Selection(
|
|
string='Data type 3', sort=True,
|
|
selection='get_sel_etype2', help='Type of data displayed',
|
|
states={
|
|
'invisible': ~Bool(Eval('dtype2', '')),
|
|
}, depends=['dtype2'])
|
|
dtype3_string = dtype3.translated('dtype3')
|
|
dtype4 = fields.Selection(
|
|
string='Data type 4', sort=True,
|
|
selection='get_sel_etype2', help='Type of data displayed',
|
|
states={
|
|
'invisible': ~Bool(Eval('dtype3', '')),
|
|
}, depends=['dtype3'])
|
|
dtype4_string = dtype4.translated('dtype4')
|
|
dtype5 = fields.Selection(
|
|
string='Data type 5', sort=True,
|
|
selection='get_sel_etype2', help='Type of data displayed',
|
|
states={
|
|
'invisible': ~Bool(Eval('dtype4', '')),
|
|
}, depends=['dtype4'])
|
|
dtype5_string = dtype5.translated('dtype5')
|
|
|
|
chart = fields.Selection(
|
|
string='Chart type', required=True, sort=False,
|
|
selection=sel_chart, help='Type of graphical presentation.')
|
|
legend = fields.Boolean(string='Legend')
|
|
maincolor = fields.Selection(
|
|
string='Color scheme', required=True,
|
|
help='The color scheme determines the hue of all ' +
|
|
'components of the chart.', selection=sel_maincolor, sort=False)
|
|
bgcolor = fields.Selection(
|
|
string='Background Color', required=True,
|
|
help='Background color of the chart area.', sort=False,
|
|
selection=sel_bgcolor)
|
|
currency = fields.Many2One(
|
|
string='Currency', ondelete='RESTRICT',
|
|
model_name='currency.currency')
|
|
|
|
cashbooks = fields.Many2Many(
|
|
string='Cashbooks', relation_name='cashbook_report.eval_line',
|
|
origin='evaluation', target='cashbook',
|
|
states={'invisible': ~Eval('dtype1', '').in_(cashbook_types)},
|
|
depends=['dtype1'])
|
|
types = fields.Many2Many(
|
|
string='Types', relation_name='cashbook_report.eval_line',
|
|
origin='evaluation', target='dtype',
|
|
states={'invisible': ~Eval('dtype1', '').in_(booktype_types)},
|
|
depends=['dtype1'])
|
|
currencies = fields.Many2Many(
|
|
string='Currencies', relation_name='cashbook_report.eval_line',
|
|
origin='evaluation', target='currency',
|
|
filter=[('cashbook_hasbookings', '=', True)],
|
|
states={'invisible': Eval('dtype1', '') != 'currencies'},
|
|
depends=['dtype1'])
|
|
categories = fields.Many2Many(
|
|
string='Categories', relation_name='cashbook_report.eval_line',
|
|
origin='evaluation', target='category',
|
|
states={'invisible': ~Eval('dtype1', '').in_(category_types)},
|
|
depends=['dtype1'])
|
|
|
|
line_values = fields.One2Many(
|
|
string='Line Values', field='evaluation', readonly=True,
|
|
model_name='cashbook_report.eval_line')
|
|
|
|
ui_view_chart = fields.Many2One(
|
|
string='UI View Chart', model_name='ir.ui.view', ondelete='SET NULL')
|
|
dashb_actwin = fields.Many2One(
|
|
string='Dashboard Window', model_name='ir.action.act_window',
|
|
ondelete='SET NULL')
|
|
dashb_actview = fields.Many2One(
|
|
string='Dashboard View', model_name='ir.action.act_window.view',
|
|
ondelete='SET NULL')
|
|
|
|
@classmethod
|
|
def __register__(cls, module_name):
|
|
super(Evaluation, cls).__register__(module_name)
|
|
|
|
table = cls.__table_handler__(module_name)
|
|
tav_eval = cls.__table__()
|
|
cursor = Transaction().connection.cursor()
|
|
|
|
# x.0.9 --> x.0.10
|
|
if table.column_exist('dtype'):
|
|
query = tav_eval.update(
|
|
columns=[tav_eval.dtype1],
|
|
values=[Case(
|
|
(tav_eval.dtype == 'category_gldiff',
|
|
'categories_gldiff'),
|
|
(tav_eval.dtype == 'category_glvalue',
|
|
'categories_glvalue'),
|
|
(tav_eval.dtype == 'category_glperc',
|
|
'categories_glperc'),
|
|
(tav_eval.dtype == 'category_glyield',
|
|
'categories_glyield'),
|
|
else_=tav_eval.dtype)
|
|
])
|
|
cursor.execute(*query)
|
|
table.drop_column('dtype')
|
|
|
|
@classmethod
|
|
def default_currency(cls):
|
|
""" currency of company
|
|
"""
|
|
Company = Pool().get('company.company')
|
|
|
|
company = cls.default_company()
|
|
if company:
|
|
company = Company(company)
|
|
if company.currency:
|
|
return company.currency.id
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company') or None
|
|
|
|
@classmethod
|
|
def default_bgcolor(cls):
|
|
""" default: Yellow 5
|
|
"""
|
|
return '#ffffc0'
|
|
|
|
@classmethod
|
|
def default_maincolor(cls):
|
|
""" default: 'default'
|
|
"""
|
|
return 'default'
|
|
|
|
@classmethod
|
|
def default_legend(cls):
|
|
""" default True
|
|
"""
|
|
return True
|
|
|
|
@classmethod
|
|
def default_dtype1(cls):
|
|
""" default 'book'
|
|
"""
|
|
return 'cashbooks'
|
|
|
|
@classmethod
|
|
def default_dtype2(cls):
|
|
""" default None
|
|
"""
|
|
return None
|
|
|
|
@classmethod
|
|
def default_dtype3(cls):
|
|
""" default None
|
|
"""
|
|
return None
|
|
|
|
@classmethod
|
|
def default_dtype4(cls):
|
|
""" default None
|
|
"""
|
|
return None
|
|
|
|
@classmethod
|
|
def default_dtype5(cls):
|
|
""" default None
|
|
"""
|
|
return None
|
|
|
|
@fields.depends('dtype1', 'dtype2', 'dtype3', 'dtype4', 'dtype5')
|
|
def on_change_dtype1(self):
|
|
""" update other dtype-fields
|
|
"""
|
|
self.get_onchange_dtypes()
|
|
|
|
@fields.depends('dtype1', 'dtype2', 'dtype3', 'dtype4', 'dtype5')
|
|
def on_change_dtype2(self):
|
|
""" update other dtype-fields
|
|
"""
|
|
self.get_onchange_dtypes()
|
|
|
|
@fields.depends('dtype1', 'dtype2', 'dtype3', 'dtype4', 'dtype5')
|
|
def on_change_dtype3(self):
|
|
""" update other dtype-fields
|
|
"""
|
|
self.get_onchange_dtypes()
|
|
|
|
@fields.depends('dtype1', 'dtype2', 'dtype3', 'dtype4', 'dtype5')
|
|
def on_change_dtype4(self):
|
|
""" update other dtype-fields
|
|
"""
|
|
self.get_onchange_dtypes()
|
|
|
|
@fields.depends('dtype1', 'dtype2', 'dtype3', 'dtype4', 'dtype5')
|
|
def on_change_dtype5(self):
|
|
""" update other dtype-fields
|
|
"""
|
|
self.get_onchange_dtypes()
|
|
|
|
def get_onchange_dtypes(self):
|
|
""" update other dtype-fields
|
|
"""
|
|
dtypes = [x[0] for x in self.get_sel_etype2()]
|
|
|
|
if not self.dtype1:
|
|
self.dtype2 = None
|
|
|
|
if self.dtype2 and (self.dtype2 not in dtypes):
|
|
self.dtype2 = None
|
|
|
|
if not self.dtype2:
|
|
self.dtype3 = None
|
|
|
|
if self.dtype3 and (self.dtype3 not in dtypes):
|
|
self.dtype3 = None
|
|
|
|
if not self.dtype3:
|
|
self.dtype4 = None
|
|
|
|
if self.dtype4 and (self.dtype4 not in dtypes):
|
|
self.dtype4 = None
|
|
|
|
if not self.dtype4:
|
|
self.dtype5 = None
|
|
|
|
if self.dtype5 and (self.dtype5 not in dtypes):
|
|
self.dtype5 = None
|
|
|
|
@classmethod
|
|
def default_chart(cls):
|
|
""" default 'pie'
|
|
"""
|
|
return 'pie'
|
|
|
|
@classmethod
|
|
def get_sel_etype(cls):
|
|
""" get list of evaluation-types
|
|
"""
|
|
result = [('', '-/-')]
|
|
result.extend([
|
|
(x, gettext('cashbook_report.msg_dtype_%s' % x))
|
|
for x in ['cashbooks', 'types', 'currencies', 'categories']])
|
|
return result
|
|
|
|
@fields.depends('dtype1')
|
|
def get_sel_etype2(self):
|
|
""" get list of allowed evaluation-types for dtype2
|
|
"""
|
|
Eval2 = Pool().get('cashbook_report.evaluation')
|
|
|
|
result = [('', '-/-')]
|
|
|
|
dtype1 = getattr(self, 'dtype1', None)
|
|
if not dtype1:
|
|
return result
|
|
|
|
dtype = dtype1.split('_')[0]
|
|
result.extend([
|
|
x
|
|
for x in Eval2.get_sel_etype()
|
|
if x[0].startswith(dtype)])
|
|
return result
|
|
|
|
@classmethod
|
|
def get_create_view_data(cls, evaluation):
|
|
""" generate dictionary to create view-xml
|
|
"""
|
|
dtypes = [{
|
|
'name': getattr(evaluation, 'dtype%d_string' % x),
|
|
'fname': 'value%d' % x}
|
|
for x in range(1, 6)
|
|
if getattr(evaluation, 'dtype%d' % x, None) is not None]
|
|
|
|
result = {
|
|
'model': 'cashbook_report.eval_line',
|
|
'module': 'cashbook_report',
|
|
'priority': 10,
|
|
'type': 'graph',
|
|
'data': template_view_graph % {
|
|
'bgcol': '' if evaluation.bgcolor == 'default'
|
|
else 'background="%s"' % evaluation.bgcolor,
|
|
'legend': '1' if evaluation.legend is True else '0',
|
|
'type': evaluation.chart,
|
|
'colscheme': '' if evaluation.maincolor == 'default'
|
|
else 'color="%s"' % evaluation.maincolor,
|
|
'lines': '\n'.join([
|
|
template_view_line % {
|
|
'fill': '1',
|
|
'fname': x['fname'],
|
|
'string': x['name']}
|
|
for x in dtypes])}}
|
|
return result
|
|
|
|
@classmethod
|
|
def uiview_delete(cls, evaluations):
|
|
""" delete action view from evalualtion
|
|
"""
|
|
pool = Pool()
|
|
UiView = pool.get('ir.ui.view')
|
|
ActWin = pool.get('ir.action.act_window')
|
|
|
|
to_delete_uiview = []
|
|
to_delete_window = []
|
|
for evaluation in evaluations:
|
|
if evaluation.ui_view_chart:
|
|
to_delete_uiview.append(evaluation.ui_view_chart)
|
|
if evaluation.dashb_actwin:
|
|
to_delete_window.append(evaluation.dashb_actwin)
|
|
|
|
with Transaction().set_context({
|
|
'_check_access': False}):
|
|
if len(to_delete_uiview) > 0:
|
|
UiView.delete(to_delete_uiview)
|
|
if len(to_delete_window) > 0:
|
|
ActWin.delete(to_delete_window)
|
|
|
|
@classmethod
|
|
def uiview_create(cls, evaluations):
|
|
""" create ui view for current setup of evaluation
|
|
"""
|
|
pool = Pool()
|
|
UiView = pool.get('ir.ui.view')
|
|
ActWin = pool.get('ir.action.act_window')
|
|
ActView = pool.get('ir.action.act_window.view')
|
|
Evaluation2 = pool.get('cashbook_report.evaluation')
|
|
try:
|
|
DashboardAction = pool.get('dashboard.action')
|
|
except Exception:
|
|
DashboardAction = None
|
|
|
|
to_write_eval = []
|
|
to_write_dbaction = []
|
|
for evaluation in evaluations:
|
|
with Transaction().set_context({
|
|
'_check_access': False}):
|
|
view_graph, = UiView.create([
|
|
cls.get_create_view_data(evaluation),
|
|
])
|
|
|
|
dashb_actwin, = ActWin.create([{
|
|
'name': evaluation.name,
|
|
'res_model': 'cashbook_report.eval_line',
|
|
'usage': 'dashboard',
|
|
'context_domain': '[["evaluation", "=", %d]]' % (
|
|
evaluation.id),
|
|
}])
|
|
|
|
dashb_actview, = ActView.create([{
|
|
'sequence': 10,
|
|
'view': view_graph.id,
|
|
'act_window': dashb_actwin.id,
|
|
}])
|
|
|
|
to_write_eval.extend([
|
|
[evaluation],
|
|
{
|
|
'ui_view_chart': view_graph.id,
|
|
'dashb_actwin': dashb_actwin.id,
|
|
'dashb_actview': dashb_actview.id,
|
|
}])
|
|
|
|
# prepare update dasboard-action
|
|
if DashboardAction is not None:
|
|
if evaluation.dashb_actwin:
|
|
db_actions = DashboardAction.search([
|
|
('act_window.id', '=', evaluation.dashb_actwin.id),
|
|
])
|
|
if len(db_actions) > 0:
|
|
to_write_dbaction.extend([
|
|
db_actions,
|
|
{
|
|
'act_window': dashb_actwin.id,
|
|
}])
|
|
|
|
if len(to_write_dbaction) > 0:
|
|
DashboardAction.write(*to_write_dbaction)
|
|
cls.uiview_delete(evaluations)
|
|
if len(to_write_eval) > 0:
|
|
Evaluation2.write(*to_write_eval)
|
|
|
|
@classmethod
|
|
def validate(cls, records):
|
|
""" check dtype_x
|
|
"""
|
|
dtypes = []
|
|
dtypes.extend(cashbook_types)
|
|
dtypes.extend(category_types)
|
|
dtypes.extend(booktype_types)
|
|
dtypes.extend(currency_types)
|
|
|
|
for record in records:
|
|
if record.dtype1 not in dtypes:
|
|
raise UserError(gettext(
|
|
'cashbook_report.msg_invalid_dtype',
|
|
typename='one of: %(names)s' % {
|
|
'names': ', '.join(dtypes)}))
|
|
|
|
# dtype2...5 must be of same range
|
|
dt1 = record.dtype1.split('_')[0]
|
|
for x in range(2, 6):
|
|
dt_val = getattr(record, 'dtype%d' % x, None)
|
|
if dt_val:
|
|
|
|
if record.chart == 'pie':
|
|
raise UserError(gettext(
|
|
'cashbook_report.msg_no_pie_with_dtype2',
|
|
evalname=record.rec_name))
|
|
|
|
if dt_val not in dtypes:
|
|
raise UserError(gettext(
|
|
'cashbook_report.msg_invalid_dtype',
|
|
typename='one of: %(names)s' % {
|
|
'names': ', '.join(dtypes)}))
|
|
|
|
if not dt_val.startswith(dt1):
|
|
raise UserError(gettext(
|
|
'cashbook_report.msg_not_same_basetype',
|
|
typename=gettext(
|
|
'cashbook_report.msg_dtype_%s' % record.dtype1)
|
|
))
|
|
|
|
@classmethod
|
|
def create(cls, vlist):
|
|
""" add chart
|
|
"""
|
|
records = super(Evaluation, cls).create(vlist)
|
|
cls.uiview_create(records)
|
|
return records
|
|
|
|
@classmethod
|
|
def write(cls, *args):
|
|
""" unlink records if dtypex changes
|
|
"""
|
|
to_write = []
|
|
to_update_uiview = []
|
|
|
|
dtypes = {'dtype1', 'dtype2', 'dtype3', 'dtype4', 'dtype5'}
|
|
|
|
actions = iter(args)
|
|
for evaluations, values in zip(actions, actions):
|
|
# update ui-view if related fields change
|
|
uiview_fields = {
|
|
'name', 'bgcolor', 'maincolor', 'legend', 'chart'}
|
|
uiview_fields.update(dtypes)
|
|
if uiview_fields.intersection(values.keys()):
|
|
to_update_uiview.extend(evaluations)
|
|
|
|
# unlink records if dtype(x) changes
|
|
if set(values.keys()).intersection(dtypes):
|
|
for evaluation in evaluations:
|
|
dt_value = {x: values.get(x, None) for x in dtypes}
|
|
dt_eval = {x: getattr(evaluation, x, None) for x in dtypes}
|
|
|
|
# skip un-link if same values are to write
|
|
if dt_value == dt_eval:
|
|
continue
|
|
|
|
dtype1 = values.get('dtype1', evaluation.dtype1)
|
|
for dt in [
|
|
'cashbooks', 'types', 'currencies',
|
|
'categories']:
|
|
if dtype1.startswith(dt):
|
|
continue
|
|
|
|
lines = getattr(evaluation, dt)
|
|
if not lines:
|
|
continue
|
|
|
|
to_write.extend([
|
|
[evaluation],
|
|
{
|
|
dt: [('remove', [x.id for x in lines])],
|
|
}])
|
|
|
|
args = list(args)
|
|
args.extend(to_write)
|
|
super(Evaluation, cls).write(*args)
|
|
|
|
if len(to_update_uiview) > 0:
|
|
cls.uiview_create(to_update_uiview)
|
|
|
|
@classmethod
|
|
def delete(cls, evaluations):
|
|
""" delete views
|
|
"""
|
|
cls.uiview_delete(evaluations)
|
|
super(Evaluation, cls).delete(evaluations)
|
|
|
|
# end Evaluation
|