[IMP] Refactor improvements using AEP

mis_builder/models/aep.py

@@ -141,13 +141,14 @@ class AccountingExpressionProcessor(object):
         """
         domains = []
         for mo in self.ACC_RE.finditer(expr):
-            field, mode, account_codes, domain = self._parse_mo(mo)
+            field, mode, account_codes, domain_partial = self._parse_mo(mo)
             if mode == 'i':
                 continue
             account_ids = set()
             for account_code in account_codes:
                 account_ids.update(self._account_ids_by_code[account_code])
             domain = [('account_id', 'in', tuple(account_ids))]
+            domain.extend(list(domain_partial))
             if field == 'crd':
                 domain.append(('credit', '>', 0))
             elif field == 'deb':

mis_builder/models/mis_builder.py

@@ -76,51 +76,6 @@ def _python_var(var_str):
     return re.sub(r'\W|^(?=\d)', '_', var_str).lower()
 
 
-def _get_sufix(is_solde=False, is_initial=False):
-    if is_solde:
-        return 's'
-    elif is_initial:
-        return 'i'
-    else:
-        return ''
-
-
-def _get_prefix(function, is_solde=False, is_initial=False):
-    return function + _get_sufix(is_solde=is_solde, is_initial=is_initial)
-
-
-# TODO : To review
-def _get_account_vars_in_expr(expr, res_vars, domain_mapping, is_solde=False,
-                              is_initial=False):
-    for function in FUNCTION_LIST:
-        prefix = _get_prefix(function, is_solde=is_solde,
-                             is_initial=is_initial)
-        find_res = re.findall(r'\b%s(?:_[0-9]+|\[.*?\])(?:\[.+?\])?' % prefix,
-                              expr)
-        for item in find_res:
-            match = re.match(r'\b(%s)(_[0-9]+|\[.*?\])(\[.+?\])?' % prefix,
-                             item)
-            var_tuple = match.groups()
-            domain = "" if var_tuple[2] is None else var_tuple[2]
-            key = ""
-            if domain != "":
-                if domain not in domain_mapping:
-                    key = 'd' + str(len(res_vars.keys()))
-                    domain_mapping[domain] = key
-                else:
-                    key = domain_mapping[domain]
-            key_domain = (key, domain)
-            if not res_vars.get(key_domain, False):
-                res_vars[key_domain] = set()
-            if var_tuple[1].startswith('_'):
-                account_codes = var_tuple[1][1:]
-            else:
-                account_codes = var_tuple[1][1:-1]
-            account_codes = [a.strip() for a in account_codes.split(',')]
-            account_codes_set = set(account_codes)
-            res_vars[key_domain] |= account_codes_set
-
-
 def _is_valid_python_var(name):
     for item in FUNCTION_LIST:
         for param in PARAMETERS:
@@ -535,57 +490,43 @@ class mis_report_instance_period(orm.Model):
          'Period name should be unique by report'),
     ]
 
-    # TODO : To review
     def compute_domain(self, cr, uid, ids, account_, context=None):
         if isinstance(ids, (int, long)):
             ids = [ids]
-        domain_list = []
+        domain = []
-        # extract all bal code
+        this = self.browse(cr, uid, ids, context=context)[0]
-        res_vars = {}
+        env = Environment(cr, uid, {})
-        domain_mapping = {}
+        aep = AccountingExpressionProcessor(env)
-        _get_account_vars_in_expr(account_, res_vars, domain_mapping,
+        aep.parse_expr(account_)
-                                  is_solde=False, is_initial=False)
+        aep.done_parsing([('company_id', '=',
-        for key_domain, account_code in res_vars.iteritems():
+                           this.report_instance_id.company_id.id)])
-            key, domain = key_domain
+        domain.extend(aep.get_aml_domain_for_expr(account_))
-            partial_domain = [('account_id.code', 'in', list(account_code))]
+        if domain != []:
-            if domain != '':
+            # compute date/period
-                partial_domain.insert(0, '&')
+            period_ids = []
-                domain_eval = safe_eval(domain)
+            date_from = None
-                partial_domain.extend(domain_eval)
+            date_to = None
-            domain_list.extend(partial_domain)
+            period_obj = self.pool['account.period']
-        nb_or = len(res_vars) - 1
+            target_move = this.report_instance_id.target_move
-        while nb_or > 0:
-            domain_list.insert(0, '|')
-            nb_or -= 1
-
-        # compute date/period
-        period_ids = []
-        date_from = None
-        date_to = None
-
-        period_obj = self.pool['account.period']
-
-        for c in self.browse(cr, uid, ids, context=context):
-            target_move = c.report_instance_id.target_move
             if target_move == 'posted':
-                domain_list.append(('move_id.state', '=', target_move))
+                domain.append(('move_id.state', '=', target_move))
-            if c.period_from:
+            if this.period_from:
                 compute_period_ids = period_obj.build_ctx_periods(
-                    cr, uid, c.period_from.id, c.period_to.id)
+                    cr, uid, this.period_from.id, this.period_to.id)
                 period_ids.extend(compute_period_ids)
             else:
-                if not date_from or date_from > c.date_from:
+                date_from = this.date_from
-                    date_from = c.date_from
+                date_to = this.date_to
-                if not date_to or date_to < c.date_to:
+            if period_ids:
-                    date_to = c.date_to
+                if date_from:
-        if period_ids:
+                    domain.append('|')
+                domain.append(('period_id', 'in', period_ids))
             if date_from:
-                domain_list.append('|')
+                domain.extend([('date', '>=', date_from),
-            domain_list.append(('period_id', 'in', period_ids))
+                               ('date', '<=', date_to)])
-        if date_from:
+        else:
-            domain_list.extend([('date', '>=', c.date_from),
+            domain = False
-                                ('date', '<=', c.date_to)])
+        return domain
-        return domain_list
 
     def compute_period_domain(self, cr, uid, period_report, is_solde,
                               is_initial, context=None):

mis_builder/static/src/js/mis_builder.js

@@ -35,16 +35,18 @@ openerp.mis_builder = function(instance) {
                     [period_id, val_c],
                     {'context': new instance.web.CompoundContext()}
                 ).then(function(result){
-                    self.do_action({
+                    if (result != false){
-                        name: val_c + ' - ' + period_name,
+                        self.do_action({
-                        domain: JSON.stringify(result),
+                            name: val_c + ' - ' + period_name,
-                        type: 'ir.actions.act_window',
+                            domain: JSON.stringify(result),
-                        res_model: "account.move.line",
+                            type: 'ir.actions.act_window',
-                        views: [[false, 'list'], [false, 'form']],
+                            res_model: "account.move.line",
-                        view_type : "list",
+                            views: [[false, 'list'], [false, 'form']],
-                        view_mode : "list",
+                            view_type : "list",
-                        target: 'current',
+                            view_mode : "list",
-                    });
+                            target: 'current',
+                        });
+                    }
                 });
             }
         },