# -*- coding: utf-8 -*- ############################################################################## # # Copyright (C) 2009 EduSense BV (). # (C) 2011 - 2013 Therp BV (). # # All other contributions are (C) by their respective contributors # # All Rights Reserved # # 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 . # ############################################################################## ''' This module shows resemblance to both account_bankimport/bankimport.py, account/account_bank_statement.py and account_payment(_export). All hail to the makers. account_bankimport is only referenced for their ideas and the framework of the filters, which they in their turn seem to have derived from account_coda. Modifications are extensive: 1. In relation to account/account_bank_statement.py: account.bank.statement is effectively stripped from its account.period association, while account.bank.statement.line is extended with the same association, thereby reflecting real world usage of bank.statement as a list of bank transactions and bank.statement.line as a bank transaction. 2. In relation to account/account_bankimport: All filter objects and extensions to res.company are removed. Instead a flexible auto-loading and auto-browsing plugin structure is created, whereby business logic and encoding logic are strictly separated. Both parsers and business logic are rewritten from scratch. The association of account.journal with res.company is replaced by an association of account.journal with res.partner.bank, thereby allowing multiple bank accounts per company and one journal per bank account. The imported bank statement file does not result in a single 'bank statement', but in a list of bank statements by definition of whatever the bank sees as a statement. Every imported bank statement contains at least one bank transaction, which is a modded account.bank.statement.line. 3. In relation to account_payment: An additional state was inserted between 'open' and 'done', to reflect a exported bank orders file which was not reported back through statements. The import of statements matches the payments and reconciles them when needed, flagging them 'done'. When no export wizards are found, the default behavior is to flag the orders as 'sent', not as 'done'. Rejected payments from the bank receive on import the status 'rejected'. ''' from openerp.osv import orm, fields from openerp.osv.osv import except_osv from openerp.tools.translate import _ from openerp import netsvc from openerp.addons.decimal_precision import decimal_precision as dp class account_banking_account_settings(orm.Model): '''Default Journal for Bank Account''' _name = 'account.banking.account.settings' _description = __doc__ _columns = { 'company_id': fields.many2one('res.company', 'Company', select=True, required=True), 'partner_bank_id': fields.many2one('res.partner.bank', 'Bank Account', select=True, required=True), 'journal_id': fields.many2one('account.journal', 'Journal', required=True), 'partner_id': fields.related( 'company_id', 'partner_id', type='many2one', relation='res.partner', string='Partner'), 'default_credit_account_id': fields.many2one( 'account.account', 'Default credit account', select=True, help=('The account to use when an unexpected payment was signaled.' ' This can happen when a direct debit payment is cancelled ' 'by a customer, or when no matching payment can be found. ' 'Mind that you can correct movements before confirming them.' ), required=True ), 'default_debit_account_id': fields.many2one( 'account.account', 'Default debit account', select=True, required=True, help=('The account to use when an unexpected payment is received. ' 'This can be needed when a customer pays in advance or when ' 'no matching invoice can be found. Mind that you can ' 'correct movements before confirming them.' ), ), 'costs_account_id': fields.many2one( 'account.account', 'Bank Costs Account', select=True, help=('The account to use when the bank invoices its own costs. ' 'Leave it blank to disable automatic invoice generation ' 'on bank costs.' ), ), 'invoice_journal_id': fields.many2one( 'account.journal', 'Costs Journal', help=('This is the journal used to create invoices for bank costs.' ), ), 'bank_partner_id': fields.many2one( 'res.partner', 'Bank Partner', help=('The partner to use for bank costs. Banks are not partners ' 'by default. You will most likely have to create one.' ), ), } def _default_company(self, cr, uid, context=None): """ Return the user's company or the first company found in the database """ user = self.pool.get('res.users').read( cr, uid, uid, ['company_id'], context=context) if user['company_id']: return user['company_id'][0] return self.pool.get('res.company').search( cr, uid, [('parent_id', '=', False)])[0] def _default_partner_id(self, cr, uid, context=None, company_id=False): if not company_id: company_id = self._default_company(cr, uid, context=context) return self.pool.get('res.company').read( cr, uid, company_id, ['partner_id'], context=context)['partner_id'][0] def _default_journal(self, cr, uid, context=None, company_id=False): if not company_id: company_id = self._default_company(cr, uid, context=context) journal_ids = self.pool.get('account.journal').search( cr, uid, [('type', '=', 'bank'), ('company_id', '=', company_id)]) return journal_ids and journal_ids[0] or False def _default_partner_bank_id( self, cr, uid, context=None, company_id=False): if not company_id: company_id = self._default_company(cr, uid, context=context) partner_id = self.pool.get('res.company').read( cr, uid, company_id, ['partner_id'], context=context)['partner_id'][0] bank_ids = self.pool.get('res.partner.bank').search( cr, uid, [('partner_id', '=', partner_id)], context=context) return bank_ids and bank_ids[0] or False def _default_debit_account_id( self, cr, uid, context=None, company_id=False): localcontext = context and context.copy() or {} localcontext['force_company'] = ( company_id or self._default_company(cr, uid, context=context)) account_def = self.pool.get('ir.property').get( cr, uid, 'property_account_receivable', 'res.partner', context=localcontext) return account_def and account_def.id or False def _default_credit_account_id( self, cr, uid, context=None, company_id=False): localcontext = context and context.copy() or {} localcontext['force_company'] = ( company_id or self._default_company(cr, uid, context=context)) account_def = self.pool.get('ir.property').get( cr, uid, 'property_account_payable', 'res.partner', context=localcontext) return account_def and account_def.id or False def find(self, cr, uid, journal_id, partner_bank_id=False, context=None): domain = [('journal_id', '=', journal_id)] if partner_bank_id: domain.append(('partner_bank_id', '=', partner_bank_id)) return self.search(cr, uid, domain, context=context) def onchange_partner_bank_id( self, cr, uid, ids, partner_bank_id, context=None): values = {} if partner_bank_id: bank = self.pool.get('res.partner.bank').read( cr, uid, partner_bank_id, ['journal_id'], context=context) if bank['journal_id']: values['journal_id'] = bank['journal_id'][0] return {'value': values} def onchange_company_id( self, cr, uid, ids, company_id=False, context=None): if not company_id: return {} result = { 'partner_id': self._default_partner_id( cr, uid, company_id=company_id, context=context), 'journal_id': self._default_journal( cr, uid, company_id=company_id, context=context), 'default_debit_account_id': self._default_debit_account_id( cr, uid, company_id=company_id, context=context), 'default_credit_account_id': self._default_credit_account_id( cr, uid, company_id=company_id, context=context), } return {'value': result} _defaults = { 'company_id': _default_company, 'partner_id': _default_partner_id, 'journal_id': _default_journal, 'default_debit_account_id': _default_debit_account_id, 'default_credit_account_id': _default_credit_account_id, 'partner_bank_id': _default_partner_bank_id, } account_banking_account_settings() class account_banking_imported_file(orm.Model): '''Imported Bank Statements File''' _name = 'account.banking.imported.file' _description = __doc__ _rec_name = 'date' _columns = { 'company_id': fields.many2one( 'res.company', 'Company', select=True, readonly=True, ), 'date': fields.datetime( 'Import Date', readonly=True, select=True, states={'draft': [('readonly', False)]}, ), 'format': fields.char( 'File Format', size=20, readonly=True, states={'draft': [('readonly', False)]}, ), 'file': fields.binary( 'Raw Data', readonly=True, states={'draft': [('readonly', False)]}, ), 'file_name': fields.char('File name', size=256), 'log': fields.text( 'Import Log', readonly=True, states={'draft': [('readonly', False)]}, ), 'user_id': fields.many2one( 'res.users', 'Responsible User', readonly=True, select=True, states={'draft': [('readonly', False)]}, ), 'state': fields.selection( [ ('unfinished', 'Unfinished'), ('error', 'Error'), ('review', 'Review'), ('ready', 'Finished'), ], 'State', select=True, readonly=True, ), 'statement_ids': fields.one2many( 'account.bank.statement', 'banking_id', 'Statements', readonly=False, ), } _defaults = { 'date': fields.date.context_today, 'user_id': lambda self, cr, uid, context: uid, } account_banking_imported_file() class account_bank_statement(orm.Model): ''' Implement changes to this model for the following features: * bank statement lines have their own period_id, derived from their effective date. The period and date are propagated to the move lines created from each statement line * bank statement lines have their own state. When a statement is confirmed, all lines are confirmed too. When a statement is reopened, lines remain confirmed until reopened individually. * upon confirmation of a statement line, the move line is created and reconciled according to the matched entry(/ies) ''' _inherit = 'account.bank.statement' _columns = { 'period_id': fields.many2one( 'account.period', 'Period', required=False, readonly=True, ), 'banking_id': fields.many2one( 'account.banking.imported.file', 'Imported File', readonly=True, ), } _defaults = { 'period_id': False, } def _check_company_id(self, cr, uid, ids, context=None): """ Adapt this constraint method from the account module to reflect the move of period_id to the statement line: also check the periods of the lines. Update the statement period if it does not have one yet. Don't call super, because its check is integrated below and it will break if a statement does not have any lines yet and therefore may not have a period. """ for statement in self.browse(cr, uid, ids, context=context): if (statement.period_id and statement.company_id != statement.period_id.company_id): return False for line in statement.line_ids: if (line.period_id and statement.company_id != line.period_id.company_id): return False if not statement.period_id: statement.write({'period_id': line.period_id.id}) statement.refresh() return True # Redefine the constraint, or it still refer to the original method _constraints = [ (_check_company_id, 'The journal and period chosen have to belong to the same company.', ['journal_id', 'period_id']), ] def _get_period(self, cr, uid, date=False, context=None): """ Used in statement line's _defaults, so it is always triggered on installation or module upgrade even if there are no records without a value. For that reason, we need to be tolerant and allow for the situation in which no period exists for the current date (i.e. when no date is specified). Cannot be used directly as a defaults method due to lp:1296229 """ local_ctx = dict(context or {}, account_period_prefer_normal=True) try: return self.pool.get('account.period').find( cr, uid, dt=date, context=local_ctx)[0] except except_osv: if date: raise return False def _prepare_move( self, cr, uid, st_line, st_line_number, context=None): """ Add the statement line's period to the move, overwriting the period on the statement """ res = super(account_bank_statement, self)._prepare_move( cr, uid, st_line, st_line_number, context=context) if context and context.get('period_id'): res['period_id'] = context['period_id'] return res def _prepare_move_line_vals( self, cr, uid, st_line, move_id, debit, credit, currency_id=False, amount_currency=False, account_id=False, analytic_id=False, partner_id=False, context=None): """ Add the statement line's period to the move lines, overwriting the period on the statement """ res = super(account_bank_statement, self)._prepare_move_line_vals( cr, uid, st_line, move_id, debit, credit, currency_id=currency_id, amount_currency=amount_currency, account_id=account_id, analytic_id=analytic_id, partner_id=partner_id, context=context) if context and context.get('period_id'): res['period_id'] = context['period_id'] return res def create_move_from_st_line(self, cr, uid, st_line_id, company_currency_id, st_line_number, context=None): if context is None: context = {} account_move_obj = self.pool.get('account.move') account_move_line_obj = self.pool.get('account.move.line') account_bank_statement_line_obj = self.pool.get( 'account.bank.statement.line') st_line = account_bank_statement_line_obj.browse( cr, uid, st_line_id, context=context) # Take period from statement line and write to context # this will be picked up by the _prepare_move* methods period_id = self._get_period( cr, uid, date=st_line.date, context=context) localctx = context.copy() localctx['period_id'] = period_id # Write date & period on the voucher, delegate to account_voucher's # override of this method. Then post the related move and return. if st_line.voucher_id: voucher_pool = self.pool.get('account.voucher') voucher_pool.write( cr, uid, [st_line.voucher_id.id], { 'date': st_line.date, 'period_id': period_id, }, context=context) res = super(account_bank_statement, self).create_move_from_st_line( cr, uid, st_line_id, company_currency_id, st_line_number, context=localctx) st_line.refresh() if st_line.voucher_id: if not st_line.voucher_id.journal_id.entry_posted: account_move_obj.post( cr, uid, [st_line.voucher_id.move_id.id], context={}) else: # Write stored reconcile_id and pay invoices through workflow if st_line.reconcile_id: move_ids = [move.id for move in st_line.move_ids] torec = account_move_line_obj.search( cr, uid, [ ('move_id', 'in', move_ids), ('account_id', '=', st_line.account_id.id)], context=context) account_move_line_obj.write(cr, uid, torec, { (st_line.reconcile_id.line_partial_ids and 'reconcile_partial_id' or 'reconcile_id'): st_line.reconcile_id.id }, context=context) for move_line in (st_line.reconcile_id.line_id or []) + ( st_line.reconcile_id.line_partial_ids or []): netsvc.LocalService("workflow").trg_trigger( uid, 'account.move.line', move_line.id, cr) return res def button_confirm_bank(self, cr, uid, ids, context=None): """ Assign journal sequence to statements without a name """ if context is None: context = {} obj_seq = self.pool.get('ir.sequence') if ids and isinstance(ids, (int, long)): ids = [ids] noname_ids = self.search( cr, uid, [('id', 'in', ids), ('name', '=', '/')], context=context) for st in self.browse(cr, uid, noname_ids, context=context): if st.journal_id.sequence_id: period_id = self._get_period( cr, uid, date=st.date, context=context) year = self.pool.get('account.period').browse( cr, uid, period_id, context=context).fiscalyear_id.id c = {'fiscalyear_id': year} st_number = obj_seq.get_id( cr, uid, st.journal_id.sequence_id.id, context=c) self.write( cr, uid, ids, {'name': st_number}, context=context) return super(account_bank_statement, self).button_confirm_bank( cr, uid, ids, context) class account_voucher(orm.Model): _inherit = 'account.voucher' def _get_period(self, cr, uid, context=None): if context is None: context = {} if not context.get('period_id') and context.get('move_line_ids'): move_line = self.pool.get('account.move.line').browse( cr, uid, context.get('move_line_ids')[0], context=context) return move_line.period_id.id return super(account_voucher, self)._get_period(cr, uid, context) class account_bank_statement_line(orm.Model): ''' Extension on basic class: 1. Extra links to account.period and res.partner.bank for tracing and matching. 2. Extra 'trans' field to carry the transaction id of the bank. 3. Readonly states for most fields except when in draft. ''' _inherit = 'account.bank.statement.line' _description = 'Bank Transaction' def _get_period(self, cr, uid, date=False, context=None): return self.pool['account.bank.statement']._get_period( cr, uid, date=date, context=context) def _get_period_context(self, cr, uid, context=None): """ Workaround for lp:1296229, context is passed positionally """ return self._get_period(cr, uid, context=context) def _get_currency(self, cr, uid, context=None): ''' Get the default currency (required to allow other modules to function, which assume currency to be a calculated field and thus optional) Remark: this is only a fallback as the real default is in the journal, which is inaccessible from within this method. ''' res_users_obj = self.pool.get('res.users') return res_users_obj.browse( cr, uid, uid, context=context).company_id.currency_id.id def _get_invoice_id(self, cr, uid, ids, name, args, context=None): res = {} for st_line in self.browse(cr, uid, ids, context): res[st_line.id] = False for move_line in ( st_line.reconcile_id and (st_line.reconcile_id.line_id or st_line.reconcile_id.line_partial_ids) or st_line.import_transaction_id and st_line.import_transaction_id.move_line_id and [st_line.import_transaction_id.move_line_id] or []): if move_line.invoice: res[st_line.id] = move_line.invoice.id continue return res _columns = { # Redefines. Todo: refactor away to view attrs 'amount': fields.float( 'Amount', readonly=True, digits_compute=dp.get_precision('Account'), states={'draft': [('readonly', False)]}, ), 'ref': fields.char( 'Ref.', size=32, readonly=True, states={'draft': [('readonly', False)]}, ), 'name': fields.char( 'Name', size=64, required=False, readonly=True, states={'draft': [('readonly', False)]}, ), 'date': fields.date( 'Date', required=True, readonly=True, states={'draft': [('readonly', False)]}, ), # New columns 'trans': fields.char( 'Bank Transaction ID', size=15, required=False, readonly=True, states={'draft': [('readonly', False)]}, ), 'partner_bank_id': fields.many2one( 'res.partner.bank', 'Bank Account', required=False, readonly=True, states={'draft': [('readonly', False)]}, ), 'period_id': fields.many2one( 'account.period', 'Period', required=True, states={'confirmed': [('readonly', True)]}, ), 'currency': fields.many2one( 'res.currency', 'Currency', required=True, states={'confirmed': [('readonly', True)]}, ), 'reconcile_id': fields.many2one( 'account.move.reconcile', 'Reconciliation', readonly=True, ), 'invoice_id': fields.function( _get_invoice_id, method=True, string='Linked Invoice', type='many2one', relation='account.invoice', ), } _defaults = { 'period_id': _get_period_context, 'currency': _get_currency, } class invoice(orm.Model): ''' Create other reference types as well. Descendant classes can extend this function to add more reference types, ie. def _get_reference_type(self, cr, uid, context=None): return super(my_class, self)._get_reference_type(cr, uid, context=context) + [('my_ref', _('My reference')] Don't forget to redefine the column "reference_type" as below or your method will never be triggered. TODO: move 'structured' part to account_banking_payment module where it belongs ''' _inherit = 'account.invoice' def test_undo_paid(self, cr, uid, ids, context=None): """ Called from the workflow. Used to unset paid state on invoices that were paid with bank transfers which are being cancelled """ for invoice in self.read(cr, uid, ids, ['reconciled'], context): if invoice['reconciled']: return False return True def _get_reference_type(self, cr, uid, context=None): ''' Return the list of reference types ''' return [('none', _('Free Reference')), ('structured', _('Structured Reference')), ] _columns = { 'reference_type': fields.selection(_get_reference_type, 'Reference Type', required=True ) } class account_move_line(orm.Model): _inherit = "account.move.line" def get_balance(self, cr, uid, ids, context=None): """ Return the balance of any set of move lines. Not to be confused with the 'balance' field on this model, which returns the account balance that the move line applies to. """ total = 0.0 if not ids: return total for line in self.read( cr, uid, ids, ['debit', 'credit'], context=context): total += (line['debit'] or 0.0) - (line['credit'] or 0.0) return total