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 Checks'), ('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('Centralized 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 account_move_prepare(self, cr, uid, journal_id, date=False, ref='', company_id=False, context=None):
1154         '''
1155         Prepares and returns a dictionary of values, ready to be passed to create() based on the parameters received.
1156         '''
1157         if not date:
1158             date = fields.date.today()
1159         period_obj = self.pool.get('account.period')
1160         if not company_id:
1161             user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1162             company_id = user.company_id.id
1163         if context is None:
1164             context = {}
1165         #put the company in context to find the good period
1166         ctx = context.copy()
1167         ctx.update({'company_id': company_id})
1168         return {
1169             'journal_id': journal_id,
1170             'date': date,
1171             'period_id': period_obj.find(cr, uid, date, context=ctx)[0],
1172             'ref': ref,
1173             'company_id': company_id,
1174         }
1175
1176     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=80):
1177         """
1178         Returns a list of tupples containing id, name, as internally it is called {def name_get}
1179         result format: {[(id, name), (id, name), ...]}
1180
1181         @param cr: A database cursor
1182         @param user: ID of the user currently logged in
1183         @param name: name to search
1184         @param args: other arguments
1185         @param operator: default operator is 'ilike', it can be changed
1186         @param context: context arguments, like lang, time zone
1187         @param limit: Returns first 'n' ids of complete result, default is 80.
1188
1189         @return: Returns a list of tuples containing id and name
1190         """
1191
1192         if not args:
1193           args = []
1194         ids = []
1195         if name:
1196             ids += self.search(cr, user, [('name','ilike',name)]+args, limit=limit, context=context)
1197
1198         if not ids and name and type(name) == int:
1199             ids += self.search(cr, user, [('id','=',name)]+args, limit=limit, context=context)
1200
1201         if not ids:
1202             ids += self.search(cr, user, args, limit=limit, context=context)
1203
1204         return self.name_get(cr, user, ids, context=context)
1205
1206     def name_get(self, cursor, user, ids, context=None):
1207         if isinstance(ids, (int, long)):
1208             ids = [ids]
1209         if not ids:
1210             return []
1211         res = []
1212         data_move = self.pool.get('account.move').browse(cursor, user, ids, context=context)
1213         for move in data_move:
1214             if move.state=='draft':
1215                 name = '*' + str(move.id)
1216             else:
1217                 name = move.name
1218             res.append((move.id, name))
1219         return res
1220
1221     def _get_period(self, cr, uid, context=None):
1222         ctx = dict(context or {}, account_period_prefer_normal=True)
1223         period_ids = self.pool.get('account.period').find(cr, uid, context=ctx)
1224         return period_ids[0]
1225
1226     def _amount_compute(self, cr, uid, ids, name, args, context, where =''):
1227         if not ids: return {}
1228         cr.execute( 'SELECT move_id, SUM(debit) '\
1229                     'FROM account_move_line '\
1230                     'WHERE move_id IN %s '\
1231                     'GROUP BY move_id', (tuple(ids),))
1232         result = dict(cr.fetchall())
1233         for id in ids:
1234             result.setdefault(id, 0.0)
1235         return result
1236
1237     def _search_amount(self, cr, uid, obj, name, args, context):
1238         ids = set()
1239         for cond in args:
1240             amount = cond[2]
1241             if isinstance(cond[2],(list,tuple)):
1242                 if cond[1] in ['in','not in']:
1243                     amount = tuple(cond[2])
1244                 else:
1245                     continue
1246             else:
1247                 if cond[1] in ['=like', 'like', 'not like', 'ilike', 'not ilike', 'in', 'not in', 'child_of']:
1248                     continue
1249
1250             cr.execute("select move_id from account_move_line group by move_id having sum(debit) %s %%s" % (cond[1]),(amount,))
1251             res_ids = set(id[0] for id in cr.fetchall())
1252             ids = ids and (ids & res_ids) or res_ids
1253         if ids:
1254             return [('id', 'in', tuple(ids))]
1255         return [('id', '=', '0')]
1256
1257     _columns = {
1258         'name': fields.char('Number', size=64, required=True),
1259         'ref': fields.char('Reference', size=64),
1260         'period_id': fields.many2one('account.period', 'Period', required=True, states={'posted':[('readonly',True)]}),
1261         'journal_id': fields.many2one('account.journal', 'Journal', required=True, states={'posted':[('readonly',True)]}),
1262         'state': fields.selection([('draft','Unposted'), ('posted','Posted')], 'Status', required=True, readonly=True,
1263             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.'),
1264         'line_id': fields.one2many('account.move.line', 'move_id', 'Entries', states={'posted':[('readonly',True)]}),
1265         '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.'),
1266         'partner_id': fields.related('line_id', 'partner_id', type="many2one", relation="res.partner", string="Partner", store=True),
1267         'amount': fields.function(_amount_compute, string='Amount', digits_compute=dp.get_precision('Account'), type='float', fnct_search=_search_amount),
1268         'date': fields.date('Date', required=True, states={'posted':[('readonly',True)]}, select=True),
1269         'narration':fields.text('Internal Note'),
1270         'company_id': fields.related('journal_id','company_id',type='many2one',relation='res.company',string='Company', store=True, readonly=True),
1271         '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"),
1272     }
1273
1274     _defaults = {
1275         'name': '/',
1276         'state': 'draft',
1277         'period_id': _get_period,
1278         'date': fields.date.context_today,
1279         'company_id': lambda self, cr, uid, c: self.pool.get('res.users').browse(cr, uid, uid, c).company_id.id,
1280     }
1281
1282     def _check_centralisation(self, cursor, user, ids, context=None):
1283         for move in self.browse(cursor, user, ids, context=context):
1284             if move.journal_id.centralisation:
1285                 move_ids = self.search(cursor, user, [
1286                     ('period_id', '=', move.period_id.id),
1287                     ('journal_id', '=', move.journal_id.id),
1288                     ])
1289                 if len(move_ids) > 1:
1290                     return False
1291         return True
1292
1293     _constraints = [
1294         (_check_centralisation,
1295             'You cannot create more than one move per period on a centralized journal.',
1296             ['journal_id']),
1297     ]
1298
1299     def post(self, cr, uid, ids, context=None):
1300         if context is None:
1301             context = {}
1302         invoice = context.get('invoice', False)
1303         valid_moves = self.validate(cr, uid, ids, context)
1304
1305         if not valid_moves:
1306             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.'))
1307         obj_sequence = self.pool.get('ir.sequence')
1308         for move in self.browse(cr, uid, valid_moves, context=context):
1309             if move.name =='/':
1310                 new_name = False
1311                 journal = move.journal_id
1312
1313                 if invoice and invoice.internal_number:
1314                     new_name = invoice.internal_number
1315                 else:
1316                     if journal.sequence_id:
1317                         c = {'fiscalyear_id': move.period_id.fiscalyear_id.id}
1318                         new_name = obj_sequence.next_by_id(cr, uid, journal.sequence_id.id, c)
1319                     else:
1320                         raise osv.except_osv(_('Error!'), _('Please define a sequence on the journal.'))
1321
1322                 if new_name:
1323                     self.write(cr, uid, [move.id], {'name':new_name})
1324
1325         cr.execute('UPDATE account_move '\
1326                    'SET state=%s '\
1327                    'WHERE id IN %s',
1328                    ('posted', tuple(valid_moves),))
1329         return True
1330
1331     def button_validate(self, cursor, user, ids, context=None):
1332         for move in self.browse(cursor, user, ids, context=context):
1333             # check that all accounts have the same topmost ancestor
1334             top_common = None
1335             for line in move.line_id:
1336                 account = line.account_id
1337                 top_account = account
1338                 while top_account.parent_id:
1339                     top_account = top_account.parent_id
1340                 if not top_common:
1341                     top_common = top_account
1342                 elif top_account.id != top_common.id:
1343                     raise osv.except_osv(_('Error!'),
1344                                          _('You cannot validate this journal entry because account "%s" does not belong to chart of accounts "%s".') % (account.name, top_common.name))
1345         return self.post(cursor, user, ids, context=context)
1346
1347     def button_cancel(self, cr, uid, ids, context=None):
1348         for line in self.browse(cr, uid, ids, context=context):
1349             if not line.journal_id.update_posted:
1350                 raise osv.except_osv(_('Error!'), _('You cannot modify a posted entry of this journal.\nFirst you should set the journal to allow cancelling entries.'))
1351         if ids:
1352             cr.execute('UPDATE account_move '\
1353                        'SET state=%s '\
1354                        'WHERE id IN %s', ('draft', tuple(ids),))
1355         return True
1356
1357     def write(self, cr, uid, ids, vals, context=None):
1358         if context is None:
1359             context = {}
1360         c = context.copy()
1361         c['novalidate'] = True
1362         result = super(account_move, self).write(cr, uid, ids, vals, c)
1363         self.validate(cr, uid, ids, context=context)
1364         return result
1365
1366     #
1367     # TODO: Check if period is closed !
1368     #
1369     def create(self, cr, uid, vals, context=None):
1370         if context is None:
1371             context = {}
1372         if 'line_id' in vals and context.get('copy'):
1373             for l in vals['line_id']:
1374                 if not l[0]:
1375                     l[2].update({
1376                         'reconcile_id':False,
1377                         'reconcile_partial_id':False,
1378                         'analytic_lines':False,
1379                         'invoice':False,
1380                         'ref':False,
1381                         'balance':False,
1382                         'account_tax_id':False,
1383                     })
1384
1385             if 'journal_id' in vals and vals.get('journal_id', False):
1386                 for l in vals['line_id']:
1387                     if not l[0]:
1388                         l[2]['journal_id'] = vals['journal_id']
1389                 context['journal_id'] = vals['journal_id']
1390             if 'period_id' in vals:
1391                 for l in vals['line_id']:
1392                     if not l[0]:
1393                         l[2]['period_id'] = vals['period_id']
1394                 context['period_id'] = vals['period_id']
1395             else:
1396                 default_period = self._get_period(cr, uid, context)
1397                 for l in vals['line_id']:
1398                     if not l[0]:
1399                         l[2]['period_id'] = default_period
1400                 context['period_id'] = default_period
1401
1402         if 'line_id' in vals:
1403             c = context.copy()
1404             c['novalidate'] = True
1405             c['period_id'] = vals['period_id'] if 'period_id' in vals else self._get_period(cr, uid, context)
1406             c['journal_id'] = vals['journal_id']
1407             if 'date' in vals: c['date'] = vals['date']
1408             result = super(account_move, self).create(cr, uid, vals, c)
1409             self.validate(cr, uid, [result], context)
1410         else:
1411             result = super(account_move, self).create(cr, uid, vals, context)
1412         return result
1413
1414     def copy(self, cr, uid, id, default=None, context=None):
1415         default = {} if default is None else default.copy()
1416         context = {} if context is None else context.copy()
1417         default.update({
1418             'state':'draft',
1419             'name':'/',
1420         })
1421         context.update({
1422             'copy':True
1423         })
1424         return super(account_move, self).copy(cr, uid, id, default, context)
1425
1426     def unlink(self, cr, uid, ids, context=None, check=True):
1427         if context is None:
1428             context = {}
1429         toremove = []
1430         obj_move_line = self.pool.get('account.move.line')
1431         for move in self.browse(cr, uid, ids, context=context):
1432             if move['state'] != 'draft':
1433                 raise osv.except_osv(_('User Error!'),
1434                         _('You cannot delete a posted journal entry "%s".') % \
1435                                 move['name'])
1436             for line in move.line_id:
1437                 if line.invoice:
1438                     raise osv.except_osv(_('User Error!'),
1439                             _("Move cannot be deleted if linked to an invoice. (Invoice: %s - Move ID:%s)") % \
1440                                     (line.invoice.number,move.name))
1441             line_ids = map(lambda x: x.id, move.line_id)
1442             context['journal_id'] = move.journal_id.id
1443             context['period_id'] = move.period_id.id
1444             obj_move_line._update_check(cr, uid, line_ids, context)
1445             obj_move_line.unlink(cr, uid, line_ids, context=context)
1446             toremove.append(move.id)
1447         result = super(account_move, self).unlink(cr, uid, toremove, context)
1448         return result
1449
1450     def _compute_balance(self, cr, uid, id, context=None):
1451         move = self.browse(cr, uid, id, context=context)
1452         amount = 0
1453         for line in move.line_id:
1454             amount+= (line.debit - line.credit)
1455         return amount
1456
1457     def _centralise(self, cr, uid, move, mode, context=None):
1458         assert mode in ('debit', 'credit'), 'Invalid Mode' #to prevent sql injection
1459         currency_obj = self.pool.get('res.currency')
1460         if context is None:
1461             context = {}
1462
1463         if mode=='credit':
1464             account_id = move.journal_id.default_debit_account_id.id
1465             mode2 = 'debit'
1466             if not account_id:
1467                 raise osv.except_osv(_('User Error!'),
1468                         _('There is no default debit account defined \n' \
1469                                 'on journal "%s".') % move.journal_id.name)
1470         else:
1471             account_id = move.journal_id.default_credit_account_id.id
1472             mode2 = 'credit'
1473             if not account_id:
1474                 raise osv.except_osv(_('User Error!'),
1475                         _('There is no default credit account defined \n' \
1476                                 'on journal "%s".') % move.journal_id.name)
1477
1478         # find the first line of this move with the current mode
1479         # or create it if it doesn't exist
1480         cr.execute('select id from account_move_line where move_id=%s and centralisation=%s limit 1', (move.id, mode))
1481         res = cr.fetchone()
1482         if res:
1483             line_id = res[0]
1484         else:
1485             context.update({'journal_id': move.journal_id.id, 'period_id': move.period_id.id})
1486             line_id = self.pool.get('account.move.line').create(cr, uid, {
1487                 'name': _(mode.capitalize()+' Centralisation'),
1488                 'centralisation': mode,
1489                 'partner_id': False,
1490                 'account_id': account_id,
1491                 'move_id': move.id,
1492                 'journal_id': move.journal_id.id,
1493                 'period_id': move.period_id.id,
1494                 'date': move.period_id.date_stop,
1495                 'debit': 0.0,
1496                 'credit': 0.0,
1497             }, context)
1498
1499         # find the first line of this move with the other mode
1500         # so that we can exclude it from our calculation
1501         cr.execute('select id from account_move_line where move_id=%s and centralisation=%s limit 1', (move.id, mode2))
1502         res = cr.fetchone()
1503         if res:
1504             line_id2 = res[0]
1505         else:
1506             line_id2 = 0
1507
1508         cr.execute('SELECT SUM(%s) FROM account_move_line WHERE move_id=%%s AND id!=%%s' % (mode,), (move.id, line_id2))
1509         result = cr.fetchone()[0] or 0.0
1510         cr.execute('update account_move_line set '+mode2+'=%s where id=%s', (result, line_id))
1511
1512         #adjust also the amount in currency if needed
1513         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,))
1514         for row in cr.dictfetchall():
1515             currency_id = currency_obj.browse(cr, uid, row['currency_id'], context=context)
1516             if not currency_obj.is_zero(cr, uid, currency_id, row['amount_currency']):
1517                 amount_currency = row['amount_currency'] * -1
1518                 account_id = amount_currency > 0 and move.journal_id.default_debit_account_id.id or move.journal_id.default_credit_account_id.id
1519                 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']))
1520                 res = cr.fetchone()
1521                 if res:
1522                     cr.execute('update account_move_line set amount_currency=%s , account_id=%s where id=%s', (amount_currency, account_id, res[0]))
1523                 else:
1524                     context.update({'journal_id': move.journal_id.id, 'period_id': move.period_id.id})
1525                     line_id = self.pool.get('account.move.line').create(cr, uid, {
1526                         'name': _('Currency Adjustment'),
1527                         'centralisation': 'currency',
1528                         'partner_id': False,
1529                         'account_id': account_id,
1530                         'move_id': move.id,
1531                         'journal_id': move.journal_id.id,
1532                         'period_id': move.period_id.id,
1533                         'date': move.period_id.date_stop,
1534                         'debit': 0.0,
1535                         'credit': 0.0,
1536                         'currency_id': row['currency_id'],
1537                         'amount_currency': amount_currency,
1538                     }, context)
1539
1540         return True
1541
1542     #
1543     # Validate a balanced move. If it is a centralised journal, create a move.
1544     #
1545     def validate(self, cr, uid, ids, context=None):
1546         if context and ('__last_update' in context):
1547             del context['__last_update']
1548
1549         valid_moves = [] #Maintains a list of moves which can be responsible to create analytic entries
1550         obj_analytic_line = self.pool.get('account.analytic.line')
1551         obj_move_line = self.pool.get('account.move.line')
1552         for move in self.browse(cr, uid, ids, context):
1553             # Unlink old analytic lines on move_lines
1554             for obj_line in move.line_id:
1555                 for obj in obj_line.analytic_lines:
1556                     obj_analytic_line.unlink(cr,uid,obj.id)
1557
1558             journal = move.journal_id
1559             amount = 0
1560             line_ids = []
1561             line_draft_ids = []
1562             company_id = None
1563             for line in move.line_id:
1564                 amount += line.debit - line.credit
1565                 line_ids.append(line.id)
1566                 if line.state=='draft':
1567                     line_draft_ids.append(line.id)
1568
1569                 if not company_id:
1570                     company_id = line.account_id.company_id.id
1571                 if not company_id == line.account_id.company_id.id:
1572                     raise osv.except_osv(_('Error!'), _("Cannot create moves for different companies."))
1573
1574                 if line.account_id.currency_id and line.currency_id:
1575                     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):
1576                         raise osv.except_osv(_('Error!'), _("""Cannot create move with currency different from ..""") % (line.account_id.code, line.account_id.name))
1577
1578             if abs(amount) < 10 ** -4:
1579                 # If the move is balanced
1580                 # Add to the list of valid moves
1581                 # (analytic lines will be created later for valid moves)
1582                 valid_moves.append(move)
1583
1584                 # Check whether the move lines are confirmed
1585
1586                 if not line_draft_ids:
1587                     continue
1588                 # Update the move lines (set them as valid)
1589
1590                 obj_move_line.write(cr, uid, line_draft_ids, {
1591                     'state': 'valid'
1592                 }, context, check=False)
1593
1594                 account = {}
1595                 account2 = {}
1596
1597                 if journal.type in ('purchase','sale'):
1598                     for line in move.line_id:
1599                         code = amount = 0
1600                         key = (line.account_id.id, line.tax_code_id.id)
1601                         if key in account2:
1602                             code = account2[key][0]
1603                             amount = account2[key][1] * (line.debit + line.credit)
1604                         elif line.account_id.id in account:
1605                             code = account[line.account_id.id][0]
1606                             amount = account[line.account_id.id][1] * (line.debit + line.credit)
1607                         if (code or amount) and not (line.tax_code_id or line.tax_amount):
1608                             obj_move_line.write(cr, uid, [line.id], {
1609                                 'tax_code_id': code,
1610                                 'tax_amount': amount
1611                             }, context, check=False)
1612             elif journal.centralisation:
1613                 # If the move is not balanced, it must be centralised...
1614
1615                 # Add to the list of valid moves
1616                 # (analytic lines will be created later for valid moves)
1617                 valid_moves.append(move)
1618
1619                 #
1620                 # Update the move lines (set them as valid)
1621                 #
1622                 self._centralise(cr, uid, move, 'debit', context=context)
1623                 self._centralise(cr, uid, move, 'credit', context=context)
1624                 obj_move_line.write(cr, uid, line_draft_ids, {
1625                     'state': 'valid'
1626                 }, context, check=False)
1627             else:
1628                 # We can't validate it (it's unbalanced)
1629                 # Setting the lines as draft
1630                 obj_move_line.write(cr, uid, line_ids, {
1631                     'state': 'draft'
1632                 }, context, check=False)
1633         # Create analytic lines for the valid moves
1634         for record in valid_moves:
1635             obj_move_line.create_analytic_lines(cr, uid, [line.id for line in record.line_id], context)
1636
1637         valid_moves = [move.id for move in valid_moves]
1638         return len(valid_moves) > 0 and valid_moves or False
1639
1640 account_move()
1641
1642 class account_move_reconcile(osv.osv):
1643     _name = "account.move.reconcile"
1644     _description = "Account Reconciliation"
1645     _columns = {
1646         'name': fields.char('Name', size=64, required=True),
1647         'type': fields.char('Type', size=16, required=True),
1648         'line_id': fields.one2many('account.move.line', 'reconcile_id', 'Entry Lines'),
1649         'line_partial_ids': fields.one2many('account.move.line', 'reconcile_partial_id', 'Partial Entry lines'),
1650         'create_date': fields.date('Creation date', readonly=True),
1651         'opening_reconciliation': fields.boolean('Opening Entries Reconciliation', help="Is this reconciliation produced by the opening of a new fiscal year ?."),
1652     }
1653     _defaults = {
1654         'name': lambda self,cr,uid,ctx=None: self.pool.get('ir.sequence').get(cr, uid, 'account.reconcile', context=ctx) or '/',
1655     }
1656
1657     # You cannot unlink a reconciliation if it is a opening_reconciliation one,
1658     # you should use the generate opening entries wizard for that
1659     def unlink(self, cr, uid, ids, context=None):
1660         for move_rec in self.browse(cr, uid, ids, context=context):
1661             if move_rec.opening_reconciliation:
1662                 raise osv.except_osv(_('Error!'), _('You cannot unreconcile journal items if they has been generated by the \
1663                                                         opening/closing fiscal year process.'))
1664         return super(account_move_reconcile, self).unlink(cr, uid, ids, context=context)
1665
1666     # Look in the line_id and line_partial_ids to ensure the partner is the same or empty
1667     # on all lines. We allow that only for opening/closing period
1668     def _check_same_partner(self, cr, uid, ids, context=None):
1669         for reconcile in self.browse(cr, uid, ids, context=context):
1670             move_lines = []
1671             if not reconcile.opening_reconciliation:
1672                 if reconcile.line_id:
1673                     first_partner = reconcile.line_id[0].partner_id.id
1674                     move_lines = reconcile.line_id
1675                 elif reconcile.line_partial_ids:
1676                     first_partner = reconcile.line_partial_ids[0].partner_id.id
1677                     move_lines = reconcile.line_partial_ids
1678                 if any([line.partner_id.id != first_partner for line in move_lines]):
1679                     return False
1680         return True
1681
1682     _constraints = [
1683         (_check_same_partner, 'You can only reconcile journal items with the same partner.', ['line_id']),
1684     ]
1685
1686     def reconcile_partial_check(self, cr, uid, ids, type='auto', context=None):
1687         total = 0.0
1688         for rec in self.browse(cr, uid, ids, context=context):
1689             for line in rec.line_partial_ids:
1690                 if line.account_id.currency_id:
1691                     total += line.amount_currency
1692                 else:
1693                     total += (line.debit or 0.0) - (line.credit or 0.0)
1694         if not total:
1695             self.pool.get('account.move.line').write(cr, uid,
1696                 map(lambda x: x.id, rec.line_partial_ids),
1697                 {'reconcile_id': rec.id }
1698             )
1699         return True
1700
1701     def name_get(self, cr, uid, ids, context=None):
1702         if not ids:
1703             return []
1704         result = []
1705         for r in self.browse(cr, uid, ids, context=context):
1706             total = reduce(lambda y,t: (t.debit or 0.0) - (t.credit or 0.0) + y, r.line_partial_ids, 0.0)
1707             if total:
1708                 name = '%s (%.2f)' % (r.name, total)
1709                 result.append((r.id,name))
1710             else:
1711                 result.append((r.id,r.name))
1712         return result
1713
1714 account_move_reconcile()
1715
1716 #----------------------------------------------------------
1717 # Tax
1718 #----------------------------------------------------------
1719 """
1720 a documenter
1721 child_depend: la taxe depend des taxes filles
1722 """
1723 class account_tax_code(osv.osv):
1724     """
1725     A code for the tax object.
1726
1727     This code is used for some tax declarations.
1728     """
1729     def _sum(self, cr, uid, ids, name, args, context, where ='', where_params=()):
1730         parent_ids = tuple(self.search(cr, uid, [('parent_id', 'child_of', ids)]))
1731         if context.get('based_on', 'invoices') == 'payments':
1732             cr.execute('SELECT line.tax_code_id, sum(line.tax_amount) \
1733                     FROM account_move_line AS line, \
1734                         account_move AS move \
1735                         LEFT JOIN account_invoice invoice ON \
1736                             (invoice.move_id = move.id) \
1737                     WHERE line.tax_code_id IN %s '+where+' \
1738                         AND move.id = line.move_id \
1739                         AND ((invoice.state = \'paid\') \
1740                             OR (invoice.id IS NULL)) \
1741                             GROUP BY line.tax_code_id',
1742                                 (parent_ids,) + where_params)
1743         else:
1744             cr.execute('SELECT line.tax_code_id, sum(line.tax_amount) \
1745                     FROM account_move_line AS line, \
1746                     account_move AS move \
1747                     WHERE line.tax_code_id IN %s '+where+' \
1748                     AND move.id = line.move_id \
1749                     GROUP BY line.tax_code_id',
1750                        (parent_ids,) + where_params)
1751         res=dict(cr.fetchall())
1752         obj_precision = self.pool.get('decimal.precision')
1753         res2 = {}
1754         for record in self.browse(cr, uid, ids, context=context):
1755             def _rec_get(record):
1756                 amount = res.get(record.id, 0.0)
1757                 for rec in record.child_ids:
1758                     amount += _rec_get(rec) * rec.sign
1759                 return amount
1760             res2[record.id] = round(_rec_get(record), obj_precision.precision_get(cr, uid, 'Account'))
1761         return res2
1762
1763     def _sum_year(self, cr, uid, ids, name, args, context=None):
1764         if context is None:
1765             context = {}
1766         move_state = ('posted', )
1767         if context.get('state', 'all') == 'all':
1768             move_state = ('draft', 'posted', )
1769         if context.get('fiscalyear_id', False):
1770             fiscalyear_id = [context['fiscalyear_id']]
1771         else:
1772             fiscalyear_id = self.pool.get('account.fiscalyear').finds(cr, uid, exception=False)
1773         where = ''
1774         where_params = ()
1775         if fiscalyear_id:
1776             pids = []
1777             for fy in fiscalyear_id:
1778                 pids += map(lambda x: str(x.id), self.pool.get('account.fiscalyear').browse(cr, uid, fy).period_ids)
1779             if pids:
1780                 where = ' AND line.period_id IN %s AND move.state IN %s '
1781                 where_params = (tuple(pids), move_state)
1782         return self._sum(cr, uid, ids, name, args, context,
1783                 where=where, where_params=where_params)
1784
1785     def _sum_period(self, cr, uid, ids, name, args, context):
1786         if context is None:
1787             context = {}
1788         move_state = ('posted', )
1789         if context.get('state', False) == 'all':
1790             move_state = ('draft', 'posted', )
1791         if context.get('period_id', False):
1792             period_id = context['period_id']
1793         else:
1794             period_id = self.pool.get('account.period').find(cr, uid)
1795             if not period_id:
1796                 return dict.fromkeys(ids, 0.0)
1797             period_id = period_id[0]
1798         return self._sum(cr, uid, ids, name, args, context,
1799                 where=' AND line.period_id=%s AND move.state IN %s', where_params=(period_id, move_state))
1800
1801     _name = 'account.tax.code'
1802     _description = 'Tax Code'
1803     _rec_name = 'code'
1804     _columns = {
1805         'name': fields.char('Tax Case Name', size=64, required=True, translate=True),
1806         'code': fields.char('Case Code', size=64),
1807         'info': fields.text('Description'),
1808         'sum': fields.function(_sum_year, string="Year Sum"),
1809         'sum_period': fields.function(_sum_period, string="Period Sum"),
1810         'parent_id': fields.many2one('account.tax.code', 'Parent Code', select=True),
1811         'child_ids': fields.one2many('account.tax.code', 'parent_id', 'Child Codes'),
1812         'line_ids': fields.one2many('account.move.line', 'tax_code_id', 'Lines'),
1813         'company_id': fields.many2one('res.company', 'Company', required=True),
1814         '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.'),
1815         '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"),
1816         'sequence': fields.integer('Sequence', help="Determine the display order in the report 'Accounting \ Reporting \ Generic Reporting \ Taxes \ Taxes Report'"),
1817     }
1818
1819     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=80):
1820         if not args:
1821             args = []
1822         if context is None:
1823             context = {}
1824         ids = self.search(cr, user, ['|',('name',operator,name),('code',operator,name)] + args, limit=limit, context=context)
1825         return self.name_get(cr, user, ids, context)
1826
1827     def name_get(self, cr, uid, ids, context=None):
1828         if isinstance(ids, (int, long)):
1829             ids = [ids]
1830         if not ids:
1831             return []
1832         if isinstance(ids, (int, long)):
1833             ids = [ids]
1834         reads = self.read(cr, uid, ids, ['name','code'], context, load='_classic_write')
1835         return [(x['id'], (x['code'] and (x['code'] + ' - ') or '') + x['name']) \
1836                 for x in reads]
1837
1838     def _default_company(self, cr, uid, context=None):
1839         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1840         if user.company_id:
1841             return user.company_id.id
1842         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
1843     _defaults = {
1844         'company_id': _default_company,
1845         'sign': 1.0,
1846         'notprintable': False,
1847     }
1848
1849     def copy(self, cr, uid, id, default=None, context=None):
1850         if default is None:
1851             default = {}
1852         default = default.copy()
1853         default.update({'line_ids': []})
1854         return super(account_tax_code, self).copy(cr, uid, id, default, context)
1855
1856     _check_recursion = check_cycle
1857     _constraints = [
1858         (_check_recursion, 'Error!\nYou cannot create recursive accounts.', ['parent_id'])
1859     ]
1860     _order = 'code'
1861
1862 account_tax_code()
1863
1864 class account_tax(osv.osv):
1865     """
1866     A tax object.
1867
1868     Type: percent, fixed, none, code
1869         PERCENT: tax = price * amount
1870         FIXED: tax = price + amount
1871         NONE: no tax line
1872         CODE: execute python code. localcontext = {'price_unit':pu}
1873             return result in the context
1874             Ex: result=round(price_unit*0.21,4)
1875     """
1876
1877     def get_precision_tax():
1878         def change_digit_tax(cr):
1879             res = pooler.get_pool(cr.dbname).get('decimal.precision').precision_get(cr, SUPERUSER_ID, 'Account')
1880             return (16, res+2)
1881         return change_digit_tax
1882
1883     _name = 'account.tax'
1884     _description = 'Tax'
1885     _columns = {
1886         'name': fields.char('Tax Name', size=64, required=True, translate=True, help="This name will be displayed on reports"),
1887         '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."),
1888         'amount': fields.float('Amount', required=True, digits_compute=get_precision_tax(), help="For taxes of type percentage, enter % ratio between 0-1."),
1889         'active': fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the tax without removing it."),
1890         'type': fields.selection( [('percent','Percentage'), ('fixed','Fixed Amount'), ('none','None'), ('code','Python Code'), ('balance','Balance')], 'Tax Type', required=True,
1891             help="The computation method for the tax amount."),
1892         'applicable_type': fields.selection( [('true','Always'), ('code','Given by Python Code')], 'Applicability', required=True,
1893             help="If not applicable (computed through a Python code), the tax won't appear on the invoice."),
1894         '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."),
1895         '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."),
1896         '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."),
1897         '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."),
1898         '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."),
1899         'parent_id':fields.many2one('account.tax', 'Parent Tax Account', select=True),
1900         'child_ids':fields.one2many('account.tax', 'parent_id', 'Child Tax Accounts'),
1901         '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."),
1902         'python_compute':fields.text('Python Code'),
1903         'python_compute_inv':fields.text('Python Code (reverse)'),
1904         'python_applicable':fields.text('Python Code'),
1905
1906         #
1907         # Fields used for the Tax declaration
1908         #
1909         'base_code_id': fields.many2one('account.tax.code', 'Account Base Code', help="Use this code for the tax declaration."),
1910         'tax_code_id': fields.many2one('account.tax.code', 'Account Tax Code', help="Use this code for the tax declaration."),
1911         'base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
1912         'tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
1913
1914         # Same fields for refund invoices
1915
1916         'ref_base_code_id': fields.many2one('account.tax.code', 'Refund Base Code', help="Use this code for the tax declaration."),
1917         'ref_tax_code_id': fields.many2one('account.tax.code', 'Refund Tax Code', help="Use this code for the tax declaration."),
1918         'ref_base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
1919         'ref_tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
1920         '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"),
1921         'company_id': fields.many2one('res.company', 'Company', required=True),
1922         'description': fields.char('Tax Code'),
1923         'price_include': fields.boolean('Tax Included in Price', help="Check this if the price you use on the product and invoices includes this tax."),
1924         'type_tax_use': fields.selection([('sale','Sale'),('purchase','Purchase'),('all','All')], 'Tax Application', required=True)
1925
1926     }
1927     _sql_constraints = [
1928         ('name_company_uniq', 'unique(name, company_id)', 'Tax Name must be unique per company!'),
1929     ]
1930
1931     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=80):
1932         """
1933         Returns a list of tupples containing id, name, as internally it is called {def name_get}
1934         result format: {[(id, name), (id, name), ...]}
1935
1936         @param cr: A database cursor
1937         @param user: ID of the user currently logged in
1938         @param name: name to search
1939         @param args: other arguments
1940         @param operator: default operator is 'ilike', it can be changed
1941         @param context: context arguments, like lang, time zone
1942         @param limit: Returns first 'n' ids of complete result, default is 80.
1943
1944         @return: Returns a list of tupples containing id and name
1945         """
1946         if not args:
1947             args = []
1948         if context is None:
1949             context = {}
1950         ids = []
1951         if name:
1952             ids = self.search(cr, user, [('description', '=', name)] + args, limit=limit, context=context)
1953             if not ids:
1954                 ids = self.search(cr, user, [('name', operator, name)] + args, limit=limit, context=context)
1955         else:
1956             ids = self.search(cr, user, args, limit=limit, context=context or {})
1957         return self.name_get(cr, user, ids, context=context)
1958
1959     def write(self, cr, uid, ids, vals, context=None):
1960         if vals.get('type', False) and vals['type'] in ('none', 'code'):
1961             vals.update({'amount': 0.0})
1962         return super(account_tax, self).write(cr, uid, ids, vals, context=context)
1963
1964     def search(self, cr, uid, args, offset=0, limit=None, order=None, context=None, count=False):
1965         journal_pool = self.pool.get('account.journal')
1966
1967         if context and context.has_key('type'):
1968             if context.get('type') in ('out_invoice','out_refund'):
1969                 args += [('type_tax_use','in',['sale','all'])]
1970             elif context.get('type') in ('in_invoice','in_refund'):
1971                 args += [('type_tax_use','in',['purchase','all'])]
1972
1973         if context and context.has_key('journal_id'):
1974             journal = journal_pool.browse(cr, uid, context.get('journal_id'))
1975             if journal.type in ('sale', 'purchase'):
1976                 args += [('type_tax_use','in',[journal.type,'all'])]
1977
1978         return super(account_tax, self).search(cr, uid, args, offset, limit, order, context, count)
1979
1980     def name_get(self, cr, uid, ids, context=None):
1981         if not ids:
1982             return []
1983         res = []
1984         for record in self.read(cr, uid, ids, ['description','name'], context=context):
1985             name = record['description'] and record['description'] or record['name']
1986             res.append((record['id'],name ))
1987         return res
1988
1989     def _default_company(self, cr, uid, context=None):
1990         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1991         if user.company_id:
1992             return user.company_id.id
1993         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
1994
1995     _defaults = {
1996         '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''',
1997         'python_compute_inv': '''# price_unit\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
1998         'applicable_type': 'true',
1999         'type': 'percent',
2000         'amount': 0,
2001         'price_include': 0,
2002         'active': 1,
2003         'type_tax_use': 'all',
2004         'sequence': 1,
2005         'ref_tax_sign': 1,
2006         'ref_base_sign': 1,
2007         'tax_sign': 1,
2008         'base_sign': 1,
2009         'include_base_amount': False,
2010         'company_id': _default_company,
2011     }
2012     _order = 'sequence'
2013
2014     def _applicable(self, cr, uid, taxes, price_unit, product=None, partner=None):
2015         res = []
2016         for tax in taxes:
2017             if tax.applicable_type=='code':
2018                 localdict = {'price_unit':price_unit, 'product':product, 'partner':partner}
2019                 exec tax.python_applicable in localdict
2020                 if localdict.get('result', False):
2021                     res.append(tax)
2022             else:
2023                 res.append(tax)
2024         return res
2025
2026     def _unit_compute(self, cr, uid, taxes, price_unit, product=None, partner=None, quantity=0):
2027         taxes = self._applicable(cr, uid, taxes, price_unit ,product, partner)
2028         res = []
2029         cur_price_unit=price_unit
2030         for tax in taxes:
2031             # we compute the amount for the current tax object and append it to the result
2032             data = {'id':tax.id,
2033                     'name':tax.description and tax.description + " - " + tax.name or tax.name,
2034                     'account_collected_id':tax.account_collected_id.id,
2035                     'account_paid_id':tax.account_paid_id.id,
2036                     'account_analytic_collected_id': tax.account_analytic_collected_id.id,
2037                     'account_analytic_paid_id': tax.account_analytic_paid_id.id,
2038                     'base_code_id': tax.base_code_id.id,
2039                     'ref_base_code_id': tax.ref_base_code_id.id,
2040                     'sequence': tax.sequence,
2041                     'base_sign': tax.base_sign,
2042                     'tax_sign': tax.tax_sign,
2043                     'ref_base_sign': tax.ref_base_sign,
2044                     'ref_tax_sign': tax.ref_tax_sign,
2045                     'price_unit': cur_price_unit,
2046                     'tax_code_id': tax.tax_code_id.id,
2047                     'ref_tax_code_id': tax.ref_tax_code_id.id,
2048             }
2049             res.append(data)
2050             if tax.type=='percent':
2051                 amount = cur_price_unit * tax.amount
2052                 data['amount'] = amount
2053
2054             elif tax.type=='fixed':
2055                 data['amount'] = tax.amount
2056                 data['tax_amount']=quantity
2057                # data['amount'] = quantity
2058             elif tax.type=='code':
2059                 localdict = {'price_unit':cur_price_unit, 'product':product, 'partner':partner}
2060                 exec tax.python_compute in localdict
2061                 amount = localdict['result']
2062                 data['amount'] = amount
2063             elif tax.type=='balance':
2064                 data['amount'] = cur_price_unit - reduce(lambda x,y: y.get('amount',0.0)+x, res, 0.0)
2065                 data['balance'] = cur_price_unit
2066
2067             amount2 = data.get('amount', 0.0)
2068             if tax.child_ids:
2069                 if tax.child_depend:
2070                     latest = res.pop()
2071                 amount = amount2
2072                 child_tax = self._unit_compute(cr, uid, tax.child_ids, amount, product, partner, quantity)
2073                 res.extend(child_tax)
2074                 if tax.child_depend:
2075                     for r in res:
2076                         for name in ('base','ref_base'):
2077                             if latest[name+'_code_id'] and latest[name+'_sign'] and not r[name+'_code_id']:
2078                                 r[name+'_code_id'] = latest[name+'_code_id']
2079                                 r[name+'_sign'] = latest[name+'_sign']
2080                                 r['price_unit'] = latest['price_unit']
2081                                 latest[name+'_code_id'] = False
2082                         for name in ('tax','ref_tax'):
2083                             if latest[name+'_code_id'] and latest[name+'_sign'] and not r[name+'_code_id']:
2084                                 r[name+'_code_id'] = latest[name+'_code_id']
2085                                 r[name+'_sign'] = latest[name+'_sign']
2086                                 r['amount'] = data['amount']
2087                                 latest[name+'_code_id'] = False
2088             if tax.include_base_amount:
2089                 cur_price_unit+=amount2
2090         return res
2091
2092     def compute_all(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, force_excluded=False):
2093         """
2094         :param force_excluded: boolean used to say that we don't want to consider the value of field price_include of
2095             tax. It's used in encoding by line where you don't matter if you encoded a tax with that boolean to True or
2096             False
2097         RETURN: {
2098                 'total': 0.0,                # Total without taxes
2099                 'total_included: 0.0,        # Total with taxes
2100                 'taxes': []                  # List of taxes, see compute for the format
2101             }
2102         """
2103
2104         # By default, for each tax, tax amount will first be computed
2105         # and rounded at the 'Account' decimal precision for each
2106         # PO/SO/invoice line and then these rounded amounts will be
2107         # summed, leading to the total amount for that tax. But, if the
2108         # company has tax_calculation_rounding_method = round_globally,
2109         # we still follow the same method, but we use a much larger
2110         # precision when we round the tax amount for each line (we use
2111         # the 'Account' decimal precision + 5), and that way it's like
2112         # rounding after the sum of the tax amounts of each line
2113         precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
2114         tax_compute_precision = precision
2115         if taxes and taxes[0].company_id.tax_calculation_rounding_method == 'round_globally':
2116             tax_compute_precision += 5
2117         totalin = totalex = float_round(price_unit * quantity, precision)
2118         tin = []
2119         tex = []
2120         for tax in taxes:
2121             if not tax.price_include or force_excluded:
2122                 tex.append(tax)
2123             else:
2124                 tin.append(tax)
2125         tin = self.compute_inv(cr, uid, tin, price_unit, quantity, product=product, partner=partner, precision=tax_compute_precision)
2126         for r in tin:
2127             totalex -= r.get('amount', 0.0)
2128         totlex_qty = 0.0
2129         try:
2130             totlex_qty = totalex/quantity
2131         except:
2132             pass
2133         tex = self._compute(cr, uid, tex, totlex_qty, quantity, product=product, partner=partner, precision=tax_compute_precision)
2134         for r in tex:
2135             totalin += r.get('amount', 0.0)
2136         return {
2137             'total': totalex,
2138             'total_included': totalin,
2139             'taxes': tin + tex
2140         }
2141
2142     def compute(self, cr, uid, taxes, price_unit, quantity,  product=None, partner=None):
2143         _logger.warning("Deprecated, use compute_all(...)['taxes'] instead of compute(...) to manage prices with tax included.")
2144         return self._compute(cr, uid, taxes, price_unit, quantity, product, partner)
2145
2146     def _compute(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, precision=None):
2147         """
2148         Compute tax values for given PRICE_UNIT, QUANTITY and a buyer/seller ADDRESS_ID.
2149
2150         RETURN:
2151             [ tax ]
2152             tax = {'name':'', 'amount':0.0, 'account_collected_id':1, 'account_paid_id':2}
2153             one tax for each tax id in IDS and their children
2154         """
2155         if not precision:
2156             precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
2157         res = self._unit_compute(cr, uid, taxes, price_unit, product, partner, quantity)
2158         total = 0.0
2159         for r in res:
2160             if r.get('balance',False):
2161                 r['amount'] = round(r.get('balance', 0.0) * quantity, precision) - total
2162             else:
2163                 r['amount'] = round(r.get('amount', 0.0) * quantity, precision)
2164                 total += r['amount']
2165         return res
2166
2167     def _unit_compute_inv(self, cr, uid, taxes, price_unit, product=None, partner=None):
2168         taxes = self._applicable(cr, uid, taxes, price_unit,  product, partner)
2169         res = []
2170         taxes.reverse()
2171         cur_price_unit = price_unit
2172
2173         tax_parent_tot = 0.0
2174         for tax in taxes:
2175             if (tax.type=='percent') and not tax.include_base_amount:
2176                 tax_parent_tot += tax.amount
2177
2178         for tax in taxes:
2179             if (tax.type=='fixed') and not tax.include_base_amount:
2180                 cur_price_unit -= tax.amount
2181
2182         for tax in taxes:
2183             if tax.type=='percent':
2184                 if tax.include_base_amount:
2185                     amount = cur_price_unit - (cur_price_unit / (1 + tax.amount))
2186                 else:
2187                     amount = (cur_price_unit / (1 + tax_parent_tot)) * tax.amount
2188
2189             elif tax.type=='fixed':
2190                 amount = tax.amount
2191
2192             elif tax.type=='code':
2193                 localdict = {'price_unit':cur_price_unit, 'product':product, 'partner':partner}
2194                 exec tax.python_compute_inv in localdict
2195                 amount = localdict['result']
2196             elif tax.type=='balance':
2197                 amount = cur_price_unit - reduce(lambda x,y: y.get('amount',0.0)+x, res, 0.0)
2198
2199             if tax.include_base_amount:
2200                 cur_price_unit -= amount
2201                 todo = 0
2202             else:
2203                 todo = 1
2204             res.append({
2205                 'id': tax.id,
2206                 'todo': todo,
2207                 'name': tax.name,
2208                 'amount': amount,
2209                 'account_collected_id': tax.account_collected_id.id,
2210                 'account_paid_id': tax.account_paid_id.id,
2211                 'account_analytic_collected_id': tax.account_analytic_collected_id.id,
2212                 'account_analytic_paid_id': tax.account_analytic_paid_id.id,
2213                 'base_code_id': tax.base_code_id.id,
2214                 'ref_base_code_id': tax.ref_base_code_id.id,
2215                 'sequence': tax.sequence,
2216                 'base_sign': tax.base_sign,
2217                 'tax_sign': tax.tax_sign,
2218                 'ref_base_sign': tax.ref_base_sign,
2219                 'ref_tax_sign': tax.ref_tax_sign,
2220                 'price_unit': cur_price_unit,
2221                 'tax_code_id': tax.tax_code_id.id,
2222                 'ref_tax_code_id': tax.ref_tax_code_id.id,
2223             })
2224             if tax.child_ids:
2225                 if tax.child_depend:
2226                     del res[-1]
2227                     amount = price_unit
2228
2229             parent_tax = self._unit_compute_inv(cr, uid, tax.child_ids, amount, product, partner)
2230             res.extend(parent_tax)
2231
2232         total = 0.0
2233         for r in res:
2234             if r['todo']:
2235                 total += r['amount']
2236         for r in res:
2237             r['price_unit'] -= total
2238             r['todo'] = 0
2239         return res
2240
2241     def compute_inv(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, precision=None):
2242         """
2243         Compute tax values for given PRICE_UNIT, QUANTITY and a buyer/seller ADDRESS_ID.
2244         Price Unit is a Tax included price
2245
2246         RETURN:
2247             [ tax ]
2248             tax = {'name':'', 'amount':0.0, 'account_collected_id':1, 'account_paid_id':2}
2249             one tax for each tax id in IDS and their children
2250         """
2251         if not precision:
2252             precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
2253         res = self._unit_compute_inv(cr, uid, taxes, price_unit, product, partner=None)
2254         total = 0.0
2255         for r in res:
2256             if r.get('balance',False):
2257                 r['amount'] = round(r['balance'] * quantity, precision) - total
2258             else:
2259                 r['amount'] = round(r['amount'] * quantity, precision)
2260                 total += r['amount']
2261         return res
2262
2263 account_tax()
2264
2265 # ---------------------------------------------------------
2266 # Account Entries Models
2267 # ---------------------------------------------------------
2268
2269 class account_model(osv.osv):
2270     _name = "account.model"
2271     _description = "Account Model"
2272     _columns = {
2273         'name': fields.char('Model Name', size=64, required=True, help="This is a model for recurring accounting entries"),
2274         'journal_id': fields.many2one('account.journal', 'Journal', required=True),
2275         'company_id': fields.related('journal_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True),
2276         'lines_id': fields.one2many('account.model.line', 'model_id', 'Model Entries'),
2277         'legend': fields.text('Legend', readonly=True, size=100),
2278     }
2279
2280     _defaults = {
2281         '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'),
2282     }
2283
2284     def generate(self, cr, uid, ids, data=None, context=None):
2285         if data is None:
2286             data = {}
2287         move_ids = []
2288         entry = {}
2289         account_move_obj = self.pool.get('account.move')
2290         account_move_line_obj = self.pool.get('account.move.line')
2291         pt_obj = self.pool.get('account.payment.term')
2292         period_obj = self.pool.get('account.period')
2293
2294         if context is None:
2295             context = {}
2296
2297         if data.get('date', False):
2298             context.update({'date': data['date']})
2299
2300         move_date = context.get('date', time.strftime('%Y-%m-%d'))
2301         move_date = datetime.strptime(move_date,"%Y-%m-%d")
2302         for model in self.browse(cr, uid, ids, context=context):
2303             ctx = context.copy()
2304             ctx.update({'company_id': model.company_id.id})
2305             period_ids = period_obj.find(cr, uid, dt=context.get('date', False), context=ctx)
2306             period_id = period_ids and period_ids[0] or False
2307             ctx.update({'journal_id': model.journal_id.id,'period_id': period_id})
2308             try:
2309                 entry['name'] = model.name%{'year': move_date.strftime('%Y'), 'month': move_date.strftime('%m'), 'date': move_date.strftime('%Y-%m')}
2310             except:
2311                 raise osv.except_osv(_('Wrong model !'), _('You have a wrong expression "%(...)s" in your model !'))
2312             move_id = account_move_obj.create(cr, uid, {
2313                 'ref': entry['name'],
2314                 'period_id': period_id,
2315                 'journal_id': model.journal_id.id,
2316                 'date': context.get('date', fields.date.context_today(self,cr,uid,context=context))
2317             })
2318             move_ids.append(move_id)
2319             for line in model.lines_id:
2320                 analytic_account_id = False
2321                 if line.analytic_account_id:
2322                     if not model.journal_id.analytic_journal_id:
2323                         raise osv.except_osv(_('No Analytic Journal !'),_("You have to define an analytic journal on the '%s' journal!") % (model.journal_id.name,))
2324                     analytic_account_id = line.analytic_account_id.id
2325                 val = {
2326                     'move_id': move_id,
2327                     'journal_id': model.journal_id.id,
2328                     'period_id': period_id,
2329                     'analytic_account_id': analytic_account_id
2330                 }
2331
2332                 date_maturity = context.get('date',time.strftime('%Y-%m-%d'))
2333                 if line.date_maturity == 'partner':
2334                     if not line.partner_id:
2335                         raise osv.except_osv(_('Error!'), _("Maturity date of entry line generated by model line '%s' of model '%s' is based on partner payment term!" \
2336                                                                 "\nPlease define partner on it!")%(line.name, model.name))
2337
2338                     payment_term_id = False
2339                     if model.journal_id.type in ('purchase', 'purchase_refund') and line.partner_id.property_supplier_payment_term:
2340                         payment_term_id = line.partner_id.property_supplier_payment_term.id
2341                     elif line.partner_id.property_payment_term:
2342                         payment_term_id = line.partner_id.property_payment_term.id
2343                     if payment_term_id:
2344                         pterm_list = pt_obj.compute(cr, uid, payment_term_id, value=1, date_ref=date_maturity)
2345                         if pterm_list:
2346                             pterm_list = [l[0] for l in pterm_list]
2347                             pterm_list.sort()
2348                             date_maturity = pterm_list[-1]
2349
2350                 val.update({
2351                     'name': line.name,
2352                     'quantity': line.quantity,
2353                     'debit': line.debit,
2354                     'credit': line.credit,
2355                     'account_id': line.account_id.id,
2356                     'move_id': move_id,
2357                     'partner_id': line.partner_id.id,
2358                     'date': context.get('date', fields.date.context_today(self,cr,uid,context=context)),
2359                     'date_maturity': date_maturity
2360                 })
2361                 account_move_line_obj.create(cr, uid, val, context=ctx)
2362
2363         return move_ids
2364
2365     def onchange_journal_id(self, cr, uid, ids, journal_id, context=None):
2366         company_id = False
2367
2368         if journal_id:
2369             journal = self.pool.get('account.journal').browse(cr, uid, journal_id, context=context)
2370             if journal.company_id.id:
2371                 company_id = journal.company_id.id
2372
2373         return {'value': {'company_id': company_id}}
2374
2375 account_model()
2376
2377 class account_model_line(osv.osv):
2378     _name = "account.model.line"
2379     _description = "Account Model Entries"
2380     _columns = {
2381         'name': fields.char('Name', size=64, required=True),
2382         'sequence': fields.integer('Sequence', required=True, help="The sequence field is used to order the resources from lower sequences to higher ones."),
2383         'quantity': fields.float('Quantity', digits_compute=dp.get_precision('Account'), help="The optional quantity on entries."),
2384         'debit': fields.float('Debit', digits_compute=dp.get_precision('Account')),
2385         'credit': fields.float('Credit', digits_compute=dp.get_precision('Account')),
2386         'account_id': fields.many2one('account.account', 'Account', required=True, ondelete="cascade"),
2387         'analytic_account_id': fields.many2one('account.analytic.account', 'Analytic Account', ondelete="cascade"),
2388         'model_id': fields.many2one('account.model', 'Model', required=True, ondelete="cascade", select=True),
2389         'amount_currency': fields.float('Amount Currency', help="The amount expressed in an optional other currency."),
2390         'currency_id': fields.many2one('res.currency', 'Currency'),
2391         'partner_id': fields.many2one('res.partner', 'Partner'),
2392         '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."),
2393     }
2394     _order = 'sequence'
2395     _sql_constraints = [
2396         ('credit_debit1', 'CHECK (credit*debit=0)',  'Wrong credit or debit value in model, they must be positive!'),
2397         ('credit_debit2', 'CHECK (credit+debit>=0)', 'Wrong credit or debit value in model, they must be positive!'),
2398     ]
2399 account_model_line()
2400
2401 # ---------------------------------------------------------
2402 # Account Subscription
2403 # ---------------------------------------------------------
2404
2405
2406 class account_subscription(osv.osv):
2407     _name = "account.subscription"
2408     _description = "Account Subscription"
2409     _columns = {
2410         'name': fields.char('Name', size=64, required=True),
2411         'ref': fields.char('Reference', size=16),
2412         'model_id': fields.many2one('account.model', 'Model', required=True),
2413         'date_start': fields.date('Start Date', required=True),
2414         'period_total': fields.integer('Number of Periods', required=True),
2415         'period_nbr': fields.integer('Period', required=True),
2416         'period_type': fields.selection([('day','days'),('month','month'),('year','year')], 'Period Type', required=True),
2417         'state': fields.selection([('draft','Draft'),('running','Running'),('done','Done')], 'Status', required=True, readonly=True),
2418         'lines_id': fields.one2many('account.subscription.line', 'subscription_id', 'Subscription Lines')
2419     }
2420     _defaults = {
2421         'date_start': fields.date.context_today,
2422         'period_type': 'month',
2423         'period_total': 12,
2424         'period_nbr': 1,
2425         'state': 'draft',
2426     }
2427     def state_draft(self, cr, uid, ids, context=None):
2428         self.write(cr, uid, ids, {'state':'draft'})
2429         return False
2430
2431     def check(self, cr, uid, ids, context=None):
2432         todone = []
2433         for sub in self.browse(cr, uid, ids, context=context):
2434             ok = True
2435             for line in sub.lines_id:
2436                 if not line.move_id.id:
2437                     ok = False
2438                     break
2439             if ok:
2440                 todone.append(sub.id)
2441         if todone:
2442             self.write(cr, uid, todone, {'state':'done'})
2443         return False
2444
2445     def remove_line(self, cr, uid, ids, context=None):
2446         toremove = []
2447         for sub in self.browse(cr, uid, ids, context=context):
2448             for line in sub.lines_id:
2449                 if not line.move_id.id:
2450                     toremove.append(line.id)
2451         if toremove:
2452             self.pool.get('account.subscription.line').unlink(cr, uid, toremove)
2453         self.write(cr, uid, ids, {'state':'draft'})
2454         return False
2455
2456     def compute(self, cr, uid, ids, context=None):
2457         for sub in self.browse(cr, uid, ids, context=context):
2458             ds = sub.date_start
2459             for i in range(sub.period_total):
2460                 self.pool.get('account.subscription.line').create(cr, uid, {
2461                     'date': ds,
2462                     'subscription_id': sub.id,
2463                 })
2464                 if sub.period_type=='day':
2465                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(days=sub.period_nbr)).strftime('%Y-%m-%d')
2466                 if sub.period_type=='month':
2467                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(months=sub.period_nbr)).strftime('%Y-%m-%d')
2468                 if sub.period_type=='year':
2469                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(years=sub.period_nbr)).strftime('%Y-%m-%d')
2470         self.write(cr, uid, ids, {'state':'running'})
2471         return True
2472
2473 account_subscription()
2474
2475 class account_subscription_line(osv.osv):
2476     _name = "account.subscription.line"
2477     _description = "Account Subscription Line"
2478     _columns = {
2479         'subscription_id': fields.many2one('account.subscription', 'Subscription', required=True, select=True),
2480         'date': fields.date('Date', required=True),
2481         'move_id': fields.many2one('account.move', 'Entry'),
2482     }
2483
2484     def move_create(self, cr, uid, ids, context=None):
2485         tocheck = {}
2486         all_moves = []
2487         obj_model = self.pool.get('account.model')
2488         for line in self.browse(cr, uid, ids, context=context):
2489             data = {
2490                 'date': line.date,
2491             }
2492             move_ids = obj_model.generate(cr, uid, [line.subscription_id.model_id.id], data, context)
2493             tocheck[line.subscription_id.id] = True
2494             self.write(cr, uid, [line.id], {'move_id':move_ids[0]})
2495             all_moves.extend(move_ids)
2496         if tocheck:
2497             self.pool.get('account.subscription').check(cr, uid, tocheck.keys(), context)
2498         return all_moves
2499
2500     _rec_name = 'date'
2501
2502 account_subscription_line()
2503
2504 #  ---------------------------------------------------------------
2505 #   Account Templates: Account, Tax, Tax Code and chart. + Wizard
2506 #  ---------------------------------------------------------------
2507
2508 class account_tax_template(osv.osv):
2509     _name = 'account.tax.template'
2510 account_tax_template()
2511
2512 class account_account_template(osv.osv):
2513     _order = "code"
2514     _name = "account.account.template"
2515     _description ='Templates for Accounts'
2516
2517     _columns = {
2518         'name': fields.char('Name', size=256, required=True, select=True),
2519         'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
2520         'code': fields.char('Code', size=64, required=True, select=1),
2521         'type': fields.selection([
2522             ('receivable','Receivable'),
2523             ('payable','Payable'),
2524             ('view','View'),
2525             ('consolidation','Consolidation'),
2526             ('liquidity','Liquidity'),
2527             ('other','Regular'),
2528             ('closed','Closed'),
2529             ], 'Internal Type', required=True,help="This type is used to differentiate types with "\
2530             "special effects in OpenERP: view can not have entries, consolidation are accounts that "\
2531             "can have children accounts for multi-company consolidations, payable/receivable are for "\
2532             "partners accounts (for debit/credit computations), closed for depreciated accounts."),
2533         'user_type': fields.many2one('account.account.type', 'Account Type', required=True,
2534             help="These types are defined according to your country. The type contains more information "\
2535             "about the account and its specificities."),
2536         'financial_report_ids': fields.many2many('account.financial.report', 'account_template_financial_report', 'account_template_id', 'report_line_id', 'Financial Reports'),
2537         'reconcile': fields.boolean('Allow Reconciliation', help="Check this option if you want the user to reconcile entries in this account."),
2538         'shortcut': fields.char('Shortcut', size=12),
2539         'note': fields.text('Note'),
2540         'parent_id': fields.many2one('account.account.template', 'Parent Account Template', ondelete='cascade', domain=[('type','=','view')]),
2541         'child_parent_ids':fields.one2many('account.account.template', 'parent_id', 'Children'),
2542         'tax_ids': fields.many2many('account.tax.template', 'account_account_template_tax_rel', 'account_id', 'tax_id', 'Default Taxes'),
2543         'nocreate': fields.boolean('Optional create', help="If checked, the new chart of accounts will not contain this by default."),
2544         '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)."),
2545     }
2546
2547     _defaults = {
2548         'reconcile': False,
2549         'type': 'view',
2550         'nocreate': False,
2551     }
2552
2553     _check_recursion = check_cycle
2554     _constraints = [
2555         (_check_recursion, 'Error!\nYou cannot create recursive account templates.', ['parent_id']),
2556     ]
2557
2558     def name_get(self, cr, uid, ids, context=None):
2559         if not ids:
2560             return []
2561         reads = self.read(cr, uid, ids, ['name','code'], context=context)
2562         res = []
2563         for record in reads:
2564             name = record['name']
2565             if record['code']:
2566                 name = record['code']+' '+name
2567             res.append((record['id'],name ))
2568         return res
2569
2570     def generate_account(self, cr, uid, chart_template_id, tax_template_ref, acc_template_ref, code_digits, company_id, context=None):
2571         """
2572         This method for generating accounts from templates.
2573
2574         :param chart_template_id: id of the chart template chosen in the wizard
2575         :param tax_template_ref: Taxes templates reference for write taxes_id in account_account.
2576         :paramacc_template_ref: dictionary with the mappping between the account templates and the real accounts.
2577         :param code_digits: number of digits got from wizard.multi.charts.accounts, this is use for account code.
2578         :param company_id: company_id selected from wizard.multi.charts.accounts.
2579         :returns: return acc_template_ref for reference purpose.
2580         :rtype: dict
2581         """
2582         if context is None:
2583             context = {}
2584         obj_acc = self.pool.get('account.account')
2585         company_name = self.pool.get('res.company').browse(cr, uid, company_id, context=context).name
2586         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
2587         #deactivate the parent_store functionnality on account_account for rapidity purpose
2588         ctx = context.copy()
2589         ctx.update({'defer_parent_store_computation': True})
2590         level_ref = {}
2591         children_acc_criteria = [('chart_template_id','=', chart_template_id)]
2592         if template.account_root_id.id:
2593             children_acc_criteria = ['|'] + children_acc_criteria + ['&',('parent_id','child_of', [template.account_root_id.id]),('chart_template_id','=', False)]
2594         children_acc_template = self.search(cr, uid, [('nocreate','!=',True)] + children_acc_criteria, order='id')
2595         for account_template in self.browse(cr, uid, children_acc_template, context=context):
2596             # skip the root of COA if it's not the main one
2597             if (template.account_root_id.id == account_template.id) and template.parent_id:
2598                 continue
2599             tax_ids = []
2600             for tax in account_template.tax_ids:
2601                 tax_ids.append(tax_template_ref[tax.id])
2602
2603             code_main = account_template.code and len(account_template.code) or 0
2604             code_acc = account_template.code or ''
2605             if code_main > 0 and code_main <= code_digits and account_template.type != 'view':
2606                 code_acc = str(code_acc) + (str('0'*(code_digits-code_main)))
2607             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
2608             #the level as to be given as well at the creation time, because of the defer_parent_store_computation in
2609             #context. Indeed because of this, the parent_left and parent_right are not computed and thus the child_of
2610             #operator does not return the expected values, with result of having the level field not computed at all.
2611             if parent_id:
2612                 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
2613             else:
2614                 level = 0
2615             vals={
2616                 'name': (template.account_root_id.id == account_template.id) and company_name or account_template.name,
2617                 'currency_id': account_template.currency_id and account_template.currency_id.id or False,
2618                 'code': code_acc,
2619                 'type': account_template.type,
2620                 'user_type': account_template.user_type and account_template.user_type.id or False,
2621                 'reconcile': account_template.reconcile,
2622                 'shortcut': account_template.shortcut,
2623                 'note': account_template.note,
2624                 'financial_report_ids': account_template.financial_report_ids and [(6,0,[x.id for x in account_template.financial_report_ids])] or False,
2625                 'parent_id': parent_id,
2626                 'tax_ids': [(6,0,tax_ids)],
2627                 'company_id': company_id,
2628                 'level': level,
2629             }
2630             new_account = obj_acc.create(cr, uid, vals, context=ctx)
2631             acc_template_ref[account_template.id] = new_account
2632             level_ref[new_account] = level
2633
2634         #reactivate the parent_store functionnality on account_account
2635         obj_acc._parent_store_compute(cr)
2636         return acc_template_ref
2637
2638 account_account_template()
2639
2640 class account_add_tmpl_wizard(osv.osv_memory):
2641     """Add one more account from the template.
2642
2643     With the 'nocreate' option, some accounts may not be created. Use this to add them later."""
2644     _name = 'account.addtmpl.wizard'
2645
2646     def _get_def_cparent(self, cr, uid, context=None):
2647         acc_obj = self.pool.get('account.account')
2648         tmpl_obj = self.pool.get('account.account.template')
2649         tids = tmpl_obj.read(cr, uid, [context['tmpl_ids']], ['parent_id'])
2650         if not tids or not tids[0]['parent_id']:
2651             return False
2652         ptids = tmpl_obj.read(cr, uid, [tids[0]['parent_id'][0]], ['code'])
2653         res = None
2654         if not ptids or not ptids[0]['code']:
2655             raise osv.except_osv(_('Error!'), _('There is no parent code for the template account.'))
2656             res = acc_obj.search(cr, uid, [('code','=',ptids[0]['code'])])
2657         return res and res[0] or False
2658
2659     _columns = {
2660         'cparent_id':fields.many2one('account.account', 'Parent target', help="Creates an account with the selected template under this existing parent.", required=True),
2661     }
2662     _defaults = {
2663         'cparent_id': _get_def_cparent,
2664     }
2665
2666     def action_create(self,cr,uid,ids,context=None):
2667         if context is None:
2668             context = {}
2669         acc_obj = self.pool.get('account.account')
2670         tmpl_obj = self.pool.get('account.account.template')
2671         data = self.read(cr, uid, ids)[0]
2672         company_id = acc_obj.read(cr, uid, [data['cparent_id'][0]], ['company_id'])[0]['company_id'][0]
2673         account_template = tmpl_obj.browse(cr, uid, context['tmpl_ids'])
2674         vals = {
2675             'name': account_template.name,
2676             'currency_id': account_template.currency_id and account_template.currency_id.id or False,
2677             'code': account_template.code,
2678             'type': account_template.type,
2679             'user_type': account_template.user_type and account_template.user_type.id or False,
2680             'reconcile': account_template.reconcile,
2681             'shortcut': account_template.shortcut,
2682             'note': account_template.note,
2683             'parent_id': data['cparent_id'][0],
2684             'company_id': company_id,
2685             }
2686         acc_obj.create(cr, uid, vals)
2687         return {'type':'state', 'state': 'end' }
2688
2689     def action_cancel(self, cr, uid, ids, context=None):
2690         return { 'type': 'state', 'state': 'end' }
2691
2692 account_add_tmpl_wizard()
2693
2694 class account_tax_code_template(osv.osv):
2695
2696     _name = 'account.tax.code.template'
2697     _description = 'Tax Code Template'
2698     _order = 'code'
2699     _rec_name = 'code'
2700     _columns = {
2701         'name': fields.char('Tax Case Name', size=64, required=True),
2702         'code': fields.char('Case Code', size=64),
2703         'info': fields.text('Description'),
2704         'parent_id': fields.many2one('account.tax.code.template', 'Parent Code', select=True),
2705         'child_ids': fields.one2many('account.tax.code.template', 'parent_id', 'Child Codes'),
2706         'sign': fields.float('Sign For Parent', required=True),
2707         '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."),
2708     }
2709
2710     _defaults = {
2711         'sign': 1.0,
2712         'notprintable': False,
2713     }
2714
2715     def generate_tax_code(self, cr, uid, tax_code_root_id, company_id, context=None):
2716         '''
2717         This function generates the tax codes from the templates of tax code that are children of the given one passed
2718         in argument. Then it returns a dictionary with the mappping between the templates and the real objects.
2719
2720         :param tax_code_root_id: id of the root of all the tax code templates to process
2721         :param company_id: id of the company the wizard is running for
2722         :returns: dictionary with the mappping between the templates and the real objects.
2723         :rtype: dict
2724         '''
2725         obj_tax_code_template = self.pool.get('account.tax.code.template')
2726         obj_tax_code = self.pool.get('account.tax.code')
2727         tax_code_template_ref = {}
2728         company = self.pool.get('res.company').browse(cr, uid, company_id, context=context)
2729
2730         #find all the children of the tax_code_root_id
2731         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 []
2732         for tax_code_template in obj_tax_code_template.browse(cr, uid, children_tax_code_template, context=context):
2733             vals = {
2734                 'name': (tax_code_root_id == tax_code_template.id) and company.name or tax_code_template.name,
2735                 'code': tax_code_template.code,
2736                 'info': tax_code_template.info,
2737                 '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,
2738                 'company_id': company_id,
2739                 'sign': tax_code_template.sign,
2740             }
2741             #check if this tax code already exists
2742             rec_list = obj_tax_code.search(cr, uid, [('name', '=', vals['name']),('code', '=', vals['code']),('company_id', '=', vals['company_id'])], context=context)
2743             if not rec_list:
2744                 #if not yet, create it
2745                 new_tax_code = obj_tax_code.create(cr, uid, vals)
2746                 #recording the new tax code to do the mapping
2747                 tax_code_template_ref[tax_code_template.id] = new_tax_code
2748         return tax_code_template_ref
2749
2750     def name_get(self, cr, uid, ids, context=None):
2751         if not ids:
2752             return []
2753         if isinstance(ids, (int, long)):
2754             ids = [ids]
2755         reads = self.read(cr, uid, ids, ['name','code'], context, load='_classic_write')
2756         return [(x['id'], (x['code'] and x['code'] + ' - ' or '') + x['name']) \
2757                 for x in reads]
2758
2759     _check_recursion = check_cycle
2760     _constraints = [
2761         (_check_recursion, 'Error!\nYou cannot create recursive Tax Codes.', ['parent_id'])
2762     ]
2763     _order = 'code,name'
2764 account_tax_code_template()
2765
2766
2767 class account_chart_template(osv.osv):
2768     _name="account.chart.template"
2769     _description= "Templates for Account Chart"
2770
2771     _columns={
2772         'name': fields.char('Name', size=64, required=True),
2773         'parent_id': fields.many2one('account.chart.template', 'Parent Chart Template'),
2774         'code_digits': fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
2775         '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."),
2776         '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'),
2777         'account_root_id': fields.many2one('account.account.template', 'Root Account', domain=[('parent_id','=',False)]),
2778         'tax_code_root_id': fields.many2one('account.tax.code.template', 'Root Tax Code', domain=[('parent_id','=',False)]),
2779         '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'),
2780         'bank_account_view_id': fields.many2one('account.account.template', 'Bank Account'),
2781         'property_account_receivable': fields.many2one('account.account.template', 'Receivable Account'),
2782         'property_account_payable': fields.many2one('account.account.template', 'Payable Account'),
2783         'property_account_expense_categ': fields.many2one('account.account.template', 'Expense Category Account'),
2784         'property_account_income_categ': fields.many2one('account.account.template', 'Income Category Account'),
2785         'property_account_expense': fields.many2one('account.account.template', 'Expense Account on Product Template'),
2786         'property_account_income': fields.many2one('account.account.template', 'Income Account on Product Template'),
2787         'property_account_income_opening': fields.many2one('account.account.template', 'Opening Entries Income Account'),
2788         'property_account_expense_opening': fields.many2one('account.account.template', 'Opening Entries Expense Account'),
2789     }
2790
2791     _defaults = {
2792         'visible': True,
2793         'code_digits': 6,
2794         'complete_tax_set': True,
2795     }
2796
2797 account_chart_template()
2798
2799 class account_tax_template(osv.osv):
2800
2801     _name = 'account.tax.template'
2802     _description = 'Templates for Taxes'
2803
2804     _columns = {
2805         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
2806         'name': fields.char('Tax Name', size=64, required=True),
2807         '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."),
2808         'amount': fields.float('Amount', required=True, digits=(14,4), help="For Tax Type percent enter % ratio between 0-1."),
2809         'type': fields.selection( [('percent','Percent'), ('fixed','Fixed'), ('none','None'), ('code','Python Code'), ('balance','Balance')], 'Tax Type', required=True),
2810         '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."),
2811         '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."),
2812         'account_collected_id':fields.many2one('account.account.template', 'Invoice Tax Account'),
2813         'account_paid_id':fields.many2one('account.account.template', 'Refund Tax Account'),
2814         'parent_id':fields.many2one('account.tax.template', 'Parent Tax Account', select=True),
2815         '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."),
2816         'python_compute':fields.text('Python Code'),
2817         'python_compute_inv':fields.text('Python Code (reverse)'),
2818         'python_applicable':fields.text('Python Code'),
2819
2820         #
2821         # Fields used for the Tax declaration
2822         #
2823         'base_code_id': fields.many2one('account.tax.code.template', 'Base Code', help="Use this code for the tax declaration."),
2824         'tax_code_id': fields.many2one('account.tax.code.template', 'Tax Code', help="Use this code for the tax declaration."),
2825         'base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
2826         'tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
2827
2828         # Same fields for refund invoices
2829
2830         'ref_base_code_id': fields.many2one('account.tax.code.template', 'Refund Base Code', help="Use this code for the tax declaration."),
2831         'ref_tax_code_id': fields.many2one('account.tax.code.template', 'Refund Tax Code', help="Use this code for the tax declaration."),
2832         'ref_base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
2833         'ref_tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
2834         '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."),
2835         'description': fields.char('Internal Name'),
2836         'type_tax_use': fields.selection([('sale','Sale'),('purchase','Purchase'),('all','All')], 'Tax Use In', required=True,),
2837         'price_include': fields.boolean('Tax Included in Price', help="Check this if the price you use on the product and invoices includes this tax."),
2838     }
2839
2840     def name_get(self, cr, uid, ids, context=None):
2841         if not ids:
2842             return []
2843         res = []
2844         for record in self.read(cr, uid, ids, ['description','name'], context=context):
2845             name = record['description'] and record['description'] or record['name']
2846             res.append((record['id'],name ))
2847         return res
2848
2849     def _default_company(self, cr, uid, context=None):
2850         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
2851         if user.company_id:
2852             return user.company_id.id
2853         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
2854
2855     _defaults = {
2856         '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''',
2857         'python_compute_inv': lambda *a: '''# price_unit\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
2858         'applicable_type': 'true',
2859         'type': 'percent',
2860         'amount': 0,
2861         'sequence': 1,
2862         'ref_tax_sign': 1,
2863         'ref_base_sign': 1,
2864         'tax_sign': 1,
2865         'base_sign': 1,
2866         'include_base_amount': False,
2867         'type_tax_use': 'all',
2868         'price_include': 0,
2869     }
2870     _order = 'sequence'
2871
2872     def _generate_tax(self, cr, uid, tax_templates, tax_code_template_ref, company_id, context=None):
2873         """
2874         This method generate taxes from templates.
2875
2876         :param tax_templates: list of browse record of the tax templates to process
2877         :param tax_code_template_ref: Taxcode templates reference.
2878         :param company_id: id of the company the wizard is running for
2879         :returns:
2880             {
2881             'tax_template_to_tax': mapping between tax template and the newly generated taxes corresponding,
2882             'account_dict': dictionary containing a to-do list with all the accounts to assign on new taxes
2883             }
2884         """
2885         if context is None:
2886             context = {}
2887         res = {}
2888         todo_dict = {}
2889         tax_template_to_tax = {}
2890         for tax in tax_templates:
2891             vals_tax = {
2892                 'name':tax.name,
2893                 'sequence': tax.sequence,
2894                 'amount': tax.amount,
2895                 'type': tax.type,
2896                 'applicable_type': tax.applicable_type,
2897                 'domain': tax.domain,
2898                 '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,
2899                 'child_depend': tax.child_depend,
2900                 'python_compute': tax.python_compute,
2901                 'python_compute_inv': tax.python_compute_inv,
2902                 'python_applicable': tax.python_applicable,
2903                 '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,
2904                 '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,
2905                 'base_sign': tax.base_sign,
2906                 'tax_sign': tax.tax_sign,
2907                 '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,
2908                 '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,
2909                 'ref_base_sign': tax.ref_base_sign,
2910                 'ref_tax_sign': tax.ref_tax_sign,
2911                 'include_base_amount': tax.include_base_amount,
2912                 'description': tax.description,
2913                 'company_id': company_id,
2914                 'type_tax_use': tax.type_tax_use,
2915                 'price_include': tax.price_include
2916             }
2917             new_tax = self.pool.get('account.tax').create(cr, uid, vals_tax)
2918             tax_template_to_tax[tax.id] = new_tax
2919             #as the accounts have not been created yet, we have to wait before filling these fields
2920             todo_dict[new_tax] = {
2921                 'account_collected_id': tax.account_collected_id and tax.account_collected_id.id or False,
2922                 'account_paid_id': tax.account_paid_id and tax.account_paid_id.id or False,
2923             }
2924         res.update({'tax_template_to_tax': tax_template_to_tax, 'account_dict': todo_dict})
2925         return res
2926
2927 account_tax_template()
2928
2929 # Fiscal Position Templates
2930
2931 class account_fiscal_position_template(osv.osv):
2932     _name = 'account.fiscal.position.template'
2933     _description = 'Template for Fiscal Position'
2934
2935     _columns = {
2936         'name': fields.char('Fiscal Position Template', size=64, required=True),
2937         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
2938         'account_ids': fields.one2many('account.fiscal.position.account.template', 'position_id', 'Account Mapping'),
2939         'tax_ids': fields.one2many('account.fiscal.position.tax.template', 'position_id', 'Tax Mapping'),
2940         'note': fields.text('Notes', translate=True),
2941     }
2942
2943     def generate_fiscal_position(self, cr, uid, chart_temp_id, tax_template_ref, acc_template_ref, company_id, context=None):
2944         """
2945         This method generate Fiscal Position, Fiscal Position Accounts and Fiscal Position Taxes from templates.
2946
2947         :param chart_temp_id: Chart Template Id.
2948         :param taxes_ids: Taxes templates reference for generating account.fiscal.position.tax.
2949         :param acc_template_ref: Account templates reference for generating account.fiscal.position.account.
2950         :param company_id: company_id selected from wizard.multi.charts.accounts.
2951         :returns: True
2952         """
2953         if context is None:
2954             context = {}
2955         obj_tax_fp = self.pool.get('account.fiscal.position.tax')
2956         obj_ac_fp = self.pool.get('account.fiscal.position.account')
2957         obj_fiscal_position = self.pool.get('account.fiscal.position')
2958         fp_ids = self.search(cr, uid, [('chart_template_id', '=', chart_temp_id)])
2959         for position in self.browse(cr, uid, fp_ids, context=context):
2960             new_fp = obj_fiscal_position.create(cr, uid, {'company_id': company_id, 'name': position.name, 'note': position.note})
2961             for tax in position.tax_ids:
2962                 obj_tax_fp.create(cr, uid, {
2963                     'tax_src_id': tax_template_ref[tax.tax_src_id.id],
2964                     'tax_dest_id': tax.tax_dest_id and tax_template_ref[tax.tax_dest_id.id] or False,
2965                     'position_id': new_fp
2966                 })
2967             for acc in position.account_ids:
2968                 obj_ac_fp.create(cr, uid, {
2969                     'account_src_id': acc_template_ref[acc.account_src_id.id],
2970                     'account_dest_id': acc_template_ref[acc.account_dest_id.id],
2971                     'position_id': new_fp
2972                 })
2973         return True
2974
2975 account_fiscal_position_template()
2976
2977 class account_fiscal_position_tax_template(osv.osv):
2978     _name = 'account.fiscal.position.tax.template'
2979     _description = 'Template Tax Fiscal Position'
2980     _rec_name = 'position_id'
2981
2982     _columns = {
2983         'position_id': fields.many2one('account.fiscal.position.template', 'Fiscal Position', required=True, ondelete='cascade'),
2984         'tax_src_id': fields.many2one('account.tax.template', 'Tax Source', required=True),
2985         'tax_dest_id': fields.many2one('account.tax.template', 'Replacement Tax')
2986     }
2987
2988 account_fiscal_position_tax_template()
2989
2990 class account_fiscal_position_account_template(osv.osv):
2991     _name = 'account.fiscal.position.account.template'
2992     _description = 'Template Account Fiscal Mapping'
2993     _rec_name = 'position_id'
2994     _columns = {
2995         'position_id': fields.many2one('account.fiscal.position.template', 'Fiscal Mapping', required=True, ondelete='cascade'),
2996         'account_src_id': fields.many2one('account.account.template', 'Account Source', domain=[('type','<>','view')], required=True),
2997         'account_dest_id': fields.many2one('account.account.template', 'Account Destination', domain=[('type','<>','view')], required=True)
2998     }
2999
3000 account_fiscal_position_account_template()
3001
3002 # ---------------------------------------------------------
3003 # Account generation from template wizards
3004 # ---------------------------------------------------------
3005
3006 class wizard_multi_charts_accounts(osv.osv_memory):
3007     """
3008     Create a new account chart for a company.
3009     Wizards ask for:
3010         * a company
3011         * an account chart template
3012         * a number of digits for formatting code of non-view accounts
3013         * a list of bank accounts owned by the company
3014     Then, the wizard:
3015         * generates all accounts from the template and assigns them to the right company
3016         * generates all taxes and tax codes, changing account assignations
3017         * generates all accounting properties and assigns them correctly
3018     """
3019     _name='wizard.multi.charts.accounts'
3020     _inherit = 'res.config'
3021
3022     _columns = {
3023         'company_id':fields.many2one('res.company', 'Company', required=True),
3024         'currency_id': fields.many2one('res.currency', 'Currency', help="Currency as per company's country."),
3025         'only_one_chart_template': fields.boolean('Only One Chart Template Available'),
3026         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
3027         'bank_accounts_id': fields.one2many('account.bank.accounts.wizard', 'bank_account_id', 'Cash and Banks', required=True),
3028         'code_digits':fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
3029         "sale_tax": fields.many2one("account.tax.template", "Default Sale Tax"),
3030         "purchase_tax": fields.many2one("account.tax.template", "Default Purchase Tax"),
3031         'sale_tax_rate': fields.float('Sales Tax(%)'),
3032         'purchase_tax_rate': fields.float('Purchase Tax(%)'),
3033         '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'),
3034     }
3035
3036     def onchange_company_id(self, cr, uid, ids, company_id, context=None):
3037         currency_id = False
3038         if company_id:
3039             currency_id = self.pool.get('res.company').browse(cr, uid, company_id, context=context).currency_id.id
3040         return {'value': {'currency_id': currency_id}}
3041
3042     def onchange_tax_rate(self, cr, uid, ids, rate=False, context=None):
3043         return {'value': {'purchase_tax_rate': rate or False}}
3044
3045     def onchange_chart_template_id(self, cr, uid, ids, chart_template_id=False, context=None):
3046         res = {}
3047         tax_templ_obj = self.pool.get('account.tax.template')
3048         res['value'] = {'complete_tax_set': False, 'sale_tax': False, 'purchase_tax': False}
3049         if chart_template_id:
3050             data = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3051             res['value'].update({'complete_tax_set': data.complete_tax_set})
3052             if data.complete_tax_set:
3053             # 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
3054                 sale_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3055                                               , "=", chart_template_id), ('type_tax_use', 'in', ('sale','all'))], order="sequence, id desc")
3056                 purchase_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3057                                               , "=", chart_template_id), ('type_tax_use', 'in', ('purchase','all'))], order="sequence, id desc")
3058                 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})
3059
3060             if data.code_digits:
3061                res['value'].update({'code_digits': data.code_digits})
3062         return res
3063
3064     def default_get(self, cr, uid, fields, context=None):
3065         res = super(wizard_multi_charts_accounts, self).default_get(cr, uid, fields, context=context)
3066         tax_templ_obj = self.pool.get('account.tax.template')
3067
3068         if 'bank_accounts_id' in fields:
3069             res.update({'bank_accounts_id': [{'acc_name': _('Cash'), 'account_type': 'cash'},{'acc_name': _('Bank'), 'account_type': 'bank'}]})
3070         if 'company_id' in fields:
3071             res.update({'company_id': self.pool.get('res.users').browse(cr, uid, [uid], context=context)[0].company_id.id})
3072         if 'currency_id' in fields:
3073             company_id = res.get('company_id') or False
3074             if company_id:
3075                 company_obj = self.pool.get('res.company')
3076                 country_id = company_obj.browse(cr, uid, company_id, context=context).country_id.id
3077                 currency_id = company_obj.on_change_country(cr, uid, company_id, country_id, context=context)['value']['currency_id']
3078                 res.update({'currency_id': currency_id})
3079
3080         ids = self.pool.get('account.chart.template').search(cr, uid, [('visible', '=', True)], context=context)
3081         if ids:
3082             if 'chart_template_id' in fields:
3083                 res.update({'only_one_chart_template': len(ids) == 1, 'chart_template_id': ids[0]})
3084             if 'sale_tax' in fields:
3085                 sale_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3086                                               , "=", ids[0]), ('type_tax_use', 'in', ('sale','all'))], order="sequence")
3087                 res.update({'sale_tax': sale_tax_ids and sale_tax_ids[0] or False})
3088             if 'purchase_tax' in fields:
3089                 purchase_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3090                                           , "=", ids[0]), ('type_tax_use', 'in', ('purchase','all'))], order="sequence")
3091                 res.update({'purchase_tax': purchase_tax_ids and purchase_tax_ids[0] or False})
3092         res.update({
3093             'purchase_tax_rate': 15.0,
3094             'sale_tax_rate': 15.0,
3095         })
3096         return res
3097
3098     def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
3099         if context is None:context = {}
3100         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)
3101         cmp_select = []
3102         acc_template_obj = self.pool.get('account.chart.template')
3103         company_obj = self.pool.get('res.company')
3104
3105         company_ids = company_obj.search(cr, uid, [], context=context)
3106         #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)
3107         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",))
3108         configured_cmp = [r[0] for r in cr.fetchall()]
3109         unconfigured_cmp = list(set(company_ids)-set(configured_cmp))
3110         for field in res['fields']:
3111             if field == 'company_id':
3112                 res['fields'][field]['domain'] = [('id','in',unconfigured_cmp)]
3113                 res['fields'][field]['selection'] = [('', '')]
3114                 if unconfigured_cmp:
3115                     cmp_select = [(line.id, line.name) for line in company_obj.browse(cr, uid, unconfigured_cmp)]
3116                     res['fields'][field]['selection'] = cmp_select
3117         return res
3118
3119     def check_created_journals(self, cr, uid, vals_journal, company_id, context=None):
3120         """
3121         This method used for checking journals already created or not. If not then create new journal.
3122         """
3123         obj_journal = self.pool.get('account.journal')
3124         rec_list = obj_journal.search(cr, uid, [('name','=', vals_journal['name']),('company_id', '=', company_id)], context=context)
3125         if not rec_list:
3126             obj_journal.create(cr, uid, vals_journal, context=context)
3127         return True
3128
3129     def generate_journals(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3130         """
3131         This method is used for creating journals.
3132
3133         :param chart_temp_id: Chart Template Id.
3134         :param acc_template_ref: Account templates reference.
3135         :param company_id: company_id selected from wizard.multi.charts.accounts.
3136         :returns: True
3137         """
3138         journal_data = self._prepare_all_journals(cr, uid, chart_template_id, acc_template_ref, company_id, context=context)
3139         for vals_journal in journal_data:
3140             self.check_created_journals(cr, uid, vals_journal, company_id, context=context)
3141         return True
3142
3143     def _prepare_all_journals(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3144         def _get_analytic_journal(journal_type):
3145             # Get the analytic journal
3146             data = False
3147             if journal_type in ('sale', 'sale_refund'):
3148                 data = obj_data.get_object_reference(cr, uid, 'account', 'analytic_journal_sale')
3149             elif journal_type in ('purchase', 'purchase_refund'):
3150                 pass
3151             elif journal_type == 'general':
3152                 pass
3153             return data and data[1] or False
3154
3155         def _get_default_account(journal_type, type='debit'):
3156             # Get the default accounts
3157             default_account = False
3158             if journal_type in ('sale', 'sale_refund'):
3159                 default_account = acc_template_ref.get(template.property_account_income_categ.id)
3160             elif journal_type in ('purchase', 'purchase_refund'):
3161                 default_account = acc_template_ref.get(template.property_account_expense_categ.id)
3162             elif journal_type == 'situation':
3163                 if type == 'debit':
3164                     default_account = acc_template_ref.get(template.property_account_expense_opening.id)
3165                 else:
3166                     default_account = acc_template_ref.get(template.property_account_income_opening.id)
3167             return default_account
3168
3169         journal_names = {
3170             'sale': _('Sales Journal'),
3171             'purchase': _('Purchase Journal'),
3172             'sale_refund': _('Sales Refund Journal'),
3173             'purchase_refund': _('Purchase Refund Journal'),
3174             'general': _('Miscellaneous Journal'),
3175             'situation': _('Opening Entries Journal'),
3176         }
3177         journal_codes = {
3178             'sale': _('SAJ'),
3179             'purchase': _('EXJ'),
3180             'sale_refund': _('SCNJ'),
3181             'purchase_refund': _('ECNJ'),
3182             'general': _('MISC'),
3183             'situation': _('OPEJ'),
3184         }
3185
3186         obj_data = self.pool.get('ir.model.data')
3187         analytic_journal_obj = self.pool.get('account.analytic.journal')
3188         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3189
3190         journal_data = []
3191         for journal_type in ['sale', 'purchase', 'sale_refund', 'purchase_refund', 'general', 'situation']:
3192             vals = {
3193                 'type': journal_type,
3194                 'name': journal_names[journal_type],
3195                 'code': journal_codes[journal_type],
3196                 'company_id': company_id,
3197                 'centralisation': journal_type == 'situation',
3198                 'analytic_journal_id': _get_analytic_journal(journal_type),
3199                 'default_credit_account_id': _get_default_account(journal_type, 'credit'),
3200                 'default_debit_account_id': _get_default_account(journal_type, 'debit'),
3201             }
3202             journal_data.append(vals)
3203         return journal_data
3204
3205     def generate_properties(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3206         """
3207         This method used for creating properties.
3208
3209         :param chart_template_id: id of the current chart template for which we need to create properties
3210         :param acc_template_ref: Mapping between ids of account templates and real accounts created from them
3211         :param company_id: company_id selected from wizard.multi.charts.accounts.
3212         :returns: True
3213         """
3214         property_obj = self.pool.get('ir.property')
3215         field_obj = self.pool.get('ir.model.fields')
3216         todo_list = [
3217             ('property_account_receivable','res.partner','account.account'),
3218             ('property_account_payable','res.partner','account.account'),
3219             ('property_account_expense_categ','product.category','account.account'),
3220             ('property_account_income_categ','product.category','account.account'),
3221             ('property_account_expense','product.template','account.account'),
3222             ('property_account_income','product.template','account.account'),
3223         ]
3224         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3225         for record in todo_list:
3226             account = getattr(template, record[0])
3227             value = account and 'account.account,' + str(acc_template_ref[account.id]) or False
3228             if value:
3229                 field = field_obj.search(cr, uid, [('name', '=', record[0]),('model', '=', record[1]),('relation', '=', record[2])], context=context)
3230                 vals = {
3231                     'name': record[0],
3232                     'company_id': company_id,
3233                     'fields_id': field[0],
3234                     'value': value,
3235                 }
3236                 property_ids = property_obj.search(cr, uid, [('name','=', record[0]),('company_id', '=', company_id)], context=context)
3237                 if property_ids:
3238                     #the property exist: modify it
3239                     property_obj.write(cr, uid, property_ids, vals, context=context)
3240                 else:
3241                     #create the property
3242                     property_obj.create(cr, uid, vals, context=context)
3243         return True
3244
3245     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):
3246         '''
3247         This function recursively loads the template objects and create the real objects from them.
3248
3249         :param template_id: id of the chart template to load
3250         :param company_id: id of the company the wizard is running for
3251         :param code_digits: integer that depicts the number of digits the accounts code should have in the COA
3252         :param obj_wizard: the current wizard for generating the COA from the templates
3253         :param acc_ref: Mapping between ids of account templates and real accounts created from them
3254         :param taxes_ref: Mapping between ids of tax templates and real taxes created from them
3255         :param tax_code_ref: Mapping between ids of tax code templates and real tax codes created from them
3256         :returns: return a tuple with a dictionary containing
3257             * the mapping between the account template ids and the ids of the real accounts that have been generated
3258               from them, as first item,
3259             * a similar dictionary for mapping the tax templates and taxes, as second item,
3260             * a last identical containing the mapping of tax code templates and tax codes
3261         :rtype: tuple(dict, dict, dict)
3262         '''
3263         if acc_ref is None:
3264             acc_ref = {}
3265         if taxes_ref is None:
3266             taxes_ref = {}
3267         if tax_code_ref is None:
3268             tax_code_ref = {}
3269         template = self.pool.get('account.chart.template').browse(cr, uid, template_id, context=context)
3270         if template.parent_id:
3271             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)
3272             acc_ref.update(tmp1)
3273             taxes_ref.update(tmp2)
3274             tax_code_ref.update(tmp3)
3275         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)
3276         acc_ref.update(tmp1)
3277         taxes_ref.update(tmp2)
3278         tax_code_ref.update(tmp3)
3279         return acc_ref, taxes_ref, tax_code_ref
3280
3281     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):
3282         '''
3283         This function generates all the objects from the templates
3284
3285         :param template_id: id of the chart template to load
3286         :param company_id: id of the company the wizard is running for
3287         :param code_digits: integer that depicts the number of digits the accounts code should have in the COA
3288         :param obj_wizard: the current wizard for generating the COA from the templates
3289         :param acc_ref: Mapping between ids of account templates and real accounts created from them
3290         :param taxes_ref: Mapping between ids of tax templates and real taxes created from them
3291         :param tax_code_ref: Mapping between ids of tax code templates and real tax codes created from them
3292         :returns: return a tuple with a dictionary containing
3293             * the mapping between the account template ids and the ids of the real accounts that have been generated
3294               from them, as first item,
3295             * a similar dictionary for mapping the tax templates and taxes, as second item,
3296             * a last identical containing the mapping of tax code templates and tax codes
3297         :rtype: tuple(dict, dict, dict)
3298         '''
3299         if account_ref is None:
3300             account_ref = {}
3301         if taxes_ref is None:
3302             taxes_ref = {}
3303         if tax_code_ref is None:
3304             tax_code_ref = {}
3305         template = self.pool.get('account.chart.template').browse(cr, uid, template_id, context=context)
3306         obj_tax_code_template = self.pool.get('account.tax.code.template')
3307         obj_acc_tax = self.pool.get('account.tax')
3308         obj_tax_temp = self.pool.get('account.tax.template')
3309         obj_acc_template = self.pool.get('account.account.template')
3310         obj_fiscal_position_template = self.pool.get('account.fiscal.position.template')
3311
3312         # create all the tax code.
3313         tax_code_ref.update(obj_tax_code_template.generate_tax_code(cr, uid, template.tax_code_root_id.id, company_id, context=context))
3314
3315         # Generate taxes from templates.
3316         tax_templates = [x for x in template.tax_template_ids]
3317         generated_tax_res = obj_tax_temp._generate_tax(cr, uid, tax_templates, tax_code_ref, company_id, context=context)
3318         taxes_ref.update(generated_tax_res['tax_template_to_tax'])
3319
3320         # Generating Accounts from templates.
3321         account_template_ref = obj_acc_template.generate_account(cr, uid, template_id, taxes_ref, account_ref, code_digits, company_id, context=context)
3322         account_ref.update(account_template_ref)
3323
3324         # writing account values on tax after creation of accounts
3325         for key,value in generated_tax_res['account_dict'].items():
3326             if value['account_collected_id'] or value['account_paid_id']:
3327                 obj_acc_tax.write(cr, uid, [key], {
3328                     'account_collected_id': account_ref.get(value['account_collected_id'], False),
3329                     'account_paid_id': account_ref.get(value['account_paid_id'], False),
3330                 })
3331
3332         # Create Journals
3333         self.generate_journals(cr, uid, template_id, account_ref, company_id, context=context)
3334
3335         # generate properties function
3336         self.generate_properties(cr, uid, template_id, account_ref, company_id, context=context)
3337
3338         # Generate Fiscal Position , Fiscal Position Accounts and Fiscal Position Taxes from templates
3339         obj_fiscal_position_template.generate_fiscal_position(cr, uid, template_id, taxes_ref, account_ref, company_id, context=context)
3340
3341         return account_ref, taxes_ref, tax_code_ref
3342
3343     def _create_tax_templates_from_rates(self, cr, uid, obj_wizard, company_id, context=None):
3344         '''
3345         This function checks if the chosen chart template is configured as containing a full set of taxes, and if
3346         it's not the case, it creates the templates for account.tax.code and for account.account.tax objects accordingly
3347         to the provided sale/purchase rates. Then it saves the new tax templates as default taxes to use for this chart
3348         template.
3349
3350         :param obj_wizard: browse record of wizard to generate COA from templates
3351         :param company_id: id of the company for wich the wizard is running
3352         :return: True
3353         '''
3354         obj_tax_code_template = self.pool.get('account.tax.code.template')
3355         obj_tax_temp = self.pool.get('account.tax.template')
3356         chart_template = obj_wizard.chart_template_id
3357         vals = {}
3358         # get the ids of all the parents of the selected account chart template
3359         current_chart_template = chart_template
3360         all_parents = [current_chart_template.id]
3361         while current_chart_template.parent_id:
3362             current_chart_template = current_chart_template.parent_id
3363             all_parents.append(current_chart_template.id)
3364         # create tax templates and tax code templates from purchase_tax_rate and sale_tax_rate fields
3365         if not chart_template.complete_tax_set:
3366             value = obj_wizard.sale_tax_rate
3367             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)
3368             obj_tax_temp.write(cr, uid, ref_tax_ids, {'amount': value/100.0, 'name': _('Tax %.2f%%') % value})
3369             value = obj_wizard.purchase_tax_rate
3370             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)
3371             obj_tax_temp.write(cr, uid, ref_tax_ids, {'amount': value/100.0, 'name': _('Purchase Tax %.2f%%') % value})
3372         return True
3373
3374     def execute(self, cr, uid, ids, context=None):
3375         '''
3376         This function is called at the confirmation of the wizard to generate the COA from the templates. It will read
3377         all the provided information to create the accounts, the banks, the journals, the taxes, the tax codes, the
3378         accounting properties... accordingly for the chosen company.
3379         '''
3380         obj_data = self.pool.get('ir.model.data')
3381         ir_values_obj = self.pool.get('ir.values')
3382         obj_wizard = self.browse(cr, uid, ids[0])
3383         company_id = obj_wizard.company_id.id
3384
3385         self.pool.get('res.company').write(cr, uid, [company_id], {'currency_id': obj_wizard.currency_id.id})
3386
3387         # When we install the CoA of first company, set the currency to price types and pricelists
3388         if company_id==1:
3389             for ref in (('product','list_price'),('product','standard_price'),('product','list0'),('purchase','list0')):
3390                 try:
3391                     tmp2 = obj_data.get_object_reference(cr, uid, *ref)
3392                     if tmp2:
3393                         self.pool.get(tmp2[0]).write(cr, uid, tmp2[1], {
3394                             'currency_id': obj_wizard.currency_id.id
3395                         })
3396                 except ValueError, e:
3397                     pass
3398
3399         # If the floats for sale/purchase rates have been filled, create templates from them
3400         self._create_tax_templates_from_rates(cr, uid, obj_wizard, company_id, context=context)
3401
3402         # Install all the templates objects and generate the real objects
3403         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)
3404
3405         # write values of default taxes for product as super user
3406         if obj_wizard.sale_tax and taxes_ref:
3407             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)
3408         if obj_wizard.purchase_tax and taxes_ref:
3409             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)
3410
3411         # Create Bank journals
3412         self._create_bank_journals_from_o2m(cr, uid, obj_wizard, company_id, acc_template_ref, context=context)
3413         return {}
3414
3415     def _prepare_bank_journal(self, cr, uid, line, current_num, default_account_id, company_id, context=None):
3416         '''
3417         This function prepares the value to use for the creation of a bank journal created through the wizard of
3418         generating COA from templates.
3419
3420         :param line: dictionary containing the values encoded by the user related to his bank account
3421         :param current_num: integer corresponding to a counter of the already created bank journals through this wizard.
3422         :param default_account_id: id of the default debit.credit account created before for this journal.
3423         :param company_id: id of the company for which the wizard is running
3424         :return: mapping of field names and values
3425         :rtype: dict
3426         '''
3427         obj_data = self.pool.get('ir.model.data')
3428         obj_journal = self.pool.get('account.journal')
3429
3430
3431         # we need to loop again to find next number for journal code
3432         # because we can't rely on the value current_num as,
3433         # its possible that we already have bank journals created (e.g. by the creation of res.partner.bank)
3434         # and the next number for account code might have been already used before for journal
3435         for num in xrange(current_num, 100):
3436             # journal_code has a maximal size of 5, hence we can enforce the boundary num < 100
3437             journal_code = _('BNK')[:3] + str(num)
3438             ids = obj_journal.search(cr, uid, [('code', '=', journal_code), ('company_id', '=', company_id)], context=context)
3439             if not ids:
3440                 break
3441         else:
3442             raise osv.except_osv(_('Error!'), _('Cannot generate an unused journal code.'))
3443
3444         vals = {
3445                 'name': line['acc_name'],
3446                 'code': journal_code,
3447                 'type': line['account_type'] == 'cash' and 'cash' or 'bank',
3448                 'company_id': company_id,
3449                 'analytic_journal_id': False,
3450                 'currency': False,
3451                 'default_credit_account_id': default_account_id,
3452                 'default_debit_account_id': default_account_id,
3453         }
3454         if line['currency_id']:
3455             vals['currency'] = line['currency_id']
3456
3457         return vals
3458
3459     def _prepare_bank_account(self, cr, uid, line, new_code, acc_template_ref, ref_acc_bank, company_id, context=None):
3460         '''
3461         This function prepares the value to use for the creation of the default debit and credit accounts of a
3462         bank journal created through the wizard of generating COA from templates.
3463
3464         :param line: dictionary containing the values encoded by the user related to his bank account
3465         :param new_code: integer corresponding to the next available number to use as account code
3466         :param acc_template_ref: the dictionary containing the mapping between the ids of account templates and the ids
3467             of the accounts that have been generated from them.
3468         :param ref_acc_bank: browse record of the account template set as root of all bank accounts for the chosen
3469             template
3470         :param company_id: id of the company for which the wizard is running
3471         :return: mapping of field names and values
3472         :rtype: dict
3473         '''
3474         obj_data = self.pool.get('ir.model.data')
3475
3476         # Get the id of the user types fr-or cash and bank
3477         tmp = obj_data.get_object_reference(cr, uid, 'account', 'data_account_type_cash')
3478         cash_type = tmp and tmp[1] or False
3479         tmp = obj_data.get_object_reference(cr, uid, 'account', 'data_account_type_bank')
3480         bank_type = tmp and tmp[1] or False
3481         return {
3482                 'name': line['acc_name'],
3483                 'currency_id': line['currency_id'],
3484                 'code': new_code,
3485                 'type': 'liquidity',
3486                 'user_type': line['account_type'] == 'cash' and cash_type or bank_type,
3487                 'parent_id': acc_template_ref[ref_acc_bank.id] or False,
3488                 'company_id': company_id,
3489         }
3490
3491     def _create_bank_journals_from_o2m(self, cr, uid, obj_wizard, company_id, acc_template_ref, context=None):
3492         '''
3493         This function creates bank journals and its accounts for each line encoded in the field bank_accounts_id of the
3494         wizard.
3495
3496         :param obj_wizard: the current wizard that generates the COA from the templates.
3497         :param company_id: the id of the company for which the wizard is running.
3498         :param acc_template_ref: the dictionary containing the mapping between the ids of account templates and the ids
3499             of the accounts that have been generated from them.
3500         :return: True
3501         '''
3502         obj_acc = self.pool.get('account.account')
3503         obj_journal = self.pool.get('account.journal')
3504         code_digits = obj_wizard.code_digits
3505
3506         # Build a list with all the data to process
3507         journal_data = []
3508         if obj_wizard.bank_accounts_id:
3509             for acc in obj_wizard.bank_accounts_id:
3510                 vals = {
3511                     'acc_name': acc.acc_name,
3512                     'account_type': acc.account_type,
3513                     'currency_id': acc.currency_id.id,
3514                 }
3515                 journal_data.append(vals)
3516         ref_acc_bank = obj_wizard.chart_template_id.bank_account_view_id
3517         if journal_data and not ref_acc_bank.code:
3518             raise osv.except_osv(_('Configuration Error!'), _('You have to set a code for the bank account defined on the selected chart of accounts.'))
3519
3520         current_num = 1
3521         for line in journal_data:
3522             # Seek the next available number for the account code
3523             while True:
3524                 new_code = str(ref_acc_bank.code.ljust(code_digits-len(str(current_num)), '0')) + str(current_num)
3525                 ids = obj_acc.search(cr, uid, [('code', '=', new_code), ('company_id', '=', company_id)])
3526                 if not ids:
3527                     break
3528                 else:
3529                     current_num += 1
3530             # Create the default debit/credit accounts for this bank journal
3531             vals = self._prepare_bank_account(cr, uid, line, new_code, acc_template_ref, ref_acc_bank, company_id, context=context)
3532             default_account_id  = obj_acc.create(cr, uid, vals, context=context)
3533
3534             #create the bank journal
3535             vals_journal = self._prepare_bank_journal(cr, uid, line, current_num, default_account_id, company_id, context=context)
3536             obj_journal.create(cr, uid, vals_journal)
3537             current_num += 1
3538         return True
3539
3540 wizard_multi_charts_accounts()
3541
3542 class account_bank_accounts_wizard(osv.osv_memory):
3543     _name='account.bank.accounts.wizard'
3544
3545     _columns = {
3546         'acc_name': fields.char('Account Name.', size=64, required=True),
3547         'bank_account_id': fields.many2one('wizard.multi.charts.accounts', 'Bank Account', required=True, ondelete='cascade'),
3548         'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
3549         'account_type': fields.selection([('cash','Cash'), ('check','Check'), ('bank','Bank')], 'Account Type', size=32),
3550     }
3551
3552 account_bank_accounts_wizard()
3553
3554 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: