From c6298b094ec276868e7548d8d9ac333dbd0c4f05 Mon Sep 17 00:00:00 2001 From: "Pedro M. Baeza" Date: Mon, 4 Aug 2014 17:31:24 +0200 Subject: [PATCH] [IMP] account_statement_base_completion: Fix PEP8 --- .../__openerp__.py | 98 +++--- account_statement_base_completion/partner.py | 52 ++-- .../statement.py | 281 +++++++++--------- .../tests/test_base_completion.py | 57 ++-- 4 files changed, 250 insertions(+), 238 deletions(-) diff --git a/account_statement_base_completion/__openerp__.py b/account_statement_base_completion/__openerp__.py index d414aa00..36988cac 100644 --- a/account_statement_base_completion/__openerp__.py +++ b/account_statement_base_completion/__openerp__.py @@ -19,59 +19,67 @@ # ############################################################################## -{'name': "Bank statement base completion", - 'version': '1.0.3', - 'author': 'Camptocamp', - 'maintainer': 'Camptocamp', - 'category': 'Finance', - 'complexity': 'normal', - 'depends': ['account_statement_ext'], - 'description': """ - The goal of this module is to improve the basic bank statement, help dealing with huge volume of - reconciliation by providing basic rules to identify the partner of a bank statement line. - Each bank statement profile can have its own rules to be applied according to a sequence order. +{ + 'name': "Bank statement base completion", + 'version': '1.0.3', + 'author': 'Camptocamp', + 'maintainer': 'Camptocamp', + 'category': 'Finance', + 'complexity': 'normal', + 'depends': ['account_statement_ext'], + 'description': """ + The goal of this module is to improve the basic bank statement, help dealing + with huge volume of reconciliation by providing basic rules to identify the + partner of a bank statement line. + Each bank statement profile can have its own rules to be applied according to a + sequence order. Some basic rules are provided in this module: - 1) Match from statement line label (based on partner field 'Bank Statement Label') + 1) Match from statement line label (based on partner field 'Bank Statement + Label') 2) Match from statement line label (based on partner name) 3) Match from statement line reference (based on Invoice number) - You can easily override this module and add your own rules in your own one. The basic rules only - fill in the partner, but you can use them to fill in any value of the line (in the future, we will - add a rule to automatically match and reconcile the line). + You can easily override this module and add your own rules in your own one. The + basic rules only fill in the partner, but you can use them to fill in any + value of the line (in the future, we will add a rule to automatically match and + reconcile the line). - It adds as well a label on the bank statement line (on which the pre-define rules can match) and - a char field on the partner called 'Bank Statement Label'. Using the pre-define rules, you will be - able to match various labels for a partner. + It adds as well a label on the bank statement line (on which the pre-define + rules can match) and a char field on the partner called 'Bank Statement Label'. + Using the pre-define rules, you will be able to match various labels for a + partner. - The reference of the line is always used by the reconciliation process. We're supposed to copy - there (or write manually) the matching string. This can be: the order Number or an invoice number, - or anything that will be found in the invoice accounting entry part to make the match. + The reference of the line is always used by the reconciliation process. We're + supposed to copy there (or write manually) the matching string. This can be: + the order Number or an invoice number, or anything that will be found in the + invoice accounting entry part to make the match. - You can use it with our account_advanced_reconcile module to automatize the reconciliation process. + You can use it with our account_advanced_reconcile module to automatize the + reconciliation process. - TODO: The rules that look for invoices to find out the partner should take back the payable / receivable - account from there directly instead of retrieving it from partner properties ! - - """, - 'website': 'http://www.camptocamp.com', - 'data': [ - 'statement_view.xml', - 'partner_view.xml', - 'data.xml', - 'security/ir.model.access.csv', - ], - 'demo': [], - 'test': [ - 'test/partner.yml', - 'test/invoice.yml', - 'test/supplier_invoice.yml', - 'test/completion_test.yml' - ], - 'installable': True, - 'images': [], - 'auto_install': False, - 'license': 'AGPL-3', - } + TODO: The rules that look for invoices to find out the partner should take back + the payable / receivable account from there directly instead of retrieving it + from partner properties ! + """, + 'website': 'http://www.camptocamp.com', + 'data': [ + 'statement_view.xml', + 'partner_view.xml', + 'data.xml', + 'security/ir.model.access.csv', + ], + 'demo': [], + 'test': [ + 'test/partner.yml', + 'test/invoice.yml', + 'test/supplier_invoice.yml', + 'test/completion_test.yml' + ], + 'installable': True, + 'images': [], + 'auto_install': False, + 'license': 'AGPL-3', +} diff --git a/account_statement_base_completion/partner.py b/account_statement_base_completion/partner.py index 5057a8d8..2670d8aa 100644 --- a/account_statement_base_completion/partner.py +++ b/account_statement_base_completion/partner.py @@ -1,39 +1,39 @@ # -*- coding: utf-8 -*- ########################################################################## -# # +# # Copyright (C) 2011 Akretion & Camptocamp -# Author : Sébastien BEAU, Joel Grand-Guillaume # -# # -# This program is free software: you can redistribute it and/or modify # -# it under the terms of the GNU Affero General Public License as # -# published by the Free Software Foundation, either version 3 of the # -# License, or (at your option) any later version. # -# # -# This program is distributed in the hope that it will be useful, # -# but WITHOUT ANY WARRANTY; without even the implied warranty of # -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # -# GNU Affero General Public License for more details. # -# # -# You should have received a copy of the GNU Affero General Public License # -# along with this program. If not, see . # -# # +# Author : Sébastien BEAU, Joel Grand-Guillaume +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . +# ########################################################################## -from openerp.osv.orm import Model -from openerp.osv import fields +from openerp.osv import orm, fields -class res_partner(Model): - - """ - Add a bank label on the partner so that we can use it to match +class ResPartner(orm.Model): + """Add a bank label on the partner so that we can use it to match this partner when we found this in a statement line. """ _inherit = 'res.partner' _columns = { - 'bank_statement_label': fields.char('Bank Statement Label', size=100, - help="Enter the various label found on your bank statement separated by a ; If " - "one of this label is include in the bank statement line, the partner will be automatically " - "filled (as long as you use this method/rules in your statement profile)."), + 'bank_statement_label': fields.char( + 'Bank Statement Label', size=100, + help="Enter the various label found on your bank statement " + "separated by a ; If one of this label is include in the bank " + "statement line, the partner will be automatically filled (as " + "long as you use this method/rules in your statement " + "profile)."), } diff --git a/account_statement_base_completion/statement.py b/account_statement_base_completion/statement.py index ac72016c..ba1771f5 100644 --- a/account_statement_base_completion/statement.py +++ b/account_statement_base_completion/statement.py @@ -31,7 +31,7 @@ import psycopg2 from collections import defaultdict import re from openerp.tools.translate import _ -from openerp.osv import osv, orm, fields +from openerp.osv import orm, fields from openerp.tools import DEFAULT_SERVER_DATETIME_FORMAT from operator import attrgetter @@ -40,10 +40,8 @@ _logger = logging.getLogger(__name__) class ErrorTooManyPartner(Exception): - - """ - New Exception definition that is raised when more than one partner is matched by - the completion rule. + """ New Exception definition that is raised when more than one partner is + matched by the completion rule. """ def __init__(self, value): @@ -57,20 +55,18 @@ class ErrorTooManyPartner(Exception): class AccountStatementProfil(orm.Model): - + """Extend the class to add rules per profile that will match at least the + partner, but it could also be used to match other values as well. """ - Extend the class to add rules per profile that will match at least the partner, - but it could also be used to match other values as well. - """ - _inherit = "account.statement.profile" _columns = { - # @Akretion: For now, we don't implement this features, but this would probably be there: - # 'auto_completion': fields.text('Auto Completion'), - # 'transferts_account_id':fields.many2one('account.account', 'Transferts Account'), - # => You can implement it in a module easily, we design it with your needs in mind - # as well! + # @Akretion: For now, we don't implement this features, but this would + # probably be there: 'auto_completion': fields.text('Auto Completion'), + # 'transferts_account_id':fields.many2one('account.account', + # 'Transferts Account'), + # => You can implement it in a module easily, we design it with your + # needs in mind as well! 'rule_ids': fields.many2many( 'account.statement.completion.rule', @@ -87,8 +83,7 @@ class AccountStatementProfil(orm.Model): return sorted(prof.rule_ids, key=attrgetter('sequence')) def _find_values_from_rules(self, cr, uid, calls, line, context=None): - """ - This method will execute all related rules, in their sequence order, + """This method will execute all related rules, in their sequence order, to retrieve all the values returned by the first rules that will match. :param calls: list of lookup function name available in rules :param dict line: read of the concerned account.bank.statement.line @@ -100,13 +95,10 @@ class AccountStatementProfil(orm.Model): ...} """ - if context is None: - context = {} if not calls: calls = self._get_rules( cr, uid, line['profile_id'], context=context) rule_obj = self.pool.get('account.statement.completion.rule') - for call in calls: method_to_call = getattr(rule_obj, call.function_to_call) if len(inspect.getargspec(method_to_call).args) == 6: @@ -120,24 +112,19 @@ class AccountStatementProfil(orm.Model): class AccountStatementCompletionRule(orm.Model): - - """ - This will represent all the completion method that we can have to - fullfill the bank statement lines. You'll be able to extend them in you own module - and choose those to apply for every statement profile. + """This will represent all the completion method that we can have to + fullfill the bank statement lines. You'll be able to extend them in you own + module and choose those to apply for every statement profile. The goal of a rule is to fullfill at least the partner of the line, but if possible also the reference because we'll use it in the reconciliation process. The reference should contain the invoice number or the SO number or any reference that will be matched by the invoice accounting move. """ - _name = "account.statement.completion.rule" _order = "sequence asc" def _get_functions(self, cr, uid, context=None): - """ - List of available methods for rules. Override this to add you own. - """ + """List of available methods for rules. Override this to add you own.""" return [ ('get_from_ref_and_invoice', 'From line reference (based on customer invoice number)'), @@ -145,14 +132,17 @@ class AccountStatementCompletionRule(orm.Model): 'From line reference (based on supplier invoice number)'), ('get_from_label_and_partner_field', 'From line label (based on partner field)'), - ('get_from_label_and_partner_name', 'From line label (based on partner name)')] + ('get_from_label_and_partner_name', + 'From line label (based on partner name)') + ] def __get_functions(self, cr, uid, context=None): """ Call method which can be inherited """ return self._get_functions(cr, uid, context=context) _columns = { - 'sequence': fields.integer('Sequence', help="Lower means parsed first."), + 'sequence': fields.integer('Sequence', + help="Lower means parsed first."), 'name': fields.char('Name', size=128), 'profile_ids': fields.many2many( 'account.statement.profile', @@ -171,8 +161,9 @@ class AccountStatementCompletionRule(orm.Model): type_domain = ('out_invoice', 'out_refund') number_field = 'number' else: - raise osv.except_osv(_('System error'), - _('Invalid invoice type for completion: %') % inv_type) + raise orm.except_orm( + _('System error'), + _('Invalid invoice type for completion: %') % inv_type) inv_id = inv_obj.search(cr, uid, [(number_field, '=', st_line['ref'].strip()), @@ -182,17 +173,19 @@ class AccountStatementCompletionRule(orm.Model): if len(inv_id) == 1: inv = inv_obj.browse(cr, uid, inv_id[0], context=context) else: - raise ErrorTooManyPartner(_('Line named "%s" (Ref:%s) was matched by more ' - 'than one partner while looking on %s invoices') % - (st_line['name'], st_line['ref'], inv_type)) + raise ErrorTooManyPartner( + _('Line named "%s" (Ref:%s) was matched by more than one ' + 'partner while looking on %s invoices') % + (st_line['name'], st_line['ref'], inv_type)) return inv return False def _from_invoice(self, cr, uid, line, inv_type, context): """Populate statement line values""" - if not inv_type in ('supplier', 'customer'): - raise osv.except_osv(_('System error'), - _('Invalid invoice type for completion: %') % inv_type) + if inv_type not in ('supplier', 'customer'): + raise orm.except_orm(_('System error'), + _('Invalid invoice type for completion: %') % + inv_type) res = {} inv = self._find_invoice(cr, uid, line, inv_type, context=context) if inv: @@ -203,7 +196,6 @@ class AccountStatementCompletionRule(orm.Model): partner_id = inv.commercial_partner_id.id else: partner_id = inv.partner_id.id - res = {'partner_id': partner_id, 'account_id': inv.account_id.id, 'type': inv_type} @@ -214,10 +206,10 @@ class AccountStatementCompletionRule(orm.Model): # Should be private but data are initialised with no update XML def get_from_ref_and_supplier_invoice(self, cr, uid, line, context=None): - """ - Match the partner based on the invoice supplier invoice number and the reference of the statement - line. Then, call the generic get_values_for_line method to complete other values. - If more than one partner matched, raise the ErrorTooManyPartner error. + """Match the partner based on the invoice supplier invoice number and + the reference of the statement line. Then, call the generic + get_values_for_line method to complete other values. If more than one + partner matched, raise the ErrorTooManyPartner error. :param dict line: read of the concerned account.bank.statement.line :return: @@ -232,10 +224,10 @@ class AccountStatementCompletionRule(orm.Model): # Should be private but data are initialised with no update XML def get_from_ref_and_invoice(self, cr, uid, line, context=None): - """ - Match the partner based on the invoice number and the reference of the statement - line. Then, call the generic get_values_for_line method to complete other values. - If more than one partner matched, raise the ErrorTooManyPartner error. + """Match the partner based on the invoice number and the reference of + the statement line. Then, call the generic get_values_for_line method to + complete other values. If more than one partner matched, raise the + ErrorTooManyPartner error. :param dict line: read of the concerned account.bank.statement.line :return: @@ -265,7 +257,7 @@ class AccountStatementCompletionRule(orm.Model): ...} """ - partner_obj = self.pool.get('res.partner') + partner_obj = self.pool['res.partner'] st_obj = self.pool.get('account.bank.statement.line') res = {} # As we have to iterate on each partner for each line, @@ -275,13 +267,15 @@ class AccountStatementCompletionRule(orm.Model): # but this option is not really maintanable if not context.get('label_memoizer'): context['label_memoizer'] = defaultdict(list) - partner_ids = partner_obj.search(cr, - uid, - [('bank_statement_label', '!=', False)]) + partner_ids = partner_obj.search( + cr, uid, [('bank_statement_label', '!=', False)], + context=context) line_ids = context.get('line_ids', []) - for partner in partner_obj.browse(cr, uid, partner_ids, context=context): - vals = '|'.join(re.escape(x.strip()) - for x in partner.bank_statement_label.split(';')) + for partner in partner_obj.browse(cr, uid, partner_ids, + context=context): + vals = '|'.join( + re.escape(x.strip()) + for x in partner.bank_statement_label.split(';')) or_regex = ".*%s.*" % vals sql = ("SELECT id from account_bank_statement_line" " WHERE id in %s" @@ -290,36 +284,29 @@ class AccountStatementCompletionRule(orm.Model): pairs = cr.fetchall() for pair in pairs: context['label_memoizer'][pair[0]].append(partner) - if st_line['id'] in context['label_memoizer']: found_partner = context['label_memoizer'][st_line['id']] if len(found_partner) > 1: - msg = (_('Line named "%s" (Ref:%s) was matched by ' - 'more than one partner while looking on partner label: %s') % - (st_line['name'], st_line['ref'], ','.join([x.name for x in found_partner]))) + msg = (_('Line named "%s" (Ref:%s) was matched by more than ' + 'one partner while looking on partner label: %s') % + (st_line['name'], st_line['ref'], + ','.join([x.name for x in found_partner]))) raise ErrorTooManyPartner(msg) res['partner_id'] = found_partner[0].id - st_vals = st_obj.get_values_for_line(cr, - uid, - profile_id=st_line[ - 'profile_id'], - master_account_id=st_line[ - 'master_account_id'], - partner_id=found_partner[ - 0].id, - line_type=False, - amount=st_line['amount'] if st_line[ - 'amount'] else 0.0, - context=context) + st_vals = st_obj.get_values_for_line( + cr, uid, profile_id=st_line['profile_id'], + master_account_id=st_line['master_account_id'], + partner_id=found_partner[0].id, line_type=False, + amount=st_line['amount'] if st_line['amount'] else 0.0, + context=context) res.update(st_vals) return res def get_from_label_and_partner_name(self, cr, uid, st_line, context=None): - """ - Match the partner based on the label field of the statement line - and the name of the partner. - Then, call the generic get_values_for_line method to complete other values. - If more than one partner matched, raise the ErrorTooManyPartner error. + """Match the partner based on the label field of the statement line + and the name of the partner. Then, call the generic get_values_for_line + method to complete other values. If more than one partner matched, raise + the ErrorTooManyPartner error. :param dict st_line: read of the concerned account.bank.statement.line :return: @@ -342,33 +329,37 @@ class AccountStatementCompletionRule(orm.Model): # example: 'John J. Doe (No 1)' is escaped to 'John J\. Doe \(No 1\)' # See http://stackoverflow.com/a/400316/1504003 for a list of # chars to escape. Postgres is POSIX-ARE, compatible with - # POSIX-ERE excepted that '\' must be escaped inside brackets according to: - # http://www.postgresql.org/docs/9.0/static/functions-matching.html + # POSIX-ERE excepted that '\' must be escaped inside brackets according + # to: + # http://www.postgresql.org/docs/9.0/static/functions-matching.html # in chapter 9.7.3.6. Limits and Compatibility - sql = """SELECT id FROM ( - SELECT id, regexp_matches(%s, regexp_replace(name,'([\.\^\$\*\+\?\(\)\[\{\\\|])', %s, 'g'), 'i') AS name_match FROM res_partner - WHERE id IN %s) AS res_patner_matcher - WHERE name_match IS NOT NULL""" + sql = """ + SELECT id FROM ( + SELECT id, + regexp_matches(%s, + regexp_replace(name,'([\.\^\$\*\+\?\(\)\[\{\\\|])', %s, + 'g'), 'i') AS name_match + FROM res_partner + WHERE id IN %s) + AS res_patner_matcher + WHERE name_match IS NOT NULL""" cr.execute( sql, (st_line['name'], r"\\\1", context['partner_memoizer'])) result = cr.fetchall() if not result: return res if len(result) > 1: - raise ErrorTooManyPartner(_('Line named "%s" (Ref:%s) was matched by more ' - 'than one partner while looking on partner by name') % - (st_line['name'], st_line['ref'])) + raise ErrorTooManyPartner( + _('Line named "%s" (Ref:%s) was matched by more than one ' + 'partner while looking on partner by name') % + (st_line['name'], st_line['ref'])) res['partner_id'] = result[0][0] - st_vals = st_obj.get_values_for_line(cr, - uid, - profile_id=st_line['profile_id'], - master_account_id=st_line[ - 'master_account_id'], - partner_id=res['partner_id'], - line_type=False, - amount=st_line['amount'] if st_line[ - 'amount'] else 0.0, - context=context) + st_vals = st_obj.get_values_for_line( + cr, uid, profile_id=st_line['profile_id'], + master_account_id=st_line['master_account_id'], + partner_id=res['partner_id'], line_type=False, + amount=st_line['amount'] if st_line['amount'] else 0.0, + context=context) res.update(st_vals) return res @@ -385,22 +376,23 @@ class AccountStatement(orm.Model): ], context=context) if line_without_account: stat = self.browse(cr, uid, stat_id, context=context) - raise orm.except_orm(_('User error'), - _('You should fill all account on the line of the' - ' statement %s') % stat.name) + raise orm.except_orm( + _('User error'), + _('You should fill all account on the line of the' + ' statement %s') % stat.name) return super(AccountStatement, self).button_confirm_bank( cr, uid, ids, context=context) class AccountStatementLine(orm.Model): - """ Add sparse field on the statement line to allow to store all the bank infos that are given by a bank/office. You can then add you own in your - module. The idea here is to store all bank/office infos in the additionnal_bank_fields - serialized field when importing the file. If many values, add a tab in the bank - statement line to store your specific one. Have a look in account_statement_base_import - module to see how we've done it. + module. The idea here is to store all bank/office infos in the + additionnal_bank_fields serialized field when importing the file. If many + values, add a tab in the bank statement line to store your specific one. + Have a look in account_statement_base_import module to see how we've done + it. """ _inherit = "account.bank.statement.line" _order = "already_completed desc, date asc" @@ -430,16 +422,17 @@ class AccountStatementLine(orm.Model): } def _get_line_values_from_rules(self, cr, uid, line, rules, context=None): - """ - We'll try to find out the values related to the line based on rules setted on - the profile.. We will ignore line for which already_completed is ticked. + """We'll try to find out the values related to the line based on rules + setted on the profile.. We will ignore line for which already_completed + is ticked. :return: - A dict of dict value that can be passed directly to the write method of - the statement line or {}. The first dict has statement line ID as a key: - {117009: {'partner_id': 100997, 'account_id': 489L}} + A dict of dict value that can be passed directly to the write + method of the statement line or {}. The first dict has statement + line ID as a key: {117009: {'partner_id': 100997, + 'account_id': 489L}} """ - profile_obj = self.pool.get('account.statement.profile') + profile_obj = self.pool['account.statement.profile'] if line.get('already_completed'): return {} # Ask the rule @@ -450,7 +443,8 @@ class AccountStatementLine(orm.Model): return vals return {} - def _get_available_columns(self, statement_store, include_serializable=False): + def _get_available_columns(self, statement_store, + include_serializable=False): """Return writeable by SQL columns""" statement_line_obj = self.pool['account.bank.statement.line'] model_cols = statement_line_obj._columns @@ -460,7 +454,7 @@ class AccountStatementLine(orm.Model): # add sparse fields.. if include_serializable: for k, col in model_cols.iteritems(): - if k in statement_store[0].keys() and \ + if k in statement_store[0].keys() and \ isinstance(col, fields.sparse) and \ col.serialization_field not in keys and \ col._type == 'char': @@ -493,8 +487,9 @@ class AccountStatementLine(orm.Model): """ statement_line_obj = self.pool['account.bank.statement.line'] model_cols = statement_line_obj._columns - sparse_fields = dict([(k, col) for k, col in model_cols.iteritems() if isinstance( - col, fields.sparse) and col._type == 'char']) + sparse_fields = dict( + [(k, col) for k, col in model_cols.iteritems() if isinstance( + col, fields.sparse) and col._type == 'char']) values = [] for statement in statement_store: to_json_k = set() @@ -522,13 +517,15 @@ class AccountStatementLine(orm.Model): statement_store, include_serializable=True) statement_store = self._prepare_manyinsert(statement_store, cols) tmp_vals = (', '.join(cols), ', '.join(['%%(%s)s' % i for i in cols])) - sql = "INSERT INTO account_bank_statement_line (%s) VALUES (%s);" % tmp_vals + sql = "INSERT INTO account_bank_statement_line (%s) " \ + "VALUES (%s);" % tmp_vals try: cr.executemany( - sql, tuple(self._serialize_sparse_fields(cols, statement_store))) + sql, tuple(self._serialize_sparse_fields(cols, + statement_store))) except psycopg2.Error as sql_err: cr.rollback() - raise osv.except_osv(_("ORM bypass error"), + raise orm.except_orm(_("ORM bypass error"), sql_err.pgerror) def _update_line(self, cr, uid, vals, context=None): @@ -542,19 +539,18 @@ class AccountStatementLine(orm.Model): cols = self._get_available_columns([vals]) vals = self._prepare_insert(vals, cols) tmp_vals = (', '.join(['%s = %%(%s)s' % (i, i) for i in cols])) - sql = "UPDATE account_bank_statement_line SET %s where id = %%(id)s;" % tmp_vals + sql = "UPDATE account_bank_statement_line " \ + "SET %s where id = %%(id)s;" % tmp_vals try: cr.execute(sql, vals) except psycopg2.Error as sql_err: cr.rollback() - raise osv.except_osv(_("ORM bypass error"), + raise orm.except_orm(_("ORM bypass error"), sql_err.pgerror) class AccountBankStatement(orm.Model): - - """ - We add a basic button and stuff to support the auto-completion + """We add a basic button and stuff to support the auto-completion of the bank statement once line have been imported or manually fullfill. """ _inherit = "account.bank.statement" @@ -563,46 +559,42 @@ class AccountBankStatement(orm.Model): 'completion_logs': fields.text('Completion Log', readonly=True), } - def write_completion_log(self, cr, uid, stat_id, error_msg, number_imported, context=None): - """ - Write the log in the completion_logs field of the bank statement to let the user - know what have been done. This is an append mode, so we don't overwrite what - already recoded. + def write_completion_log(self, cr, uid, stat_id, error_msg, + number_imported, context=None): + """Write the log in the completion_logs field of the bank statement to + let the user know what have been done. This is an append mode, so we + don't overwrite what already recoded. :param int/long stat_id: ID of the account.bank.statement :param char error_msg: Message to add :number_imported int/long: Number of lines that have been completed :return True """ - user_name = self.pool.get('res.users').read(cr, uid, uid, - ['name'], context=context)['name'] + user_name = self.pool.get('res.users').read( + cr, uid, uid, ['name'], context=context)['name'] statement = self.browse(cr, uid, stat_id, context=context) number_line = len(statement.line_ids) - log = self.read(cr, uid, stat_id, ['completion_logs'], context=context)['completion_logs'] log = log if log else "" - completion_date = datetime.datetime.now().strftime( DEFAULT_SERVER_DATETIME_FORMAT) - message = (_("%s Bank Statement ID %s has %s/%s lines completed by %s \n%s\n%s\n") % - (completion_date, stat_id, number_imported, number_line, user_name, - error_msg, log)) + message = (_("%s Bank Statement ID %s has %s/%s lines completed by " + "%s \n%s\n%s\n") % (completion_date, stat_id, + number_imported, number_line, + user_name, error_msg, log)) self.write( cr, uid, [stat_id], {'completion_logs': message}, context=context) body = (_('Statement ID %s auto-completed for %s/%s lines completed') % (stat_id, number_imported, number_line)), - self.message_post(cr, uid, - [stat_id], - body=body, - context=context) + self.message_post(cr, uid, [stat_id], body=body, context=context) return True def button_auto_completion(self, cr, uid, ids, context=None): - """ - Complete line with values given by rules and tic the already_completed - checkbox so we won't compute them again unless the user untick them! + """Complete line with values given by rules and tic the + already_completed checkbox so we won't compute them again unless the + user untick them! """ if context is None: context = {} @@ -621,15 +613,16 @@ class AccountBankStatement(orm.Model): # Only for perfo even it gains almost nothing profile_id = b_profile.id master_account_id = b_profile.receivable_account_id - master_account_id = master_account_id.id if master_account_id else False + master_account_id = master_account_id.id if \ + master_account_id else False res = False for line in stat_line_obj.read(cr, uid, ctx['line_ids']): try: # performance trick line['master_account_id'] = master_account_id line['profile_id'] = profile_id - res = stat_line_obj._get_line_values_from_rules(cr, uid, line, - rules, context=ctx) + res = stat_line_obj._get_line_values_from_rules( + cr, uid, line, rules, context=ctx) if res: compl_lines += 1 except ErrorTooManyPartner, exc: diff --git a/account_statement_base_completion/tests/test_base_completion.py b/account_statement_base_completion/tests/test_base_completion.py index 56cfeb8a..acbabbb0 100644 --- a/account_statement_base_completion/tests/test_base_completion.py +++ b/account_statement_base_completion/tests/test_base_completion.py @@ -38,9 +38,11 @@ NAMES_COMPLETION_CASES = [ name_completion_case( "Acsone SA", "Line for Acsone ([^a-zA-Z0-9 -]) SA test", False), name_completion_case( - "Acsone ([^a-zA-Z0-9 -]) SA", "Line for Acsone ([^a-zA-Z0-9 -]) SA test", True), + "Acsone ([^a-zA-Z0-9 -]) SA", "Line for Acsone ([^a-zA-Z0-9 -]) SA " + "test", True), name_completion_case( - r"Acsone (.^$*+?()[{\| -]\) SA", r"Line for Acsone (.^$*+?()[{\| -]\) SA test", True), + r"Acsone (.^$*+?()[{\| -]\) SA", r"Line for Acsone (.^$*+?()[{\| -]\) " + r"SA test", True), name_completion_case("Acšone SA", "Line for Acšone SA test", True), ] @@ -63,11 +65,12 @@ class base_completion(common.TransactionCase): def test_name_completion(self): """Test complete partner_id from statement line label - Test the automatic completion of the partner_id based if the name of the partner appears in - the statement line label + Test the automatic completion of the partner_id based if the name of the + partner appears in the statement line label """ self.completion_rule_id = self.ref( - 'account_statement_base_completion.bank_statement_completion_rule_3') + 'account_statement_base_completion.' + 'bank_statement_completion_rule_3') # Create the profile self.profile_id = self.profile_obj.create(self.cr, self.uid, { "name": "TEST", @@ -75,35 +78,43 @@ class base_completion(common.TransactionCase): "journal_id": self.journal_id, "rule_ids": [(6, 0, [self.completion_rule_id])]}) # Create a bank statement - self.statement_id = self.account_bank_statement_obj.create(self.cr, self.uid, { - "balance_end_real": 0.0, - "balance_start": 0.0, - "date": time.strftime('%Y-%m-%d'), - "journal_id": self.journal_id, - "profile_id": self.profile_id - }) + self.statement_id = self.account_bank_statement_obj.create( + self.cr, self.uid, { + "balance_end_real": 0.0, + "balance_start": 0.0, + "date": time.strftime('%Y-%m-%d'), + "journal_id": self.journal_id, + "profile_id": self.profile_id + }) for case in NAMES_COMPLETION_CASES: self.partner_obj.write( self.cr, self.uid, self.partner_id, {'name': case.partner_name}) - statement_line_id = self.account_bank_statement_line_obj.create(self.cr, self.uid, { - 'amount': 1000.0, - 'name': case.line_label, - 'ref': 'My ref', - 'statement_id': self.statement_id, - }) + statement_line_id = self.account_bank_statement_line_obj.create( + self.cr, self.uid, { + 'amount': 1000.0, + 'name': case.line_label, + 'ref': 'My ref', + 'statement_id': self.statement_id, + }) statement_line = self.account_bank_statement_line_obj.browse( self.cr, self.uid, statement_line_id) self.assertFalse( - statement_line.partner_id, "Partner_id must be blank before completion") + statement_line.partner_id, + "Partner_id must be blank before completion") statement_obj = self.account_bank_statement_obj.browse( self.cr, self.uid, self.statement_id) statement_obj.button_auto_completion() statement_line = self.account_bank_statement_line_obj.browse( self.cr, self.uid, statement_line_id) if case.should_match: - self.assertEquals(self.partner_id, statement_line.partner_id['id'], - "Missing expected partner id after completion (partner_name: %s, line_name: %s)" % (case.partner_name, case.line_label)) + self.assertEquals( + self.partner_id, statement_line.partner_id['id'], + "Missing expected partner id after completion " + "(partner_name: %s, line_name: %s)" % + (case.partner_name, case.line_label)) else: - self.assertNotEquals(self.partner_id, statement_line.partner_id['id'], - "Partner id should be empty after completion(partner_name: %s, line_name: %s)" % (case.partner_name, case.line_label)) + self.assertNotEquals( + self.partner_id, statement_line.partner_id['id'], + "Partner id should be empty after completion(partner_name: " + "%s, line_name: %s)" % (case.partner_name, case.line_label))