addons/account/account.py

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