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