addons/account/account.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 import time
  23 from datetime import datetime
  24 from dateutil.relativedelta import relativedelta
  25 from operator import itemgetter
  26
  27 import logging
  28 import pooler
  29 from osv import fields, osv
  30 import decimal_precision as dp
  31 from tools.translate import _
  32 from tools.float_utils import float_round
  33
  34 _logger = logging.getLogger(__name__)
  35
  36 def check_cycle(self, cr, uid, ids, context=None):
  37     """ climbs the ``self._table.parent_id`` chains for 100 levels or
  38     until it can't find any more parent(s)
  39
  40     Returns true if it runs out of parents (no cycle), false if
  41     it can recurse 100 times without ending all chains
  42     """
  43     level = 100
  44     while len(ids):
  45         cr.execute('SELECT DISTINCT parent_id '\
  46                     'FROM '+self._table+' '\
  47                     'WHERE id IN %s '\
  48                     'AND parent_id IS NOT NULL',(tuple(ids),))
  49         ids = map(itemgetter(0), cr.fetchall())
  50         if not level:
  51             return False
  52         level -= 1
  53     return True
  54
  55 class account_payment_term(osv.osv):
  56     _name = "account.payment.term"
  57     _description = "Payment Term"
  58     _columns = {
  59         'name': fields.char('Payment Term', size=64, translate=True, required=True),
  60         'active': fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the payment term without removing it."),
  61         'note': fields.text('Description', translate=True),
  62         'line_ids': fields.one2many('account.payment.term.line', 'payment_id', 'Terms'),
  63     }
  64     _defaults = {
  65         'active': 1,
  66     }
  67     _order = "name"
  68
  69     def compute(self, cr, uid, id, value, date_ref=False, context=None):
  70         if not date_ref:
  71             date_ref = datetime.now().strftime('%Y-%m-%d')
  72         pt = self.browse(cr, uid, id, context=context)
  73         amount = value
  74         result = []
  75         obj_precision = self.pool.get('decimal.precision')
  76         for line in pt.line_ids:
  77             prec = obj_precision.precision_get(cr, uid, 'Account')
  78             if line.value == 'fixed':
  79                 amt = round(line.value_amount, prec)
  80             elif line.value == 'procent':
  81                 amt = round(value * line.value_amount, prec)
  82             elif line.value == 'balance':
  83                 amt = round(amount, prec)
  84             if amt:
  85                 next_date = (datetime.strptime(date_ref, '%Y-%m-%d') + relativedelta(days=line.days))
  86                 if line.days2 < 0:
  87                     next_first_date = next_date + relativedelta(day=1,months=1) #Getting 1st of next month
  88                     next_date = next_first_date + relativedelta(days=line.days2)
  89                 if line.days2 > 0:
  90                     next_date += relativedelta(day=line.days2, months=1)
  91                 result.append( (next_date.strftime('%Y-%m-%d'), amt) )
  92                 amount -= amt
  93         return result
  94
  95 account_payment_term()
  96
  97 class account_payment_term_line(osv.osv):
  98     _name = "account.payment.term.line"
  99     _description = "Payment Term Line"
 100     _columns = {
 101         'name': fields.char('Line Name', size=32, required=True),
 102         'sequence': fields.integer('Sequence', required=True, help="The sequence field is used to order the payment term lines from the lowest sequences to the higher ones"),
 103         'value': fields.selection([('procent', 'Percent'),
 104                                    ('balance', 'Balance'),
 105                                    ('fixed', 'Fixed Amount')], 'Valuation',
 106                                    required=True, help="""Select here the kind of valuation related to this payment term line. Note that you should have your last line with the type 'Balance' to ensure that the whole amount will be treated."""),
 107
 108         'value_amount': fields.float('Amount To Pay', digits_compute=dp.get_precision('Payment Term'), help="For percent enter a ratio between 0-1."),
 109         'days': fields.integer('Number of Days', required=True, help="Number of days to add before computation of the day of month." \
 110             "If Date=15/01, Number of Days=22, Day of Month=-1, then the due date is 28/02."),
 111         'days2': fields.integer('Day of the Month', required=True, help="Day of the month, set -1 for the last day of the current month. If it's positive, it gives the day of the next month. Set 0 for net days (otherwise it's based on the beginning of the month)."),
 112         'payment_id': fields.many2one('account.payment.term', 'Payment Term', required=True, select=True),
 113     }
 114     _defaults = {
 115         'value': 'balance',
 116         'sequence': 5,
 117         'days2': 0,
 118     }
 119     _order = "sequence"
 120
 121     def _check_percent(self, cr, uid, ids, context=None):
 122         obj = self.browse(cr, uid, ids[0], context=context)
 123         if obj.value == 'procent' and ( obj.value_amount < 0.0 or obj.value_amount > 1.0):
 124             return False
 125         return True
 126
 127     _constraints = [
 128         (_check_percent, 'Percentages for Payment Term Line must be between 0 and 1, Example: 0.02 for 2% ', ['value_amount']),
 129     ]
 130
 131 account_payment_term_line()
 132
 133 class account_account_type(osv.osv):
 134     _name = "account.account.type"
 135     _description = "Account Type"
 136
 137     def _get_current_report_type(self, cr, uid, ids, name, arg, context=None):
 138         obj_data = self.pool.get('ir.model.data')
 139         obj_financial_report = self.pool.get('account.financial.report')
 140         res = {}
 141         financial_report_ref = {
 142             'asset': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_assets0')[1], context=context),
 143             'liability': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_liability0')[1], context=context),
 144             'income': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_income0')[1], context=context),
 145             'expense': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_expense0')[1], context=context),
 146         }
 147         for record in self.browse(cr, uid, ids, context=context):
 148             res[record.id] = 'none'
 149             for key, financial_report in financial_report_ref.items():
 150                 list_ids = [x.id for x in financial_report.account_type_ids]
 151                 if record.id in list_ids:
 152                     res[record.id] = key
 153         return res
 154
 155     def _save_report_type(self, cr, uid, account_type_id, field_name, field_value, arg, context=None):
 156         obj_data = self.pool.get('ir.model.data')
 157         obj_financial_report = self.pool.get('account.financial.report')
 158         #unlink if it exists somewhere in the financial reports related to BS or PL
 159         financial_report_ref = {
 160             'asset': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_assets0')[1], context=context),
 161             'liability': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_liability0')[1], context=context),
 162             'income': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_income0')[1], context=context),
 163             'expense': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_expense0')[1], context=context),
 164         }
 165         for key, financial_report in financial_report_ref.items():
 166             list_ids = [x.id for x in financial_report.account_type_ids]
 167             if account_type_id in list_ids:
 168                 obj_financial_report.write(cr, uid, [financial_report.id], {'account_type_ids': [(3, account_type_id)]})
 169         #write it in the good place
 170         if field_value != 'none':
 171             return obj_financial_report.write(cr, uid, [financial_report_ref[field_value].id], {'account_type_ids': [(4, account_type_id)]})
 172
 173     _columns = {
 174         'name': fields.char('Account Type', size=64, required=True, translate=True),
 175         'code': fields.char('Code', size=32, required=True, select=True),
 176         'close_method': fields.selection([('none', 'None'), ('balance', 'Balance'), ('detail', 'Detail'), ('unreconciled', 'Unreconciled')], 'Deferral Method', required=True, help="""Set here the method that will be used to generate the end of year journal entries for all the accounts of this type.
 177
 178  'None' means that nothing will be done.
 179  'Balance' will generally be used for cash accounts.
 180  'Detail' will copy each existing journal item of the previous year, even the reconciled ones.
 181  'Unreconciled' will copy only the journal items that were unreconciled on the first day of the new fiscal year."""),
 182         'report_type': fields.function(_get_current_report_type, fnct_inv=_save_report_type, type='selection', string='P&L / BS Category',
 183             selection= [('none','/'),
 184                         ('income', _('Profit & Loss (Income account)')),
 185                         ('expense', _('Profit & Loss (Expense account)')),
 186                         ('asset', _('Balance Sheet (Asset account)')),
 187                         ('liability', _('Balance Sheet (Liability account)'))], help="This field is used to generate legal reports: profit and loss, balance sheet.", required=True),
 188         'note': fields.text('Description'),
 189     }
 190     _defaults = {
 191         'close_method': 'none',
 192         'report_type': 'none',
 193     }
 194     _order = "code"
 195
 196 account_account_type()
 197
 198 def _code_get(self, cr, uid, context=None):
 199     acc_type_obj = self.pool.get('account.account.type')
 200     ids = acc_type_obj.search(cr, uid, [])
 201     res = acc_type_obj.read(cr, uid, ids, ['code', 'name'], context=context)
 202     return [(r['code'], r['name']) for r in res]
 203
 204 #----------------------------------------------------------
 205 # Accounts
 206 #----------------------------------------------------------
 207
 208 class account_tax(osv.osv):
 209     _name = 'account.tax'
 210 account_tax()
 211
 212 class account_account(osv.osv):
 213     _order = "parent_left"
 214     _parent_order = "code"
 215     _name = "account.account"
 216     _description = "Account"
 217     _parent_store = True
 218
 219     def search(self, cr, uid, args, offset=0, limit=None, order=None,
 220             context=None, count=False):
 221         if context is None:
 222             context = {}
 223         pos = 0
 224
 225         while pos < len(args):
 226
 227             if args[pos][0] == 'code' and args[pos][1] in ('like', 'ilike') and args[pos][2]:
 228                 args[pos] = ('code', '=like', str(args[pos][2].replace('%', ''))+'%')
 229             if args[pos][0] == 'journal_id':
 230                 if not args[pos][2]:
 231                     del args[pos]
 232                     continue
 233                 jour = self.pool.get('account.journal').browse(cr, uid, args[pos][2], context=context)
 234                 if (not (jour.account_control_ids or jour.type_control_ids)) or not args[pos][2]:
 235                     args[pos] = ('type','not in',('consolidation','view'))
 236                     continue
 237                 ids3 = map(lambda x: x.id, jour.type_control_ids)
 238                 ids1 = super(account_account, self).search(cr, uid, [('user_type', 'in', ids3)])
 239                 ids1 += map(lambda x: x.id, jour.account_control_ids)
 240                 args[pos] = ('id', 'in', ids1)
 241             pos += 1
 242
 243         if context and context.has_key('consolidate_children'): #add consolidated children of accounts
 244             ids = super(account_account, self).search(cr, uid, args, offset, limit,
 245                 order, context=context, count=count)
 246             for consolidate_child in self.browse(cr, uid, context['account_id'], context=context).child_consol_ids:
 247                 ids.append(consolidate_child.id)
 248             return ids
 249
 250         return super(account_account, self).search(cr, uid, args, offset, limit,
 251                 order, context=context, count=count)
 252
 253     def _get_children_and_consol(self, cr, uid, ids, context=None):
 254         #this function search for all the children and all consolidated children (recursively) of the given account ids
 255         ids2 = self.search(cr, uid, [('parent_id', 'child_of', ids)], context=context)
 256         ids3 = []
 257         for rec in self.browse(cr, uid, ids2, context=context):
 258             for child in rec.child_consol_ids:
 259                 ids3.append(child.id)
 260         if ids3:
 261             ids3 = self._get_children_and_consol(cr, uid, ids3, context)
 262         return ids2 + ids3
 263
 264     def __compute(self, cr, uid, ids, field_names, arg=None, context=None,
 265                   query='', query_params=()):
 266         """ compute the balance, debit and/or credit for the provided
 267         account ids
 268         Arguments:
 269         `ids`: account ids
 270         `field_names`: the fields to compute (a list of any of
 271                        'balance', 'debit' and 'credit')
 272         `arg`: unused fields.function stuff
 273         `query`: additional query filter (as a string)
 274         `query_params`: parameters for the provided query string
 275                         (__compute will handle their escaping) as a
 276                         tuple
 277         """
 278         mapping = {
 279             'balance': "COALESCE(SUM(l.debit),0) - COALESCE(SUM(l.credit), 0) as balance",
 280             'debit': "COALESCE(SUM(l.debit), 0) as debit",
 281             'credit': "COALESCE(SUM(l.credit), 0) as credit",
 282             # by convention, foreign_balance is 0 when the account has no secondary currency, because the amounts may be in different currencies
 283             'foreign_balance': "(SELECT CASE WHEN currency_id IS NULL THEN 0 ELSE COALESCE(SUM(l.amount_currency), 0) END FROM account_account WHERE id IN (l.account_id)) as foreign_balance",
 284         }
 285         #get all the necessary accounts
 286         children_and_consolidated = self._get_children_and_consol(cr, uid, ids, context=context)
 287         #compute for each account the balance/debit/credit from the move lines
 288         accounts = {}
 289         res = {}
 290         null_result = dict((fn, 0.0) for fn in field_names)
 291         if children_and_consolidated:
 292             aml_query = self.pool.get('account.move.line')._query_get(cr, uid, context=context)
 293
 294             wheres = [""]
 295             if query.strip():
 296                 wheres.append(query.strip())
 297             if aml_query.strip():
 298                 wheres.append(aml_query.strip())
 299             filters = " AND ".join(wheres)
 300             _logger.debug('Filters: %s',(filters))
 301             # IN might not work ideally in case there are too many
 302             # children_and_consolidated, in that case join on a
 303             # values() e.g.:
 304             # SELECT l.account_id as id FROM account_move_line l
 305             # INNER JOIN (VALUES (id1), (id2), (id3), ...) AS tmp (id)
 306             # ON l.account_id = tmp.id
 307             # or make _get_children_and_consol return a query and join on that
 308             request = ("SELECT l.account_id as id, " +\
 309                        ', '.join(mapping.values()) +
 310                        " FROM account_move_line l" \
 311                        " WHERE l.account_id IN %s " \
 312                             + filters +
 313                        " GROUP BY l.account_id")
 314             params = (tuple(children_and_consolidated),) + query_params
 315             cr.execute(request, params)
 316             _logger.debug('Status: %s',(cr.statusmessage))
 317
 318             for row in cr.dictfetchall():
 319                 accounts[row['id']] = row
 320
 321             # consolidate accounts with direct children
 322             children_and_consolidated.reverse()
 323             brs = list(self.browse(cr, uid, children_and_consolidated, context=context))
 324             sums = {}
 325             currency_obj = self.pool.get('res.currency')
 326             while brs:
 327                 current = brs.pop(0)
 328 #                can_compute = True
 329 #                for child in current.child_id:
 330 #                    if child.id not in sums:
 331 #                        can_compute = False
 332 #                        try:
 333 #                            brs.insert(0, brs.pop(brs.index(child)))
 334 #                        except ValueError:
 335 #                            brs.insert(0, child)
 336 #                if can_compute:
 337                 for fn in field_names:
 338                     sums.setdefault(current.id, {})[fn] = accounts.get(current.id, {}).get(fn, 0.0)
 339                     for child in current.child_id:
 340                         if child.company_id.currency_id.id == current.company_id.currency_id.id:
 341                             sums[current.id][fn] += sums[child.id][fn]
 342                         else:
 343                             sums[current.id][fn] += currency_obj.compute(cr, uid, child.company_id.currency_id.id, current.company_id.currency_id.id, sums[child.id][fn], context=context)
 344
 345                 # as we have to relay on values computed before this is calculated separately than previous fields
 346                 if current.currency_id and current.exchange_rate and \
 347                             ('adjusted_balance' in field_names or 'unrealized_gain_loss' in field_names):
 348                     # Computing Adjusted Balance and Unrealized Gains and losses
 349                     # Adjusted Balance = Foreign Balance / Exchange Rate
 350                     # Unrealized Gains and losses = Adjusted Balance - Balance
 351                     adj_bal = sums[current.id].get('foreign_balance', 0.0) / current.exchange_rate
 352                     sums[current.id].update({'adjusted_balance': adj_bal, 'unrealized_gain_loss': adj_bal - sums[current.id].get('balance', 0.0)})
 353
 354             for id in ids:
 355                 res[id] = sums.get(id, null_result)
 356         else:
 357             for id in ids:
 358                 res[id] = null_result
 359         return res
 360
 361     def _get_company_currency(self, cr, uid, ids, field_name, arg, context=None):
 362         result = {}
 363         for rec in self.browse(cr, uid, ids, context=context):
 364             result[rec.id] = (rec.company_id.currency_id.id,rec.company_id.currency_id.symbol)
 365         return result
 366
 367     def _get_child_ids(self, cr, uid, ids, field_name, arg, context=None):
 368         result = {}
 369         for record in self.browse(cr, uid, ids, context=context):
 370             if record.child_parent_ids:
 371                 result[record.id] = [x.id for x in record.child_parent_ids]
 372             else:
 373                 result[record.id] = []
 374
 375             if record.child_consol_ids:
 376                 for acc in record.child_consol_ids:
 377                     if acc.id not in result[record.id]:
 378                         result[record.id].append(acc.id)
 379
 380         return result
 381
 382     def _get_level(self, cr, uid, ids, field_name, arg, context=None):
 383         res = {}
 384         for account in self.browse(cr, uid, ids, context=context):
 385             #we may not know the level of the parent at the time of computation, so we
 386             # can't simply do res[account.id] = account.parent_id.level + 1
 387             level = 0
 388             parent = account.parent_id
 389             while parent:
 390                 level += 1
 391                 parent = parent.parent_id
 392             res[account.id] = level
 393         return res
 394
 395     def _set_credit_debit(self, cr, uid, account_id, name, value, arg, context=None):
 396         if context.get('config_invisible', True):
 397             return True
 398
 399         account = self.browse(cr, uid, account_id, context=context)
 400         diff = value - getattr(account,name)
 401         if not diff:
 402             return True
 403
 404         journal_obj = self.pool.get('account.journal')
 405         jids = journal_obj.search(cr, uid, [('type','=','situation'),('centralisation','=',1),('company_id','=',account.company_id.id)], context=context)
 406         if not jids:
 407             raise osv.except_osv(_('Error!'),_("You need an Opening journal with centralisation checked to set the initial balance!"))
 408
 409         period_obj = self.pool.get('account.period')
 410         pids = period_obj.search(cr, uid, [('special','=',True),('company_id','=',account.company_id.id)], context=context)
 411         if not pids:
 412             raise osv.except_osv(_('Error!'),_("No opening/closing period defined, please create one to set the initial balance!"))
 413
 414         move_obj = self.pool.get('account.move.line')
 415         move_id = move_obj.search(cr, uid, [
 416             ('journal_id','=',jids[0]),
 417             ('period_id','=',pids[0]),
 418             ('account_id','=', account_id),
 419             (name,'>', 0.0),
 420             ('name','=', _('Opening Balance'))
 421         ], context=context)
 422         if move_id:
 423             move = move_obj.browse(cr, uid, move_id[0], context=context)
 424             move_obj.write(cr, uid, move_id[0], {
 425                 name: diff+getattr(move,name)
 426             }, context=context)
 427         else:
 428             if diff<0.0:
 429                 raise osv.except_osv(_('Error!'),_("Unable to adapt the initial balance (negative value)!"))
 430             nameinv = (name=='credit' and 'debit') or 'credit'
 431             move_id = move_obj.create(cr, uid, {
 432                 'name': _('Opening Balance'),
 433                 'account_id': account_id,
 434                 'journal_id': jids[0],
 435                 'period_id': pids[0],
 436                 name: diff,
 437                 nameinv: 0.0
 438             }, context=context)
 439         return True
 440
 441     _columns = {
 442         'name': fields.char('Name', size=256, required=True, select=True),
 443         'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
 444         'code': fields.char('Code', size=64, required=True, select=1),
 445         'type': fields.selection([
 446             ('view', 'View'),
 447             ('other', 'Regular'),
 448             ('receivable', 'Receivable'),
 449             ('payable', 'Payable'),
 450             ('liquidity','Liquidity'),
 451             ('consolidation', 'Consolidation'),
 452             ('closed', 'Closed'),
 453         ], 'Internal Type', required=True, help="The 'Internal Type' is used for features available on "\
 454             "different types of accounts: view can not have journal items, consolidation are accounts that "\
 455             "can have children accounts for multi-company consolidations, payable/receivable are for "\
 456             "partners accounts (for debit/credit computations), closed for depreciated accounts."),
 457         'user_type': fields.many2one('account.account.type', 'Account Type', required=True,
 458             help="Account Type is used for information purpose, to generate "
 459               "country-specific legal reports, and set the rules to close a fiscal year and generate opening entries."),
 460         'financial_report_ids': fields.many2many('account.financial.report', 'account_account_financial_report', 'account_id', 'report_line_id', 'Financial Reports'),
 461         'parent_id': fields.many2one('account.account', 'Parent', ondelete='cascade', domain=[('type','=','view')]),
 462         'child_parent_ids': fields.one2many('account.account','parent_id','Children'),
 463         'child_consol_ids': fields.many2many('account.account', 'account_account_consol_rel', 'child_id', 'parent_id', 'Consolidated Children'),
 464         'child_id': fields.function(_get_child_ids, type='many2many', relation="account.account", string="Child Accounts"),
 465         'balance': fields.function(__compute, digits_compute=dp.get_precision('Account'), string='Balance', multi='balance'),
 466         'credit': fields.function(__compute, fnct_inv=_set_credit_debit, digits_compute=dp.get_precision('Account'), string='Credit', multi='balance'),
 467         'debit': fields.function(__compute, fnct_inv=_set_credit_debit, digits_compute=dp.get_precision('Account'), string='Debit', multi='balance'),
 468         'foreign_balance': fields.function(__compute, digits_compute=dp.get_precision('Account'), string='Foreign Balance', multi='balance',
 469                                            help="Total amount (in Secondary currency) for transactions held in secondary currency for this account."),
 470         'adjusted_balance': fields.function(__compute, digits_compute=dp.get_precision('Account'), string='Adjusted Balance', multi='balance',
 471                                             help="Total amount (in Company currency) for transactions held in secondary currency for this account."),
 472         'unrealized_gain_loss': fields.function(__compute, digits_compute=dp.get_precision('Account'), string='Unrealized Gain or Loss', multi='balance',
 473                                                 help="Value of Loss or Gain due to changes in exchange rate when doing multi-currency transactions."),
 474         'reconcile': fields.boolean('Allow Reconciliation', help="Check this box if this account allows reconciliation of journal items."),
 475         'exchange_rate': fields.related('currency_id', 'rate', type='float', string='Exchange Rate', digits=(12,6)),
 476         'shortcut': fields.char('Shortcut', size=12),
 477         'tax_ids': fields.many2many('account.tax', 'account_account_tax_default_rel',
 478             'account_id', 'tax_id', 'Default Taxes'),
 479         'note': fields.text('Internal Notes'),
 480         'company_currency_id': fields.function(_get_company_currency, type='many2one', relation='res.currency', string='Company Currency'),
 481         'company_id': fields.many2one('res.company', 'Company', required=True),
 482         'active': fields.boolean('Active', select=2, help="If the active field is set to False, it will allow you to hide the account without removing it."),
 483
 484         'parent_left': fields.integer('Parent Left', select=1),
 485         'parent_right': fields.integer('Parent Right', select=1),
 486         'currency_mode': fields.selection([('current', 'At Date'), ('average', 'Average Rate')], 'Outgoing Currencies Rate',
 487             help=
 488             'This will select how the current currency rate for outgoing transactions is computed. '\
 489             'In most countries the legal method is "average" but only a few software systems are able to '\
 490             'manage this. So if you import from another software system you may have to use the rate at date. ' \
 491             'Incoming transactions always use the rate at date.', \
 492             required=True),
 493         'level': fields.function(_get_level, string='Level', method=True, type='integer',
 494              store={
 495                     'account.account': (_get_children_and_consol, ['level', 'parent_id'], 10),
 496                    }),
 497     }
 498
 499     _defaults = {
 500         'type': 'other',
 501         'reconcile': False,
 502         'active': True,
 503         'currency_mode': 'current',
 504         'company_id': lambda s, cr, uid, c: s.pool.get('res.company')._company_default_get(cr, uid, 'account.account', context=c),
 505     }
 506
 507     def _check_recursion(self, cr, uid, ids, context=None):
 508         obj_self = self.browse(cr, uid, ids[0], context=context)
 509         p_id = obj_self.parent_id and obj_self.parent_id.id
 510         if (obj_self in obj_self.child_consol_ids) or (p_id and (p_id is obj_self.id)):
 511             return False
 512         while(ids):
 513             cr.execute('SELECT DISTINCT child_id '\
 514                        'FROM account_account_consol_rel '\
 515                        'WHERE parent_id IN %s', (tuple(ids),))
 516             child_ids = map(itemgetter(0), cr.fetchall())
 517             c_ids = child_ids
 518             if (p_id and (p_id in c_ids)) or (obj_self.id in c_ids):
 519                 return False
 520             while len(c_ids):
 521                 s_ids = self.search(cr, uid, [('parent_id', 'in', c_ids)])
 522                 if p_id and (p_id in s_ids):
 523                     return False
 524                 c_ids = s_ids
 525             ids = child_ids
 526         return True
 527
 528     def _check_type(self, cr, uid, ids, context=None):
 529         if context is None:
 530             context = {}
 531         accounts = self.browse(cr, uid, ids, context=context)
 532         for account in accounts:
 533             if account.child_id and account.type not in ('view', 'consolidation'):
 534                 return False
 535         return True
 536
 537     def _check_account_type(self, cr, uid, ids, context=None):
 538         for account in self.browse(cr, uid, ids, context=context):
 539             if account.type in ('receivable', 'payable') and account.user_type.close_method != 'unreconciled':
 540                 return False
 541         return True
 542
 543     _constraints = [
 544         (_check_recursion, 'Error ! You can not create recursive accounts.', ['parent_id']),
 545         (_check_type, 'Configuration Error! \nYou can not define children to an account with internal type different of "View"! ', ['type']),
 546         (_check_account_type, 'Configuration Error! \nYou can not select an account type with a deferral method different of "Unreconciled" for accounts with internal type "Payable/Receivable"! ', ['user_type','type']),
 547     ]
 548     _sql_constraints = [
 549         ('code_company_uniq', 'unique (code,company_id)', 'The code of the account must be unique per company !')
 550     ]
 551     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=100):
 552         if not args:
 553             args = []
 554         args = args[:]
 555         ids = []
 556         try:
 557             if name and str(name).startswith('partner:'):
 558                 part_id = int(name.split(':')[1])
 559                 part = self.pool.get('res.partner').browse(cr, user, part_id, context=context)
 560                 args += [('id', 'in', (part.property_account_payable.id, part.property_account_receivable.id))]
 561                 name = False
 562             if name and str(name).startswith('type:'):
 563                 type = name.split(':')[1]
 564                 args += [('type', '=', type)]
 565                 name = False
 566         except:
 567             pass
 568         if name:
 569             ids = self.search(cr, user, [('code', '=like', name+"%")]+args, limit=limit)
 570             if not ids:
 571                 ids = self.search(cr, user, [('shortcut', '=', name)]+ args, limit=limit)
 572             if not ids:
 573                 ids = self.search(cr, user, [('name', operator, name)]+ args, limit=limit)
 574             if not ids and len(name.split()) >= 2:
 575                 #Separating code and name of account for searching
 576                 operand1,operand2 = name.split(' ',1) #name can contain spaces e.g. OpenERP S.A.
 577                 ids = self.search(cr, user, [('code', operator, operand1), ('name', operator, operand2)]+ args, limit=limit)
 578         else:
 579             ids = self.search(cr, user, args, context=context, limit=limit)
 580         return self.name_get(cr, user, ids, context=context)
 581
 582     def name_get(self, cr, uid, ids, context=None):
 583         if not ids:
 584             return []
 585         reads = self.read(cr, uid, ids, ['name', 'code'], context=context)
 586         res = []
 587         for record in reads:
 588             name = record['name']
 589             if record['code']:
 590                 name = record['code'] + ' ' + name
 591             res.append((record['id'], name))
 592         return res
 593
 594     def copy(self, cr, uid, id, default={}, context=None, done_list=[], local=False):
 595         account = self.browse(cr, uid, id, context=context)
 596         new_child_ids = []
 597         if not default:
 598             default = {}
 599         default = default.copy()
 600         default['code'] = (account['code'] or '') + '(copy)'
 601         if not local:
 602             done_list = []
 603         if account.id in done_list:
 604             return False
 605         done_list.append(account.id)
 606         if account:
 607             for child in account.child_id:
 608                 child_ids = self.copy(cr, uid, child.id, default, context=context, done_list=done_list, local=True)
 609                 if child_ids:
 610                     new_child_ids.append(child_ids)
 611             default['child_parent_ids'] = [(6, 0, new_child_ids)]
 612         else:
 613             default['child_parent_ids'] = False
 614         return super(account_account, self).copy(cr, uid, id, default, context=context)
 615
 616     def _check_moves(self, cr, uid, ids, method, context=None):
 617         line_obj = self.pool.get('account.move.line')
 618         account_ids = self.search(cr, uid, [('id', 'child_of', ids)])
 619
 620         if line_obj.search(cr, uid, [('account_id', 'in', account_ids)]):
 621             if method == 'write':
 622                 raise osv.except_osv(_('Error !'), _('You can not desactivate an account that contains some journal items.'))
 623             elif method == 'unlink':
 624                 raise osv.except_osv(_('Error !'), _('You can not remove an account containing journal items.'))
 625         #Checking whether the account is set as a property to any Partner or not
 626         value = 'account.account,' + str(ids[0])
 627         partner_prop_acc = self.pool.get('ir.property').search(cr, uid, [('value_reference','=',value)], context=context)
 628         if partner_prop_acc:
 629             raise osv.except_osv(_('Warning !'), _('You can not remove/desactivate an account which is set on a customer or supplier.'))
 630         return True
 631
 632     def _check_allow_type_change(self, cr, uid, ids, new_type, context=None):
 633         group1 = ['payable', 'receivable', 'other']
 634         group2 = ['consolidation','view']
 635         line_obj = self.pool.get('account.move.line')
 636         for account in self.browse(cr, uid, ids, context=context):
 637             old_type = account.type
 638             account_ids = self.search(cr, uid, [('id', 'child_of', [account.id])])
 639             if line_obj.search(cr, uid, [('account_id', 'in', account_ids)]):
 640                 #Check for 'Closed' type
 641                 if old_type == 'closed' and new_type !='closed':
 642                     raise osv.except_osv(_('Warning !'), _("You cannot change the type of account from 'Closed' to any other type which contains journal items!"))
 643                 #Check for change From group1 to group2 and vice versa
 644                 if (old_type in group1 and new_type in group2) or (old_type in group2 and new_type in group1):
 645                     raise osv.except_osv(_('Warning !'), _("You cannot change the type of account from '%s' to '%s' type as it contains journal items!") % (old_type,new_type,))
 646         return True
 647
 648     def write(self, cr, uid, ids, vals, context=None):
 649
 650         if context is None:
 651             context = {}
 652         if not ids:
 653             return True
 654         if isinstance(ids, (int, long)):
 655             ids = [ids]
 656
 657         # Dont allow changing the company_id when account_move_line already exist
 658         if 'company_id' in vals:
 659             move_lines = self.pool.get('account.move.line').search(cr, uid, [('account_id', 'in', ids)])
 660             if move_lines:
 661                 # Allow the write if the value is the same
 662                 for i in [i['company_id'][0] for i in self.read(cr,uid,ids,['company_id'])]:
 663                     if vals['company_id']!=i:
 664                         raise osv.except_osv(_('Warning !'), _('You cannot change the owner company of an account that already contains journal items.'))
 665         if 'active' in vals and not vals['active']:
 666             self._check_moves(cr, uid, ids, "write", context=context)
 667         if 'type' in vals.keys():
 668             self._check_allow_type_change(cr, uid, ids, vals['type'], context=context)
 669         return super(account_account, self).write(cr, uid, ids, vals, context=context)
 670
 671     def unlink(self, cr, uid, ids, context=None):
 672         self._check_moves(cr, uid, ids, "unlink", context=context)
 673         return super(account_account, self).unlink(cr, uid, ids, context=context)
 674
 675 account_account()
 676
 677 class account_journal_view(osv.osv):
 678     _name = "account.journal.view"
 679     _description = "Journal View"
 680     _columns = {
 681         'name': fields.char('Journal View', size=64, required=True),
 682         'columns_id': fields.one2many('account.journal.column', 'view_id', 'Columns')
 683     }
 684     _order = "name"
 685
 686 account_journal_view()
 687
 688
 689 class account_journal_column(osv.osv):
 690
 691     def _col_get(self, cr, user, context=None):
 692         result = []
 693         cols = self.pool.get('account.move.line')._columns
 694         for col in cols:
 695             if col in ('period_id', 'journal_id'):
 696                 continue
 697             result.append( (col, cols[col].string) )
 698         result.sort()
 699         return result
 700
 701     _name = "account.journal.column"
 702     _description = "Journal Column"
 703     _columns = {
 704         'name': fields.char('Column Name', size=64, required=True),
 705         'field': fields.selection(_col_get, 'Field Name', required=True, size=32),
 706         'view_id': fields.many2one('account.journal.view', 'Journal View', select=True),
 707         'sequence': fields.integer('Sequence', help="Gives the sequence order to journal column.", readonly=True),
 708         'required': fields.boolean('Required'),
 709         'readonly': fields.boolean('Readonly'),
 710     }
 711     _order = "view_id, sequence"
 712
 713 account_journal_column()
 714
 715 class account_journal(osv.osv):
 716     _name = "account.journal"
 717     _description = "Journal"
 718     _columns = {
 719         'with_last_closing_balance' : fields.boolean('Opening With Last Closing Balance'),
 720         'name': fields.char('Journal Name', size=64, required=True),
 721         'code': fields.char('Code', size=5, required=True, help="The code will be displayed on reports."),
 722         'type': fields.selection([('sale', 'Sale'),('sale_refund','Sale Refund'), ('purchase', 'Purchase'), ('purchase_refund','Purchase Refund'), ('cash', 'Cash'), ('bank', 'Bank and Cheques'), ('general', 'General'), ('situation', 'Opening/Closing Situation')], 'Type', size=32, required=True,
 723                                  help="Select 'Sale' for customer invoices journals."\
 724                                  " Select 'Purchase' for supplier invoices journals."\
 725                                  " Select 'Cash' or 'Bank' for journals that are used in customer or supplier payments."\
 726                                  " Select 'General' for miscellaneous operations journals."\
 727                                  " Select 'Opening/Closing Situation' for entries generated for new fiscal years."),
 728         'type_control_ids': fields.many2many('account.account.type', 'account_journal_type_rel', 'journal_id','type_id', 'Type Controls', domain=[('code','<>','view'), ('code', '<>', 'closed')]),
 729         'account_control_ids': fields.many2many('account.account', 'account_account_type_rel', 'journal_id','account_id', 'Account', domain=[('type','<>','view'), ('type', '<>', 'closed')]),
 730         'view_id': fields.many2one('account.journal.view', 'Display Mode', required=True, help="Gives the view used when writing or browsing entries in this journal. The view tells OpenERP which fields should be visible, required or readonly and in which order. You can create your own view for a faster encoding in each journal."),
 731         'default_credit_account_id': fields.many2one('account.account', 'Default Credit Account', domain="[('type','!=','view')]", help="It acts as a default account for credit amount"),
 732         'default_debit_account_id': fields.many2one('account.account', 'Default Debit Account', domain="[('type','!=','view')]", help="It acts as a default account for debit amount"),
 733         'centralisation': fields.boolean('Centralised counterpart', help="Check this box to determine that each entry of this journal won't create a new counterpart but will share the same counterpart. This is used in fiscal year closing."),
 734         'update_posted': fields.boolean('Allow Cancelling Entries', help="Check this box if you want to allow the cancellation the entries related to this journal or of the invoice related to this journal"),
 735         'group_invoice_lines': fields.boolean('Group Invoice Lines', help="If this box is checked, the system will try to group the accounting lines when generating them from invoices."),
 736         'sequence_id': fields.many2one('ir.sequence', 'Entry Sequence', help="This field contains the information related to the numbering of the journal entries of this journal.", required=True),
 737         'user_id': fields.many2one('res.users', 'User', help="The user responsible for this journal"),
 738         'groups_id': fields.many2many('res.groups', 'account_journal_group_rel', 'journal_id', 'group_id', 'Groups'),
 739         'currency': fields.many2one('res.currency', 'Currency', help='The currency used to enter statement'),
 740         'entry_posted': fields.boolean('Skip \'Draft\' State for Manual Entries', help='Check this box if you don\'t want new journal entries to pass through the \'draft\' state and instead goes directly to the \'posted state\' without any manual validation. \nNote that journal entries that are automatically created by the system are always skipping that state.'),
 741         'company_id': fields.many2one('res.company', 'Company', required=True, select=1, help="Company related to this journal"),
 742         'allow_date':fields.boolean('Check Date in Period', help= 'If set to True then do not accept the entry if the entry date is not into the period dates'),
 743
 744         'profit_account_id' : fields.many2one('account.account', 'Profit Account'),
 745         'loss_account_id' : fields.many2one('account.account', 'Loss Account'),
 746         'internal_account_id' : fields.many2one('account.account', 'Internal Transfers Account', select=1),
 747     }
 748
 749     _defaults = {
 750         'with_last_closing_balance' : False,
 751         'user_id': lambda self, cr, uid, context: uid,
 752         'company_id': lambda self, cr, uid, c: self.pool.get('res.users').browse(cr, uid, uid, c).company_id.id,
 753     }
 754     _sql_constraints = [
 755         ('code_company_uniq', 'unique (code, company_id)', 'The code of the journal must be unique per company !'),
 756         ('name_company_uniq', 'unique (name, company_id)', 'The name of the journal must be unique per company !'),
 757     ]
 758
 759     _order = 'code'
 760
 761     def _check_currency(self, cr, uid, ids, context=None):
 762         for journal in self.browse(cr, uid, ids, context=context):
 763             if journal.currency:
 764                 if journal.default_credit_account_id and not journal.default_credit_account_id.currency_id.id == journal.currency.id:
 765                     return False
 766                 if journal.default_debit_account_id and not journal.default_debit_account_id.currency_id.id == journal.currency.id:
 767                     return False
 768         return True
 769
 770     _constraints = [
 771         (_check_currency, 'Configuration error! The currency chosen should be shared by the default accounts too.', ['currency','default_debit_account_id','default_credit_account_id']),
 772     ]
 773
 774     def copy(self, cr, uid, id, default={}, context=None, done_list=[], local=False):
 775         journal = self.browse(cr, uid, id, context=context)
 776         if not default:
 777             default = {}
 778         default = default.copy()
 779         default['code'] = (journal['code'] or '') + '(copy)'
 780         default['name'] = (journal['name'] or '') + '(copy)'
 781         default['sequence_id'] = False
 782         return super(account_journal, self).copy(cr, uid, id, default, context=context)
 783
 784     def write(self, cr, uid, ids, vals, context=None):
 785         if context is None:
 786             context = {}
 787         if isinstance(ids, (int, long)):
 788             ids = [ids]
 789         for journal in self.browse(cr, uid, ids, context=context):
 790             if 'company_id' in vals and journal.company_id.id != vals['company_id']:
 791                 move_lines = self.pool.get('account.move.line').search(cr, uid, [('journal_id', 'in', ids)])
 792                 if move_lines:
 793                     raise osv.except_osv(_('Warning !'), _('You can not modify the company of this journal as its related record exist in journal items'))
 794         return super(account_journal, self).write(cr, uid, ids, vals, context=context)
 795
 796     def create_sequence(self, cr, uid, vals, context=None):
 797         """ Create new no_gap entry sequence for every new Joural
 798         """
 799         # in account.journal code is actually the prefix of the sequence
 800         # whereas ir.sequence code is a key to lookup global sequences.
 801         prefix = vals['code'].upper()
 802
 803         seq = {
 804             'name': vals['name'],
 805             'implementation':'no_gap',
 806             'prefix': prefix + "/%(year)s/",
 807             'padding': 4,
 808             'number_increment': 1
 809         }
 810         if 'company_id' in vals:
 811             seq['company_id'] = vals['company_id']
 812         return self.pool.get('ir.sequence').create(cr, uid, seq)
 813
 814     def create(self, cr, uid, vals, context=None):
 815         if not 'sequence_id' in vals or not vals['sequence_id']:
 816             # if we have the right to create a journal, we should be able to
 817             # create it's sequence.
 818             vals.update({'sequence_id': self.create_sequence(cr, 1, vals, context)})
 819         return super(account_journal, self).create(cr, uid, vals, context)
 820
 821     def name_get(self, cr, user, ids, context=None):
 822         """
 823         Returns a list of tupples containing id, name.
 824         result format: {[(id, name), (id, name), ...]}
 825
 826         @param cr: A database cursor
 827         @param user: ID of the user currently logged in
 828         @param ids: list of ids for which name should be read
 829         @param context: context arguments, like lang, time zone
 830
 831         @return: Returns a list of tupples containing id, name
 832         """
 833         result = self.browse(cr, user, ids, context=context)
 834         res = []
 835         for rs in result:
 836             if rs.currency:
 837                 currency = rs.currency
 838             else:
 839                 currency = rs.company_id.currency_id
 840             name = "%s (%s)" % (rs.name, currency.name)
 841             res += [(rs.id, name)]
 842         return res
 843
 844     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=100):
 845         if not args:
 846             args = []
 847         if context is None:
 848             context = {}
 849         ids = []
 850         if context.get('journal_type', False):
 851             args += [('type','=',context.get('journal_type'))]
 852         if name:
 853             ids = self.search(cr, user, [('code', 'ilike', name)]+ args, limit=limit, context=context)
 854         if not ids:
 855             ids = self.search(cr, user, [('name', 'ilike', name)]+ args, limit=limit, context=context)#fix it ilike should be replace with operator
 856
 857         return self.name_get(cr, user, ids, context=context)
 858
 859     def onchange_type(self, cr, uid, ids, type, currency, context=None):
 860         obj_data = self.pool.get('ir.model.data')
 861         user_pool = self.pool.get('res.users')
 862
 863         type_map = {
 864             'sale':'account_sp_journal_view',
 865             'sale_refund':'account_sp_refund_journal_view',
 866             'purchase':'account_sp_journal_view',
 867             'purchase_refund':'account_sp_refund_journal_view',
 868             'cash':'account_journal_bank_view',
 869             'bank':'account_journal_bank_view',
 870             'general':'account_journal_view',
 871             'situation':'account_journal_view'
 872         }
 873
 874         res = {}
 875         view_id = type_map.get(type, 'account_journal_view')
 876         user = user_pool.browse(cr, uid, uid)
 877         if type in ('cash', 'bank') and currency and user.company_id.currency_id.id != currency:
 878             view_id = 'account_journal_bank_view_multi'
 879         data_id = obj_data.search(cr, uid, [('model','=','account.journal.view'), ('name','=',view_id)])
 880         data = obj_data.browse(cr, uid, data_id[0], context=context)
 881
 882         res.update({
 883             'centralisation':type == 'situation',
 884             'view_id':data.res_id,
 885         })
 886         return {
 887             'value':res
 888         }
 889
 890 account_journal()
 891
 892 class account_fiscalyear(osv.osv):
 893     _name = "account.fiscalyear"
 894     _description = "Fiscal Year"
 895     _columns = {
 896         'name': fields.char('Fiscal Year', size=64, required=True),
 897         'code': fields.char('Code', size=6, required=True),
 898         'company_id': fields.many2one('res.company', 'Company', required=True),
 899         'date_start': fields.date('Start Date', required=True),
 900         'date_stop': fields.date('End Date', required=True),
 901         'period_ids': fields.one2many('account.period', 'fiscalyear_id', 'Periods'),
 902         'state': fields.selection([('draft','Open'), ('done','Closed')], 'Status', readonly=True),
 903     }
 904     _defaults = {
 905         'state': 'draft',
 906         'company_id': lambda self,cr,uid,c: self.pool.get('res.users').browse(cr, uid, uid, c).company_id.id,
 907     }
 908     _order = "date_start, id"
 909
 910
 911     def _check_duration(self, cr, uid, ids, context=None):
 912         obj_fy = self.browse(cr, uid, ids[0], context=context)
 913         if obj_fy.date_stop < obj_fy.date_start:
 914             return False
 915         return True
 916
 917     _constraints = [
 918         (_check_duration, 'Error! The start date of the fiscal year must be before his end date.', ['date_start','date_stop'])
 919     ]
 920
 921     def create_period3(self, cr, uid, ids, context=None):
 922         return self.create_period(cr, uid, ids, context, 3)
 923
 924     def create_period(self, cr, uid, ids, context=None, interval=1):
 925         period_obj = self.pool.get('account.period')
 926         for fy in self.browse(cr, uid, ids, context=context):
 927             ds = datetime.strptime(fy.date_start, '%Y-%m-%d')
 928             period_obj.create(cr, uid, {
 929                     'name':  "%s %s" % (_('Opening Period'), ds.strftime('%Y')),
 930                     'code': ds.strftime('00/%Y'),
 931                     'date_start': ds,
 932                     'date_stop': ds,
 933                     'special': True,
 934                     'fiscalyear_id': fy.id,
 935                 })
 936             while ds.strftime('%Y-%m-%d') < fy.date_stop:
 937                 de = ds + relativedelta(months=interval, days=-1)
 938
 939                 if de.strftime('%Y-%m-%d') > fy.date_stop:
 940                     de = datetime.strptime(fy.date_stop, '%Y-%m-%d')
 941
 942                 period_obj.create(cr, uid, {
 943                     'name': ds.strftime('%m/%Y'),
 944                     'code': ds.strftime('%m/%Y'),
 945                     'date_start': ds.strftime('%Y-%m-%d'),
 946                     'date_stop': de.strftime('%Y-%m-%d'),
 947                     'fiscalyear_id': fy.id,
 948                 })
 949                 ds = ds + relativedelta(months=interval)
 950         return True
 951
 952     def find(self, cr, uid, dt=None, exception=True, context=None):
 953         res = self.finds(cr, uid, dt, exception, context=context)
 954         return res and res[0] or False
 955
 956     def finds(self, cr, uid, dt=None, exception=True, context=None):
 957         if context is None: context = {}
 958         if not dt:
 959             dt = fields.date.context_today(self,cr,uid,context=context)
 960         args = [('date_start', '<=' ,dt), ('date_stop', '>=', dt)]
 961         if context.get('company_id', False):
 962             company_id = context['company_id']
 963         else:
 964             company_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.id
 965         args.append(('company_id', '=', company_id))
 966         ids = self.search(cr, uid, args, context=context)
 967         if not ids:
 968             if exception:
 969                 raise osv.except_osv(_('Error !'), _('No fiscal year defined for this date !\nPlease create one from the configuration of the accounting menu.'))
 970             else:
 971                 return []
 972         return ids
 973
 974     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=80):
 975         if args is None:
 976             args = []
 977         if context is None:
 978             context = {}
 979         ids = []
 980         if name:
 981             ids = self.search(cr, user, [('code', 'ilike', name)]+ args, limit=limit)
 982         if not ids:
 983             ids = self.search(cr, user, [('name', operator, name)]+ args, limit=limit)
 984         return self.name_get(cr, user, ids, context=context)
 985
 986 account_fiscalyear()
 987
 988 class account_period(osv.osv):
 989     _name = "account.period"
 990     _description = "Account period"
 991     _columns = {
 992         'name': fields.char('Period Name', size=64, required=True),
 993         'code': fields.char('Code', size=12),
 994         'special': fields.boolean('Opening/Closing Period', size=12,
 995             help="These periods can overlap."),
 996         'date_start': fields.date('Start of Period', required=True, states={'done':[('readonly',True)]}),
 997         'date_stop': fields.date('End of Period', required=True, states={'done':[('readonly',True)]}),
 998         'fiscalyear_id': fields.many2one('account.fiscalyear', 'Fiscal Year', required=True, states={'done':[('readonly',True)]}, select=True),
 999         'state': fields.selection([('draft','Open'), ('done','Closed')], 'Status', readonly=True,
1000                                   help='When monthly periods are created. The state is \'Draft\'. At the end of monthly period it is in \'Done\' state.'),
1001         'company_id': fields.related('fiscalyear_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True)
1002     }
1003     _defaults = {
1004         'state': 'draft',
1005     }
1006     _order = "date_start, special desc"
1007     _sql_constraints = [
1008         ('name_company_uniq', 'unique(name, company_id)', 'The name of the period must be unique per company!'),
1009     ]
1010
1011     def _check_duration(self,cr,uid,ids,context=None):
1012         obj_period = self.browse(cr, uid, ids[0], context=context)
1013         if obj_period.date_stop < obj_period.date_start:
1014             return False
1015         return True
1016
1017     def _check_year_limit(self,cr,uid,ids,context=None):
1018         for obj_period in self.browse(cr, uid, ids, context=context):
1019             if obj_period.special:
1020                 continue
1021
1022             if obj_period.fiscalyear_id.date_stop < obj_period.date_stop or \
1023                obj_period.fiscalyear_id.date_stop < obj_period.date_start or \
1024                obj_period.fiscalyear_id.date_start > obj_period.date_start or \
1025                obj_period.fiscalyear_id.date_start > obj_period.date_stop:
1026                 return False
1027
1028             pids = self.search(cr, uid, [('date_stop','>=',obj_period.date_start),('date_start','<=',obj_period.date_stop),('special','=',False),('id','<>',obj_period.id)])
1029             for period in self.browse(cr, uid, pids):
1030                 if period.fiscalyear_id.company_id.id==obj_period.fiscalyear_id.company_id.id:
1031                     return False
1032         return True
1033
1034     _constraints = [
1035         (_check_duration, 'Error ! The duration of the Period(s) is/are invalid. ', ['date_stop']),
1036         (_check_year_limit, 'Invalid period ! Some periods overlap or the date period is not in the scope of the fiscal year. ', ['date_stop'])
1037     ]
1038
1039     def next(self, cr, uid, period, step, context=None):
1040         ids = self.search(cr, uid, [('date_start','>',period.date_start)])
1041         if len(ids)>=step:
1042             return ids[step-1]
1043         return False
1044
1045     def find(self, cr, uid, dt=None, context=None):
1046         if context is None: context = {}
1047         if not dt:
1048             dt = fields.date.context_today(self,cr,uid,context=context)
1049 #CHECKME: shouldn't we check the state of the period?
1050         args = [('date_start', '<=' ,dt), ('date_stop', '>=', dt)]
1051         if context.get('company_id', False):
1052             args.append(('company_id', '=', context['company_id']))
1053         else:
1054             company_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.id
1055             args.append(('company_id', '=', company_id))
1056         ids = self.search(cr, uid, args, context=context)
1057         if not ids:
1058             raise osv.except_osv(_('Error !'), _('No period defined for this date: %s !\nPlease create one.')%dt)
1059         return ids
1060
1061     def action_draft(self, cr, uid, ids, *args):
1062         mode = 'draft'
1063         cr.execute('update account_journal_period set state=%s where period_id in %s', (mode, tuple(ids),))
1064         cr.execute('update account_period set state=%s where id in %s', (mode, tuple(ids),))
1065         return True
1066
1067     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=100):
1068         if args is None:
1069             args = []
1070         if context is None:
1071             context = {}
1072         ids = []
1073         if name:
1074             ids = self.search(cr, user, [('code','ilike',name)]+ args, limit=limit)
1075         if not ids:
1076             ids = self.search(cr, user, [('name',operator,name)]+ args, limit=limit)
1077         return self.name_get(cr, user, ids, context=context)
1078
1079     def write(self, cr, uid, ids, vals, context=None):
1080         if 'company_id' in vals:
1081             move_lines = self.pool.get('account.move.line').search(cr, uid, [('period_id', 'in', ids)])
1082             if move_lines:
1083                 raise osv.except_osv(_('Warning !'), _('You can not modify company of this period as some journal items exists.'))
1084         return super(account_period, self).write(cr, uid, ids, vals, context=context)
1085
1086     def build_ctx_periods(self, cr, uid, period_from_id, period_to_id):
1087         if period_from_id == period_to_id:
1088             return [period_from_id]
1089         period_from = self.browse(cr, uid, period_from_id)
1090         period_date_start = period_from.date_start
1091         company1_id = period_from.company_id.id
1092         period_to = self.browse(cr, uid, period_to_id)
1093         period_date_stop = period_to.date_stop
1094         company2_id = period_to.company_id.id
1095         if company1_id != company2_id:
1096             raise osv.except_osv(_('Error'), _('You should have chosen periods that belongs to the same company'))
1097         if period_date_start > period_date_stop:
1098             raise osv.except_osv(_('Error'), _('Start period should be smaller then End period'))
1099         #for period from = january, we want to exclude the opening period (but it has same date_from, so we have to check if period_from is special or not to include that clause or not in the search).
1100         if period_from.special:
1101             return self.search(cr, uid, [('date_start', '>=', period_date_start), ('date_stop', '<=', period_date_stop), ('company_id', '=', company1_id)])
1102         return self.search(cr, uid, [('date_start', '>=', period_date_start), ('date_stop', '<=', period_date_stop), ('company_id', '=', company1_id), ('special', '=', False)])
1103
1104 account_period()
1105
1106 class account_journal_period(osv.osv):
1107     _name = "account.journal.period"
1108     _description = "Journal Period"
1109
1110     def _icon_get(self, cr, uid, ids, field_name, arg=None, context=None):
1111         result = {}.fromkeys(ids, 'STOCK_NEW')
1112         for r in self.read(cr, uid, ids, ['state']):
1113             result[r['id']] = {
1114                 'draft': 'STOCK_NEW',
1115                 'printed': 'STOCK_PRINT_PREVIEW',
1116                 'done': 'STOCK_DIALOG_AUTHENTICATION',
1117             }.get(r['state'], 'STOCK_NEW')
1118         return result
1119
1120     _columns = {
1121         'name': fields.char('Journal-Period Name', size=64, required=True),
1122         'journal_id': fields.many2one('account.journal', 'Journal', required=True, ondelete="cascade"),
1123         'period_id': fields.many2one('account.period', 'Period', required=True, ondelete="cascade"),
1124         'icon': fields.function(_icon_get, string='Icon', type='char', size=32),
1125         'active': fields.boolean('Active', required=True, help="If the active field is set to False, it will allow you to hide the journal period without removing it."),
1126         'state': fields.selection([('draft','Draft'), ('printed','Printed'), ('done','Done')], 'Status', required=True, readonly=True,
1127                                   help='When journal period is created. The state is \'Draft\'. If a report is printed it comes to \'Printed\' state. When all transactions are done, it comes in \'Done\' state.'),
1128         'fiscalyear_id': fields.related('period_id', 'fiscalyear_id', string='Fiscal Year', type='many2one', relation='account.fiscalyear'),
1129         'company_id': fields.related('journal_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True)
1130     }
1131
1132     def _check(self, cr, uid, ids, context=None):
1133         for obj in self.browse(cr, uid, ids, context=context):
1134             cr.execute('select * from account_move_line where journal_id=%s and period_id=%s limit 1', (obj.journal_id.id, obj.period_id.id))
1135             res = cr.fetchall()
1136             if res:
1137                 raise osv.except_osv(_('Error !'), _('You can not modify/delete a journal with entries for this period !'))
1138         return True
1139
1140     def write(self, cr, uid, ids, vals, context=None):
1141         self._check(cr, uid, ids, context=context)
1142         return super(account_journal_period, self).write(cr, uid, ids, vals, context=context)
1143
1144     def create(self, cr, uid, vals, context=None):
1145         period_id = vals.get('period_id',False)
1146         if period_id:
1147             period = self.pool.get('account.period').browse(cr, uid, period_id, context=context)
1148             vals['state']=period.state
1149         return super(account_journal_period, self).create(cr, uid, vals, context)
1150
1151     def unlink(self, cr, uid, ids, context=None):
1152         self._check(cr, uid, ids, context=context)
1153         return super(account_journal_period, self).unlink(cr, uid, ids, context=context)
1154
1155     _defaults = {
1156         'state': 'draft',
1157         'active': True,
1158     }
1159     _order = "period_id"
1160
1161 account_journal_period()
1162
1163 class account_fiscalyear(osv.osv):
1164     _inherit = "account.fiscalyear"
1165     _description = "Fiscal Year"
1166     _columns = {
1167         'end_journal_period_id':fields.many2one('account.journal.period','End of Year Entries Journal', readonly=True),
1168     }
1169
1170     def copy(self, cr, uid, id, default={}, context=None):
1171         default.update({
1172             'period_ids': [],
1173             'end_journal_period_id': False
1174         })
1175         return super(account_fiscalyear, self).copy(cr, uid, id, default=default, context=context)
1176
1177 account_fiscalyear()
1178 #----------------------------------------------------------
1179 # Entries
1180 #----------------------------------------------------------
1181 class account_move(osv.osv):
1182     _name = "account.move"
1183     _description = "Account Entry"
1184     _order = 'id desc'
1185
1186     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=80):
1187         """
1188         Returns a list of tupples containing id, name, as internally it is called {def name_get}
1189         result format: {[(id, name), (id, name), ...]}
1190
1191         @param cr: A database cursor
1192         @param user: ID of the user currently logged in
1193         @param name: name to search
1194         @param args: other arguments
1195         @param operator: default operator is 'ilike', it can be changed
1196         @param context: context arguments, like lang, time zone
1197         @param limit: Returns first 'n' ids of complete result, default is 80.
1198
1199         @return: Returns a list of tuples containing id and name
1200         """
1201
1202         if not args:
1203           args = []
1204         ids = []
1205         if name:
1206             ids += self.search(cr, user, [('name','ilike',name)]+args, limit=limit, context=context)
1207
1208         if not ids and name and type(name) == int:
1209             ids += self.search(cr, user, [('id','=',name)]+args, limit=limit, context=context)
1210
1211         if not ids:
1212             ids += self.search(cr, user, args, limit=limit, context=context)
1213
1214         return self.name_get(cr, user, ids, context=context)
1215
1216     def name_get(self, cursor, user, ids, context=None):
1217         if isinstance(ids, (int, long)):
1218             ids = [ids]
1219         if not ids:
1220             return []
1221         res = []
1222         data_move = self.pool.get('account.move').browse(cursor, user, ids, context=context)
1223         for move in data_move:
1224             if move.state=='draft':
1225                 name = '*' + str(move.id)
1226             else:
1227                 name = move.name
1228             res.append((move.id, name))
1229         return res
1230
1231     def _get_period(self, cr, uid, context=None):
1232         periods = self.pool.get('account.period').find(cr, uid)
1233         if periods:
1234             return periods[0]
1235         return False
1236
1237     def _amount_compute(self, cr, uid, ids, name, args, context, where =''):
1238         if not ids: return {}
1239         cr.execute( 'SELECT move_id, SUM(debit) '\
1240                     'FROM account_move_line '\
1241                     'WHERE move_id IN %s '\
1242                     'GROUP BY move_id', (tuple(ids),))
1243         result = dict(cr.fetchall())
1244         for id in ids:
1245             result.setdefault(id, 0.0)
1246         return result
1247
1248     def _search_amount(self, cr, uid, obj, name, args, context):
1249         ids = set()
1250         for cond in args:
1251             amount = cond[2]
1252             if isinstance(cond[2],(list,tuple)):
1253                 if cond[1] in ['in','not in']:
1254                     amount = tuple(cond[2])
1255                 else:
1256                     continue
1257             else:
1258                 if cond[1] in ['=like', 'like', 'not like', 'ilike', 'not ilike', 'in', 'not in', 'child_of']:
1259                     continue
1260
1261             cr.execute("select move_id from account_move_line group by move_id having sum(debit) %s %%s" % (cond[1]),(amount,))
1262             res_ids = set(id[0] for id in cr.fetchall())
1263             ids = ids and (ids & res_ids) or res_ids
1264         if ids:
1265             return [('id', 'in', tuple(ids))]
1266         return [('id', '=', '0')]
1267
1268     _columns = {
1269         'name': fields.char('Number', size=64, required=True),
1270         'ref': fields.char('Reference', size=64),
1271         'period_id': fields.many2one('account.period', 'Period', required=True, states={'posted':[('readonly',True)]}),
1272         'journal_id': fields.many2one('account.journal', 'Journal', required=True, states={'posted':[('readonly',True)]}),
1273         'state': fields.selection([('draft','Unposted'), ('posted','Posted')], 'Status', required=True, readonly=True,
1274             help='All manually created new journal entries are usually in the state \'Unposted\', but you can set the option to skip that state on the related journal. In that case, they will behave as journal entries automatically created by the system on document validation (invoices, bank statements...) and will be created in \'Posted\' state.'),
1275         'line_id': fields.one2many('account.move.line', 'move_id', 'Entries', states={'posted':[('readonly',True)]}),
1276         'to_check': fields.boolean('To Review', help='Check this box if you are unsure of that journal entry and if you want to note it as \'to be reviewed\' by an accounting expert.'),
1277         'partner_id': fields.related('line_id', 'partner_id', type="many2one", relation="res.partner", string="Partner", store=True),
1278         'amount': fields.function(_amount_compute, string='Amount', digits_compute=dp.get_precision('Account'), type='float', fnct_search=_search_amount),
1279         'date': fields.date('Date', required=True, states={'posted':[('readonly',True)]}, select=True),
1280         'narration':fields.text('Internal Note'),
1281         'company_id': fields.related('journal_id','company_id',type='many2one',relation='res.company',string='Company', store=True, readonly=True),
1282         'balance': fields.float('balance', digits_compute=dp.get_precision('Account'), help="This is a field only used for internal purpose and shouldn't be displayed"),
1283     }
1284
1285     _defaults = {
1286         'name': '/',
1287         'state': 'draft',
1288         'period_id': _get_period,
1289         'date': fields.date.context_today,
1290         'company_id': lambda self, cr, uid, c: self.pool.get('res.users').browse(cr, uid, uid, c).company_id.id,
1291     }
1292
1293     def _check_centralisation(self, cursor, user, ids, context=None):
1294         for move in self.browse(cursor, user, ids, context=context):
1295             if move.journal_id.centralisation:
1296                 move_ids = self.search(cursor, user, [
1297                     ('period_id', '=', move.period_id.id),
1298                     ('journal_id', '=', move.journal_id.id),
1299                     ])
1300                 if len(move_ids) > 1:
1301                     return False
1302         return True
1303
1304     _constraints = [
1305         (_check_centralisation,
1306             'You can not create more than one move per period on centralized journal',
1307             ['journal_id']),
1308     ]
1309
1310     def post(self, cr, uid, ids, context=None):
1311         if context is None:
1312             context = {}
1313         invoice = context.get('invoice', False)
1314         valid_moves = self.validate(cr, uid, ids, context)
1315
1316         if not valid_moves:
1317             raise osv.except_osv(_('Integrity Error !'), _('You can not validate a non-balanced entry !\nMake sure you have configured payment terms properly !\nThe latest payment term line should be of the type "Balance" !'))
1318         obj_sequence = self.pool.get('ir.sequence')
1319         for move in self.browse(cr, uid, valid_moves, context=context):
1320             if move.name =='/':
1321                 new_name = False
1322                 journal = move.journal_id
1323
1324                 if invoice and invoice.internal_number:
1325                     new_name = invoice.internal_number
1326                 else:
1327                     if journal.sequence_id:
1328                         c = {'fiscalyear_id': move.period_id.fiscalyear_id.id}
1329                         new_name = obj_sequence.next_by_id(cr, uid, journal.sequence_id.id, c)
1330                     else:
1331                         raise osv.except_osv(_('Error'), _('No sequence defined on the journal !'))
1332
1333                 if new_name:
1334                     self.write(cr, uid, [move.id], {'name':new_name})
1335
1336         cr.execute('UPDATE account_move '\
1337                    'SET state=%s '\
1338                    'WHERE id IN %s',
1339                    ('posted', tuple(valid_moves),))
1340         return True
1341
1342     def button_validate(self, cursor, user, ids, context=None):
1343         for move in self.browse(cursor, user, ids, context=context):
1344             # check that all accounts have the same topmost ancestor
1345             top_common = None
1346             for line in move.line_id:
1347                 account = line.account_id
1348                 top_account = account
1349                 while top_account.parent_id:
1350                     top_account = top_account.parent_id
1351                 if not top_common:
1352                     top_common = top_account
1353                 elif top_account.id != top_common.id:
1354                     raise osv.except_osv(_('Error !'),
1355                                          _('You cannot validate this journal entry because account "%s" does not belong to chart of accounts "%s"!') % (account.name, top_common.name))
1356         return self.post(cursor, user, ids, context=context)
1357
1358     def button_cancel(self, cr, uid, ids, context=None):
1359         for line in self.browse(cr, uid, ids, context=context):
1360             if not line.journal_id.update_posted:
1361                 raise osv.except_osv(_('Error !'), _('You can not modify a posted entry of this journal !\nYou should set the journal to allow cancelling entries if you want to do that.'))
1362         if ids:
1363             cr.execute('UPDATE account_move '\
1364                        'SET state=%s '\
1365                        'WHERE id IN %s', ('draft', tuple(ids),))
1366         return True
1367
1368     def onchange_line_id(self, cr, uid, ids, line_ids, context=None):
1369         balance = 0.0
1370         for line in line_ids:
1371             if line[2]:
1372                 balance += (line[2]['debit'] or 0.00)- (line[2]['credit'] or 0.00)
1373         return {'value': {'balance': balance}}
1374
1375     def write(self, cr, uid, ids, vals, context=None):
1376         if context is None:
1377             context = {}
1378         c = context.copy()
1379         c['novalidate'] = True
1380         result = super(account_move, self).write(cr, uid, ids, vals, c)
1381         self.validate(cr, uid, ids, context=context)
1382         return result
1383
1384     #
1385     # TODO: Check if period is closed !
1386     #
1387     def create(self, cr, uid, vals, context=None):
1388         if context is None:
1389             context = {}
1390         if 'line_id' in vals and context.get('copy'):
1391             for l in vals['line_id']:
1392                 if not l[0]:
1393                     l[2].update({
1394                         'reconcile_id':False,
1395                         'reconcil_partial_id':False,
1396                         'analytic_lines':False,
1397                         'invoice':False,
1398                         'ref':False,
1399                         'balance':False,
1400                         'account_tax_id':False,
1401                     })
1402
1403             if 'journal_id' in vals and vals.get('journal_id', False):
1404                 for l in vals['line_id']:
1405                     if not l[0]:
1406                         l[2]['journal_id'] = vals['journal_id']
1407                 context['journal_id'] = vals['journal_id']
1408             if 'period_id' in vals:
1409                 for l in vals['line_id']:
1410                     if not l[0]:
1411                         l[2]['period_id'] = vals['period_id']
1412                 context['period_id'] = vals['period_id']
1413             else:
1414                 default_period = self._get_period(cr, uid, context)
1415                 for l in vals['line_id']:
1416                     if not l[0]:
1417                         l[2]['period_id'] = default_period
1418                 context['period_id'] = default_period
1419
1420         if 'line_id' in vals:
1421             c = context.copy()
1422             c['novalidate'] = True
1423             result = super(account_move, self).create(cr, uid, vals, c)
1424             self.validate(cr, uid, [result], context)
1425         else:
1426             result = super(account_move, self).create(cr, uid, vals, context)
1427         return result
1428
1429     def copy(self, cr, uid, id, default={}, context=None):
1430         if context is None:
1431             context = {}
1432         default.update({
1433             'state':'draft',
1434             'name':'/',
1435         })
1436         context.update({
1437             'copy':True
1438         })
1439         return super(account_move, self).copy(cr, uid, id, default, context)
1440
1441     def unlink(self, cr, uid, ids, context=None, check=True):
1442         if context is None:
1443             context = {}
1444         toremove = []
1445         obj_move_line = self.pool.get('account.move.line')
1446         for move in self.browse(cr, uid, ids, context=context):
1447             if move['state'] != 'draft':
1448                 raise osv.except_osv(_('UserError'),
1449                         _('You can not delete a posted journal entry "%s"!') % \
1450                                 move['name'])
1451             line_ids = map(lambda x: x.id, move.line_id)
1452             context['journal_id'] = move.journal_id.id
1453             context['period_id'] = move.period_id.id
1454             obj_move_line._update_check(cr, uid, line_ids, context)
1455             obj_move_line.unlink(cr, uid, line_ids, context=context)
1456             toremove.append(move.id)
1457         result = super(account_move, self).unlink(cr, uid, toremove, context)
1458         return result
1459
1460     def _compute_balance(self, cr, uid, id, context=None):
1461         move = self.browse(cr, uid, id, context=context)
1462         amount = 0
1463         for line in move.line_id:
1464             amount+= (line.debit - line.credit)
1465         return amount
1466
1467     def _centralise(self, cr, uid, move, mode, context=None):
1468         assert mode in ('debit', 'credit'), 'Invalid Mode' #to prevent sql injection
1469         currency_obj = self.pool.get('res.currency')
1470         if context is None:
1471             context = {}
1472
1473         if mode=='credit':
1474             account_id = move.journal_id.default_debit_account_id.id
1475             mode2 = 'debit'
1476             if not account_id:
1477                 raise osv.except_osv(_('UserError'),
1478                         _('There is no default default debit account defined \n' \
1479                                 'on journal "%s"') % move.journal_id.name)
1480         else:
1481             account_id = move.journal_id.default_credit_account_id.id
1482             mode2 = 'credit'
1483             if not account_id:
1484                 raise osv.except_osv(_('UserError'),
1485                         _('There is no default default credit account defined \n' \
1486                                 'on journal "%s"') % move.journal_id.name)
1487
1488         # find the first line of this move with the current mode
1489         # or create it if it doesn't exist
1490         cr.execute('select id from account_move_line where move_id=%s and centralisation=%s limit 1', (move.id, mode))
1491         res = cr.fetchone()
1492         if res:
1493             line_id = res[0]
1494         else:
1495             context.update({'journal_id': move.journal_id.id, 'period_id': move.period_id.id})
1496             line_id = self.pool.get('account.move.line').create(cr, uid, {
1497                 'name': _(mode.capitalize()+' Centralisation'),
1498                 'centralisation': mode,
1499                 'account_id': account_id,
1500                 'move_id': move.id,
1501                 'journal_id': move.journal_id.id,
1502                 'period_id': move.period_id.id,
1503                 'date': move.period_id.date_stop,
1504                 'debit': 0.0,
1505                 'credit': 0.0,
1506             }, context)
1507
1508         # find the first line of this move with the other mode
1509         # so that we can exclude it from our calculation
1510         cr.execute('select id from account_move_line where move_id=%s and centralisation=%s limit 1', (move.id, mode2))
1511         res = cr.fetchone()
1512         if res:
1513             line_id2 = res[0]
1514         else:
1515             line_id2 = 0
1516
1517         cr.execute('SELECT SUM(%s) FROM account_move_line WHERE move_id=%%s AND id!=%%s' % (mode,), (move.id, line_id2))
1518         result = cr.fetchone()[0] or 0.0
1519         cr.execute('update account_move_line set '+mode2+'=%s where id=%s', (result, line_id))
1520
1521         #adjust also the amount in currency if needed
1522         cr.execute("select currency_id, sum(amount_currency) as amount_currency from account_move_line where move_id = %s and currency_id is not null group by currency_id", (move.id,))
1523         for row in cr.dictfetchall():
1524             currency_id = currency_obj.browse(cr, uid, row['currency_id'], context=context)
1525             if not currency_obj.is_zero(cr, uid, currency_id, row['amount_currency']):
1526                 amount_currency = row['amount_currency'] * -1
1527                 account_id = amount_currency > 0 and move.journal_id.default_debit_account_id.id or move.journal_id.default_credit_account_id.id
1528                 cr.execute('select id from account_move_line where move_id=%s and centralisation=\'currency\' and currency_id = %slimit 1', (move.id, row['currency_id']))
1529                 res = cr.fetchone()
1530                 if res:
1531                     cr.execute('update account_move_line set amount_currency=%s , account_id=%s where id=%s', (amount_currency, account_id, res[0]))
1532                 else:
1533                     context.update({'journal_id': move.journal_id.id, 'period_id': move.period_id.id})
1534                     line_id = self.pool.get('account.move.line').create(cr, uid, {
1535                         'name': _('Currency Adjustment'),
1536                         'centralisation': 'currency',
1537                         'account_id': account_id,
1538                         'move_id': move.id,
1539                         'journal_id': move.journal_id.id,
1540                         'period_id': move.period_id.id,
1541                         'date': move.period_id.date_stop,
1542                         'debit': 0.0,
1543                         'credit': 0.0,
1544                         'currency_id': row['currency_id'],
1545                         'amount_currency': amount_currency,
1546                     }, context)
1547
1548         return True
1549
1550     #
1551     # Validate a balanced move. If it is a centralised journal, create a move.
1552     #
1553     def validate(self, cr, uid, ids, context=None):
1554         if context and ('__last_update' in context):
1555             del context['__last_update']
1556
1557         valid_moves = [] #Maintains a list of moves which can be responsible to create analytic entries
1558         obj_analytic_line = self.pool.get('account.analytic.line')
1559         obj_move_line = self.pool.get('account.move.line')
1560         for move in self.browse(cr, uid, ids, context):
1561             # Unlink old analytic lines on move_lines
1562             for obj_line in move.line_id:
1563                 for obj in obj_line.analytic_lines:
1564                     obj_analytic_line.unlink(cr,uid,obj.id)
1565
1566             journal = move.journal_id
1567             amount = 0
1568             line_ids = []
1569             line_draft_ids = []
1570             company_id = None
1571             for line in move.line_id:
1572                 amount += line.debit - line.credit
1573                 line_ids.append(line.id)
1574                 if line.state=='draft':
1575                     line_draft_ids.append(line.id)
1576
1577                 if not company_id:
1578                     company_id = line.account_id.company_id.id
1579                 if not company_id == line.account_id.company_id.id:
1580                     raise osv.except_osv(_('Error'), _("Couldn't create move between different companies"))
1581
1582                 if line.account_id.currency_id and line.currency_id:
1583                     if line.account_id.currency_id.id != line.currency_id.id and (line.account_id.currency_id.id != line.account_id.company_id.currency_id.id):
1584                         raise osv.except_osv(_('Error'), _("""Couldn't create move with currency different from the secondary currency of the account "%s - %s". Clear the secondary currency field of the account definition if you want to accept all currencies.""") % (line.account_id.code, line.account_id.name))
1585
1586             if abs(amount) < 10 ** -4:
1587                 # If the move is balanced
1588                 # Add to the list of valid moves
1589                 # (analytic lines will be created later for valid moves)
1590                 valid_moves.append(move)
1591
1592                 # Check whether the move lines are confirmed
1593
1594                 if not line_draft_ids:
1595                     continue
1596                 # Update the move lines (set them as valid)
1597
1598                 obj_move_line.write(cr, uid, line_draft_ids, {
1599                     'state': 'valid'
1600                 }, context, check=False)
1601
1602                 account = {}
1603                 account2 = {}
1604
1605                 if journal.type in ('purchase','sale'):
1606                     for line in move.line_id:
1607                         code = amount = 0
1608                         key = (line.account_id.id, line.tax_code_id.id)
1609                         if key in account2:
1610                             code = account2[key][0]
1611                             amount = account2[key][1] * (line.debit + line.credit)
1612                         elif line.account_id.id in account:
1613                             code = account[line.account_id.id][0]
1614                             amount = account[line.account_id.id][1] * (line.debit + line.credit)
1615                         if (code or amount) and not (line.tax_code_id or line.tax_amount):
1616                             obj_move_line.write(cr, uid, [line.id], {
1617                                 'tax_code_id': code,
1618                                 'tax_amount': amount
1619                             }, context, check=False)
1620             elif journal.centralisation:
1621                 # If the move is not balanced, it must be centralised...
1622
1623                 # Add to the list of valid moves
1624                 # (analytic lines will be created later for valid moves)
1625                 valid_moves.append(move)
1626
1627                 #
1628                 # Update the move lines (set them as valid)
1629                 #
1630                 self._centralise(cr, uid, move, 'debit', context=context)
1631                 self._centralise(cr, uid, move, 'credit', context=context)
1632                 obj_move_line.write(cr, uid, line_draft_ids, {
1633                     'state': 'valid'
1634                 }, context, check=False)
1635             else:
1636                 # We can't validate it (it's unbalanced)
1637                 # Setting the lines as draft
1638                 obj_move_line.write(cr, uid, line_ids, {
1639                     'state': 'draft'
1640                 }, context, check=False)
1641         # Create analytic lines for the valid moves
1642         for record in valid_moves:
1643             obj_move_line.create_analytic_lines(cr, uid, [line.id for line in record.line_id], context)
1644
1645         valid_moves = [move.id for move in valid_moves]
1646         return len(valid_moves) > 0 and valid_moves or False
1647
1648 account_move()
1649
1650 class account_move_reconcile(osv.osv):
1651     _name = "account.move.reconcile"
1652     _description = "Account Reconciliation"
1653     _columns = {
1654         'name': fields.char('Name', size=64, required=True),
1655         'type': fields.char('Type', size=16, required=True),
1656         'line_id': fields.one2many('account.move.line', 'reconcile_id', 'Entry Lines'),
1657         'line_partial_ids': fields.one2many('account.move.line', 'reconcile_partial_id', 'Partial Entry lines'),
1658         'create_date': fields.date('Creation date', readonly=True),
1659     }
1660     _defaults = {
1661         'name': lambda self,cr,uid,ctx=None: self.pool.get('ir.sequence').get(cr, uid, 'account.reconcile', context=ctx) or '/',
1662     }
1663
1664     def reconcile_partial_check(self, cr, uid, ids, type='auto', context=None):
1665         total = 0.0
1666         for rec in self.browse(cr, uid, ids, context=context):
1667             for line in rec.line_partial_ids:
1668                 if line.account_id.currency_id:
1669                     total += line.amount_currency
1670                 else:
1671                     total += (line.debit or 0.0) - (line.credit or 0.0)
1672         if not total:
1673             self.pool.get('account.move.line').write(cr, uid,
1674                 map(lambda x: x.id, rec.line_partial_ids),
1675                 {'reconcile_id': rec.id }
1676             )
1677         return True
1678
1679     def name_get(self, cr, uid, ids, context=None):
1680         if not ids:
1681             return []
1682         result = []
1683         for r in self.browse(cr, uid, ids, context=context):
1684             total = reduce(lambda y,t: (t.debit or 0.0) - (t.credit or 0.0) + y, r.line_partial_ids, 0.0)
1685             if total:
1686                 name = '%s (%.2f)' % (r.name, total)
1687                 result.append((r.id,name))
1688             else:
1689                 result.append((r.id,r.name))
1690         return result
1691
1692 account_move_reconcile()
1693
1694 #----------------------------------------------------------
1695 # Tax
1696 #----------------------------------------------------------
1697 """
1698 a documenter
1699 child_depend: la taxe depend des taxes filles
1700 """
1701 class account_tax_code(osv.osv):
1702     """
1703     A code for the tax object.
1704
1705     This code is used for some tax declarations.
1706     """
1707     def _sum(self, cr, uid, ids, name, args, context, where ='', where_params=()):
1708         parent_ids = tuple(self.search(cr, uid, [('parent_id', 'child_of', ids)]))
1709         if context.get('based_on', 'invoices') == 'payments':
1710             cr.execute('SELECT line.tax_code_id, sum(line.tax_amount) \
1711                     FROM account_move_line AS line, \
1712                         account_move AS move \
1713                         LEFT JOIN account_invoice invoice ON \
1714                             (invoice.move_id = move.id) \
1715                     WHERE line.tax_code_id IN %s '+where+' \
1716                         AND move.id = line.move_id \
1717                         AND ((invoice.state = \'paid\') \
1718                             OR (invoice.id IS NULL)) \
1719                             GROUP BY line.tax_code_id',
1720                                 (parent_ids,) + where_params)
1721         else:
1722             cr.execute('SELECT line.tax_code_id, sum(line.tax_amount) \
1723                     FROM account_move_line AS line, \
1724                     account_move AS move \
1725                     WHERE line.tax_code_id IN %s '+where+' \
1726                     AND move.id = line.move_id \
1727                     GROUP BY line.tax_code_id',
1728                        (parent_ids,) + where_params)
1729         res=dict(cr.fetchall())
1730         obj_precision = self.pool.get('decimal.precision')
1731         res2 = {}
1732         for record in self.browse(cr, uid, ids, context=context):
1733             def _rec_get(record):
1734                 amount = res.get(record.id, 0.0)
1735                 for rec in record.child_ids:
1736                     amount += _rec_get(rec) * rec.sign
1737                 return amount
1738             res2[record.id] = round(_rec_get(record), obj_precision.precision_get(cr, uid, 'Account'))
1739         return res2
1740
1741     def _sum_year(self, cr, uid, ids, name, args, context=None):
1742         if context is None:
1743             context = {}
1744         move_state = ('posted', )
1745         if context.get('state', 'all') == 'all':
1746             move_state = ('draft', 'posted', )
1747         if context.get('fiscalyear_id', False):
1748             fiscalyear_id = [context['fiscalyear_id']]
1749         else:
1750             fiscalyear_id = self.pool.get('account.fiscalyear').finds(cr, uid, exception=False)
1751         where = ''
1752         where_params = ()
1753         if fiscalyear_id:
1754             pids = []
1755             for fy in fiscalyear_id:
1756                 pids += map(lambda x: str(x.id), self.pool.get('account.fiscalyear').browse(cr, uid, fy).period_ids)
1757             if pids:
1758                 where = ' AND line.period_id IN %s AND move.state IN %s '
1759                 where_params = (tuple(pids), move_state)
1760         return self._sum(cr, uid, ids, name, args, context,
1761                 where=where, where_params=where_params)
1762
1763     def _sum_period(self, cr, uid, ids, name, args, context):
1764         if context is None:
1765             context = {}
1766         move_state = ('posted', )
1767         if context.get('state', False) == 'all':
1768             move_state = ('draft', 'posted', )
1769         if context.get('period_id', False):
1770             period_id = context['period_id']
1771         else:
1772             period_id = self.pool.get('account.period').find(cr, uid)
1773             if not period_id:
1774                 return dict.fromkeys(ids, 0.0)
1775             period_id = period_id[0]
1776         return self._sum(cr, uid, ids, name, args, context,
1777                 where=' AND line.period_id=%s AND move.state IN %s', where_params=(period_id, move_state))
1778
1779     _name = 'account.tax.code'
1780     _description = 'Tax Code'
1781     _rec_name = 'code'
1782     _columns = {
1783         'name': fields.char('Tax Case Name', size=64, required=True, translate=True),
1784         'code': fields.char('Case Code', size=64),
1785         'info': fields.text('Description'),
1786         'sum': fields.function(_sum_year, string="Year Sum"),
1787         'sum_period': fields.function(_sum_period, string="Period Sum"),
1788         'parent_id': fields.many2one('account.tax.code', 'Parent Code', select=True),
1789         'child_ids': fields.one2many('account.tax.code', 'parent_id', 'Child Codes'),
1790         'line_ids': fields.one2many('account.move.line', 'tax_code_id', 'Lines'),
1791         'company_id': fields.many2one('res.company', 'Company', required=True),
1792         'sign': fields.float('Coefficent for parent', required=True, help='You can specify here the coefficient that will be used when consolidating the amount of this case into its parent. For example, set 1/-1 if you want to add/substract it.'),
1793         'notprintable':fields.boolean("Not Printable in Invoice", help="Check this box if you don't want any tax related to this tax code to appear on invoices"),
1794         'sequence': fields.integer('Sequence', help="Determine the display order in the report 'Accounting \ Reporting \ Generic Reporting \ Taxes \ Taxes Report'"),
1795     }
1796
1797     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=80):
1798         if not args:
1799             args = []
1800         if context is None:
1801             context = {}
1802         ids = self.search(cr, user, ['|',('name',operator,name),('code',operator,name)] + args, limit=limit, context=context)
1803         return self.name_get(cr, user, ids, context)
1804
1805     def name_get(self, cr, uid, ids, context=None):
1806         if isinstance(ids, (int, long)):
1807             ids = [ids]
1808         if not ids:
1809             return []
1810         if isinstance(ids, (int, long)):
1811             ids = [ids]
1812         reads = self.read(cr, uid, ids, ['name','code'], context, load='_classic_write')
1813         return [(x['id'], (x['code'] and (x['code'] + ' - ') or '') + x['name']) \
1814                 for x in reads]
1815
1816     def _default_company(self, cr, uid, context=None):
1817         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1818         if user.company_id:
1819             return user.company_id.id
1820         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
1821     _defaults = {
1822         'company_id': _default_company,
1823         'sign': 1.0,
1824         'notprintable': False,
1825     }
1826
1827     def copy(self, cr, uid, id, default=None, context=None):
1828         if default is None:
1829             default = {}
1830         default = default.copy()
1831         default.update({'line_ids': []})
1832         return super(account_tax_code, self).copy(cr, uid, id, default, context)
1833
1834     _check_recursion = check_cycle
1835     _constraints = [
1836         (_check_recursion, 'Error ! You can not create recursive accounts.', ['parent_id'])
1837     ]
1838     _order = 'code'
1839
1840 account_tax_code()
1841
1842 class account_tax(osv.osv):
1843     """
1844     A tax object.
1845
1846     Type: percent, fixed, none, code
1847         PERCENT: tax = price * amount
1848         FIXED: tax = price + amount
1849         NONE: no tax line
1850         CODE: execute python code. localcontext = {'price_unit':pu}
1851             return result in the context
1852             Ex: result=round(price_unit*0.21,4)
1853     """
1854
1855     def get_precision_tax():
1856         def change_digit_tax(cr):
1857             res = pooler.get_pool(cr.dbname).get('decimal.precision').precision_get(cr, 1, 'Account')
1858             return (16, res+2)
1859         return change_digit_tax
1860
1861     _name = 'account.tax'
1862     _description = 'Tax'
1863     _columns = {
1864         'name': fields.char('Tax Name', size=64, required=True, translate=True, help="This name will be displayed on reports"),
1865         'sequence': fields.integer('Sequence', required=True, help="The sequence field is used to order the tax lines from the lowest sequences to the higher ones. The order is important if you have a tax with several tax children. In this case, the evaluation order is important."),
1866         'amount': fields.float('Amount', required=True, digits_compute=get_precision_tax(), help="For taxes of type percentage, enter % ratio between 0-1."),
1867         'active': fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the tax without removing it."),
1868         'type': fields.selection( [('percent','Percentage'), ('fixed','Fixed Amount'), ('none','None'), ('code','Python Code'), ('balance','Balance')], 'Tax Type', required=True,
1869             help="The computation method for the tax amount."),
1870         'applicable_type': fields.selection( [('true','Always'), ('code','Given by Python Code')], 'Applicability', required=True,
1871             help="If not applicable (computed through a Python code), the tax won't appear on the invoice."),
1872         'domain':fields.char('Domain', size=32, help="This field is only used if you develop your own module allowing developers to create specific taxes in a custom domain."),
1873         'account_collected_id':fields.many2one('account.account', 'Invoice Tax Account', help="Set the account that will be set by default on invoice tax lines for invoices. Leave empty to use the expense account."),
1874         'account_paid_id':fields.many2one('account.account', 'Refund Tax Account', help="Set the account that will be set by default on invoice tax lines for refunds. Leave empty to use the expense account."),
1875         'account_analytic_collected_id':fields.many2one('account.analytic.account', 'Invoice Tax Analytic Account', help="Set the analytic account that will be used by default on the invoice tax lines for invoices. Leave empty if you don't want to use an analytic account on the invoice tax lines by default."),
1876         'account_analytic_paid_id':fields.many2one('account.analytic.account', 'Refund Tax Analytic Account', help="Set the analytic account that will be used by default on the invoice tax lines for refunds. Leave empty if you don't want to use an analytic account on the invoice tax lines by default."),
1877         'parent_id':fields.many2one('account.tax', 'Parent Tax Account', select=True),
1878         'child_ids':fields.one2many('account.tax', 'parent_id', 'Child Tax Accounts'),
1879         'child_depend':fields.boolean('Tax on Children', help="Set if the tax computation is based on the computation of child taxes rather than on the total amount."),
1880         'python_compute':fields.text('Python Code'),
1881         'python_compute_inv':fields.text('Python Code (reverse)'),
1882         'python_applicable':fields.text('Python Code'),
1883
1884         #
1885         # Fields used for the Tax declaration
1886         #
1887         'base_code_id': fields.many2one('account.tax.code', 'Account Base Code', help="Use this code for the tax declaration."),
1888         'tax_code_id': fields.many2one('account.tax.code', 'Account Tax Code', help="Use this code for the tax declaration."),
1889         'base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
1890         'tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
1891
1892         # Same fields for refund invoices
1893
1894         'ref_base_code_id': fields.many2one('account.tax.code', 'Refund Base Code', help="Use this code for the tax declaration."),
1895         'ref_tax_code_id': fields.many2one('account.tax.code', 'Refund Tax Code', help="Use this code for the tax declaration."),
1896         'ref_base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
1897         'ref_tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
1898         'include_base_amount': fields.boolean('Included in base amount', help="Indicates if the amount of tax must be included in the base amount for the computation of the next taxes"),
1899         'company_id': fields.many2one('res.company', 'Company', required=True),
1900         'description': fields.char('Tax Code',size=32),
1901         'price_include': fields.boolean('Tax Included in Price', help="Check this if the price you use on the product and invoices includes this tax."),
1902         'type_tax_use': fields.selection([('sale','Sale'),('purchase','Purchase'),('all','All')], 'Tax Application', required=True)
1903
1904     }
1905     _sql_constraints = [
1906         ('name_company_uniq', 'unique(name, company_id)', 'Tax Name must be unique per company!'),
1907     ]
1908
1909     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=80):
1910         """
1911         Returns a list of tupples containing id, name, as internally it is called {def name_get}
1912         result format: {[(id, name), (id, name), ...]}
1913
1914         @param cr: A database cursor
1915         @param user: ID of the user currently logged in
1916         @param name: name to search
1917         @param args: other arguments
1918         @param operator: default operator is 'ilike', it can be changed
1919         @param context: context arguments, like lang, time zone
1920         @param limit: Returns first 'n' ids of complete result, default is 80.
1921
1922         @return: Returns a list of tupples containing id and name
1923         """
1924         if not args:
1925             args = []
1926         if context is None:
1927             context = {}
1928         ids = []
1929         if name:
1930             ids = self.search(cr, user, [('description', '=', name)] + args, limit=limit, context=context)
1931             if not ids:
1932                 ids = self.search(cr, user, [('name', operator, name)] + args, limit=limit, context=context)
1933         else:
1934             ids = self.search(cr, user, args, limit=limit, context=context or {})
1935         return self.name_get(cr, user, ids, context=context)
1936
1937     def write(self, cr, uid, ids, vals, context=None):
1938         if vals.get('type', False) and vals['type'] in ('none', 'code'):
1939             vals.update({'amount': 0.0})
1940         return super(account_tax, self).write(cr, uid, ids, vals, context=context)
1941
1942     def search(self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False):
1943         journal_pool = self.pool.get('account.journal')
1944
1945         if context and context.has_key('type'):
1946             if context.get('type') in ('out_invoice','out_refund'):
1947                 args += [('type_tax_use','in',['sale','all'])]
1948             elif context.get('type') in ('in_invoice','in_refund'):
1949                 args += [('type_tax_use','in',['purchase','all'])]
1950
1951         if context and context.has_key('journal_id'):
1952             journal = journal_pool.browse(cr, uid, context.get('journal_id'))
1953             if journal.type in ('sale', 'purchase'):
1954                 args += [('type_tax_use','in',[journal.type,'all'])]
1955
1956         return super(account_tax, self).search(cr, uid, args, offset, limit, order, context, count)
1957
1958     def name_get(self, cr, uid, ids, context=None):
1959         if not ids:
1960             return []
1961         res = []
1962         for record in self.read(cr, uid, ids, ['description','name'], context=context):
1963             name = record['description'] and record['description'] or record['name']
1964             res.append((record['id'],name ))
1965         return res
1966
1967     def _default_company(self, cr, uid, context=None):
1968         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1969         if user.company_id:
1970             return user.company_id.id
1971         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
1972
1973     _defaults = {
1974         'python_compute': '''# price_unit\n# or False\n# product: product.product object or None\n# partner: res.partner object or None\n\nresult = price_unit * 0.10''',
1975         'python_compute_inv': '''# price_unit\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
1976         'applicable_type': 'true',
1977         'type': 'percent',
1978         'amount': 0,
1979         'price_include': 0,
1980         'active': 1,
1981         'type_tax_use': 'all',
1982         'sequence': 1,
1983         'ref_tax_sign': 1,
1984         'ref_base_sign': 1,
1985         'tax_sign': 1,
1986         'base_sign': 1,
1987         'include_base_amount': False,
1988         'company_id': _default_company,
1989     }
1990     _order = 'sequence'
1991
1992     def _applicable(self, cr, uid, taxes, price_unit, product=None, partner=None):
1993         res = []
1994         for tax in taxes:
1995             if tax.applicable_type=='code':
1996                 localdict = {'price_unit':price_unit, 'product':product, 'partner':partner}
1997                 exec tax.python_applicable in localdict
1998                 if localdict.get('result', False):
1999                     res.append(tax)
2000             else:
2001                 res.append(tax)
2002         return res
2003
2004     def _unit_compute(self, cr, uid, taxes, price_unit, product=None, partner=None, quantity=0):
2005         taxes = self._applicable(cr, uid, taxes, price_unit ,product, partner)
2006         res = []
2007         cur_price_unit=price_unit
2008         for tax in taxes:
2009             # we compute the amount for the current tax object and append it to the result
2010             data = {'id':tax.id,
2011                     'name':tax.description and tax.description + " - " + tax.name or tax.name,
2012                     'account_collected_id':tax.account_collected_id.id,
2013                     'account_paid_id':tax.account_paid_id.id,
2014                     'account_analytic_collected_id': tax.account_analytic_collected_id.id,
2015                     'account_analytic_paid_id': tax.account_analytic_paid_id.id,
2016                     'base_code_id': tax.base_code_id.id,
2017                     'ref_base_code_id': tax.ref_base_code_id.id,
2018                     'sequence': tax.sequence,
2019                     'base_sign': tax.base_sign,
2020                     'tax_sign': tax.tax_sign,
2021                     'ref_base_sign': tax.ref_base_sign,
2022                     'ref_tax_sign': tax.ref_tax_sign,
2023                     'price_unit': cur_price_unit,
2024                     'tax_code_id': tax.tax_code_id.id,
2025                     'ref_tax_code_id': tax.ref_tax_code_id.id,
2026             }
2027             res.append(data)
2028             if tax.type=='percent':
2029                 amount = cur_price_unit * tax.amount
2030                 data['amount'] = amount
2031
2032             elif tax.type=='fixed':
2033                 data['amount'] = tax.amount
2034                 data['tax_amount']=quantity
2035                # data['amount'] = quantity
2036             elif tax.type=='code':
2037                 localdict = {'price_unit':cur_price_unit, 'product':product, 'partner':partner}
2038                 exec tax.python_compute in localdict
2039                 amount = localdict['result']
2040                 data['amount'] = amount
2041             elif tax.type=='balance':
2042                 data['amount'] = cur_price_unit - reduce(lambda x,y: y.get('amount',0.0)+x, res, 0.0)
2043                 data['balance'] = cur_price_unit
2044
2045             amount2 = data.get('amount', 0.0)
2046             if tax.child_ids:
2047                 if tax.child_depend:
2048                     latest = res.pop()
2049                 amount = amount2
2050                 child_tax = self._unit_compute(cr, uid, tax.child_ids, amount, product, partner, quantity)
2051                 res.extend(child_tax)
2052                 if tax.child_depend:
2053                     for r in res:
2054                         for name in ('base','ref_base'):
2055                             if latest[name+'_code_id'] and latest[name+'_sign'] and not r[name+'_code_id']:
2056                                 r[name+'_code_id'] = latest[name+'_code_id']
2057                                 r[name+'_sign'] = latest[name+'_sign']
2058                                 r['price_unit'] = latest['price_unit']
2059                                 latest[name+'_code_id'] = False
2060                         for name in ('tax','ref_tax'):
2061                             if latest[name+'_code_id'] and latest[name+'_sign'] and not r[name+'_code_id']:
2062                                 r[name+'_code_id'] = latest[name+'_code_id']
2063                                 r[name+'_sign'] = latest[name+'_sign']
2064                                 r['amount'] = data['amount']
2065                                 latest[name+'_code_id'] = False
2066             if tax.include_base_amount:
2067                 cur_price_unit+=amount2
2068         return res
2069
2070     def compute_all(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, force_excluded=False):
2071         """
2072         :param force_excluded: boolean used to say that we don't want to consider the value of field price_include of
2073             tax. It's used in encoding by line where you don't matter if you encoded a tax with that boolean to True or
2074             False
2075         RETURN: {
2076                 'total': 0.0,                # Total without taxes
2077                 'total_included: 0.0,        # Total with taxes
2078                 'taxes': []                  # List of taxes, see compute for the format
2079             }
2080         """
2081
2082         # By default, for each tax, tax amount will first be computed
2083         # and rounded at the 'Account' decimal precision for each
2084         # PO/SO/invoice line and then these rounded amounts will be
2085         # summed, leading to the total amount for that tax. But, if the
2086         # company has tax_calculation_rounding_method = round_globally,
2087         # we still follow the same method, but we use a much larger
2088         # precision when we round the tax amount for each line (we use
2089         # the 'Account' decimal precision + 5), and that way it's like
2090         # rounding after the sum of the tax amounts of each line
2091         precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
2092         tax_compute_precision = precision
2093         if taxes and taxes[0].company_id.tax_calculation_rounding_method == 'round_globally':
2094             tax_compute_precision += 5
2095         totalin = totalex = float_round(price_unit * quantity, precision)
2096         tin = []
2097         tex = []
2098         for tax in taxes:
2099             if not tax.price_include or force_excluded:
2100                 tex.append(tax)
2101             else:
2102                 tin.append(tax)
2103         tin = self.compute_inv(cr, uid, tin, price_unit, quantity, product=product, partner=partner, precision=tax_compute_precision)
2104         for r in tin:
2105             totalex -= r.get('amount', 0.0)
2106         totlex_qty = 0.0
2107         try:
2108             totlex_qty = totalex/quantity
2109         except:
2110             pass
2111         tex = self._compute(cr, uid, tex, totlex_qty, quantity, product=product, partner=partner, precision=tax_compute_precision)
2112         for r in tex:
2113             totalin += r.get('amount', 0.0)
2114         return {
2115             'total': totalex,
2116             'total_included': totalin,
2117             'taxes': tin + tex
2118         }
2119
2120     def compute(self, cr, uid, taxes, price_unit, quantity,  product=None, partner=None):
2121         _logger.warning("Deprecated, use compute_all(...)['taxes'] instead of compute(...) to manage prices with tax included")
2122         return self._compute(cr, uid, taxes, price_unit, quantity, product, partner)
2123
2124     def _compute(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, precision=None):
2125         """
2126         Compute tax values for given PRICE_UNIT, QUANTITY and a buyer/seller ADDRESS_ID.
2127
2128         RETURN:
2129             [ tax ]
2130             tax = {'name':'', 'amount':0.0, 'account_collected_id':1, 'account_paid_id':2}
2131             one tax for each tax id in IDS and their children
2132         """
2133         if not precision:
2134             precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
2135         res = self._unit_compute(cr, uid, taxes, price_unit, product, partner, quantity)
2136         total = 0.0
2137         for r in res:
2138             if r.get('balance',False):
2139                 r['amount'] = round(r.get('balance', 0.0) * quantity, precision) - total
2140             else:
2141                 r['amount'] = round(r.get('amount', 0.0) * quantity, precision)
2142                 total += r['amount']
2143         return res
2144
2145     def _unit_compute_inv(self, cr, uid, taxes, price_unit, product=None, partner=None):
2146         taxes = self._applicable(cr, uid, taxes, price_unit,  product, partner)
2147         res = []
2148         taxes.reverse()
2149         cur_price_unit = price_unit
2150
2151         tax_parent_tot = 0.0
2152         for tax in taxes:
2153             if (tax.type=='percent') and not tax.include_base_amount:
2154                 tax_parent_tot += tax.amount
2155
2156         for tax in taxes:
2157             if (tax.type=='fixed') and not tax.include_base_amount:
2158                 cur_price_unit -= tax.amount
2159
2160         for tax in taxes:
2161             if tax.type=='percent':
2162                 if tax.include_base_amount:
2163                     amount = cur_price_unit - (cur_price_unit / (1 + tax.amount))
2164                 else:
2165                     amount = (cur_price_unit / (1 + tax_parent_tot)) * tax.amount
2166
2167             elif tax.type=='fixed':
2168                 amount = tax.amount
2169
2170             elif tax.type=='code':
2171                 localdict = {'price_unit':cur_price_unit, 'product':product, 'partner':partner}
2172                 exec tax.python_compute_inv in localdict
2173                 amount = localdict['result']
2174             elif tax.type=='balance':
2175                 amount = cur_price_unit - reduce(lambda x,y: y.get('amount',0.0)+x, res, 0.0)
2176
2177             if tax.include_base_amount:
2178                 cur_price_unit -= amount
2179                 todo = 0
2180             else:
2181                 todo = 1
2182             res.append({
2183                 'id': tax.id,
2184                 'todo': todo,
2185                 'name': tax.name,
2186                 'amount': amount,
2187                 'account_collected_id': tax.account_collected_id.id,
2188                 'account_paid_id': tax.account_paid_id.id,
2189                 'account_analytic_collected_id': tax.account_analytic_collected_id.id,
2190                 'account_analytic_paid_id': tax.account_analytic_paid_id.id,
2191                 'base_code_id': tax.base_code_id.id,
2192                 'ref_base_code_id': tax.ref_base_code_id.id,
2193                 'sequence': tax.sequence,
2194                 'base_sign': tax.base_sign,
2195                 'tax_sign': tax.tax_sign,
2196                 'ref_base_sign': tax.ref_base_sign,
2197                 'ref_tax_sign': tax.ref_tax_sign,
2198                 'price_unit': cur_price_unit,
2199                 'tax_code_id': tax.tax_code_id.id,
2200                 'ref_tax_code_id': tax.ref_tax_code_id.id,
2201             })
2202             if tax.child_ids:
2203                 if tax.child_depend:
2204                     del res[-1]
2205                     amount = price_unit
2206
2207             parent_tax = self._unit_compute_inv(cr, uid, tax.child_ids, amount, product, partner)
2208             res.extend(parent_tax)
2209
2210         total = 0.0
2211         for r in res:
2212             if r['todo']:
2213                 total += r['amount']
2214         for r in res:
2215             r['price_unit'] -= total
2216             r['todo'] = 0
2217         return res
2218
2219     def compute_inv(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, precision=None):
2220         """
2221         Compute tax values for given PRICE_UNIT, QUANTITY and a buyer/seller ADDRESS_ID.
2222         Price Unit is a Tax included price
2223
2224         RETURN:
2225             [ tax ]
2226             tax = {'name':'', 'amount':0.0, 'account_collected_id':1, 'account_paid_id':2}
2227             one tax for each tax id in IDS and their children
2228         """
2229         if not precision:
2230             precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
2231         res = self._unit_compute_inv(cr, uid, taxes, price_unit, product, partner=None)
2232         total = 0.0
2233         for r in res:
2234             if r.get('balance',False):
2235                 r['amount'] = round(r['balance'] * quantity, precision) - total
2236             else:
2237                 r['amount'] = round(r['amount'] * quantity, precision)
2238                 total += r['amount']
2239         return res
2240
2241 account_tax()
2242
2243 # ---------------------------------------------------------
2244 # Account Entries Models
2245 # ---------------------------------------------------------
2246
2247 class account_model(osv.osv):
2248     _name = "account.model"
2249     _description = "Account Model"
2250     _columns = {
2251         'name': fields.char('Model Name', size=64, required=True, help="This is a model for recurring accounting entries"),
2252         'journal_id': fields.many2one('account.journal', 'Journal', required=True),
2253         'company_id': fields.related('journal_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True),
2254         'lines_id': fields.one2many('account.model.line', 'model_id', 'Model Entries'),
2255         'legend': fields.text('Legend', readonly=True, size=100),
2256     }
2257
2258     _defaults = {
2259         'legend': lambda self, cr, uid, context:_('You can specify year, month and date in the name of the model using the following labels:\n\n%(year)s: To Specify Year \n%(month)s: To Specify Month \n%(date)s: Current Date\n\ne.g. My model on %(date)s'),
2260     }
2261     def generate(self, cr, uid, ids, datas={}, context=None):
2262         move_ids = []
2263         entry = {}
2264         account_move_obj = self.pool.get('account.move')
2265         account_move_line_obj = self.pool.get('account.move.line')
2266         pt_obj = self.pool.get('account.payment.term')
2267         period_obj = self.pool.get('account.period')
2268
2269         if context is None:
2270             context = {}
2271
2272         if datas.get('date', False):
2273             context.update({'date': datas['date']})
2274
2275         move_date = context.get('date', time.strftime('%Y-%m-%d'))
2276         move_date = datetime.strptime(move_date,"%Y-%m-%d")
2277         for model in self.browse(cr, uid, ids, context=context):
2278             ctx = context.copy()
2279             ctx.update({'company_id': model.company_id.id})
2280             period_ids = period_obj.find(cr, uid, dt=context.get('date', False), context=ctx)
2281             period_id = period_ids and period_ids[0] or False
2282             ctx.update({'journal_id': model.journal_id.id,'period_id': period_id})
2283             try:
2284                 entry['name'] = model.name%{'year': move_date.strftime('%Y'), 'month': move_date.strftime('%m'), 'date': move_date.strftime('%Y-%m')}
2285             except:
2286                 raise osv.except_osv(_('Wrong model !'), _('You have a wrong expression "%(...)s" in your model !'))
2287             move_id = account_move_obj.create(cr, uid, {
2288                 'ref': entry['name'],
2289                 'period_id': period_id,
2290                 'journal_id': model.journal_id.id,
2291                 'date': context.get('date', fields.date.context_today(self,cr,uid,context=context))
2292             })
2293             move_ids.append(move_id)
2294             for line in model.lines_id:
2295                 analytic_account_id = False
2296                 if line.analytic_account_id:
2297                     if not model.journal_id.analytic_journal_id:
2298                         raise osv.except_osv(_('No Analytic Journal !'),_("You have to define an analytic journal on the '%s' journal!") % (model.journal_id.name,))
2299                     analytic_account_id = line.analytic_account_id.id
2300                 val = {
2301                     'move_id': move_id,
2302                     'journal_id': model.journal_id.id,
2303                     'period_id': period_id,
2304                     'analytic_account_id': analytic_account_id
2305                 }
2306
2307                 date_maturity = context.get('date',time.strftime('%Y-%m-%d'))
2308                 if line.date_maturity == 'partner':
2309                     if not line.partner_id:
2310                         raise osv.except_osv(_('Error !'), _("Maturity date of entry line generated by model line '%s' of model '%s' is based on partner payment term!" \
2311                                                                 "\nPlease define partner on it!")%(line.name, model.name))
2312
2313                     payment_term_id = False
2314                     if model.journal_id.type in ('purchase', 'purchase_refund') and line.partner_id.property_supplier_payment_term:
2315                         payment_term_id = line.partner_id.property_supplier_payment_term.id
2316                     elif line.partner_id.property_payment_term:
2317                         payment_term_id = line.partner_id.property_payment_term.id
2318                     if payment_term_id:
2319                         pterm_list = pt_obj.compute(cr, uid, payment_term_id, value=1, date_ref=date_maturity)
2320                         if pterm_list:
2321                             pterm_list = [l[0] for l in pterm_list]
2322                             pterm_list.sort()
2323                             date_maturity = pterm_list[-1]
2324
2325                 val.update({
2326                     'name': line.name,
2327                     'quantity': line.quantity,
2328                     'debit': line.debit,
2329                     'credit': line.credit,
2330                     'account_id': line.account_id.id,
2331                     'move_id': move_id,
2332                     'partner_id': line.partner_id.id,
2333                     'date': context.get('date', fields.date.context_today(self,cr,uid,context=context)),
2334                     'date_maturity': date_maturity
2335                 })
2336                 account_move_line_obj.create(cr, uid, val, context=ctx)
2337
2338         return move_ids
2339
2340 account_model()
2341
2342 class account_model_line(osv.osv):
2343     _name = "account.model.line"
2344     _description = "Account Model Entries"
2345     _columns = {
2346         'name': fields.char('Name', size=64, required=True),
2347         'sequence': fields.integer('Sequence', required=True, help="The sequence field is used to order the resources from lower sequences to higher ones."),
2348         'quantity': fields.float('Quantity', digits_compute=dp.get_precision('Account'), help="The optional quantity on entries."),
2349         'debit': fields.float('Debit', digits_compute=dp.get_precision('Account')),
2350         'credit': fields.float('Credit', digits_compute=dp.get_precision('Account')),
2351         'account_id': fields.many2one('account.account', 'Account', required=True, ondelete="cascade"),
2352         'analytic_account_id': fields.many2one('account.analytic.account', 'Analytic Account', ondelete="cascade"),
2353         'model_id': fields.many2one('account.model', 'Model', required=True, ondelete="cascade", select=True),
2354         'amount_currency': fields.float('Amount Currency', help="The amount expressed in an optional other currency."),
2355         'currency_id': fields.many2one('res.currency', 'Currency'),
2356         'partner_id': fields.many2one('res.partner', 'Partner'),
2357         'date_maturity': fields.selection([('today','Date of the day'), ('partner','Partner Payment Term')], 'Maturity Date', help="The maturity date of the generated entries for this model. You can choose between the creation date or the creation date of the entries plus the partner payment terms."),
2358     }
2359     _order = 'sequence'
2360     _sql_constraints = [
2361         ('credit_debit1', 'CHECK (credit*debit=0)',  'Wrong credit or debit value in model, they must be positive!'),
2362         ('credit_debit2', 'CHECK (credit+debit>=0)', 'Wrong credit or debit value in model, they must be positive!'),
2363     ]
2364 account_model_line()
2365
2366 # ---------------------------------------------------------
2367 # Account Subscription
2368 # ---------------------------------------------------------
2369
2370
2371 class account_subscription(osv.osv):
2372     _name = "account.subscription"
2373     _description = "Account Subscription"
2374     _columns = {
2375         'name': fields.char('Name', size=64, required=True),
2376         'ref': fields.char('Reference', size=16),
2377         'model_id': fields.many2one('account.model', 'Model', required=True),
2378         'date_start': fields.date('Start Date', required=True),
2379         'period_total': fields.integer('Number of Periods', required=True),
2380         'period_nbr': fields.integer('Period', required=True),
2381         'period_type': fields.selection([('day','days'),('month','month'),('year','year')], 'Period Type', required=True),
2382         'state': fields.selection([('draft','Draft'),('running','Running'),('done','Done')], 'Status', required=True, readonly=True),
2383         'lines_id': fields.one2many('account.subscription.line', 'subscription_id', 'Subscription Lines')
2384     }
2385     _defaults = {
2386         'date_start': fields.date.context_today,
2387         'period_type': 'month',
2388         'period_total': 12,
2389         'period_nbr': 1,
2390         'state': 'draft',
2391     }
2392     def state_draft(self, cr, uid, ids, context=None):
2393         self.write(cr, uid, ids, {'state':'draft'})
2394         return False
2395
2396     def check(self, cr, uid, ids, context=None):
2397         todone = []
2398         for sub in self.browse(cr, uid, ids, context=context):
2399             ok = True
2400             for line in sub.lines_id:
2401                 if not line.move_id.id:
2402                     ok = False
2403                     break
2404             if ok:
2405                 todone.append(sub.id)
2406         if todone:
2407             self.write(cr, uid, todone, {'state':'done'})
2408         return False
2409
2410     def remove_line(self, cr, uid, ids, context=None):
2411         toremove = []
2412         for sub in self.browse(cr, uid, ids, context=context):
2413             for line in sub.lines_id:
2414                 if not line.move_id.id:
2415                     toremove.append(line.id)
2416         if toremove:
2417             self.pool.get('account.subscription.line').unlink(cr, uid, toremove)
2418         self.write(cr, uid, ids, {'state':'draft'})
2419         return False
2420
2421     def compute(self, cr, uid, ids, context=None):
2422         for sub in self.browse(cr, uid, ids, context=context):
2423             ds = sub.date_start
2424             for i in range(sub.period_total):
2425                 self.pool.get('account.subscription.line').create(cr, uid, {
2426                     'date': ds,
2427                     'subscription_id': sub.id,
2428                 })
2429                 if sub.period_type=='day':
2430                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(days=sub.period_nbr)).strftime('%Y-%m-%d')
2431                 if sub.period_type=='month':
2432                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(months=sub.period_nbr)).strftime('%Y-%m-%d')
2433                 if sub.period_type=='year':
2434                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(years=sub.period_nbr)).strftime('%Y-%m-%d')
2435         self.write(cr, uid, ids, {'state':'running'})
2436         return True
2437
2438 account_subscription()
2439
2440 class account_subscription_line(osv.osv):
2441     _name = "account.subscription.line"
2442     _description = "Account Subscription Line"
2443     _columns = {
2444         'subscription_id': fields.many2one('account.subscription', 'Subscription', required=True, select=True),
2445         'date': fields.date('Date', required=True),
2446         'move_id': fields.many2one('account.move', 'Entry'),
2447     }
2448
2449     def move_create(self, cr, uid, ids, context=None):
2450         tocheck = {}
2451         all_moves = []
2452         obj_model = self.pool.get('account.model')
2453         for line in self.browse(cr, uid, ids, context=context):
2454             datas = {
2455                 'date': line.date,
2456             }
2457             move_ids = obj_model.generate(cr, uid, [line.subscription_id.model_id.id], datas, context)
2458             tocheck[line.subscription_id.id] = True
2459             self.write(cr, uid, [line.id], {'move_id':move_ids[0]})
2460             all_moves.extend(move_ids)
2461         if tocheck:
2462             self.pool.get('account.subscription').check(cr, uid, tocheck.keys(), context)
2463         return all_moves
2464
2465     _rec_name = 'date'
2466
2467 account_subscription_line()
2468
2469 #  ---------------------------------------------------------------
2470 #   Account Templates: Account, Tax, Tax Code and chart. + Wizard
2471 #  ---------------------------------------------------------------
2472
2473 class account_tax_template(osv.osv):
2474     _name = 'account.tax.template'
2475 account_tax_template()
2476
2477 class account_account_template(osv.osv):
2478     _order = "code"
2479     _name = "account.account.template"
2480     _description ='Templates for Accounts'
2481
2482     _columns = {
2483         'name': fields.char('Name', size=256, required=True, select=True),
2484         'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
2485         'code': fields.char('Code', size=64, required=True, select=1),
2486         'type': fields.selection([
2487             ('receivable','Receivable'),
2488             ('payable','Payable'),
2489             ('view','View'),
2490             ('consolidation','Consolidation'),
2491             ('liquidity','Liquidity'),
2492             ('other','Regular'),
2493             ('closed','Closed'),
2494             ], 'Internal Type', required=True,help="This type is used to differentiate types with "\
2495             "special effects in OpenERP: view can not have entries, consolidation are accounts that "\
2496             "can have children accounts for multi-company consolidations, payable/receivable are for "\
2497             "partners accounts (for debit/credit computations), closed for depreciated accounts."),
2498         'user_type': fields.many2one('account.account.type', 'Account Type', required=True,
2499             help="These types are defined according to your country. The type contains more information "\
2500             "about the account and its specificities."),
2501         'financial_report_ids': fields.many2many('account.financial.report', 'account_template_financial_report', 'account_template_id', 'report_line_id', 'Financial Reports'),
2502         'reconcile': fields.boolean('Allow Reconciliation', help="Check this option if you want the user to reconcile entries in this account."),
2503         'shortcut': fields.char('Shortcut', size=12),
2504         'note': fields.text('Note'),
2505         'parent_id': fields.many2one('account.account.template', 'Parent Account Template', ondelete='cascade'),
2506         'child_parent_ids':fields.one2many('account.account.template', 'parent_id', 'Children'),
2507         'tax_ids': fields.many2many('account.tax.template', 'account_account_template_tax_rel', 'account_id', 'tax_id', 'Default Taxes'),
2508         'nocreate': fields.boolean('Optional create', help="If checked, the new chart of accounts will not contain this by default."),
2509         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', help="This optional field allow you to link an account template to a specific chart template that may differ from the one its root parent belongs to. This allow you to define chart templates that extend another and complete it with few new accounts (You don't need to define the whole structure that is common to both several times)."),
2510     }
2511
2512     _defaults = {
2513         'reconcile': False,
2514         'type': 'view',
2515         'nocreate': False,
2516     }
2517
2518     def _check_type(self, cr, uid, ids, context=None):
2519         if context is None:
2520             context = {}
2521         accounts = self.browse(cr, uid, ids, context=context)
2522         for account in accounts:
2523             if account.parent_id and account.parent_id.type != 'view':
2524                 return False
2525         return True
2526
2527     _check_recursion = check_cycle
2528     _constraints = [
2529         (_check_recursion, 'Error ! You can not create recursive account templates.', ['parent_id']),
2530         (_check_type, 'Configuration Error!\nYou can not define children to an account with internal type different of "View"! ', ['type']),
2531
2532     ]
2533
2534     def name_get(self, cr, uid, ids, context=None):
2535         if not ids:
2536             return []
2537         reads = self.read(cr, uid, ids, ['name','code'], context=context)
2538         res = []
2539         for record in reads:
2540             name = record['name']
2541             if record['code']:
2542                 name = record['code']+' '+name
2543             res.append((record['id'],name ))
2544         return res
2545
2546     def generate_account(self, cr, uid, chart_template_id, tax_template_ref, acc_template_ref, code_digits, company_id, context=None):
2547         """
2548         This method for generating accounts from templates.
2549
2550         :param chart_template_id: id of the chart template chosen in the wizard
2551         :param tax_template_ref: Taxes templates reference for write taxes_id in account_account.
2552         :paramacc_template_ref: dictionary with the mappping between the account templates and the real accounts.
2553         :param code_digits: number of digits got from wizard.multi.charts.accounts, this is use for account code.
2554         :param company_id: company_id selected from wizard.multi.charts.accounts.
2555         :returns: return acc_template_ref for reference purpose.
2556         :rtype: dict
2557         """
2558         if context is None:
2559             context = {}
2560         obj_acc = self.pool.get('account.account')
2561         company_name = self.pool.get('res.company').browse(cr, uid, company_id, context=context).name
2562         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
2563         #deactivate the parent_store functionnality on account_account for rapidity purpose
2564         ctx = context.copy()
2565         ctx.update({'defer_parent_store_computation': True})
2566         level_ref = {}
2567         children_acc_criteria = [('chart_template_id','=', chart_template_id)]
2568         if template.account_root_id.id:
2569             children_acc_criteria = ['|'] + children_acc_criteria + ['&',('parent_id','child_of', [template.account_root_id.id]),('chart_template_id','=', False)]
2570         children_acc_template = self.search(cr, uid, [('nocreate','!=',True)] + children_acc_criteria, order='id')
2571         for account_template in self.browse(cr, uid, children_acc_template, context=context):
2572             # skip the root of COA if it's not the main one
2573             if (template.account_root_id.id == account_template.id) and template.parent_id:
2574                 continue
2575             tax_ids = []
2576             for tax in account_template.tax_ids:
2577                 tax_ids.append(tax_template_ref[tax.id])
2578
2579             code_main = account_template.code and len(account_template.code) or 0
2580             code_acc = account_template.code or ''
2581             if code_main > 0 and code_main <= code_digits and account_template.type != 'view':
2582                 code_acc = str(code_acc) + (str('0'*(code_digits-code_main)))
2583             parent_id = account_template.parent_id and ((account_template.parent_id.id in acc_template_ref) and acc_template_ref[account_template.parent_id.id]) or False
2584             #the level as to be given as well at the creation time, because of the defer_parent_store_computation in
2585             #context. Indeed because of this, the parent_left and parent_right are not computed and thus the child_of
2586             #operator does not return the expected values, with result of having the level field not computed at all.
2587             if parent_id:
2588                 level = parent_id in level_ref and level_ref[parent_id] + 1 or obj_acc._get_level(cr, uid, [parent_id], 'level', None, context=context)[parent_id] + 1
2589             else:
2590                 level = 0
2591             vals={
2592                 'name': (template.account_root_id.id == account_template.id) and company_name or account_template.name,
2593                 'currency_id': account_template.currency_id and account_template.currency_id.id or False,
2594                 'code': code_acc,
2595                 'type': account_template.type,
2596                 'user_type': account_template.user_type and account_template.user_type.id or False,
2597                 'reconcile': account_template.reconcile,
2598                 'shortcut': account_template.shortcut,
2599                 'note': account_template.note,
2600                 'financial_report_ids': account_template.financial_report_ids and [(6,0,[x.id for x in account_template.financial_report_ids])] or False,
2601                 'parent_id': parent_id,
2602                 'tax_ids': [(6,0,tax_ids)],
2603                 'company_id': company_id,
2604                 'level': level,
2605             }
2606             new_account = obj_acc.create(cr, uid, vals, context=ctx)
2607             acc_template_ref[account_template.id] = new_account
2608             level_ref[new_account] = level
2609
2610         #reactivate the parent_store functionnality on account_account
2611         obj_acc._parent_store_compute(cr)
2612         return acc_template_ref
2613
2614 account_account_template()
2615
2616 class account_add_tmpl_wizard(osv.osv_memory):
2617     """Add one more account from the template.
2618
2619     With the 'nocreate' option, some accounts may not be created. Use this to add them later."""
2620     _name = 'account.addtmpl.wizard'
2621
2622     def _get_def_cparent(self, cr, uid, context=None):
2623         acc_obj = self.pool.get('account.account')
2624         tmpl_obj = self.pool.get('account.account.template')
2625         tids = tmpl_obj.read(cr, uid, [context['tmpl_ids']], ['parent_id'])
2626         if not tids or not tids[0]['parent_id']:
2627             return False
2628         ptids = tmpl_obj.read(cr, uid, [tids[0]['parent_id'][0]], ['code'])
2629         res = None
2630         if not ptids or not ptids[0]['code']:
2631             raise osv.except_osv(_('Error !'), _('I can not locate a parent code for the template account!'))
2632             res = acc_obj.search(cr, uid, [('code','=',ptids[0]['code'])])
2633         return res and res[0] or False
2634
2635     _columns = {
2636         'cparent_id':fields.many2one('account.account', 'Parent target', help="Creates an account with the selected template under this existing parent.", required=True),
2637     }
2638     _defaults = {
2639         'cparent_id': _get_def_cparent,
2640     }
2641
2642     def action_create(self,cr,uid,ids,context=None):
2643         if context is None:
2644             context = {}
2645         acc_obj = self.pool.get('account.account')
2646         tmpl_obj = self.pool.get('account.account.template')
2647         data = self.read(cr, uid, ids)[0]
2648         company_id = acc_obj.read(cr, uid, [data['cparent_id'][0]], ['company_id'])[0]['company_id'][0]
2649         account_template = tmpl_obj.browse(cr, uid, context['tmpl_ids'])
2650         vals = {
2651             'name': account_template.name,
2652             'currency_id': account_template.currency_id and account_template.currency_id.id or False,
2653             'code': account_template.code,
2654             'type': account_template.type,
2655             'user_type': account_template.user_type and account_template.user_type.id or False,
2656             'reconcile': account_template.reconcile,
2657             'shortcut': account_template.shortcut,
2658             'note': account_template.note,
2659             'parent_id': data['cparent_id'][0],
2660             'company_id': company_id,
2661             }
2662         acc_obj.create(cr, uid, vals)
2663         return {'type':'state', 'state': 'end' }
2664
2665     def action_cancel(self, cr, uid, ids, context=None):
2666         return { 'type': 'state', 'state': 'end' }
2667
2668 account_add_tmpl_wizard()
2669
2670 class account_tax_code_template(osv.osv):
2671
2672     _name = 'account.tax.code.template'
2673     _description = 'Tax Code Template'
2674     _order = 'code'
2675     _rec_name = 'code'
2676     _columns = {
2677         'name': fields.char('Tax Case Name', size=64, required=True),
2678         'code': fields.char('Case Code', size=64),
2679         'info': fields.text('Description'),
2680         'parent_id': fields.many2one('account.tax.code.template', 'Parent Code', select=True),
2681         'child_ids': fields.one2many('account.tax.code.template', 'parent_id', 'Child Codes'),
2682         'sign': fields.float('Sign For Parent', required=True),
2683         'notprintable':fields.boolean("Not Printable in Invoice", help="Check this box if you don't want any tax related to this tax Code to appear on invoices."),
2684     }
2685
2686     _defaults = {
2687         'sign': 1.0,
2688         'notprintable': False,
2689     }
2690
2691     def generate_tax_code(self, cr, uid, tax_code_root_id, company_id, context=None):
2692         '''
2693         This function generates the tax codes from the templates of tax code that are children of the given one passed
2694         in argument. Then it returns a dictionary with the mappping between the templates and the real objects.
2695
2696         :param tax_code_root_id: id of the root of all the tax code templates to process
2697         :param company_id: id of the company the wizard is running for
2698         :returns: dictionary with the mappping between the templates and the real objects.
2699         :rtype: dict
2700         '''
2701         obj_tax_code_template = self.pool.get('account.tax.code.template')
2702         obj_tax_code = self.pool.get('account.tax.code')
2703         tax_code_template_ref = {}
2704         company = self.pool.get('res.company').browse(cr, uid, company_id, context=context)
2705
2706         #find all the children of the tax_code_root_id
2707         children_tax_code_template = tax_code_root_id and obj_tax_code_template.search(cr, uid, [('parent_id','child_of',[tax_code_root_id])], order='id') or []
2708         for tax_code_template in obj_tax_code_template.browse(cr, uid, children_tax_code_template, context=context):
2709             vals = {
2710                 'name': (tax_code_root_id == tax_code_template.id) and company.name or tax_code_template.name,
2711                 'code': tax_code_template.code,
2712                 'info': tax_code_template.info,
2713                 'parent_id': tax_code_template.parent_id and ((tax_code_template.parent_id.id in tax_code_template_ref) and tax_code_template_ref[tax_code_template.parent_id.id]) or False,
2714                 'company_id': company_id,
2715                 'sign': tax_code_template.sign,
2716             }
2717             #check if this tax code already exists
2718             rec_list = obj_tax_code.search(cr, uid, [('name', '=', vals['name']),('code', '=', vals['code']),('company_id', '=', vals['company_id'])], context=context)
2719             if not rec_list:
2720                 #if not yet, create it
2721                 new_tax_code = obj_tax_code.create(cr, uid, vals)
2722                 #recording the new tax code to do the mapping
2723                 tax_code_template_ref[tax_code_template.id] = new_tax_code
2724         return tax_code_template_ref
2725
2726     def name_get(self, cr, uid, ids, context=None):
2727         if not ids:
2728             return []
2729         if isinstance(ids, (int, long)):
2730             ids = [ids]
2731         reads = self.read(cr, uid, ids, ['name','code'], context, load='_classic_write')
2732         return [(x['id'], (x['code'] and x['code'] + ' - ' or '') + x['name']) \
2733                 for x in reads]
2734
2735     _check_recursion = check_cycle
2736     _constraints = [
2737         (_check_recursion, 'Error ! You can not create recursive Tax Codes.', ['parent_id'])
2738     ]
2739     _order = 'code,name'
2740 account_tax_code_template()
2741
2742
2743 class account_chart_template(osv.osv):
2744     _name="account.chart.template"
2745     _description= "Templates for Account Chart"
2746
2747     _columns={
2748         'name': fields.char('Name', size=64, required=True),
2749         'parent_id': fields.many2one('account.chart.template', 'Parent Chart Template'),
2750         'code_digits': fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
2751         'visible': fields.boolean('Can be Visible?', help="Set this to False if you don't want this template to be used actively in the wizard that generate Chart of Accounts from templates, this is useful when you want to generate accounts of this template only when loading its child template."),
2752         'complete_tax_set': fields.boolean('Complete Set of Taxes', help='This boolean helps you to choose if you want to propose to the user to encode the sale and purchase rates or choose from list of taxes. This last choice assumes that the set of tax defined on this template is complete'),
2753         'account_root_id': fields.many2one('account.account.template', 'Root Account', domain=[('parent_id','=',False)]),
2754         'tax_code_root_id': fields.many2one('account.tax.code.template', 'Root Tax Code', domain=[('parent_id','=',False)]),
2755         'tax_template_ids': fields.one2many('account.tax.template', 'chart_template_id', 'Tax Template List', help='List of all the taxes that have to be installed by the wizard'),
2756         'bank_account_view_id': fields.many2one('account.account.template', 'Bank Account'),
2757         'property_account_receivable': fields.many2one('account.account.template', 'Receivable Account'),
2758         'property_account_payable': fields.many2one('account.account.template', 'Payable Account'),
2759         'property_account_expense_categ': fields.many2one('account.account.template', 'Expense Category Account'),
2760         'property_account_income_categ': fields.many2one('account.account.template', 'Income Category Account'),
2761         'property_account_expense': fields.many2one('account.account.template', 'Expense Account on Product Template'),
2762         'property_account_income': fields.many2one('account.account.template', 'Income Account on Product Template'),
2763         'property_reserve_and_surplus_account': fields.many2one('account.account.template', 'Reserve and Profit/Loss Account', domain=[('type', '=', 'payable')], help='This Account is used for transferring Profit/Loss(If It is Profit: Amount will be added, Loss: Amount will be deducted.), Which is calculated from Profilt & Loss Report'),
2764         'property_account_income_opening': fields.many2one('account.account.template', 'Opening Entries Income Account'),
2765         'property_account_expense_opening': fields.many2one('account.account.template', 'Opening Entries Expense Account'),
2766     }
2767
2768     _defaults = {
2769         'visible': True,
2770         'code_digits': 6,
2771         'complete_tax_set': True,
2772     }
2773
2774 account_chart_template()
2775
2776 class account_tax_template(osv.osv):
2777
2778     _name = 'account.tax.template'
2779     _description = 'Templates for Taxes'
2780
2781     _columns = {
2782         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
2783         'name': fields.char('Tax Name', size=64, required=True),
2784         'sequence': fields.integer('Sequence', required=True, help="The sequence field is used to order the taxes lines from lower sequences to higher ones. The order is important if you have a tax that has several tax children. In this case, the evaluation order is important."),
2785         'amount': fields.float('Amount', required=True, digits=(14,4), help="For Tax Type percent enter % ratio between 0-1."),
2786         'type': fields.selection( [('percent','Percent'), ('fixed','Fixed'), ('none','None'), ('code','Python Code'), ('balance','Balance')], 'Tax Type', required=True),
2787         'applicable_type': fields.selection( [('true','True'), ('code','Python Code')], 'Applicable Type', required=True, help="If not applicable (computed through a Python code), the tax won't appear on the invoice."),
2788         'domain':fields.char('Domain', size=32, help="This field is only used if you develop your own module allowing developers to create specific taxes in a custom domain."),
2789         'account_collected_id':fields.many2one('account.account.template', 'Invoice Tax Account'),
2790         'account_paid_id':fields.many2one('account.account.template', 'Refund Tax Account'),
2791         'parent_id':fields.many2one('account.tax.template', 'Parent Tax Account', select=True),
2792         'child_depend':fields.boolean('Tax on Children', help="Set if the tax computation is based on the computation of child taxes rather than on the total amount."),
2793         'python_compute':fields.text('Python Code'),
2794         'python_compute_inv':fields.text('Python Code (reverse)'),
2795         'python_applicable':fields.text('Python Code'),
2796
2797         #
2798         # Fields used for the Tax declaration
2799         #
2800         'base_code_id': fields.many2one('account.tax.code.template', 'Base Code', help="Use this code for the tax declaration."),
2801         'tax_code_id': fields.many2one('account.tax.code.template', 'Tax Code', help="Use this code for the tax declaration."),
2802         'base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
2803         'tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
2804
2805         # Same fields for refund invoices
2806
2807         'ref_base_code_id': fields.many2one('account.tax.code.template', 'Refund Base Code', help="Use this code for the tax declaration."),
2808         'ref_tax_code_id': fields.many2one('account.tax.code.template', 'Refund Tax Code', help="Use this code for the tax declaration."),
2809         'ref_base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
2810         'ref_tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
2811         'include_base_amount': fields.boolean('Include in Base Amount', help="Set if the amount of tax must be included in the base amount before computing the next taxes."),
2812         'description': fields.char('Internal Name', size=32),
2813         'type_tax_use': fields.selection([('sale','Sale'),('purchase','Purchase'),('all','All')], 'Tax Use In', required=True,),
2814         'price_include': fields.boolean('Tax Included in Price', help="Check this if the price you use on the product and invoices includes this tax."),
2815     }
2816
2817     def name_get(self, cr, uid, ids, context=None):
2818         if not ids:
2819             return []
2820         res = []
2821         for record in self.read(cr, uid, ids, ['description','name'], context=context):
2822             name = record['description'] and record['description'] or record['name']
2823             res.append((record['id'],name ))
2824         return res
2825
2826     def _default_company(self, cr, uid, context=None):
2827         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
2828         if user.company_id:
2829             return user.company_id.id
2830         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
2831
2832     _defaults = {
2833         'python_compute': lambda *a: '''# price_unit\n# product: product.product object or None\n# partner: res.partner object or None\n\nresult = price_unit * 0.10''',
2834         'python_compute_inv': lambda *a: '''# price_unit\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
2835         'applicable_type': 'true',
2836         'type': 'percent',
2837         'amount': 0,
2838         'sequence': 1,
2839         'ref_tax_sign': 1,
2840         'ref_base_sign': 1,
2841         'tax_sign': 1,
2842         'base_sign': 1,
2843         'include_base_amount': False,
2844         'type_tax_use': 'all',
2845         'price_include': 0,
2846     }
2847     _order = 'sequence'
2848
2849     def _generate_tax(self, cr, uid, tax_templates, tax_code_template_ref, company_id, context=None):
2850         """
2851         This method generate taxes from templates.
2852
2853         :param tax_templates: list of browse record of the tax templates to process
2854         :param tax_code_template_ref: Taxcode templates reference.
2855         :param company_id: id of the company the wizard is running for
2856         :returns:
2857             {
2858             'tax_template_to_tax': mapping between tax template and the newly generated taxes corresponding,
2859             'account_dict': dictionary containing a to-do list with all the accounts to assign on new taxes
2860             }
2861         """
2862         if context is None:
2863             context = {}
2864         res = {}
2865         todo_dict = {}
2866         tax_template_to_tax = {}
2867         for tax in tax_templates:
2868             vals_tax = {
2869                 'name':tax.name,
2870                 'sequence': tax.sequence,
2871                 'amount': tax.amount,
2872                 'type': tax.type,
2873                 'applicable_type': tax.applicable_type,
2874                 'domain': tax.domain,
2875                 'parent_id': tax.parent_id and ((tax.parent_id.id in tax_template_to_tax) and tax_template_to_tax[tax.parent_id.id]) or False,
2876                 'child_depend': tax.child_depend,
2877                 'python_compute': tax.python_compute,
2878                 'python_compute_inv': tax.python_compute_inv,
2879                 'python_applicable': tax.python_applicable,
2880                 'base_code_id': tax.base_code_id and ((tax.base_code_id.id in tax_code_template_ref) and tax_code_template_ref[tax.base_code_id.id]) or False,
2881                 'tax_code_id': tax.tax_code_id and ((tax.tax_code_id.id in tax_code_template_ref) and tax_code_template_ref[tax.tax_code_id.id]) or False,
2882                 'base_sign': tax.base_sign,
2883                 'tax_sign': tax.tax_sign,
2884                 'ref_base_code_id': tax.ref_base_code_id and ((tax.ref_base_code_id.id in tax_code_template_ref) and tax_code_template_ref[tax.ref_base_code_id.id]) or False,
2885                 'ref_tax_code_id': tax.ref_tax_code_id and ((tax.ref_tax_code_id.id in tax_code_template_ref) and tax_code_template_ref[tax.ref_tax_code_id.id]) or False,
2886                 'ref_base_sign': tax.ref_base_sign,
2887                 'ref_tax_sign': tax.ref_tax_sign,
2888                 'include_base_amount': tax.include_base_amount,
2889                 'description': tax.description,
2890                 'company_id': company_id,
2891                 'type_tax_use': tax.type_tax_use,
2892                 'price_include': tax.price_include
2893             }
2894             new_tax = self.pool.get('account.tax').create(cr, uid, vals_tax)
2895             tax_template_to_tax[tax.id] = new_tax
2896             #as the accounts have not been created yet, we have to wait before filling these fields
2897             todo_dict[new_tax] = {
2898                 'account_collected_id': tax.account_collected_id and tax.account_collected_id.id or False,
2899                 'account_paid_id': tax.account_paid_id and tax.account_paid_id.id or False,
2900             }
2901         res.update({'tax_template_to_tax': tax_template_to_tax, 'account_dict': todo_dict})
2902         return res
2903
2904 account_tax_template()
2905
2906 # Fiscal Position Templates
2907
2908 class account_fiscal_position_template(osv.osv):
2909     _name = 'account.fiscal.position.template'
2910     _description = 'Template for Fiscal Position'
2911
2912     _columns = {
2913         'name': fields.char('Fiscal Position Template', size=64, required=True),
2914         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
2915         'account_ids': fields.one2many('account.fiscal.position.account.template', 'position_id', 'Account Mapping'),
2916         'tax_ids': fields.one2many('account.fiscal.position.tax.template', 'position_id', 'Tax Mapping'),
2917         'note': fields.text('Notes', translate=True),
2918     }
2919
2920     def generate_fiscal_position(self, cr, uid, chart_temp_id, tax_template_ref, acc_template_ref, company_id, context=None):
2921         """
2922         This method generate Fiscal Position, Fiscal Position Accounts and Fiscal Position Taxes from templates.
2923
2924         :param chart_temp_id: Chart Template Id.
2925         :param taxes_ids: Taxes templates reference for generating account.fiscal.position.tax.
2926         :param acc_template_ref: Account templates reference for generating account.fiscal.position.account.
2927         :param company_id: company_id selected from wizard.multi.charts.accounts.
2928         :returns: True
2929         """
2930         if context is None:
2931             context = {}
2932         obj_tax_fp = self.pool.get('account.fiscal.position.tax')
2933         obj_ac_fp = self.pool.get('account.fiscal.position.account')
2934         obj_fiscal_position = self.pool.get('account.fiscal.position')
2935         fp_ids = self.search(cr, uid, [('chart_template_id', '=', chart_temp_id)])
2936         for position in self.browse(cr, uid, fp_ids, context=context):
2937             new_fp = obj_fiscal_position.create(cr, uid, {'company_id': company_id, 'name': position.name, 'note': position.note})
2938             for tax in position.tax_ids:
2939                 obj_tax_fp.create(cr, uid, {
2940                     'tax_src_id': tax_template_ref[tax.tax_src_id.id],
2941                     'tax_dest_id': tax.tax_dest_id and tax_template_ref[tax.tax_dest_id.id] or False,
2942                     'position_id': new_fp
2943                 })
2944             for acc in position.account_ids:
2945                 obj_ac_fp.create(cr, uid, {
2946                     'account_src_id': acc_template_ref[acc.account_src_id.id],
2947                     'account_dest_id': acc_template_ref[acc.account_dest_id.id],
2948                     'position_id': new_fp
2949                 })
2950         return True
2951
2952 account_fiscal_position_template()
2953
2954 class account_fiscal_position_tax_template(osv.osv):
2955     _name = 'account.fiscal.position.tax.template'
2956     _description = 'Template Tax Fiscal Position'
2957     _rec_name = 'position_id'
2958
2959     _columns = {
2960         'position_id': fields.many2one('account.fiscal.position.template', 'Fiscal Position', required=True, ondelete='cascade'),
2961         'tax_src_id': fields.many2one('account.tax.template', 'Tax Source', required=True),
2962         'tax_dest_id': fields.many2one('account.tax.template', 'Replacement Tax')
2963     }
2964
2965 account_fiscal_position_tax_template()
2966
2967 class account_fiscal_position_account_template(osv.osv):
2968     _name = 'account.fiscal.position.account.template'
2969     _description = 'Template Account Fiscal Mapping'
2970     _rec_name = 'position_id'
2971     _columns = {
2972         'position_id': fields.many2one('account.fiscal.position.template', 'Fiscal Mapping', required=True, ondelete='cascade'),
2973         'account_src_id': fields.many2one('account.account.template', 'Account Source', domain=[('type','<>','view')], required=True),
2974         'account_dest_id': fields.many2one('account.account.template', 'Account Destination', domain=[('type','<>','view')], required=True)
2975     }
2976
2977 account_fiscal_position_account_template()
2978
2979 # ---------------------------------------------------------
2980 # Account generation from template wizards
2981 # ---------------------------------------------------------
2982
2983 class wizard_multi_charts_accounts(osv.osv_memory):
2984     """
2985     Create a new account chart for a company.
2986     Wizards ask for:
2987         * a company
2988         * an account chart template
2989         * a number of digits for formatting code of non-view accounts
2990         * a list of bank accounts owned by the company
2991     Then, the wizard:
2992         * generates all accounts from the template and assigns them to the right company
2993         * generates all taxes and tax codes, changing account assignations
2994         * generates all accounting properties and assigns them correctly
2995     """
2996     _name='wizard.multi.charts.accounts'
2997     _inherit = 'res.config'
2998
2999     _columns = {
3000         'company_id':fields.many2one('res.company', 'Company', required=True),
3001         'only_one_chart_template': fields.boolean('Only One Chart Template Available'),
3002         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
3003         'bank_accounts_id': fields.one2many('account.bank.accounts.wizard', 'bank_account_id', 'Cash and Banks', required=True),
3004         'code_digits':fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
3005         "sale_tax": fields.many2one("account.tax.template", "Default Sale Tax"),
3006         "purchase_tax": fields.many2one("account.tax.template", "Default Purchase Tax"),
3007         'sale_tax_rate': fields.float('Sales Tax(%)'),
3008         'purchase_tax_rate': fields.float('Purchase Tax(%)'),
3009         'complete_tax_set': fields.boolean('Complete Set of Taxes', help='This boolean helps you to choose if you want to propose to the user to encode the sales and purchase rates or use the usual m2o fields. This last choice assumes that the set of tax defined for the chosen template is complete'),
3010     }
3011     def onchange_tax_rate(self, cr, uid, ids, rate=False, context=None):
3012         return {'value': {'purchase_tax_rate': rate or False}}
3013
3014     def onchange_chart_template_id(self, cr, uid, ids, chart_template_id=False, context=None):
3015         res = {}
3016         tax_templ_obj = self.pool.get('account.tax.template')
3017         res['value'] = {'complete_tax_set': False, 'sale_tax': False, 'purchase_tax': False}
3018         if chart_template_id:
3019             data = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3020             res['value'].update({'complete_tax_set': data.complete_tax_set})
3021             if data.complete_tax_set:
3022             # default tax is given by the lowest sequence. For same sequence we will take the latest created as it will be the case for tax created while isntalling the generic chart of account
3023                 sale_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3024                                               , "=", chart_template_id), ('type_tax_use', 'in', ('sale','all'))], order="sequence, id desc")
3025                 purchase_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3026                                               , "=", chart_template_id), ('type_tax_use', 'in', ('purchase','all'))], order="sequence, id desc")
3027                 res['value'].update({'sale_tax': sale_tax_ids and sale_tax_ids[0] or False, 'purchase_tax': purchase_tax_ids and purchase_tax_ids[0] or False})
3028
3029             if data.code_digits:
3030                res['value'].update({'code_digits': data.code_digits})
3031         return res
3032
3033     def default_get(self, cr, uid, fields, context=None):
3034         res = super(wizard_multi_charts_accounts, self).default_get(cr, uid, fields, context=context)
3035         tax_templ_obj = self.pool.get('account.tax.template')
3036
3037         if 'bank_accounts_id' in fields:
3038             res.update({'bank_accounts_id': [{'acc_name': _('Cash'), 'account_type': 'cash'},{'acc_name': _('Bank'), 'account_type': 'bank'}]})
3039         if 'company_id' in fields:
3040             res.update({'company_id': self.pool.get('res.users').browse(cr, uid, [uid], context=context)[0].company_id.id})
3041
3042         ids = self.pool.get('account.chart.template').search(cr, uid, [('visible', '=', True)], context=context)
3043         if ids:
3044             if 'chart_template_id' in fields:
3045                 res.update({'only_one_chart_template': len(ids) == 1, 'chart_template_id': ids[0]})
3046             if 'sale_tax' in fields:
3047                 sale_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3048                                               , "=", ids[0]), ('type_tax_use', 'in', ('sale','all'))], order="sequence")
3049                 res.update({'sale_tax': sale_tax_ids and sale_tax_ids[0] or False})
3050             if 'purchase_tax' in fields:
3051                 purchase_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3052                                           , "=", ids[0]), ('type_tax_use', 'in', ('purchase','all'))], order="sequence")
3053                 res.update({'purchase_tax': purchase_tax_ids and purchase_tax_ids[0] or False})
3054         res.update({
3055             'purchase_tax_rate': 15.0,
3056             'sale_tax_rate': 15.0,
3057         })
3058         return res
3059
3060     def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
3061         if context is None:context = {}
3062         res = super(wizard_multi_charts_accounts, self).fields_view_get(cr, uid, view_id=view_id, view_type=view_type, context=context, toolbar=toolbar,submenu=False)
3063         cmp_select = []
3064         acc_template_obj = self.pool.get('account.chart.template')
3065         company_obj = self.pool.get('res.company')
3066
3067         company_ids = company_obj.search(cr, uid, [], context=context)
3068         #display in the widget selection of companies, only the companies that haven't been configured yet (but don't care about the demo chart of accounts)
3069         cr.execute("SELECT company_id FROM account_account WHERE active = 't' AND account_account.parent_id IS NULL AND name != %s", ("Chart For Automated Tests",))
3070         configured_cmp = [r[0] for r in cr.fetchall()]
3071         unconfigured_cmp = list(set(company_ids)-set(configured_cmp))
3072         for field in res['fields']:
3073             if field == 'company_id':
3074                 res['fields'][field]['domain'] = [('id','in',unconfigured_cmp)]
3075                 res['fields'][field]['selection'] = [('', '')]
3076                 if unconfigured_cmp:
3077                     cmp_select = [(line.id, line.name) for line in company_obj.browse(cr, uid, unconfigured_cmp)]
3078                     res['fields'][field]['selection'] = cmp_select
3079         return res
3080
3081     def check_created_journals(self, cr, uid, vals_journal, company_id, context=None):
3082         """
3083         This method used for checking journals already created or not. If not then create new journal.
3084         """
3085         obj_journal = self.pool.get('account.journal')
3086         rec_list = obj_journal.search(cr, uid, [('name','=', vals_journal['name']),('company_id', '=', company_id)], context=context)
3087         if not rec_list:
3088             obj_journal.create(cr, uid, vals_journal, context=context)
3089         return True
3090
3091     def generate_journals(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3092         """
3093         This method is used for creating journals.
3094
3095         :param chart_temp_id: Chart Template Id.
3096         :param acc_template_ref: Account templates reference.
3097         :param company_id: company_id selected from wizard.multi.charts.accounts.
3098         :returns: True
3099         """
3100         journal_data = self._prepare_all_journals(cr, uid, chart_template_id, acc_template_ref, company_id, context=context)
3101         for vals_journal in journal_data:
3102             self.check_created_journals(cr, uid, vals_journal, company_id, context=context)
3103         return True
3104
3105     def _prepare_all_journals(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3106         def _get_analytic_journal(journal_type):
3107             # Get the analytic journal
3108             data = False
3109             if journal_type in ('sale', 'sale_refund'):
3110                 data = obj_data.get_object_reference(cr, uid, 'account', 'analytic_journal_sale')
3111             elif journal_type in ('purchase', 'purchase_refund'):
3112                 pass
3113             elif journal_type == 'general':
3114                 pass
3115             return data and data[1] or False
3116
3117         def _get_default_account(journal_type, type='debit'):
3118             # Get the default accounts
3119             default_account = False
3120             if journal_type in ('sale', 'sale_refund'):
3121                 default_account = acc_template_ref.get(template.property_account_income_categ.id)
3122             elif journal_type in ('purchase', 'purchase_refund'):
3123                 default_account = acc_template_ref.get(template.property_account_expense_categ.id)
3124             elif journal_type == 'situation':
3125                 if type == 'debit':
3126                     default_account = acc_template_ref.get(template.property_account_expense_opening.id)
3127                 else:
3128                     default_account = acc_template_ref.get(template.property_account_income_opening.id)
3129             return default_account
3130
3131         def _get_view_id(journal_type):
3132             # Get the journal views
3133             if journal_type in ('general', 'situation'):
3134                 data = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_view')
3135             elif journal_type in ('sale_refund', 'purchase_refund'):
3136                 data = obj_data.get_object_reference(cr, uid, 'account', 'account_sp_refund_journal_view')
3137             else:
3138                 data = obj_data.get_object_reference(cr, uid, 'account', 'account_sp_journal_view')
3139             return data and data[1] or False
3140
3141         journal_names = {
3142             'sale': _('Sales Journal'),
3143             'purchase': _('Purchase Journal'),
3144             'sale_refund': _('Sales Refund Journal'),
3145             'purchase_refund': _('Purchase Refund Journal'),
3146             'general': _('Miscellaneous Journal'),
3147             'situation': _('Opening Entries Journal'),
3148         }
3149         journal_codes = {
3150             'sale': _('SAJ'),
3151             'purchase': _('EXJ'),
3152             'sale_refund': _('SCNJ'),
3153             'purchase_refund': _('ECNJ'),
3154             'general': _('MISC'),
3155             'situation': _('OPEJ'),
3156         }
3157
3158         obj_data = self.pool.get('ir.model.data')
3159         analytic_journal_obj = self.pool.get('account.analytic.journal')
3160         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3161
3162         journal_data = []
3163         for journal_type in ['sale', 'purchase', 'sale_refund', 'purchase_refund', 'general', 'situation']:
3164             vals = {
3165                 'type': journal_type,
3166                 'name': journal_names[journal_type],
3167                 'code': journal_codes[journal_type],
3168                 'company_id': company_id,
3169                 'centralisation': journal_type == 'situation',
3170                 'view_id': _get_view_id(journal_type),
3171                 'analytic_journal_id': _get_analytic_journal(journal_type),
3172                 'default_credit_account_id': _get_default_account(journal_type, 'credit'),
3173                 'default_debit_account_id': _get_default_account(journal_type, 'debit'),
3174             }
3175             journal_data.append(vals)
3176         return journal_data
3177
3178     def generate_properties(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3179         """
3180         This method used for creating properties.
3181
3182         :param chart_template_id: id of the current chart template for which we need to create properties
3183         :param acc_template_ref: Mapping between ids of account templates and real accounts created from them
3184         :param company_id: company_id selected from wizard.multi.charts.accounts.
3185         :returns: True
3186         """
3187         property_obj = self.pool.get('ir.property')
3188         field_obj = self.pool.get('ir.model.fields')
3189         todo_list = [
3190             ('property_account_receivable','res.partner','account.account'),
3191             ('property_account_payable','res.partner','account.account'),
3192             ('property_account_expense_categ','product.category','account.account'),
3193             ('property_account_income_categ','product.category','account.account'),
3194             ('property_account_expense','product.template','account.account'),
3195             ('property_account_income','product.template','account.account'),
3196             ('property_reserve_and_surplus_account','res.company','account.account')
3197         ]
3198         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3199         for record in todo_list:
3200             account = getattr(template, record[0])
3201             value = account and 'account.account,' + str(acc_template_ref[account.id]) or False
3202             if value:
3203                 field = field_obj.search(cr, uid, [('name', '=', record[0]),('model', '=', record[1]),('relation', '=', record[2])], context=context)
3204                 vals = {
3205                     'name': record[0],
3206                     'company_id': company_id,
3207                     'fields_id': field[0],
3208                     'value': value,
3209                 }
3210                 property_ids = property_obj.search(cr, uid, [('name','=', record[0]),('company_id', '=', company_id)], context=context)
3211                 if property_ids:
3212                     #the property exist: modify it
3213                     property_obj.write(cr, uid, property_ids, vals, context=context)
3214                 else:
3215                     #create the property
3216                     property_obj.create(cr, uid, vals, context=context)
3217         return True
3218
3219     def _install_template(self, cr, uid, template_id, company_id, code_digits=None, obj_wizard=None, acc_ref={}, taxes_ref={}, tax_code_ref={}, context=None):
3220         '''
3221         This function recursively loads the template objects and create the real objects from them.
3222
3223         :param template_id: id of the chart template to load
3224         :param company_id: id of the company the wizard is running for
3225         :param code_digits: integer that depicts the number of digits the accounts code should have in the COA
3226         :param obj_wizard: the current wizard for generating the COA from the templates
3227         :param acc_ref: Mapping between ids of account templates and real accounts created from them
3228         :param taxes_ref: Mapping between ids of tax templates and real taxes created from them
3229         :param tax_code_ref: Mapping between ids of tax code templates and real tax codes created from them
3230         :returns: return a tuple with a dictionary containing
3231             * the mapping between the account template ids and the ids of the real accounts that have been generated
3232               from them, as first item,
3233             * a similar dictionary for mapping the tax templates and taxes, as second item,
3234             * a last identical containing the mapping of tax code templates and tax codes
3235         :rtype: tuple(dict, dict, dict)
3236         '''
3237         template = self.pool.get('account.chart.template').browse(cr, uid, template_id, context=context)
3238         if template.parent_id:
3239             tmp1, tmp2, tmp3 = self._install_template(cr, uid, template.parent_id.id, company_id, code_digits=code_digits, acc_ref=acc_ref, taxes_ref=taxes_ref, tax_code_ref=tax_code_ref, context=context)
3240             acc_ref.update(tmp1)
3241             taxes_ref.update(tmp2)
3242             tax_code_ref.update(tmp3)
3243         tmp1, tmp2, tmp3 = self._load_template(cr, uid, template_id, company_id, code_digits=code_digits, obj_wizard=obj_wizard, account_ref=acc_ref, taxes_ref=taxes_ref, tax_code_ref=tax_code_ref, context=context)
3244         acc_ref.update(tmp1)
3245         taxes_ref.update(tmp2)
3246         tax_code_ref.update(tmp3)
3247         return acc_ref, taxes_ref, tax_code_ref
3248
3249     def _load_template(self, cr, uid, template_id, company_id, code_digits=None, obj_wizard=None, account_ref={}, taxes_ref={}, tax_code_ref={}, context=None):
3250         '''
3251         This function generates all the objects from the templates
3252
3253         :param template_id: id of the chart template to load
3254         :param company_id: id of the company the wizard is running for
3255         :param code_digits: integer that depicts the number of digits the accounts code should have in the COA
3256         :param obj_wizard: the current wizard for generating the COA from the templates
3257         :param acc_ref: Mapping between ids of account templates and real accounts created from them
3258         :param taxes_ref: Mapping between ids of tax templates and real taxes created from them
3259         :param tax_code_ref: Mapping between ids of tax code templates and real tax codes created from them
3260         :returns: return a tuple with a dictionary containing
3261             * the mapping between the account template ids and the ids of the real accounts that have been generated
3262               from them, as first item,
3263             * a similar dictionary for mapping the tax templates and taxes, as second item,
3264             * a last identical containing the mapping of tax code templates and tax codes
3265         :rtype: tuple(dict, dict, dict)
3266         '''
3267         template = self.pool.get('account.chart.template').browse(cr, uid, template_id, context=context)
3268         obj_tax_code_template = self.pool.get('account.tax.code.template')
3269         obj_acc_tax = self.pool.get('account.tax')
3270         obj_tax_temp = self.pool.get('account.tax.template')
3271         obj_acc_template = self.pool.get('account.account.template')
3272         obj_fiscal_position_template = self.pool.get('account.fiscal.position.template')
3273
3274         # create all the tax code.
3275         tax_code_ref.update(obj_tax_code_template.generate_tax_code(cr, uid, template.tax_code_root_id.id, company_id, context=context))
3276
3277         # Generate taxes from templates.
3278         tax_templates = [x for x in template.tax_template_ids]
3279         generated_tax_res = obj_tax_temp._generate_tax(cr, uid, tax_templates, tax_code_ref, company_id, context=context)
3280         taxes_ref.update(generated_tax_res['tax_template_to_tax'])
3281
3282         # Generating Accounts from templates.
3283         account_template_ref = obj_acc_template.generate_account(cr, uid, template_id, taxes_ref, account_ref, code_digits, company_id, context=context)
3284         account_ref.update(account_template_ref)
3285
3286         # writing account values on tax after creation of accounts
3287         for key,value in generated_tax_res['account_dict'].items():
3288             if value['account_collected_id'] or value['account_paid_id']:
3289                 obj_acc_tax.write(cr, uid, [key], {
3290                     'account_collected_id': account_ref.get(value['account_collected_id'], False),
3291                     'account_paid_id': account_ref.get(value['account_paid_id'], False),
3292                 })
3293
3294         # Create Journals
3295         self.generate_journals(cr, uid, template_id, account_ref, company_id, context=context)
3296
3297         # generate properties function
3298         self.generate_properties(cr, uid, template_id, account_ref, company_id, context=context)
3299
3300         # Generate Fiscal Position , Fiscal Position Accounts and Fiscal Position Taxes from templates
3301         obj_fiscal_position_template.generate_fiscal_position(cr, uid, template_id, taxes_ref, account_ref, company_id, context=context)
3302
3303         return account_ref, taxes_ref, tax_code_ref
3304
3305     def _create_tax_templates_from_rates(self, cr, uid, obj_wizard, company_id, context=None):
3306         '''
3307         This function checks if the chosen chart template is configured as containing a full set of taxes, and if
3308         it's not the case, it creates the templates for account.tax.code and for account.account.tax objects accordingly
3309         to the provided sale/purchase rates. Then it saves the new tax templates as default taxes to use for this chart
3310         template.
3311
3312         :param obj_wizard: browse record of wizard to generate COA from templates
3313         :param company_id: id of the company for wich the wizard is running
3314         :return: True
3315         '''
3316         obj_tax_code_template = self.pool.get('account.tax.code.template')
3317         obj_tax_temp = self.pool.get('account.tax.template')
3318         chart_template = obj_wizard.chart_template_id
3319         vals = {}
3320         # get the ids of all the parents of the selected account chart template
3321         current_chart_template = chart_template
3322         all_parents = [current_chart_template.id]
3323         while current_chart_template.parent_id:
3324             current_chart_template = current_chart_template.parent_id
3325             all_parents.append(current_chart_template.id)
3326         # create tax templates and tax code templates from purchase_tax_rate and sale_tax_rate fields
3327         if not chart_template.complete_tax_set:
3328             value = obj_wizard.sale_tax_rate
3329             ref_tax_ids = obj_tax_temp.search(cr, uid, [('type_tax_use','in', ('sale','all')), ('chart_template_id', 'in', all_parents)], context=context, order="sequence, id desc", limit=1)
3330             obj_tax_temp.write(cr, uid, ref_tax_ids, {'amount': value/100.0, 'name': _('Tax %.2f%%') % value})
3331             value = obj_wizard.purchase_tax_rate
3332             ref_tax_ids = obj_tax_temp.search(cr, uid, [('type_tax_use','in', ('purchase','all')), ('chart_template_id', 'in', all_parents)], context=context, order="sequence, id desc", limit=1)
3333             obj_tax_temp.write(cr, uid, ref_tax_ids, {'amount': value/100.0, 'name': _('Purchase Tax %.2f%%') % value})
3334         return True
3335
3336     def execute(self, cr, uid, ids, context=None):
3337         '''
3338         This function is called at the confirmation of the wizard to generate the COA from the templates. It will read
3339         all the provided information to create the accounts, the banks, the journals, the taxes, the tax codes, the
3340         accounting properties... accordingly for the chosen company.
3341         '''
3342         ir_values_obj = self.pool.get('ir.values')
3343         obj_wizard = self.browse(cr, uid, ids[0])
3344         company_id = obj_wizard.company_id.id
3345         # If the floats for sale/purchase rates have been filled, create templates from them
3346         self._create_tax_templates_from_rates(cr, uid, obj_wizard, company_id, context=context)
3347
3348         # Install all the templates objects and generate the real objects
3349         acc_template_ref, taxes_ref, tax_code_ref = self._install_template(cr, uid, obj_wizard.chart_template_id.id, company_id, code_digits=obj_wizard.code_digits, obj_wizard=obj_wizard, context=context)
3350
3351         # write values of default taxes for product
3352         if obj_wizard.sale_tax and taxes_ref:
3353             ir_values_obj.set(cr, uid, key='default', key2=False, name="taxes_id", company=company_id,
3354                                 models =[('product.product',False)], value=[taxes_ref[obj_wizard.sale_tax.id]])
3355         if obj_wizard.purchase_tax and taxes_ref:
3356                 ir_values_obj.set(cr, uid, key='default', key2=False, name="supplier_taxes_id", company=company_id,
3357                                 models =[('product.product',False)], value=[taxes_ref[obj_wizard.purchase_tax.id]])
3358
3359         # Create Bank journals
3360         self._create_bank_journals_from_o2m(cr, uid, obj_wizard, company_id, acc_template_ref, context=context)
3361         return {}
3362
3363     def _prepare_bank_journal(self, cr, uid, line, current_num, default_account_id, company_id, context=None):
3364         '''
3365         This function prepares the value to use for the creation of a bank journal created through the wizard of
3366         generating COA from templates.
3367
3368         :param line: dictionary containing the values encoded by the user related to his bank account
3369         :param current_num: integer corresponding to a counter of the already created bank journals through this wizard.
3370         :param default_account_id: id of the default debit.credit account created before for this journal.
3371         :param company_id: id of the company for which the wizard is running
3372         :return: mapping of field names and values
3373         :rtype: dict
3374         '''
3375         obj_data = self.pool.get('ir.model.data')
3376         obj_journal = self.pool.get('account.journal')
3377         # Get the id of journal views
3378         tmp = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_bank_view_multi')
3379         view_id_cur = tmp and tmp[1] or False
3380         tmp = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_bank_view')
3381         view_id_cash = tmp and tmp[1] or False
3382
3383         # we need to loop again to find next number for journal code
3384         # because we can't rely on the value current_num as,
3385         # its possible that we already have bank journals created (e.g. by the creation of res.partner.bank)
3386         # and the next number for account code might have been already used before for journal
3387         for num in xrange(current_num, 100):
3388             # journal_code has a maximal size of 5, hence we can enforce the boundary num < 100
3389             journal_code = _('BNK')[:3] + str(num)
3390             ids = obj_journal.search(cr, uid, [('code', '=', journal_code), ('company_id', '=', company_id)], context=context)
3391             if not ids:
3392                 break
3393         else:
3394             raise osv.except_osv(_('Error'), _('Cannot generate an unused journal code.'))
3395
3396         vals = {
3397                 'name': line['acc_name'],
3398                 'code': journal_code,
3399                 'type': line['account_type'] == 'cash' and 'cash' or 'bank',
3400                 'company_id': company_id,
3401                 'analytic_journal_id': False,
3402                 'currency': False,
3403                 'default_credit_account_id': default_account_id,
3404                 'default_debit_account_id': default_account_id,
3405         }
3406         if line['currency_id']:
3407             vals['view_id'] = view_id_cur
3408             vals['currency'] = line['currency_id']
3409         else:
3410             vals['view_id'] = view_id_cash
3411         return vals
3412
3413     def _prepare_bank_account(self, cr, uid, line, new_code, acc_template_ref, ref_acc_bank, company_id, context=None):
3414         '''
3415         This function prepares the value to use for the creation of the default debit and credit accounts of a
3416         bank journal created through the wizard of generating COA from templates.
3417
3418         :param line: dictionary containing the values encoded by the user related to his bank account
3419         :param new_code: integer corresponding to the next available number to use as account code
3420         :param acc_template_ref: the dictionary containing the mapping between the ids of account templates and the ids
3421             of the accounts that have been generated from them.
3422         :param ref_acc_bank: browse record of the account template set as root of all bank accounts for the chosen
3423             template
3424         :param company_id: id of the company for which the wizard is running
3425         :return: mapping of field names and values
3426         :rtype: dict
3427         '''
3428         obj_data = self.pool.get('ir.model.data')
3429
3430         # Get the id of the user types fr-or cash and bank
3431         tmp = obj_data.get_object_reference(cr, uid, 'account', 'data_account_type_cash')
3432         cash_type = tmp and tmp[1] or False
3433         tmp = obj_data.get_object_reference(cr, uid, 'account', 'data_account_type_bank')
3434         bank_type = tmp and tmp[1] or False
3435         return {
3436                 'name': line['acc_name'],
3437                 'currency_id': line['currency_id'],
3438                 'code': new_code,
3439                 'type': 'liquidity',
3440                 'user_type': line['account_type'] == 'cash' and cash_type or bank_type,
3441                 'parent_id': acc_template_ref[ref_acc_bank.id] or False,
3442                 'company_id': company_id,
3443         }
3444
3445     def _create_bank_journals_from_o2m(self, cr, uid, obj_wizard, company_id, acc_template_ref, context=None):
3446         '''
3447         This function creates bank journals and its accounts for each line encoded in the field bank_accounts_id of the
3448         wizard.
3449
3450         :param obj_wizard: the current wizard that generates the COA from the templates.
3451         :param company_id: the id of the company for which the wizard is running.
3452         :param acc_template_ref: the dictionary containing the mapping between the ids of account templates and the ids
3453             of the accounts that have been generated from them.
3454         :return: True
3455         '''
3456         obj_acc = self.pool.get('account.account')
3457         obj_journal = self.pool.get('account.journal')
3458         code_digits = obj_wizard.code_digits
3459
3460         # Build a list with all the data to process
3461         journal_data = []
3462         if obj_wizard.bank_accounts_id:
3463             for acc in obj_wizard.bank_accounts_id:
3464                 vals = {
3465                     'acc_name': acc.acc_name,
3466                     'account_type': acc.account_type,
3467                     'currency_id': acc.currency_id.id,
3468                 }
3469                 journal_data.append(vals)
3470         ref_acc_bank = obj_wizard.chart_template_id.bank_account_view_id
3471         if journal_data and not ref_acc_bank.code:
3472             raise osv.except_osv(_('Configuration Error !'), _('The bank account defined on the selected chart of accounts hasn\'t a code.'))
3473
3474         current_num = 1
3475         for line in journal_data:
3476             # Seek the next available number for the account code
3477             while True:
3478                 new_code = str(ref_acc_bank.code.ljust(code_digits-len(str(current_num)), '0')) + str(current_num)
3479                 ids = obj_acc.search(cr, uid, [('code', '=', new_code), ('company_id', '=', company_id)])
3480                 if not ids:
3481                     break
3482                 else:
3483                     current_num += 1
3484             # Create the default debit/credit accounts for this bank journal
3485             vals = self._prepare_bank_account(cr, uid, line, new_code, acc_template_ref, ref_acc_bank, company_id, context=context)
3486             default_account_id  = obj_acc.create(cr, uid, vals, context=context)
3487
3488             #create the bank journal
3489             vals_journal = self._prepare_bank_journal(cr, uid, line, current_num, default_account_id, company_id, context=context)
3490             obj_journal.create(cr, uid, vals_journal)
3491             current_num += 1
3492         return True
3493
3494 wizard_multi_charts_accounts()
3495
3496 class account_bank_accounts_wizard(osv.osv_memory):
3497     _name='account.bank.accounts.wizard'
3498
3499     _columns = {
3500         'acc_name': fields.char('Account Name.', size=64, required=True),
3501         'bank_account_id': fields.many2one('wizard.multi.charts.accounts', 'Bank Account', required=True),
3502         'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
3503         'account_type': fields.selection([('cash','Cash'), ('check','Check'), ('bank','Bank')], 'Account Type', size=32),
3504     }
3505
3506 account_bank_accounts_wizard()
3507
3508 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: