[ADD] mis_builder: accounting expression processor
Stéphane Bidoul
parent
e4b7c467c4
commit
3fbd04857e
|
|
@ -0,0 +1,174 @@
|
|||
import re
|
||||
from collections import defaultdict
|
||||
|
||||
|
||||
class AccountingExpressionProcessor(object):
|
||||
""" Processor for accounting expressions.
|
||||
|
||||
Expressions of the form <field><mode>[accounts][optional move line domain]
|
||||
are supported, where:
|
||||
* field is bal, crd, deb
|
||||
* mode is i (initial balance), e (ending balance), p (moves over period)
|
||||
* accounts is a list of accounts, possibly containing % wildcards
|
||||
* an optional domain on analytic lines allowing filters on eg analytic
|
||||
accounts or journal
|
||||
|
||||
Examples:
|
||||
* bal[70]: balance of moves on account 70 over the period
|
||||
(it is the same as balp[70]);
|
||||
* bali[70,60]: initial balance of accounts 70 and 60;
|
||||
* bale[1%]: balance of accounts starting with 1 at end of period.
|
||||
|
||||
How to use:
|
||||
* repeatedly invoke parse_expr() for each expression containing
|
||||
accounting variables as described above; this let the processor
|
||||
group domains and modes and accounts;
|
||||
* when all expressions have been parsed, invoke done_parsing()
|
||||
to notify the processor that he can prepare to query (mainly
|
||||
search all accounts - children, consolidation - that will need to
|
||||
be queried;
|
||||
* for each period, call do_queries(), the call replace_expr() for each
|
||||
expression to replace accounting variables with their resulting value
|
||||
for the given period.
|
||||
|
||||
How it works:
|
||||
* by accumulating the expressions before hand, it ensure to do the
|
||||
strict minimum number of queries to the database (for each period,
|
||||
one query per domain and mode);
|
||||
* it queries using the orm read_group which reduces to a query with
|
||||
sum on debit and credit and group by on account_id (note: it seems
|
||||
the orm then does one query per account to fetch the account name...);
|
||||
* additionally, one query per view/consolidation account is done to
|
||||
discover the children accounts.
|
||||
"""
|
||||
|
||||
ACC_RE = re.compile(r"(?P<field>\bbal|\bcrd|\bdeb)"
|
||||
r"(?P<mode>[pise])?"
|
||||
r"(?P<accounts>_[0-9]+|\[.*?\])"
|
||||
r"(?P<domain>\[.*?\])?")
|
||||
|
||||
def __init__(self, env):
|
||||
self.env = env
|
||||
self._map = defaultdict(set) # {(domain, mode): set(account_ids)}
|
||||
self._account_ids_by_code = defaultdict(set)
|
||||
|
||||
def _load_account_codes(self, account_codes, account_domain):
|
||||
account_model = self.env['account.account']
|
||||
# TODO: account_obj is necessary because _get_children_and_consol
|
||||
# does not work in new API?
|
||||
account_obj = self.env.registry('account.account')
|
||||
exact_codes = set()
|
||||
like_codes = set()
|
||||
for account_code in account_codes:
|
||||
if account_code in self._account_ids_by_code:
|
||||
continue
|
||||
if '%' in account_code:
|
||||
like_codes.add(account_code)
|
||||
else:
|
||||
exact_codes.add(account_code)
|
||||
for account in account_model.\
|
||||
search([('code', 'in', list(exact_codes))] + account_domain):
|
||||
if account.type in ('view', 'consolidation'):
|
||||
self._account_ids_by_code[account.code].update(
|
||||
account_obj._get_children_and_consol(
|
||||
self.env.cr, self.env.uid,
|
||||
[account.id],
|
||||
self.env.context))
|
||||
else:
|
||||
self._account_ids_by_code[account.code].add(account.id)
|
||||
for like_code in like_codes:
|
||||
for account in account_model.\
|
||||
search([('code', 'like', like_code)] + account_domain):
|
||||
if account.type in ('view', 'consolidation'):
|
||||
self._account_ids_by_code[like_code].update(
|
||||
account_obj._get_children_and_consol(
|
||||
self.env.cr, self.env.uid,
|
||||
[account.id],
|
||||
self.env.context))
|
||||
else:
|
||||
self._account_ids_by_code[like_code].add(account.id)
|
||||
|
||||
def _parse_mo(self, mo):
|
||||
"""Split a match object corresponding to an accounting variable
|
||||
|
||||
Returns field, mode, [account codes], [domain expression].
|
||||
"""
|
||||
field, mode, account_codes, domain = mo.groups()
|
||||
if not mode:
|
||||
mode = 'p'
|
||||
elif mode == 's':
|
||||
mode = 'e'
|
||||
if account_codes.startswith('_'):
|
||||
account_codes = account_codes[1:]
|
||||
else:
|
||||
account_codes = account_codes[1:-1]
|
||||
account_codes = [a.strip() for a in account_codes.split(',')]
|
||||
domain = domain or '[]'
|
||||
domain = tuple(eval(domain)) # TODO: safe_eval
|
||||
return field, mode, account_codes, domain
|
||||
|
||||
def parse_expr(self, expr):
|
||||
"""Parse an expression, extracting accounting variables.
|
||||
|
||||
Domains and accounts are extracted and stored in the map
|
||||
so when all expressions have been parsed, we know what to query.
|
||||
"""
|
||||
for mo in self.ACC_RE.finditer(expr):
|
||||
field, mode, account_codes, domain = self._parse_mo(mo)
|
||||
key = (domain, mode)
|
||||
self._map[key].update(account_codes)
|
||||
|
||||
def done_parsing(self, account_domain):
|
||||
# load account codes and replace account codes by account ids in _map
|
||||
for key, account_codes in self._map.items():
|
||||
self._load_account_codes(account_codes, account_domain)
|
||||
account_ids = set()
|
||||
for account_code in account_codes:
|
||||
account_ids.update(self._account_ids_by_code[account_code])
|
||||
self._map[key] = list(account_ids)
|
||||
|
||||
def do_queries(self, period_domain, period_domain_i, period_domain_e):
|
||||
aml_model = self.env['account.move.line']
|
||||
self._data = {} # {(domain, mode): {account_id: (debit, credit)}}
|
||||
for key in self._map:
|
||||
self._data[key] = {}
|
||||
domain, mode = key
|
||||
if mode == 'p':
|
||||
domain = list(domain) + period_domain
|
||||
elif mode == 'i':
|
||||
domain = list(domain) + period_domain_i
|
||||
elif mode == 'e':
|
||||
domain = list(domain) + period_domain_e
|
||||
else:
|
||||
raise RuntimeError("unexpected mode %s" % (mode,))
|
||||
domain = [('account_id', 'in', self._map[key])] + domain
|
||||
accs = aml_model.read_group(domain,
|
||||
['debit', 'credit', 'account_id'],
|
||||
['account_id'])
|
||||
for acc in accs:
|
||||
self._data[key][acc['account_id'][0]] = \
|
||||
(acc['debit'], acc['credit'])
|
||||
|
||||
def replace_expr(self, expr):
|
||||
"""Replace accounting variables in an expression by their amount.
|
||||
|
||||
Returns a new expression.
|
||||
|
||||
This method must be executed after do_queries().
|
||||
"""
|
||||
def f(mo):
|
||||
field, mode, account_codes, domain = self._parse_mo(mo)
|
||||
key = (domain, mode)
|
||||
account_ids_data = self._data[key]
|
||||
v = 0.0
|
||||
for account_code in account_codes:
|
||||
for account_id in self._account_ids_by_code[account_code]:
|
||||
debit, credit = account_ids_data.get(account_id, (0.0, 0.0))
|
||||
if field == 'deb':
|
||||
v += debit
|
||||
elif field == 'crd':
|
||||
v += credit
|
||||
elif field == 'bal':
|
||||
v += debit - credit
|
||||
return '(' + repr(v) + ')'
|
||||
return self.ACC_RE.sub(f, expr)
|
||||
Loading…
Reference in New Issue