addons/account/account.py

   1 # -*- coding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 #    OpenERP, Open Source Management Solution
   5 #    Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
   6 #
   7 #    This program is free software: you can redistribute it and/or modify
   8 #    it under the terms of the GNU Affero General Public License as
   9 #    published by the Free Software Foundation, either version 3 of the
  10 #    License, or (at your option) any later version.
  11 #
  12 #    This program is distributed in the hope that it will be useful,
  13 #    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 #    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 #    GNU Affero General Public License for more details.
  16 #
  17 #    You should have received a copy of the GNU Affero General Public License
  18 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 #
  20 ##############################################################################
  21
  22 import time
  23 from datetime import datetime
  24 from dateutil.relativedelta import relativedelta
  25 from operator import itemgetter
  26
  27 import logging
  28 import pooler
  29 from osv import fields, osv
  30 import decimal_precision as dp
  31 from tools.translate import _
  32 from tools.float_utils import float_round
  33
  34 _logger = logging.getLogger(__name__)
  35
  36 def check_cycle(self, cr, uid, ids, context=None):
  37     """ climbs the ``self._table.parent_id`` chains for 100 levels or
  38     until it can't find any more parent(s)
  39
  40     Returns true if it runs out of parents (no cycle), false if
  41     it can recurse 100 times without ending all chains
  42     """
  43     level = 100
  44     while len(ids):
  45         cr.execute('SELECT DISTINCT parent_id '\
  46                     'FROM '+self._table+' '\
  47                     'WHERE id IN %s '\
  48                     'AND parent_id IS NOT NULL',(tuple(ids),))
  49         ids = map(itemgetter(0), cr.fetchall())
  50         if not level:
  51             return False
  52         level -= 1
  53     return True
  54
  55 class account_payment_term(osv.osv):
  56     _name = "account.payment.term"
  57     _description = "Payment Term"
  58     _columns = {
  59         'name': fields.char('Payment Term', size=64, translate=True, required=True),
  60         'active': fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the payment term without removing it."),
  61         'note': fields.text('Description', translate=True),
  62         'line_ids': fields.one2many('account.payment.term.line', 'payment_id', 'Terms'),
  63     }
  64     _defaults = {
  65         'active': 1,
  66     }
  67     _order = "name"
  68
  69     def compute(self, cr, uid, id, value, date_ref=False, context=None):
  70         if not date_ref:
  71             date_ref = datetime.now().strftime('%Y-%m-%d')
  72         pt = self.browse(cr, uid, id, context=context)
  73         amount = value
  74         result = []
  75         obj_precision = self.pool.get('decimal.precision')
  76         for line in pt.line_ids:
  77             prec = obj_precision.precision_get(cr, uid, 'Account')
  78             if line.value == 'fixed':
  79                 amt = round(line.value_amount, prec)
  80             elif line.value == 'procent':
  81                 amt = round(value * line.value_amount, prec)
  82             elif line.value == 'balance':
  83                 amt = round(amount, prec)
  84             if amt:
  85                 next_date = (datetime.strptime(date_ref, '%Y-%m-%d') + relativedelta(days=line.days))
  86                 if line.days2 < 0:
  87                     next_first_date = next_date + relativedelta(day=1,months=1) #Getting 1st of next month
  88                     next_date = next_first_date + relativedelta(days=line.days2)
  89                 if line.days2 > 0:
  90                     next_date += relativedelta(day=line.days2, months=1)
  91                 result.append( (next_date.strftime('%Y-%m-%d'), amt) )
  92                 amount -= amt
  93         return result
  94
  95 account_payment_term()
  96
  97 class account_payment_term_line(osv.osv):
  98     _name = "account.payment.term.line"
  99     _description = "Payment Term Line"
 100     _columns = {
 101         'name': fields.char('Line Name', size=32, required=True),
 102         'sequence': fields.integer('Sequence', required=True, help="The sequence field is used to order the payment term lines from the lowest sequences to the higher ones"),
 103         'value': fields.selection([('procent', 'Percent'),
 104                                    ('balance', 'Balance'),
 105                                    ('fixed', 'Fixed Amount')], 'Valuation',
 106                                    required=True, help="""Select here the kind of valuation related to this payment term line. Note that you should have your last line with the type 'Balance' to ensure that the whole amount will be treated."""),
 107
 108         'value_amount': fields.float('Amount To Pay', digits_compute=dp.get_precision('Payment Term'), help="For percent enter a ratio between 0-1."),
 109         'days': fields.integer('Number of Days', required=True, help="Number of days to add before computation of the day of month." \
 110             "If Date=15/01, Number of Days=22, Day of Month=-1, then the due date is 28/02."),
 111         'days2': fields.integer('Day of the Month', required=True, help="Day of the month, set -1 for the last day of the current month. If it's positive, it gives the day of the next month. Set 0 for net days (otherwise it's based on the beginning of the month)."),
 112         'payment_id': fields.many2one('account.payment.term', 'Payment Term', required=True, select=True),
 113     }
 114     _defaults = {
 115         'value': 'balance',
 116         'sequence': 5,
 117         'days2': 0,
 118     }
 119     _order = "sequence"
 120
 121     def _check_percent(self, cr, uid, ids, context=None):
 122         obj = self.browse(cr, uid, ids[0], context=context)
 123         if obj.value == 'procent' and ( obj.value_amount < 0.0 or obj.value_amount > 1.0):
 124             return False
 125         return True
 126
 127     _constraints = [
 128         (_check_percent, 'Percentages for Payment Term Line must be between 0 and 1, Example: 0.02 for 2%.', ['value_amount']),
 129     ]
 130
 131 account_payment_term_line()
 132
 133 class account_account_type(osv.osv):
 134     _name = "account.account.type"
 135     _description = "Account Type"
 136
 137     def _get_current_report_type(self, cr, uid, ids, name, arg, context=None):
 138         obj_data = self.pool.get('ir.model.data')
 139         obj_financial_report = self.pool.get('account.financial.report')
 140         res = {}
 141         financial_report_ref = {
 142             'asset': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_assets0')[1], context=context),
 143             'liability': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_liability0')[1], context=context),
 144             'income': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_income0')[1], context=context),
 145             'expense': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_expense0')[1], context=context),
 146         }
 147         for record in self.browse(cr, uid, ids, context=context):
 148             res[record.id] = 'none'
 149             for key, financial_report in financial_report_ref.items():
 150                 list_ids = [x.id for x in financial_report.account_type_ids]
 151                 if record.id in list_ids:
 152                     res[record.id] = key
 153         return res
 154
 155     def _save_report_type(self, cr, uid, account_type_id, field_name, field_value, arg, context=None):
 156         obj_data = self.pool.get('ir.model.data')
 157         obj_financial_report = self.pool.get('account.financial.report')
 158         #unlink if it exists somewhere in the financial reports related to BS or PL
 159         financial_report_ref = {
 160             'asset': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_assets0')[1], context=context),
 161             'liability': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_liability0')[1], context=context),
 162             'income': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_income0')[1], context=context),
 163             'expense': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_expense0')[1], context=context),
 164         }
 165         for key, financial_report in financial_report_ref.items():
 166             list_ids = [x.id for x in financial_report.account_type_ids]
 167             if account_type_id in list_ids:
 168                 obj_financial_report.write(cr, uid, [financial_report.id], {'account_type_ids': [(3, account_type_id)]})
 169         #write it in the good place
 170         if field_value != 'none':
 171             return obj_financial_report.write(cr, uid, [financial_report_ref[field_value].id], {'account_type_ids': [(4, account_type_id)]})
 172
 173     _columns = {
 174         'name': fields.char('Account Type', size=64, required=True, translate=True),
 175         'code': fields.char('Code', size=32, required=True, select=True),
 176         'close_method': fields.selection([('none', 'None'), ('balance', 'Balance'), ('detail', 'Detail'), ('unreconciled', 'Unreconciled')], 'Deferral Method', required=True, help="""Set here the method that will be used to generate the end of year journal entries for all the accounts of this type.
 177
 178  'None' means that nothing will be done.
 179  'Balance' will generally be used for cash accounts.
 180  'Detail' will copy each existing journal item of the previous year, even the reconciled ones.
 181  'Unreconciled' will copy only the journal items that were unreconciled on the first day of the new fiscal year."""),
 182         'report_type': fields.function(_get_current_report_type, fnct_inv=_save_report_type, type='selection', string='P&L / BS Category',
 183             selection= [('none','/'),
 184                         ('income', _('Profit & Loss (Income account)')),
 185                         ('expense', _('Profit & Loss (Expense account)')),
 186                         ('asset', _('Balance Sheet (Asset account)')),
 187                         ('liability', _('Balance Sheet (Liability account)'))], help="This field is used to generate legal reports: profit and loss, balance sheet.", required=True),
 188         'note': fields.text('Description'),
 189     }
 190     _defaults = {
 191         'close_method': 'none',
 192         'report_type': 'none',
 193     }
 194     _order = "code"
 195
 196 account_account_type()
 197
 198 def _code_get(self, cr, uid, context=None):
 199     acc_type_obj = self.pool.get('account.account.type')
 200     ids = acc_type_obj.search(cr, uid, [])
 201     res = acc_type_obj.read(cr, uid, ids, ['code', 'name'], context=context)
 202     return [(r['code'], r['name']) for r in res]
 203
 204 #----------------------------------------------------------
 205 # Accounts
 206 #----------------------------------------------------------
 207
 208 class account_tax(osv.osv):
 209     _name = 'account.tax'
 210 account_tax()
 211
 212 class account_account(osv.osv):
 213     _order = "parent_left"
 214     _parent_order = "code"
 215     _name = "account.account"
 216     _description = "Account"
 217     _parent_store = True
 218
 219     def search(self, cr, uid, args, offset=0, limit=None, order=None,
 220             context=None, count=False):
 221         if context is None:
 222             context = {}
 223         pos = 0
 224
 225         while pos < len(args):
 226
 227             if args[pos][0] == 'code' and args[pos][1] in ('like', 'ilike') and args[pos][2]:
 228                 args[pos] = ('code', '=like', str(args[pos][2].replace('%', ''))+'%')
 229             if args[pos][0] == 'journal_id':
 230                 if not args[pos][2]:
 231                     del args[pos]
 232                     continue
 233                 jour = self.pool.get('account.journal').browse(cr, uid, args[pos][2], context=context)
 234                 if (not (jour.account_control_ids or jour.type_control_ids)) or not args[pos][2]:
 235                     args[pos] = ('type','not in',('consolidation','view'))
 236                     continue
 237                 ids3 = map(lambda x: x.id, jour.type_control_ids)
 238                 ids1 = super(account_account, self).search(cr, uid, [('user_type', 'in', ids3)])
 239                 ids1 += map(lambda x: x.id, jour.account_control_ids)
 240                 args[pos] = ('id', 'in', ids1)
 241             pos += 1
 242
 243         if context and context.has_key('consolidate_children'): #add consolidated children of accounts
 244             ids = super(account_account, self).search(cr, uid, args, offset, limit,
 245                 order, context=context, count=count)
 246             for consolidate_child in self.browse(cr, uid, context['account_id'], context=context).child_consol_ids:
 247                 ids.append(consolidate_child.id)
 248             return ids
 249
 250         return super(account_account, self).search(cr, uid, args, offset, limit,
 251                 order, context=context, count=count)
 252
 253     def _get_children_and_consol(self, cr, uid, ids, context=None):
 254         #this function search for all the children and all consolidated children (recursively) of the given account ids
 255         ids2 = self.search(cr, uid, [('parent_id', 'child_of', ids)], context=context)
 256         ids3 = []
 257         for rec in self.browse(cr, uid, ids2, context=context):
 258             for child in rec.child_consol_ids:
 259                 ids3.append(child.id)
 260         if ids3:
 261             ids3 = self._get_children_and_consol(cr, uid, ids3, context)
 262         return ids2 + ids3
 263
 264     def __compute(self, cr, uid, ids, field_names, arg=None, context=None,
 265                   query='', query_params=()):
 266         """ compute the balance, debit and/or credit for the provided
 267         account ids
 268         Arguments:
 269         `ids`: account ids
 270         `field_names`: the fields to compute (a list of any of
 271                        'balance', 'debit' and 'credit')
 272         `arg`: unused fields.function stuff
 273         `query`: additional query filter (as a string)
 274         `query_params`: parameters for the provided query string
 275                         (__compute will handle their escaping) as a
 276                         tuple
 277         """
 278         mapping = {
 279             'balance': "COALESCE(SUM(l.debit),0) - COALESCE(SUM(l.credit), 0) as balance",
 280             'debit': "COALESCE(SUM(l.debit), 0) as debit",
 281             'credit': "COALESCE(SUM(l.credit), 0) as credit",
 282             # by convention, foreign_balance is 0 when the account has no secondary currency, because the amounts may be in different currencies
 283             'foreign_balance': "(SELECT CASE WHEN currency_id IS NULL THEN 0 ELSE COALESCE(SUM(l.amount_currency), 0) END FROM account_account WHERE id IN (l.account_id)) as foreign_balance",
 284         }
 285         #get all the necessary accounts
 286         children_and_consolidated = self._get_children_and_consol(cr, uid, ids, context=context)
 287         #compute for each account the balance/debit/credit from the move lines
 288         accounts = {}
 289         res = {}
 290         null_result = dict((fn, 0.0) for fn in field_names)
 291         if children_and_consolidated:
 292             aml_query = self.pool.get('account.move.line')._query_get(cr, uid, context=context)
 293
 294             wheres = [""]
 295             if query.strip():
 296                 wheres.append(query.strip())
 297             if aml_query.strip():
 298                 wheres.append(aml_query.strip())
 299             filters = " AND ".join(wheres)
 300             _logger.debug('Filters: %s',(filters))
 301             # IN might not work ideally in case there are too many
 302             # children_and_consolidated, in that case join on a
 303             # values() e.g.:
 304             # SELECT l.account_id as id FROM account_move_line l
 305             # INNER JOIN (VALUES (id1), (id2), (id3), ...) AS tmp (id)
 306             # ON l.account_id = tmp.id
 307             # or make _get_children_and_consol return a query and join on that
 308             request = ("SELECT l.account_id as id, " +\
 309                        ', '.join(mapping.values()) +
 310                        " FROM account_move_line l" \
 311                        " WHERE l.account_id IN %s " \
 312                             + filters +
 313                        " GROUP BY l.account_id")
 314             params = (tuple(children_and_consolidated),) + query_params
 315             cr.execute(request, params)
 316             _logger.debug('Status: %s',(cr.statusmessage))
 317
 318             for row in cr.dictfetchall():
 319                 accounts[row['id']] = row
 320
 321             # consolidate accounts with direct children
 322             children_and_consolidated.reverse()
 323             brs = list(self.browse(cr, uid, children_and_consolidated, context=context))
 324             sums = {}
 325             currency_obj = self.pool.get('res.currency')
 326             while brs:
 327                 current = brs.pop(0)
 328 #                can_compute = True
 329 #                for child in current.child_id:
 330 #                    if child.id not in sums:
 331 #                        can_compute = False
 332 #                        try:
 333 #                            brs.insert(0, brs.pop(brs.index(child)))
 334 #                        except ValueError:
 335 #                            brs.insert(0, child)
 336 #                if can_compute:
 337                 for fn in field_names:
 338                     sums.setdefault(current.id, {})[fn] = accounts.get(current.id, {}).get(fn, 0.0)
 339                     for child in current.child_id:
 340                         if child.company_id.currency_id.id == current.company_id.currency_id.id:
 341                             sums[current.id][fn] += sums[child.id][fn]
 342                         else:
 343                             sums[current.id][fn] += currency_obj.compute(cr, uid, child.company_id.currency_id.id, current.company_id.currency_id.id, sums[child.id][fn], context=context)
 344
 345                 # as we have to relay on values computed before this is calculated separately than previous fields
 346                 if current.currency_id and current.exchange_rate and \
 347                             ('adjusted_balance' in field_names or 'unrealized_gain_loss' in field_names):
 348                     # Computing Adjusted Balance and Unrealized Gains and losses
 349                     # Adjusted Balance = Foreign Balance / Exchange Rate
 350                     # Unrealized Gains and losses = Adjusted Balance - Balance
 351                     adj_bal = sums[current.id].get('foreign_balance', 0.0) / current.exchange_rate
 352                     sums[current.id].update({'adjusted_balance': adj_bal, 'unrealized_gain_loss': adj_bal - sums[current.id].get('balance', 0.0)})
 353
 354             for id in ids:
 355                 res[id] = sums.get(id, null_result)
 356         else:
 357             for id in ids:
 358                 res[id] = null_result
 359         return res
 360
 361     def _get_company_currency(self, cr, uid, ids, field_name, arg, context=None):
 362         result = {}
 363         for rec in self.browse(cr, uid, ids, context=context):
 364             result[rec.id] = (rec.company_id.currency_id.id,rec.company_id.currency_id.symbol)
 365         return result
 366
 367     def _get_child_ids(self, cr, uid, ids, field_name, arg, context=None):
 368         result = {}
 369         for record in self.browse(cr, uid, ids, context=context):
 370             if record.child_parent_ids:
 371                 result[record.id] = [x.id for x in record.child_parent_ids]
 372             else:
 373                 result[record.id] = []
 374
 375             if record.child_consol_ids:
 376                 for acc in record.child_consol_ids:
 377                     if acc.id not in result[record.id]:
 378                         result[record.id].append(acc.id)
 379
 380         return result
 381
 382     def _get_level(self, cr, uid, ids, field_name, arg, context=None):
 383         res = {}
 384         for account in self.browse(cr, uid, ids, context=context):
 385             #we may not know the level of the parent at the time of computation, so we
 386             # can't simply do res[account.id] = account.parent_id.level + 1
 387             level = 0
 388             parent = account.parent_id
 389             while parent:
 390                 level += 1
 391                 parent = parent.parent_id
 392             res[account.id] = level
 393         return res
 394
 395     def _set_credit_debit(self, cr, uid, account_id, name, value, arg, context=None):
 396         if context.get('config_invisible', True):
 397             return True
 398
 399         account = self.browse(cr, uid, account_id, context=context)
 400         diff = value - getattr(account,name)
 401         if not diff:
 402             return True
 403
 404         journal_obj = self.pool.get('account.journal')
 405         jids = journal_obj.search(cr, uid, [('type','=','situation'),('centralisation','=',1),('company_id','=',account.company_id.id)], context=context)
 406         if not jids:
 407             raise osv.except_osv(_('Error!'),_("You need an Opening journal with centralisation checked to set the initial balance."))
 408
 409         period_obj = self.pool.get('account.period')
 410         pids = period_obj.search(cr, uid, [('special','=',True),('company_id','=',account.company_id.id)], context=context)
 411         if not pids:
 412             raise osv.except_osv(_('Error!'),_("There is no opening/closing period defined, please create one to set the initial balance."))
 413
 414         move_obj = self.pool.get('account.move.line')
 415         move_id = move_obj.search(cr, uid, [
 416             ('journal_id','=',jids[0]),
 417             ('period_id','=',pids[0]),
 418             ('account_id','=', account_id),
 419             (name,'>', 0.0),
 420             ('name','=', _('Opening Balance'))
 421         ], context=context)
 422         if move_id:
 423             move = move_obj.browse(cr, uid, move_id[0], context=context)
 424             move_obj.write(cr, uid, move_id[0], {
 425                 name: diff+getattr(move,name)
 426             }, context=context)
 427         else:
 428             if diff<0.0:
 429                 raise osv.except_osv(_('Error!'),_("Unable to adapt the initial balance (negative value)."))
 430             nameinv = (name=='credit' and 'debit') or 'credit'
 431             move_id = move_obj.create(cr, uid, {
 432                 'name': _('Opening Balance'),
 433                 'account_id': account_id,
 434                 'journal_id': jids[0],
 435                 'period_id': pids[0],
 436                 name: diff,
 437                 nameinv: 0.0
 438             }, context=context)
 439         return True
 440
 441     _columns = {
 442         'name': fields.char('Name', size=256, required=True, select=True),
 443         'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
 444         'code': fields.char('Code', size=64, required=True, select=1),
 445         'type': fields.selection([
 446             ('view', 'View'),
 447             ('other', 'Regular'),
 448             ('receivable', 'Receivable'),
 449             ('payable', 'Payable'),
 450             ('liquidity','Liquidity'),
 451             ('consolidation', 'Consolidation'),
 452             ('closed', 'Closed'),
 453         ], 'Internal Type', required=True, help="The 'Internal Type' is used for features available on "\
 454             "different types of accounts: view can not have journal items, consolidation are accounts that "\
 455             "can have children accounts for multi-company consolidations, payable/receivable are for "\
 456             "partners accounts (for debit/credit computations), closed for depreciated accounts."),
 457         'user_type': fields.many2one('account.account.type', 'Account Type', required=True,
 458             help="Account Type is used for information purpose, to generate "
 459               "country-specific legal reports, and set the rules to close a fiscal year and generate opening entries."),
 460         'financial_report_ids': fields.many2many('account.financial.report', 'account_account_financial_report', 'account_id', 'report_line_id', 'Financial Reports'),
 461         'parent_id': fields.many2one('account.account', 'Parent', ondelete='cascade', domain=[('type','=','view')]),
 462         'child_parent_ids': fields.one2many('account.account','parent_id','Children'),
 463         'child_consol_ids': fields.many2many('account.account', 'account_account_consol_rel', 'child_id', 'parent_id', 'Consolidated Children'),
 464         'child_id': fields.function(_get_child_ids, type='many2many', relation="account.account", string="Child Accounts"),
 465         'balance': fields.function(__compute, digits_compute=dp.get_precision('Account'), string='Balance', multi='balance'),
 466         'credit': fields.function(__compute, fnct_inv=_set_credit_debit, digits_compute=dp.get_precision('Account'), string='Credit', multi='balance'),
 467         'debit': fields.function(__compute, fnct_inv=_set_credit_debit, digits_compute=dp.get_precision('Account'), string='Debit', multi='balance'),
 468         'foreign_balance': fields.function(__compute, digits_compute=dp.get_precision('Account'), string='Foreign Balance', multi='balance',
 469                                            help="Total amount (in Secondary currency) for transactions held in secondary currency for this account."),
 470         'adjusted_balance': fields.function(__compute, digits_compute=dp.get_precision('Account'), string='Adjusted Balance', multi='balance',
 471                                             help="Total amount (in Company currency) for transactions held in secondary currency for this account."),
 472         'unrealized_gain_loss': fields.function(__compute, digits_compute=dp.get_precision('Account'), string='Unrealized Gain or Loss', multi='balance',
 473                                                 help="Value of Loss or Gain due to changes in exchange rate when doing multi-currency transactions."),
 474         'reconcile': fields.boolean('Allow Reconciliation', help="Check this box if this account allows reconciliation of journal items."),
 475         'exchange_rate': fields.related('currency_id', 'rate', type='float', string='Exchange Rate', digits=(12,6)),
 476         'shortcut': fields.char('Shortcut', size=12),
 477         'tax_ids': fields.many2many('account.tax', 'account_account_tax_default_rel',
 478             'account_id', 'tax_id', 'Default Taxes'),
 479         'note': fields.text('Internal Notes'),
 480         'company_currency_id': fields.function(_get_company_currency, type='many2one', relation='res.currency', string='Company Currency'),
 481         'company_id': fields.many2one('res.company', 'Company', required=True),
 482         'active': fields.boolean('Active', select=2, help="If the active field is set to False, it will allow you to hide the account without removing it."),
 483
 484         'parent_left': fields.integer('Parent Left', select=1),
 485         'parent_right': fields.integer('Parent Right', select=1),
 486         'currency_mode': fields.selection([('current', 'At Date'), ('average', 'Average Rate')], 'Outgoing Currencies Rate',
 487             help=
 488             'This will select how the current currency rate for outgoing transactions is computed. '\
 489             'In most countries the legal method is "average" but only a few software systems are able to '\
 490             'manage this. So if you import from another software system you may have to use the rate at date. ' \
 491             'Incoming transactions always use the rate at date.', \
 492             required=True),
 493         'level': fields.function(_get_level, string='Level', method=True, type='integer',
 494              store={
 495                     'account.account': (_get_children_and_consol, ['level', 'parent_id'], 10),
 496                    }),
 497     }
 498
 499     _defaults = {
 500         'type': 'other',
 501         'reconcile': False,
 502         'active': True,
 503         'currency_mode': 'current',
 504         'company_id': lambda s, cr, uid, c: s.pool.get('res.company')._company_default_get(cr, uid, 'account.account', context=c),
 505     }
 506
 507     def _check_recursion(self, cr, uid, ids, context=None):
 508         obj_self = self.browse(cr, uid, ids[0], context=context)
 509         p_id = obj_self.parent_id and obj_self.parent_id.id
 510         if (obj_self in obj_self.child_consol_ids) or (p_id and (p_id is obj_self.id)):
 511             return False
 512         while(ids):
 513             cr.execute('SELECT DISTINCT child_id '\
 514                        'FROM account_account_consol_rel '\
 515                        'WHERE parent_id IN %s', (tuple(ids),))
 516             child_ids = map(itemgetter(0), cr.fetchall())
 517             c_ids = child_ids
 518             if (p_id and (p_id in c_ids)) or (obj_self.id in c_ids):
 519                 return False
 520             while len(c_ids):
 521                 s_ids = self.search(cr, uid, [('parent_id', 'in', c_ids)])
 522                 if p_id and (p_id in s_ids):
 523                     return False
 524                 c_ids = s_ids
 525             ids = child_ids
 526         return True
 527
 528     def _check_type(self, cr, uid, ids, context=None):
 529         if context is None:
 530             context = {}
 531         accounts = self.browse(cr, uid, ids, context=context)
 532         for account in accounts:
 533             if account.child_id and account.type not in ('view', 'consolidation'):
 534                 return False
 535         return True
 536
 537     def _check_account_type(self, cr, uid, ids, context=None):
 538         for account in self.browse(cr, uid, ids, context=context):
 539             if account.type in ('receivable', 'payable') and account.user_type.close_method != 'unreconciled':
 540                 return False
 541         return True
 542
 543     _constraints = [
 544         (_check_recursion, 'Error!\nYou cannot create recursive accounts.', ['parent_id']),
 545         (_check_type, 'Configuration Error!\nYou cannot define children to an account with internal type different of "View".', ['type']),
 546         (_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']),
 547     ]
 548     _sql_constraints = [
 549         ('code_company_uniq', 'unique (code,company_id)', 'The code of the account must be unique per company !')
 550     ]
 551     def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=100):
 552         if not args:
 553             args = []
 554         args = args[:]
 555         ids = []
 556         try:
 557             if name and str(name).startswith('partner:'):
 558                 part_id = int(name.split(':')[1])
 559                 part = self.pool.get('res.partner').browse(cr, user, part_id, context=context)
 560                 args += [('id', 'in', (part.property_account_payable.id, part.property_account_receivable.id))]
 561                 name = False
 562             if name and str(name).startswith('type:'):
 563                 type = name.split(':')[1]
 564                 args += [('type', '=', type)]
 565                 name = False
 566         except:
 567             pass
 568         if name:
 569             ids = self.search(cr, user, [('code', '=like', name+"%")]+args, limit=limit)
 570             if not ids:
 571                 ids = self.search(cr, user, [('shortcut', '=', name)]+ args, limit=limit)
 572             if not ids:
 573                 ids = self.search(cr, user, [('name', operator, name)]+ args, limit=limit)
 574             if not ids and len(name.split()) >= 2:
 575                 #Separating code and name of account for searching
 576                 operand1,operand2 = name.split(' ',1) #name can contain spaces e.g. OpenERP S.A.
 577                 ids = self.search(cr, user, [('code', operator, operand1), ('name', operator, operand2)]+ args, limit=limit)
 578         else:
 579             ids = self.search(cr, user, args, context=context, limit=limit)
 580         return self.name_get(cr, user, ids, context=context)
 581
 582     def name_get(self, cr, uid, ids, context=None):
 583         if not ids:
 584             return []
 585         if isinstance(ids, (int, long)):
 586                     ids = [ids]
 587         reads = self.read(cr, uid, ids, ['name', 'code'], context=context)
 588         res = []
 589         for record in reads:
 590             name = record['name']
 591             if record['code']:
 592                 name = record['code'] + ' ' + name
 593             res.append((record['id'], name))
 594         return res
 595
 596     def copy(self, cr, uid, id, default={}, context=None, done_list=[], local=False):
 597         account = self.browse(cr, uid, id, context=context)
 598         new_child_ids = []
 599         if not default:
 600             default = {}
 601         default = default.copy()
 602         default['code'] = (account['code'] or '') + '(copy)'
 603         if not local:
 604             done_list = []
 605         if account.id in done_list:
 606             return False
 607         done_list.append(account.id)
 608         if account:
 609             for child in account.child_id:
 610                 child_ids = self.copy(cr, uid, child.id, default, context=context, done_list=done_list, local=True)
 611                 if child_ids:
 612                     new_child_ids.append(child_ids)
 613             default['child_parent_ids'] = [(6, 0, new_child_ids)]
 614         else:
 615             default['child_parent_ids'] = False
 616         return super(account_account, self).copy(cr, uid, id, default, context=context)
 617
 618     def _check_moves(self, cr, uid, ids, method, context=None):
 619         line_obj = self.pool.get('account.move.line')
 620         account_ids = self.search(cr, uid, [('id', 'child_of', ids)])
 621
 622         if line_obj.search(cr, uid, [('account_id', 'in', account_ids)]):
 623             if method == 'write':
 624                 raise osv.except_osv(_('Error!'), _('You cannot deactivate an account that contains journal items.'))
 625             elif method == 'unlink':
 626                 raise osv.except_osv(_('Error!'), _('You cannot remove an account that contains journal items.'))
 627         #Checking whether the account is set as a property to any Partner or not
 628         value = 'account.account,' + str(ids[0])
 629         partner_prop_acc = self.pool.get('ir.property').search(cr, uid, [('value_reference','=',value)], context=context)
 630         if partner_prop_acc:
 631             raise osv.except_osv(_('Warning!'), _('You cannot remove/deactivate an account which is set on a customer or supplier.'))
 632         return True
 633
 634     def _check_allow_type_change(self, cr, uid, ids, new_type, context=None):
 635         group1 = ['payable', 'receivable', 'other']
 636         group2 = ['consolidation','view']
 637         line_obj = self.pool.get('account.move.line')
 638         for account in self.browse(cr, uid, ids, context=context):
 639             old_type = account.type
 640             account_ids = self.search(cr, uid, [('id', 'child_of', [account.id])])
 641             if line_obj.search(cr, uid, [('account_id', 'in', account_ids)]):
 642                 #Check for 'Closed' type
 643                 if old_type == 'closed' and new_type !='closed':
 644                     raise osv.except_osv(_('Warning!'), _("You cannot change the type of account from 'Closed' to any other type which contains journal items!"))
 645                 #Check for change From group1 to group2 and vice versa
 646                 if (old_type in group1 and new_type in group2) or (old_type in group2 and new_type in group1):
 647                     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,))
 648         return True
 649
 650     def write(self, cr, uid, ids, vals, context=None):
 651
 652         if context is None:
 653             context = {}
 654         if not ids:
 655             return True
 656         if isinstance(ids, (int, long)):
 657             ids = [ids]
 658
 659         # Dont allow changing the company_id when account_move_line already exist
 660         if 'company_id' in vals:
 661             move_lines = self.pool.get('account.move.line').search(cr, uid, [('account_id', 'in', ids)])
 662             if move_lines:
 663                 # Allow the write if the value is the same
 664                 for i in [i['company_id'][0] for i in self.read(cr,uid,ids,['company_id'])]:
 665                     if vals['company_id']!=i:
 666                         raise osv.except_osv(_('Warning!'), _('You cannot change the owner company of an account that already contains journal items.'))
 667         if 'active' in vals and not vals['active']:
 668             self._check_moves(cr, uid, ids, "write", context=context)
 669         if 'type' in vals.keys():
 670             self._check_allow_type_change(cr, uid, ids, vals['type'], context=context)
 671         return super(account_account, self).write(cr, uid, ids, vals, context=context)
 672
 673     def unlink(self, cr, uid, ids, context=None):
 674         self._check_moves(cr, uid, ids, "unlink", context=context)
 675         return super(account_account, self).unlink(cr, uid, ids, context=context)
 676
 677 account_account()
 678
 679 class account_journal_view(osv.osv):
 680     _name = "account.journal.view"
 681     _description = "Journal View"
 682     _columns = {
 683         'name': fields.char('Journal View', size=64, required=True),
 684         'columns_id': fields.one2many('account.journal.column', 'view_id', 'Columns')
 685     }
 686     _order = "name"
 687
 688 account_journal_view()
 689
 690
 691 class account_journal_column(osv.osv):
 692
 693     def _col_get(self, cr, user, context=None):
 694         result = []
 695         cols = self.pool.get('account.move.line')._columns
 696         for col in cols:
 697             if col in ('period_id', 'journal_id'):
 698                 continue
 699             result.append( (col, cols[col].string) )
 700         result.sort()
 701         return result
 702
 703     _name = "account.journal.column"
 704     _description = "Journal Column"
 705     _columns = {
 706         'name': fields.char('Column Name', size=64, required=True),
 707         'field': fields.selection(_col_get, 'Field Name', required=True, size=32),
 708         'view_id': fields.many2one('account.journal.view', 'Journal View', select=True),
 709         'sequence': fields.integer('Sequence', help="Gives the sequence order to journal column.", readonly=True),
 710         'required': fields.boolean('Required'),
 711         'readonly': fields.boolean('Readonly'),
 712     }
 713     _order = "view_id, sequence"
 714
 715 account_journal_column()
 716
 717 class account_journal(osv.osv):
 718     _name = "account.journal"
 719     _description = "Journal"
 720     _columns = {
 721         'with_last_closing_balance' : fields.boolean('Opening With Last Closing Balance'),
 722         'name': fields.char('Journal Name', size=64, required=True),
 723         'code': fields.char('Code', size=5, required=True, help="The code will be displayed on reports."),
 724         '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,
 725                                  help="Select 'Sale' for customer invoices journals."\
 726                                  " Select 'Purchase' for supplier invoices journals."\
 727                                  " Select 'Cash' or 'Bank' for journals that are used in customer or supplier payments."\
 728                                  " Select 'General' for miscellaneous operations journals."\
 729                                  " Select 'Opening/Closing Situation' for entries generated for new fiscal years."),
 730         'type_control_ids': fields.many2many('account.account.type', 'account_journal_type_rel', 'journal_id','type_id', 'Type Controls', domain=[('code','<>','view'), ('code', '<>', 'closed')]),
 731         'account_control_ids': fields.many2many('account.account', 'account_account_type_rel', 'journal_id','account_id', 'Account', domain=[('type','<>','view'), ('type', '<>', 'closed')]),
 732         '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."),
 733         'default_credit_account_id': fields.many2one('account.account', 'Default Credit Account', domain="[('type','!=','view')]", help="It acts as a default account for credit amount"),
 734         'default_debit_account_id': fields.many2one('account.account', 'Default Debit Account', domain="[('type','!=','view')]", help="It acts as a default account for debit amount"),
 735         '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."),
 736         '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"),
 737         '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."),
 738         '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),
 739         'user_id': fields.many2one('res.users', 'User', help="The user responsible for this journal"),
 740         'groups_id': fields.many2many('res.groups', 'account_journal_group_rel', 'journal_id', 'group_id', 'Groups'),
 741         'currency': fields.many2one('res.currency', 'Currency', help='The currency used to enter statement'),
 742         '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.'),
 743         'company_id': fields.many2one('res.company', 'Company', required=True, select=1, help="Company related to this journal"),
 744         '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'),
 745
 746         'profit_account_id' : fields.many2one('account.account', 'Profit Account'),
 747         'loss_account_id' : fields.many2one('account.account', 'Loss Account'),
 748         'internal_account_id' : fields.many2one('account.account', 'Internal Transfers Account', select=1),
 749         'cash_control' : fields.boolean('Cash Control', help='If you want the journal should be control at opening/closing, check this option'),
 750     }
 751
 752     _defaults = {
 753         'cash_control' : False,
 754         'with_last_closing_balance' : False,
 755         'user_id': lambda self, cr, uid, context: uid,
 756         'company_id': lambda self, cr, uid, c: self.pool.get('res.users').browse(cr, uid, uid, c).company_id.id,
 757     }
 758     _sql_constraints = [
 759         ('code_company_uniq', 'unique (code, company_id)', 'The code of the journal must be unique per company !'),
 760         ('name_company_uniq', 'unique (name, company_id)', 'The name of the journal must be unique per company !'),
 761     ]
 762
 763     _order = 'code'
 764
 765     def _check_currency(self, cr, uid, ids, context=None):
 766         for journal in self.browse(cr, uid, ids, context=context):
 767             if journal.currency:
 768                 if journal.default_credit_account_id and not journal.default_credit_account_id.currency_id.id == journal.currency.id:
 769                     return False
 770                 if journal.default_debit_account_id and not journal.default_debit_account_id.currency_id.id == journal.currency.id:
 771                     return False
 772         return True
 773
 774     _constraints = [
 775         (_check_currency, 'Configuration error!\nThe currency chosen should be shared by the default accounts too.', ['currency','default_debit_account_id','default_credit_account_id']),
 776     ]
 777
 778     def copy(self, cr, uid, id, default={}, context=None, done_list=[], local=False):
 779         journal = self.browse(cr, uid, id, context=context)
 780         if not default:
 781             default = {}
 782         default = default.copy()
 783         default['code'] = (journal['code'] or '') + '(copy)'
 784         default['name'] = (journal['name'] or '') + '(copy)'
 785         default['sequence_id'] = False
 786         return super(account_journal, self).copy(cr, uid, id, default, context=context)
 787
 788     def write(self, cr, uid, ids, vals, context=None):
 789         if context is None:
 790             context = {}
 791         if isinstance(ids, (int, long)):
 792             ids = [ids]
 793         for journal in self.browse(cr, uid, ids, context=context):
 794             if 'company_id' in vals and journal.company_id.id != vals['company_id']:
 795                 move_lines = self.pool.get('account.move.line').search(cr, uid, [('journal_id', 'in', ids)])
 796                 if move_lines:
 797                     raise osv.except_osv(_('Warning!'), _('This journal already contains items, therefore you cannot modify its company field.'))
 798         return super(account_journal, self).write(cr, uid, ids, vals, context=context)
 799
 800     def create_sequence(self, cr, uid, vals, context=None):
 801         """ Create new no_gap entry sequence for every new Joural
 802         """
 803         # in account.journal code is actually the prefix of the sequence
 804         # whereas ir.sequence code is a key to lookup global sequences.
 805         prefix = vals['code'].upper()
 806
 807         seq = {
 808             'name': vals['name'],
 809             'implementation':'no_gap',
 810             'prefix': prefix + "/%(year)s/",
 811             'padding': 4,
 812             'number_increment': 1
 813         }
 814         if 'company_id' in vals:
 815             seq['company_id'] = vals['company_id']
 816         return self.pool.get('ir.sequence').create(cr, uid, seq)
 817
 818     def create(self, cr, uid, vals, context=None):
 819         if not 'sequence_id' in vals or not vals['sequence_id']:
 820             # if we have the right to create a journal, we should be able to
 821             # create it's sequence.
 822             vals.update({'sequence_id': self.create_sequence(cr, 1, vals, context)})
 823         return super(account_journal, self).create(cr, uid, vals, context)
 824
 825     def name_get(self, cr, user, ids, context=None):
 826         """
 827         Returns a list of tupples containing id, name.
 828         result format: {[(id, name), (id, name), ...]}
 829
 830         @param cr: A database cursor
 831         @param user: ID of the user currently logged in
 832         @param ids: list of ids for which name should be read
 833         @param context: context arguments, like lang, time zone
 834
 835         @return: Returns a list of tupples containing id, name
 836         """
 837         if isinstance(ids, (int, long)):
 838             ids = [ids]
 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]['debit'] or 0.00)- (line[2]['credit'] or 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                         'reconcil_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, 1, '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 account_model()
2342
2343 class account_model_line(osv.osv):
2344     _name = "account.model.line"
2345     _description = "Account Model Entries"
2346     _columns = {
2347         'name': fields.char('Name', size=64, required=True),
2348         'sequence': fields.integer('Sequence', required=True, help="The sequence field is used to order the resources from lower sequences to higher ones."),
2349         'quantity': fields.float('Quantity', digits_compute=dp.get_precision('Account'), help="The optional quantity on entries."),
2350         'debit': fields.float('Debit', digits_compute=dp.get_precision('Account')),
2351         'credit': fields.float('Credit', digits_compute=dp.get_precision('Account')),
2352         'account_id': fields.many2one('account.account', 'Account', required=True, ondelete="cascade"),
2353         'analytic_account_id': fields.many2one('account.analytic.account', 'Analytic Account', ondelete="cascade"),
2354         'model_id': fields.many2one('account.model', 'Model', required=True, ondelete="cascade", select=True),
2355         'amount_currency': fields.float('Amount Currency', help="The amount expressed in an optional other currency."),
2356         'currency_id': fields.many2one('res.currency', 'Currency'),
2357         'partner_id': fields.many2one('res.partner', 'Partner'),
2358         '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."),
2359     }
2360     _order = 'sequence'
2361     _sql_constraints = [
2362         ('credit_debit1', 'CHECK (credit*debit=0)',  'Wrong credit or debit value in model, they must be positive!'),
2363         ('credit_debit2', 'CHECK (credit+debit>=0)', 'Wrong credit or debit value in model, they must be positive!'),
2364     ]
2365 account_model_line()
2366
2367 # ---------------------------------------------------------
2368 # Account Subscription
2369 # ---------------------------------------------------------
2370
2371
2372 class account_subscription(osv.osv):
2373     _name = "account.subscription"
2374     _description = "Account Subscription"
2375     _columns = {
2376         'name': fields.char('Name', size=64, required=True),
2377         'ref': fields.char('Reference', size=16),
2378         'model_id': fields.many2one('account.model', 'Model', required=True),
2379         'date_start': fields.date('Start Date', required=True),
2380         'period_total': fields.integer('Number of Periods', required=True),
2381         'period_nbr': fields.integer('Period', required=True),
2382         'period_type': fields.selection([('day','days'),('month','month'),('year','year')], 'Period Type', required=True),
2383         'state': fields.selection([('draft','Draft'),('running','Running'),('done','Done')], 'Status', required=True, readonly=True),
2384         'lines_id': fields.one2many('account.subscription.line', 'subscription_id', 'Subscription Lines')
2385     }
2386     _defaults = {
2387         'date_start': fields.date.context_today,
2388         'period_type': 'month',
2389         'period_total': 12,
2390         'period_nbr': 1,
2391         'state': 'draft',
2392     }
2393     def state_draft(self, cr, uid, ids, context=None):
2394         self.write(cr, uid, ids, {'state':'draft'})
2395         return False
2396
2397     def check(self, cr, uid, ids, context=None):
2398         todone = []
2399         for sub in self.browse(cr, uid, ids, context=context):
2400             ok = True
2401             for line in sub.lines_id:
2402                 if not line.move_id.id:
2403                     ok = False
2404                     break
2405             if ok:
2406                 todone.append(sub.id)
2407         if todone:
2408             self.write(cr, uid, todone, {'state':'done'})
2409         return False
2410
2411     def remove_line(self, cr, uid, ids, context=None):
2412         toremove = []
2413         for sub in self.browse(cr, uid, ids, context=context):
2414             for line in sub.lines_id:
2415                 if not line.move_id.id:
2416                     toremove.append(line.id)
2417         if toremove:
2418             self.pool.get('account.subscription.line').unlink(cr, uid, toremove)
2419         self.write(cr, uid, ids, {'state':'draft'})
2420         return False
2421
2422     def compute(self, cr, uid, ids, context=None):
2423         for sub in self.browse(cr, uid, ids, context=context):
2424             ds = sub.date_start
2425             for i in range(sub.period_total):
2426                 self.pool.get('account.subscription.line').create(cr, uid, {
2427                     'date': ds,
2428                     'subscription_id': sub.id,
2429                 })
2430                 if sub.period_type=='day':
2431                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(days=sub.period_nbr)).strftime('%Y-%m-%d')
2432                 if sub.period_type=='month':
2433                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(months=sub.period_nbr)).strftime('%Y-%m-%d')
2434                 if sub.period_type=='year':
2435                     ds = (datetime.strptime(ds, '%Y-%m-%d') + relativedelta(years=sub.period_nbr)).strftime('%Y-%m-%d')
2436         self.write(cr, uid, ids, {'state':'running'})
2437         return True
2438
2439 account_subscription()
2440
2441 class account_subscription_line(osv.osv):
2442     _name = "account.subscription.line"
2443     _description = "Account Subscription Line"
2444     _columns = {
2445         'subscription_id': fields.many2one('account.subscription', 'Subscription', required=True, select=True),
2446         'date': fields.date('Date', required=True),
2447         'move_id': fields.many2one('account.move', 'Entry'),
2448     }
2449
2450     def move_create(self, cr, uid, ids, context=None):
2451         tocheck = {}
2452         all_moves = []
2453         obj_model = self.pool.get('account.model')
2454         for line in self.browse(cr, uid, ids, context=context):
2455             datas = {
2456                 'date': line.date,
2457             }
2458             move_ids = obj_model.generate(cr, uid, [line.subscription_id.model_id.id], datas, context)
2459             tocheck[line.subscription_id.id] = True
2460             self.write(cr, uid, [line.id], {'move_id':move_ids[0]})
2461             all_moves.extend(move_ids)
2462         if tocheck:
2463             self.pool.get('account.subscription').check(cr, uid, tocheck.keys(), context)
2464         return all_moves
2465
2466     _rec_name = 'date'
2467
2468 account_subscription_line()
2469
2470 #  ---------------------------------------------------------------
2471 #   Account Templates: Account, Tax, Tax Code and chart. + Wizard
2472 #  ---------------------------------------------------------------
2473
2474 class account_tax_template(osv.osv):
2475     _name = 'account.tax.template'
2476 account_tax_template()
2477
2478 class account_account_template(osv.osv):
2479     _order = "code"
2480     _name = "account.account.template"
2481     _description ='Templates for Accounts'
2482
2483     _columns = {
2484         'name': fields.char('Name', size=256, required=True, select=True),
2485         'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
2486         'code': fields.char('Code', size=64, required=True, select=1),
2487         'type': fields.selection([
2488             ('receivable','Receivable'),
2489             ('payable','Payable'),
2490             ('view','View'),
2491             ('consolidation','Consolidation'),
2492             ('liquidity','Liquidity'),
2493             ('other','Regular'),
2494             ('closed','Closed'),
2495             ], 'Internal Type', required=True,help="This type is used to differentiate types with "\
2496             "special effects in OpenERP: view can not have entries, consolidation are accounts that "\
2497             "can have children accounts for multi-company consolidations, payable/receivable are for "\
2498             "partners accounts (for debit/credit computations), closed for depreciated accounts."),
2499         'user_type': fields.many2one('account.account.type', 'Account Type', required=True,
2500             help="These types are defined according to your country. The type contains more information "\
2501             "about the account and its specificities."),
2502         'financial_report_ids': fields.many2many('account.financial.report', 'account_template_financial_report', 'account_template_id', 'report_line_id', 'Financial Reports'),
2503         'reconcile': fields.boolean('Allow Reconciliation', help="Check this option if you want the user to reconcile entries in this account."),
2504         'shortcut': fields.char('Shortcut', size=12),
2505         'note': fields.text('Note'),
2506         'parent_id': fields.many2one('account.account.template', 'Parent Account Template', ondelete='cascade'),
2507         'child_parent_ids':fields.one2many('account.account.template', 'parent_id', 'Children'),
2508         'tax_ids': fields.many2many('account.tax.template', 'account_account_template_tax_rel', 'account_id', 'tax_id', 'Default Taxes'),
2509         'nocreate': fields.boolean('Optional create', help="If checked, the new chart of accounts will not contain this by default."),
2510         '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)."),
2511     }
2512
2513     _defaults = {
2514         'reconcile': False,
2515         'type': 'view',
2516         'nocreate': False,
2517     }
2518
2519     def _check_type(self, cr, uid, ids, context=None):
2520         if context is None:
2521             context = {}
2522         accounts = self.browse(cr, uid, ids, context=context)
2523         for account in accounts:
2524             if account.parent_id and account.parent_id.type != 'view':
2525                 return False
2526         return True
2527
2528     _check_recursion = check_cycle
2529     _constraints = [
2530         (_check_recursion, 'Error!\nYou cannot create recursive account templates.', ['parent_id']),
2531         (_check_type, 'Configuration Error!\nYou cannot define children to an account that has internal type other than  "View".', ['type']),
2532
2533     ]
2534
2535     def name_get(self, cr, uid, ids, context=None):
2536         if not ids:
2537             return []
2538         reads = self.read(cr, uid, ids, ['name','code'], context=context)
2539         res = []
2540         for record in reads:
2541             name = record['name']
2542             if record['code']:
2543                 name = record['code']+' '+name
2544             res.append((record['id'],name ))
2545         return res
2546
2547     def generate_account(self, cr, uid, chart_template_id, tax_template_ref, acc_template_ref, code_digits, company_id, context=None):
2548         """
2549         This method for generating accounts from templates.
2550
2551         :param chart_template_id: id of the chart template chosen in the wizard
2552         :param tax_template_ref: Taxes templates reference for write taxes_id in account_account.
2553         :paramacc_template_ref: dictionary with the mappping between the account templates and the real accounts.
2554         :param code_digits: number of digits got from wizard.multi.charts.accounts, this is use for account code.
2555         :param company_id: company_id selected from wizard.multi.charts.accounts.
2556         :returns: return acc_template_ref for reference purpose.
2557         :rtype: dict
2558         """
2559         if context is None:
2560             context = {}
2561         obj_acc = self.pool.get('account.account')
2562         company_name = self.pool.get('res.company').browse(cr, uid, company_id, context=context).name
2563         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
2564         #deactivate the parent_store functionnality on account_account for rapidity purpose
2565         ctx = context.copy()
2566         ctx.update({'defer_parent_store_computation': True})
2567         level_ref = {}
2568         children_acc_criteria = [('chart_template_id','=', chart_template_id)]
2569         if template.account_root_id.id:
2570             children_acc_criteria = ['|'] + children_acc_criteria + ['&',('parent_id','child_of', [template.account_root_id.id]),('chart_template_id','=', False)]
2571         children_acc_template = self.search(cr, uid, [('nocreate','!=',True)] + children_acc_criteria, order='id')
2572         for account_template in self.browse(cr, uid, children_acc_template, context=context):
2573             # skip the root of COA if it's not the main one
2574             if (template.account_root_id.id == account_template.id) and template.parent_id:
2575                 continue
2576             tax_ids = []
2577             for tax in account_template.tax_ids:
2578                 tax_ids.append(tax_template_ref[tax.id])
2579
2580             code_main = account_template.code and len(account_template.code) or 0
2581             code_acc = account_template.code or ''
2582             if code_main > 0 and code_main <= code_digits and account_template.type != 'view':
2583                 code_acc = str(code_acc) + (str('0'*(code_digits-code_main)))
2584             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
2585             #the level as to be given as well at the creation time, because of the defer_parent_store_computation in
2586             #context. Indeed because of this, the parent_left and parent_right are not computed and thus the child_of
2587             #operator does not return the expected values, with result of having the level field not computed at all.
2588             if parent_id:
2589                 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
2590             else:
2591                 level = 0
2592             vals={
2593                 'name': (template.account_root_id.id == account_template.id) and company_name or account_template.name,
2594                 'currency_id': account_template.currency_id and account_template.currency_id.id or False,
2595                 'code': code_acc,
2596                 'type': account_template.type,
2597                 'user_type': account_template.user_type and account_template.user_type.id or False,
2598                 'reconcile': account_template.reconcile,
2599                 'shortcut': account_template.shortcut,
2600                 'note': account_template.note,
2601                 'financial_report_ids': account_template.financial_report_ids and [(6,0,[x.id for x in account_template.financial_report_ids])] or False,
2602                 'parent_id': parent_id,
2603                 'tax_ids': [(6,0,tax_ids)],
2604                 'company_id': company_id,
2605                 'level': level,
2606             }
2607             new_account = obj_acc.create(cr, uid, vals, context=ctx)
2608             acc_template_ref[account_template.id] = new_account
2609             level_ref[new_account] = level
2610
2611         #reactivate the parent_store functionnality on account_account
2612         obj_acc._parent_store_compute(cr)
2613         return acc_template_ref
2614
2615 account_account_template()
2616
2617 class account_add_tmpl_wizard(osv.osv_memory):
2618     """Add one more account from the template.
2619
2620     With the 'nocreate' option, some accounts may not be created. Use this to add them later."""
2621     _name = 'account.addtmpl.wizard'
2622
2623     def _get_def_cparent(self, cr, uid, context=None):
2624         acc_obj = self.pool.get('account.account')
2625         tmpl_obj = self.pool.get('account.account.template')
2626         tids = tmpl_obj.read(cr, uid, [context['tmpl_ids']], ['parent_id'])
2627         if not tids or not tids[0]['parent_id']:
2628             return False
2629         ptids = tmpl_obj.read(cr, uid, [tids[0]['parent_id'][0]], ['code'])
2630         res = None
2631         if not ptids or not ptids[0]['code']:
2632             raise osv.except_osv(_('Error!'), _('There is no parent code for the template account.'))
2633             res = acc_obj.search(cr, uid, [('code','=',ptids[0]['code'])])
2634         return res and res[0] or False
2635
2636     _columns = {
2637         'cparent_id':fields.many2one('account.account', 'Parent target', help="Creates an account with the selected template under this existing parent.", required=True),
2638     }
2639     _defaults = {
2640         'cparent_id': _get_def_cparent,
2641     }
2642
2643     def action_create(self,cr,uid,ids,context=None):
2644         if context is None:
2645             context = {}
2646         acc_obj = self.pool.get('account.account')
2647         tmpl_obj = self.pool.get('account.account.template')
2648         data = self.read(cr, uid, ids)[0]
2649         company_id = acc_obj.read(cr, uid, [data['cparent_id'][0]], ['company_id'])[0]['company_id'][0]
2650         account_template = tmpl_obj.browse(cr, uid, context['tmpl_ids'])
2651         vals = {
2652             'name': account_template.name,
2653             'currency_id': account_template.currency_id and account_template.currency_id.id or False,
2654             'code': account_template.code,
2655             'type': account_template.type,
2656             'user_type': account_template.user_type and account_template.user_type.id or False,
2657             'reconcile': account_template.reconcile,
2658             'shortcut': account_template.shortcut,
2659             'note': account_template.note,
2660             'parent_id': data['cparent_id'][0],
2661             'company_id': company_id,
2662             }
2663         acc_obj.create(cr, uid, vals)
2664         return {'type':'state', 'state': 'end' }
2665
2666     def action_cancel(self, cr, uid, ids, context=None):
2667         return { 'type': 'state', 'state': 'end' }
2668
2669 account_add_tmpl_wizard()
2670
2671 class account_tax_code_template(osv.osv):
2672
2673     _name = 'account.tax.code.template'
2674     _description = 'Tax Code Template'
2675     _order = 'code'
2676     _rec_name = 'code'
2677     _columns = {
2678         'name': fields.char('Tax Case Name', size=64, required=True),
2679         'code': fields.char('Case Code', size=64),
2680         'info': fields.text('Description'),
2681         'parent_id': fields.many2one('account.tax.code.template', 'Parent Code', select=True),
2682         'child_ids': fields.one2many('account.tax.code.template', 'parent_id', 'Child Codes'),
2683         'sign': fields.float('Sign For Parent', required=True),
2684         '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."),
2685     }
2686
2687     _defaults = {
2688         'sign': 1.0,
2689         'notprintable': False,
2690     }
2691
2692     def generate_tax_code(self, cr, uid, tax_code_root_id, company_id, context=None):
2693         '''
2694         This function generates the tax codes from the templates of tax code that are children of the given one passed
2695         in argument. Then it returns a dictionary with the mappping between the templates and the real objects.
2696
2697         :param tax_code_root_id: id of the root of all the tax code templates to process
2698         :param company_id: id of the company the wizard is running for
2699         :returns: dictionary with the mappping between the templates and the real objects.
2700         :rtype: dict
2701         '''
2702         obj_tax_code_template = self.pool.get('account.tax.code.template')
2703         obj_tax_code = self.pool.get('account.tax.code')
2704         tax_code_template_ref = {}
2705         company = self.pool.get('res.company').browse(cr, uid, company_id, context=context)
2706
2707         #find all the children of the tax_code_root_id
2708         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 []
2709         for tax_code_template in obj_tax_code_template.browse(cr, uid, children_tax_code_template, context=context):
2710             vals = {
2711                 'name': (tax_code_root_id == tax_code_template.id) and company.name or tax_code_template.name,
2712                 'code': tax_code_template.code,
2713                 'info': tax_code_template.info,
2714                 '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,
2715                 'company_id': company_id,
2716                 'sign': tax_code_template.sign,
2717             }
2718             #check if this tax code already exists
2719             rec_list = obj_tax_code.search(cr, uid, [('name', '=', vals['name']),('code', '=', vals['code']),('company_id', '=', vals['company_id'])], context=context)
2720             if not rec_list:
2721                 #if not yet, create it
2722                 new_tax_code = obj_tax_code.create(cr, uid, vals)
2723                 #recording the new tax code to do the mapping
2724                 tax_code_template_ref[tax_code_template.id] = new_tax_code
2725         return tax_code_template_ref
2726
2727     def name_get(self, cr, uid, ids, context=None):
2728         if not ids:
2729             return []
2730         if isinstance(ids, (int, long)):
2731             ids = [ids]
2732         reads = self.read(cr, uid, ids, ['name','code'], context, load='_classic_write')
2733         return [(x['id'], (x['code'] and x['code'] + ' - ' or '') + x['name']) \
2734                 for x in reads]
2735
2736     _check_recursion = check_cycle
2737     _constraints = [
2738         (_check_recursion, 'Error!\nYou cannot create recursive Tax Codes.', ['parent_id'])
2739     ]
2740     _order = 'code,name'
2741 account_tax_code_template()
2742
2743
2744 class account_chart_template(osv.osv):
2745     _name="account.chart.template"
2746     _description= "Templates for Account Chart"
2747
2748     _columns={
2749         'name': fields.char('Name', size=64, required=True),
2750         'parent_id': fields.many2one('account.chart.template', 'Parent Chart Template'),
2751         'code_digits': fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
2752         '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."),
2753         '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'),
2754         'account_root_id': fields.many2one('account.account.template', 'Root Account', domain=[('parent_id','=',False)]),
2755         'tax_code_root_id': fields.many2one('account.tax.code.template', 'Root Tax Code', domain=[('parent_id','=',False)]),
2756         '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'),
2757         'bank_account_view_id': fields.many2one('account.account.template', 'Bank Account'),
2758         'property_account_receivable': fields.many2one('account.account.template', 'Receivable Account'),
2759         'property_account_payable': fields.many2one('account.account.template', 'Payable Account'),
2760         'property_account_expense_categ': fields.many2one('account.account.template', 'Expense Category Account'),
2761         'property_account_income_categ': fields.many2one('account.account.template', 'Income Category Account'),
2762         'property_account_expense': fields.many2one('account.account.template', 'Expense Account on Product Template'),
2763         'property_account_income': fields.many2one('account.account.template', 'Income Account on Product Template'),
2764         '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'),
2765         'property_account_income_opening': fields.many2one('account.account.template', 'Opening Entries Income Account'),
2766         'property_account_expense_opening': fields.many2one('account.account.template', 'Opening Entries Expense Account'),
2767     }
2768
2769     _defaults = {
2770         'visible': True,
2771         'code_digits': 6,
2772         'complete_tax_set': True,
2773     }
2774
2775 account_chart_template()
2776
2777 class account_tax_template(osv.osv):
2778
2779     _name = 'account.tax.template'
2780     _description = 'Templates for Taxes'
2781
2782     _columns = {
2783         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
2784         'name': fields.char('Tax Name', size=64, required=True),
2785         '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."),
2786         'amount': fields.float('Amount', required=True, digits=(14,4), help="For Tax Type percent enter % ratio between 0-1."),
2787         'type': fields.selection( [('percent','Percent'), ('fixed','Fixed'), ('none','None'), ('code','Python Code'), ('balance','Balance')], 'Tax Type', required=True),
2788         '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."),
2789         '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."),
2790         'account_collected_id':fields.many2one('account.account.template', 'Invoice Tax Account'),
2791         'account_paid_id':fields.many2one('account.account.template', 'Refund Tax Account'),
2792         'parent_id':fields.many2one('account.tax.template', 'Parent Tax Account', select=True),
2793         '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."),
2794         'python_compute':fields.text('Python Code'),
2795         'python_compute_inv':fields.text('Python Code (reverse)'),
2796         'python_applicable':fields.text('Python Code'),
2797
2798         #
2799         # Fields used for the Tax declaration
2800         #
2801         'base_code_id': fields.many2one('account.tax.code.template', 'Base Code', help="Use this code for the tax declaration."),
2802         'tax_code_id': fields.many2one('account.tax.code.template', 'Tax Code', help="Use this code for the tax declaration."),
2803         'base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
2804         'tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
2805
2806         # Same fields for refund invoices
2807
2808         'ref_base_code_id': fields.many2one('account.tax.code.template', 'Refund Base Code', help="Use this code for the tax declaration."),
2809         'ref_tax_code_id': fields.many2one('account.tax.code.template', 'Refund Tax Code', help="Use this code for the tax declaration."),
2810         'ref_base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
2811         'ref_tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
2812         '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."),
2813         'description': fields.char('Internal Name', size=32),
2814         'type_tax_use': fields.selection([('sale','Sale'),('purchase','Purchase'),('all','All')], 'Tax Use In', required=True,),
2815         'price_include': fields.boolean('Tax Included in Price', help="Check this if the price you use on the product and invoices includes this tax."),
2816     }
2817
2818     def name_get(self, cr, uid, ids, context=None):
2819         if not ids:
2820             return []
2821         res = []
2822         for record in self.read(cr, uid, ids, ['description','name'], context=context):
2823             name = record['description'] and record['description'] or record['name']
2824             res.append((record['id'],name ))
2825         return res
2826
2827     def _default_company(self, cr, uid, context=None):
2828         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
2829         if user.company_id:
2830             return user.company_id.id
2831         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
2832
2833     _defaults = {
2834         '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''',
2835         'python_compute_inv': lambda *a: '''# price_unit\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
2836         'applicable_type': 'true',
2837         'type': 'percent',
2838         'amount': 0,
2839         'sequence': 1,
2840         'ref_tax_sign': 1,
2841         'ref_base_sign': 1,
2842         'tax_sign': 1,
2843         'base_sign': 1,
2844         'include_base_amount': False,
2845         'type_tax_use': 'all',
2846         'price_include': 0,
2847     }
2848     _order = 'sequence'
2849
2850     def _generate_tax(self, cr, uid, tax_templates, tax_code_template_ref, company_id, context=None):
2851         """
2852         This method generate taxes from templates.
2853
2854         :param tax_templates: list of browse record of the tax templates to process
2855         :param tax_code_template_ref: Taxcode templates reference.
2856         :param company_id: id of the company the wizard is running for
2857         :returns:
2858             {
2859             'tax_template_to_tax': mapping between tax template and the newly generated taxes corresponding,
2860             'account_dict': dictionary containing a to-do list with all the accounts to assign on new taxes
2861             }
2862         """
2863         if context is None:
2864             context = {}
2865         res = {}
2866         todo_dict = {}
2867         tax_template_to_tax = {}
2868         for tax in tax_templates:
2869             vals_tax = {
2870                 'name':tax.name,
2871                 'sequence': tax.sequence,
2872                 'amount': tax.amount,
2873                 'type': tax.type,
2874                 'applicable_type': tax.applicable_type,
2875                 'domain': tax.domain,
2876                 '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,
2877                 'child_depend': tax.child_depend,
2878                 'python_compute': tax.python_compute,
2879                 'python_compute_inv': tax.python_compute_inv,
2880                 'python_applicable': tax.python_applicable,
2881                 '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,
2882                 '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,
2883                 'base_sign': tax.base_sign,
2884                 'tax_sign': tax.tax_sign,
2885                 '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,
2886                 '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,
2887                 'ref_base_sign': tax.ref_base_sign,
2888                 'ref_tax_sign': tax.ref_tax_sign,
2889                 'include_base_amount': tax.include_base_amount,
2890                 'description': tax.description,
2891                 'company_id': company_id,
2892                 'type_tax_use': tax.type_tax_use,
2893                 'price_include': tax.price_include
2894             }
2895             new_tax = self.pool.get('account.tax').create(cr, uid, vals_tax)
2896             tax_template_to_tax[tax.id] = new_tax
2897             #as the accounts have not been created yet, we have to wait before filling these fields
2898             todo_dict[new_tax] = {
2899                 'account_collected_id': tax.account_collected_id and tax.account_collected_id.id or False,
2900                 'account_paid_id': tax.account_paid_id and tax.account_paid_id.id or False,
2901             }
2902         res.update({'tax_template_to_tax': tax_template_to_tax, 'account_dict': todo_dict})
2903         return res
2904
2905 account_tax_template()
2906
2907 # Fiscal Position Templates
2908
2909 class account_fiscal_position_template(osv.osv):
2910     _name = 'account.fiscal.position.template'
2911     _description = 'Template for Fiscal Position'
2912
2913     _columns = {
2914         'name': fields.char('Fiscal Position Template', size=64, required=True),
2915         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
2916         'account_ids': fields.one2many('account.fiscal.position.account.template', 'position_id', 'Account Mapping'),
2917         'tax_ids': fields.one2many('account.fiscal.position.tax.template', 'position_id', 'Tax Mapping'),
2918         'note': fields.text('Notes', translate=True),
2919     }
2920
2921     def generate_fiscal_position(self, cr, uid, chart_temp_id, tax_template_ref, acc_template_ref, company_id, context=None):
2922         """
2923         This method generate Fiscal Position, Fiscal Position Accounts and Fiscal Position Taxes from templates.
2924
2925         :param chart_temp_id: Chart Template Id.
2926         :param taxes_ids: Taxes templates reference for generating account.fiscal.position.tax.
2927         :param acc_template_ref: Account templates reference for generating account.fiscal.position.account.
2928         :param company_id: company_id selected from wizard.multi.charts.accounts.
2929         :returns: True
2930         """
2931         if context is None:
2932             context = {}
2933         obj_tax_fp = self.pool.get('account.fiscal.position.tax')
2934         obj_ac_fp = self.pool.get('account.fiscal.position.account')
2935         obj_fiscal_position = self.pool.get('account.fiscal.position')
2936         fp_ids = self.search(cr, uid, [('chart_template_id', '=', chart_temp_id)])
2937         for position in self.browse(cr, uid, fp_ids, context=context):
2938             new_fp = obj_fiscal_position.create(cr, uid, {'company_id': company_id, 'name': position.name, 'note': position.note})
2939             for tax in position.tax_ids:
2940                 obj_tax_fp.create(cr, uid, {
2941                     'tax_src_id': tax_template_ref[tax.tax_src_id.id],
2942                     'tax_dest_id': tax.tax_dest_id and tax_template_ref[tax.tax_dest_id.id] or False,
2943                     'position_id': new_fp
2944                 })
2945             for acc in position.account_ids:
2946                 obj_ac_fp.create(cr, uid, {
2947                     'account_src_id': acc_template_ref[acc.account_src_id.id],
2948                     'account_dest_id': acc_template_ref[acc.account_dest_id.id],
2949                     'position_id': new_fp
2950                 })
2951         return True
2952
2953 account_fiscal_position_template()
2954
2955 class account_fiscal_position_tax_template(osv.osv):
2956     _name = 'account.fiscal.position.tax.template'
2957     _description = 'Template Tax Fiscal Position'
2958     _rec_name = 'position_id'
2959
2960     _columns = {
2961         'position_id': fields.many2one('account.fiscal.position.template', 'Fiscal Position', required=True, ondelete='cascade'),
2962         'tax_src_id': fields.many2one('account.tax.template', 'Tax Source', required=True),
2963         'tax_dest_id': fields.many2one('account.tax.template', 'Replacement Tax')
2964     }
2965
2966 account_fiscal_position_tax_template()
2967
2968 class account_fiscal_position_account_template(osv.osv):
2969     _name = 'account.fiscal.position.account.template'
2970     _description = 'Template Account Fiscal Mapping'
2971     _rec_name = 'position_id'
2972     _columns = {
2973         'position_id': fields.many2one('account.fiscal.position.template', 'Fiscal Mapping', required=True, ondelete='cascade'),
2974         'account_src_id': fields.many2one('account.account.template', 'Account Source', domain=[('type','<>','view')], required=True),
2975         'account_dest_id': fields.many2one('account.account.template', 'Account Destination', domain=[('type','<>','view')], required=True)
2976     }
2977
2978 account_fiscal_position_account_template()
2979
2980 # ---------------------------------------------------------
2981 # Account generation from template wizards
2982 # ---------------------------------------------------------
2983
2984 class wizard_multi_charts_accounts(osv.osv_memory):
2985     """
2986     Create a new account chart for a company.
2987     Wizards ask for:
2988         * a company
2989         * an account chart template
2990         * a number of digits for formatting code of non-view accounts
2991         * a list of bank accounts owned by the company
2992     Then, the wizard:
2993         * generates all accounts from the template and assigns them to the right company
2994         * generates all taxes and tax codes, changing account assignations
2995         * generates all accounting properties and assigns them correctly
2996     """
2997     _name='wizard.multi.charts.accounts'
2998     _inherit = 'res.config'
2999
3000     _columns = {
3001         'company_id':fields.many2one('res.company', 'Company', required=True),
3002         'only_one_chart_template': fields.boolean('Only One Chart Template Available'),
3003         'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
3004         'bank_accounts_id': fields.one2many('account.bank.accounts.wizard', 'bank_account_id', 'Cash and Banks', required=True),
3005         'code_digits':fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
3006         "sale_tax": fields.many2one("account.tax.template", "Default Sale Tax"),
3007         "purchase_tax": fields.many2one("account.tax.template", "Default Purchase Tax"),
3008         'sale_tax_rate': fields.float('Sales Tax(%)'),
3009         'purchase_tax_rate': fields.float('Purchase Tax(%)'),
3010         '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'),
3011     }
3012     def onchange_tax_rate(self, cr, uid, ids, rate=False, context=None):
3013         return {'value': {'purchase_tax_rate': rate or False}}
3014
3015     def onchange_chart_template_id(self, cr, uid, ids, chart_template_id=False, context=None):
3016         res = {}
3017         tax_templ_obj = self.pool.get('account.tax.template')
3018         res['value'] = {'complete_tax_set': False, 'sale_tax': False, 'purchase_tax': False}
3019         if chart_template_id:
3020             data = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3021             res['value'].update({'complete_tax_set': data.complete_tax_set})
3022             if data.complete_tax_set:
3023             # 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
3024                 sale_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3025                                               , "=", chart_template_id), ('type_tax_use', 'in', ('sale','all'))], order="sequence, id desc")
3026                 purchase_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3027                                               , "=", chart_template_id), ('type_tax_use', 'in', ('purchase','all'))], order="sequence, id desc")
3028                 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})
3029
3030             if data.code_digits:
3031                res['value'].update({'code_digits': data.code_digits})
3032         return res
3033
3034     def default_get(self, cr, uid, fields, context=None):
3035         res = super(wizard_multi_charts_accounts, self).default_get(cr, uid, fields, context=context)
3036         tax_templ_obj = self.pool.get('account.tax.template')
3037
3038         if 'bank_accounts_id' in fields:
3039             res.update({'bank_accounts_id': [{'acc_name': _('Cash'), 'account_type': 'cash'},{'acc_name': _('Bank'), 'account_type': 'bank'}]})
3040         if 'company_id' in fields:
3041             res.update({'company_id': self.pool.get('res.users').browse(cr, uid, [uid], context=context)[0].company_id.id})
3042
3043         ids = self.pool.get('account.chart.template').search(cr, uid, [('visible', '=', True)], context=context)
3044         if ids:
3045             if 'chart_template_id' in fields:
3046                 res.update({'only_one_chart_template': len(ids) == 1, 'chart_template_id': ids[0]})
3047             if 'sale_tax' in fields:
3048                 sale_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3049                                               , "=", ids[0]), ('type_tax_use', 'in', ('sale','all'))], order="sequence")
3050                 res.update({'sale_tax': sale_tax_ids and sale_tax_ids[0] or False})
3051             if 'purchase_tax' in fields:
3052                 purchase_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
3053                                           , "=", ids[0]), ('type_tax_use', 'in', ('purchase','all'))], order="sequence")
3054                 res.update({'purchase_tax': purchase_tax_ids and purchase_tax_ids[0] or False})
3055         res.update({
3056             'purchase_tax_rate': 15.0,
3057             'sale_tax_rate': 15.0,
3058         })
3059         return res
3060
3061     def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
3062         if context is None:context = {}
3063         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)
3064         cmp_select = []
3065         acc_template_obj = self.pool.get('account.chart.template')
3066         company_obj = self.pool.get('res.company')
3067
3068         company_ids = company_obj.search(cr, uid, [], context=context)
3069         #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)
3070         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",))
3071         configured_cmp = [r[0] for r in cr.fetchall()]
3072         unconfigured_cmp = list(set(company_ids)-set(configured_cmp))
3073         for field in res['fields']:
3074             if field == 'company_id':
3075                 res['fields'][field]['domain'] = [('id','in',unconfigured_cmp)]
3076                 res['fields'][field]['selection'] = [('', '')]
3077                 if unconfigured_cmp:
3078                     cmp_select = [(line.id, line.name) for line in company_obj.browse(cr, uid, unconfigured_cmp)]
3079                     res['fields'][field]['selection'] = cmp_select
3080         return res
3081
3082     def check_created_journals(self, cr, uid, vals_journal, company_id, context=None):
3083         """
3084         This method used for checking journals already created or not. If not then create new journal.
3085         """
3086         obj_journal = self.pool.get('account.journal')
3087         rec_list = obj_journal.search(cr, uid, [('name','=', vals_journal['name']),('company_id', '=', company_id)], context=context)
3088         if not rec_list:
3089             obj_journal.create(cr, uid, vals_journal, context=context)
3090         return True
3091
3092     def generate_journals(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3093         """
3094         This method is used for creating journals.
3095
3096         :param chart_temp_id: Chart Template Id.
3097         :param acc_template_ref: Account templates reference.
3098         :param company_id: company_id selected from wizard.multi.charts.accounts.
3099         :returns: True
3100         """
3101         journal_data = self._prepare_all_journals(cr, uid, chart_template_id, acc_template_ref, company_id, context=context)
3102         for vals_journal in journal_data:
3103             self.check_created_journals(cr, uid, vals_journal, company_id, context=context)
3104         return True
3105
3106     def _prepare_all_journals(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3107         def _get_analytic_journal(journal_type):
3108             # Get the analytic journal
3109             data = False
3110             if journal_type in ('sale', 'sale_refund'):
3111                 data = obj_data.get_object_reference(cr, uid, 'account', 'analytic_journal_sale')
3112             elif journal_type in ('purchase', 'purchase_refund'):
3113                 pass
3114             elif journal_type == 'general':
3115                 pass
3116             return data and data[1] or False
3117
3118         def _get_default_account(journal_type, type='debit'):
3119             # Get the default accounts
3120             default_account = False
3121             if journal_type in ('sale', 'sale_refund'):
3122                 default_account = acc_template_ref.get(template.property_account_income_categ.id)
3123             elif journal_type in ('purchase', 'purchase_refund'):
3124                 default_account = acc_template_ref.get(template.property_account_expense_categ.id)
3125             elif journal_type == 'situation':
3126                 if type == 'debit':
3127                     default_account = acc_template_ref.get(template.property_account_expense_opening.id)
3128                 else:
3129                     default_account = acc_template_ref.get(template.property_account_income_opening.id)
3130             return default_account
3131
3132         def _get_view_id(journal_type):
3133             # Get the journal views
3134             if journal_type in ('general', 'situation'):
3135                 data = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_view')
3136             elif journal_type in ('sale_refund', 'purchase_refund'):
3137                 data = obj_data.get_object_reference(cr, uid, 'account', 'account_sp_refund_journal_view')
3138             else:
3139                 data = obj_data.get_object_reference(cr, uid, 'account', 'account_sp_journal_view')
3140             return data and data[1] or False
3141
3142         journal_names = {
3143             'sale': _('Sales Journal'),
3144             'purchase': _('Purchase Journal'),
3145             'sale_refund': _('Sales Refund Journal'),
3146             'purchase_refund': _('Purchase Refund Journal'),
3147             'general': _('Miscellaneous Journal'),
3148             'situation': _('Opening Entries Journal'),
3149         }
3150         journal_codes = {
3151             'sale': _('SAJ'),
3152             'purchase': _('EXJ'),
3153             'sale_refund': _('SCNJ'),
3154             'purchase_refund': _('ECNJ'),
3155             'general': _('MISC'),
3156             'situation': _('OPEJ'),
3157         }
3158
3159         obj_data = self.pool.get('ir.model.data')
3160         analytic_journal_obj = self.pool.get('account.analytic.journal')
3161         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3162
3163         journal_data = []
3164         for journal_type in ['sale', 'purchase', 'sale_refund', 'purchase_refund', 'general', 'situation']:
3165             vals = {
3166                 'type': journal_type,
3167                 'name': journal_names[journal_type],
3168                 'code': journal_codes[journal_type],
3169                 'company_id': company_id,
3170                 'centralisation': journal_type == 'situation',
3171                 'view_id': _get_view_id(journal_type),
3172                 'analytic_journal_id': _get_analytic_journal(journal_type),
3173                 'default_credit_account_id': _get_default_account(journal_type, 'credit'),
3174                 'default_debit_account_id': _get_default_account(journal_type, 'debit'),
3175             }
3176             journal_data.append(vals)
3177         return journal_data
3178
3179     def generate_properties(self, cr, uid, chart_template_id, acc_template_ref, company_id, context=None):
3180         """
3181         This method used for creating properties.
3182
3183         :param chart_template_id: id of the current chart template for which we need to create properties
3184         :param acc_template_ref: Mapping between ids of account templates and real accounts created from them
3185         :param company_id: company_id selected from wizard.multi.charts.accounts.
3186         :returns: True
3187         """
3188         property_obj = self.pool.get('ir.property')
3189         field_obj = self.pool.get('ir.model.fields')
3190         todo_list = [
3191             ('property_account_receivable','res.partner','account.account'),
3192             ('property_account_payable','res.partner','account.account'),
3193             ('property_account_expense_categ','product.category','account.account'),
3194             ('property_account_income_categ','product.category','account.account'),
3195             ('property_account_expense','product.template','account.account'),
3196             ('property_account_income','product.template','account.account'),
3197             ('property_reserve_and_surplus_account','res.company','account.account')
3198         ]
3199         template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
3200         for record in todo_list:
3201             account = getattr(template, record[0])
3202             value = account and 'account.account,' + str(acc_template_ref[account.id]) or False
3203             if value:
3204                 field = field_obj.search(cr, uid, [('name', '=', record[0]),('model', '=', record[1]),('relation', '=', record[2])], context=context)
3205                 vals = {
3206                     'name': record[0],
3207                     'company_id': company_id,
3208                     'fields_id': field[0],
3209                     'value': value,
3210                 }
3211                 property_ids = property_obj.search(cr, uid, [('name','=', record[0]),('company_id', '=', company_id)], context=context)
3212                 if property_ids:
3213                     #the property exist: modify it
3214                     property_obj.write(cr, uid, property_ids, vals, context=context)
3215                 else:
3216                     #create the property
3217                     property_obj.create(cr, uid, vals, context=context)
3218         return True
3219
3220     def _install_template(self, cr, uid, template_id, company_id, code_digits=None, obj_wizard=None, acc_ref={}, taxes_ref={}, tax_code_ref={}, context=None):
3221         '''
3222         This function recursively loads the template objects and create the real objects from them.
3223
3224         :param template_id: id of the chart template to load
3225         :param company_id: id of the company the wizard is running for
3226         :param code_digits: integer that depicts the number of digits the accounts code should have in the COA
3227         :param obj_wizard: the current wizard for generating the COA from the templates
3228         :param acc_ref: Mapping between ids of account templates and real accounts created from them
3229         :param taxes_ref: Mapping between ids of tax templates and real taxes created from them
3230         :param tax_code_ref: Mapping between ids of tax code templates and real tax codes created from them
3231         :returns: return a tuple with a dictionary containing
3232             * the mapping between the account template ids and the ids of the real accounts that have been generated
3233               from them, as first item,
3234             * a similar dictionary for mapping the tax templates and taxes, as second item,
3235             * a last identical containing the mapping of tax code templates and tax codes
3236         :rtype: tuple(dict, dict, dict)
3237         '''
3238         template = self.pool.get('account.chart.template').browse(cr, uid, template_id, context=context)
3239         if template.parent_id:
3240             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)
3241             acc_ref.update(tmp1)
3242             taxes_ref.update(tmp2)
3243             tax_code_ref.update(tmp3)
3244         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)
3245         acc_ref.update(tmp1)
3246         taxes_ref.update(tmp2)
3247         tax_code_ref.update(tmp3)
3248         return acc_ref, taxes_ref, tax_code_ref
3249
3250     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):
3251         '''
3252         This function generates all the objects from the templates
3253
3254         :param template_id: id of the chart template to load
3255         :param company_id: id of the company the wizard is running for
3256         :param code_digits: integer that depicts the number of digits the accounts code should have in the COA
3257         :param obj_wizard: the current wizard for generating the COA from the templates
3258         :param acc_ref: Mapping between ids of account templates and real accounts created from them
3259         :param taxes_ref: Mapping between ids of tax templates and real taxes created from them
3260         :param tax_code_ref: Mapping between ids of tax code templates and real tax codes created from them
3261         :returns: return a tuple with a dictionary containing
3262             * the mapping between the account template ids and the ids of the real accounts that have been generated
3263               from them, as first item,
3264             * a similar dictionary for mapping the tax templates and taxes, as second item,
3265             * a last identical containing the mapping of tax code templates and tax codes
3266         :rtype: tuple(dict, dict, dict)
3267         '''
3268         template = self.pool.get('account.chart.template').browse(cr, uid, template_id, context=context)
3269         obj_tax_code_template = self.pool.get('account.tax.code.template')
3270         obj_acc_tax = self.pool.get('account.tax')
3271         obj_tax_temp = self.pool.get('account.tax.template')
3272         obj_acc_template = self.pool.get('account.account.template')
3273         obj_fiscal_position_template = self.pool.get('account.fiscal.position.template')
3274
3275         # create all the tax code.
3276         tax_code_ref.update(obj_tax_code_template.generate_tax_code(cr, uid, template.tax_code_root_id.id, company_id, context=context))
3277
3278         # Generate taxes from templates.
3279         tax_templates = [x for x in template.tax_template_ids]
3280         generated_tax_res = obj_tax_temp._generate_tax(cr, uid, tax_templates, tax_code_ref, company_id, context=context)
3281         taxes_ref.update(generated_tax_res['tax_template_to_tax'])
3282
3283         # Generating Accounts from templates.
3284         account_template_ref = obj_acc_template.generate_account(cr, uid, template_id, taxes_ref, account_ref, code_digits, company_id, context=context)
3285         account_ref.update(account_template_ref)
3286
3287         # writing account values on tax after creation of accounts
3288         for key,value in generated_tax_res['account_dict'].items():
3289             if value['account_collected_id'] or value['account_paid_id']:
3290                 obj_acc_tax.write(cr, uid, [key], {
3291                     'account_collected_id': account_ref.get(value['account_collected_id'], False),
3292                     'account_paid_id': account_ref.get(value['account_paid_id'], False),
3293                 })
3294
3295         # Create Journals
3296         self.generate_journals(cr, uid, template_id, account_ref, company_id, context=context)
3297
3298         # generate properties function
3299         self.generate_properties(cr, uid, template_id, account_ref, company_id, context=context)
3300
3301         # Generate Fiscal Position , Fiscal Position Accounts and Fiscal Position Taxes from templates
3302         obj_fiscal_position_template.generate_fiscal_position(cr, uid, template_id, taxes_ref, account_ref, company_id, context=context)
3303
3304         return account_ref, taxes_ref, tax_code_ref
3305
3306     def _create_tax_templates_from_rates(self, cr, uid, obj_wizard, company_id, context=None):
3307         '''
3308         This function checks if the chosen chart template is configured as containing a full set of taxes, and if
3309         it's not the case, it creates the templates for account.tax.code and for account.account.tax objects accordingly
3310         to the provided sale/purchase rates. Then it saves the new tax templates as default taxes to use for this chart
3311         template.
3312
3313         :param obj_wizard: browse record of wizard to generate COA from templates
3314         :param company_id: id of the company for wich the wizard is running
3315         :return: True
3316         '''
3317         obj_tax_code_template = self.pool.get('account.tax.code.template')
3318         obj_tax_temp = self.pool.get('account.tax.template')
3319         chart_template = obj_wizard.chart_template_id
3320         vals = {}
3321         # get the ids of all the parents of the selected account chart template
3322         current_chart_template = chart_template
3323         all_parents = [current_chart_template.id]
3324         while current_chart_template.parent_id:
3325             current_chart_template = current_chart_template.parent_id
3326             all_parents.append(current_chart_template.id)
3327         # create tax templates and tax code templates from purchase_tax_rate and sale_tax_rate fields
3328         if not chart_template.complete_tax_set:
3329             value = obj_wizard.sale_tax_rate
3330             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)
3331             obj_tax_temp.write(cr, uid, ref_tax_ids, {'amount': value/100.0, 'name': _('Tax %.2f%%') % value})
3332             value = obj_wizard.purchase_tax_rate
3333             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)
3334             obj_tax_temp.write(cr, uid, ref_tax_ids, {'amount': value/100.0, 'name': _('Purchase Tax %.2f%%') % value})
3335         return True
3336
3337     def execute(self, cr, uid, ids, context=None):
3338         '''
3339         This function is called at the confirmation of the wizard to generate the COA from the templates. It will read
3340         all the provided information to create the accounts, the banks, the journals, the taxes, the tax codes, the
3341         accounting properties... accordingly for the chosen company.
3342         '''
3343         ir_values_obj = self.pool.get('ir.values')
3344         obj_wizard = self.browse(cr, uid, ids[0])
3345         company_id = obj_wizard.company_id.id
3346         # If the floats for sale/purchase rates have been filled, create templates from them
3347         self._create_tax_templates_from_rates(cr, uid, obj_wizard, company_id, context=context)
3348
3349         # Install all the templates objects and generate the real objects
3350         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)
3351
3352         # write values of default taxes for product
3353         if obj_wizard.sale_tax and taxes_ref:
3354             ir_values_obj.set(cr, uid, key='default', key2=False, name="taxes_id", company=company_id,
3355                                 models =[('product.product',False)], value=[taxes_ref[obj_wizard.sale_tax.id]])
3356         if obj_wizard.purchase_tax and taxes_ref:
3357                 ir_values_obj.set(cr, uid, key='default', key2=False, name="supplier_taxes_id", company=company_id,
3358                                 models =[('product.product',False)], value=[taxes_ref[obj_wizard.purchase_tax.id]])
3359
3360         # Create Bank journals
3361         self._create_bank_journals_from_o2m(cr, uid, obj_wizard, company_id, acc_template_ref, context=context)
3362         return {}
3363
3364     def _prepare_bank_journal(self, cr, uid, line, current_num, default_account_id, company_id, context=None):
3365         '''
3366         This function prepares the value to use for the creation of a bank journal created through the wizard of
3367         generating COA from templates.
3368
3369         :param line: dictionary containing the values encoded by the user related to his bank account
3370         :param current_num: integer corresponding to a counter of the already created bank journals through this wizard.
3371         :param default_account_id: id of the default debit.credit account created before for this journal.
3372         :param company_id: id of the company for which the wizard is running
3373         :return: mapping of field names and values
3374         :rtype: dict
3375         '''
3376         obj_data = self.pool.get('ir.model.data')
3377         obj_journal = self.pool.get('account.journal')
3378         # Get the id of journal views
3379         tmp = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_bank_view_multi')
3380         view_id_cur = tmp and tmp[1] or False
3381         tmp = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_bank_view')
3382         view_id_cash = tmp and tmp[1] or False
3383
3384         # we need to loop again to find next number for journal code
3385         # because we can't rely on the value current_num as,
3386         # its possible that we already have bank journals created (e.g. by the creation of res.partner.bank)
3387         # and the next number for account code might have been already used before for journal
3388         for num in xrange(current_num, 100):
3389             # journal_code has a maximal size of 5, hence we can enforce the boundary num < 100
3390             journal_code = _('BNK')[:3] + str(num)
3391             ids = obj_journal.search(cr, uid, [('code', '=', journal_code), ('company_id', '=', company_id)], context=context)
3392             if not ids:
3393                 break
3394         else:
3395             raise osv.except_osv(_('Error!'), _('Cannot generate an unused journal code.'))
3396
3397         vals = {
3398                 'name': line['acc_name'],
3399                 'code': journal_code,
3400                 'type': line['account_type'] == 'cash' and 'cash' or 'bank',
3401                 'company_id': company_id,
3402                 'analytic_journal_id': False,
3403                 'currency': False,
3404                 'default_credit_account_id': default_account_id,
3405                 'default_debit_account_id': default_account_id,
3406         }
3407         if line['currency_id']:
3408             vals['view_id'] = view_id_cur
3409             vals['currency'] = line['currency_id']
3410         else:
3411             vals['view_id'] = view_id_cash
3412         return vals
3413
3414     def _prepare_bank_account(self, cr, uid, line, new_code, acc_template_ref, ref_acc_bank, company_id, context=None):
3415         '''
3416         This function prepares the value to use for the creation of the default debit and credit accounts of a
3417         bank journal created through the wizard of generating COA from templates.
3418
3419         :param line: dictionary containing the values encoded by the user related to his bank account
3420         :param new_code: integer corresponding to the next available number to use as account code
3421         :param acc_template_ref: the dictionary containing the mapping between the ids of account templates and the ids
3422             of the accounts that have been generated from them.
3423         :param ref_acc_bank: browse record of the account template set as root of all bank accounts for the chosen
3424             template
3425         :param company_id: id of the company for which the wizard is running
3426         :return: mapping of field names and values
3427         :rtype: dict
3428         '''
3429         obj_data = self.pool.get('ir.model.data')
3430
3431         # Get the id of the user types fr-or cash and bank
3432         tmp = obj_data.get_object_reference(cr, uid, 'account', 'data_account_type_cash')
3433         cash_type = tmp and tmp[1] or False
3434         tmp = obj_data.get_object_reference(cr, uid, 'account', 'data_account_type_bank')
3435         bank_type = tmp and tmp[1] or False
3436         return {
3437                 'name': line['acc_name'],
3438                 'currency_id': line['currency_id'],
3439                 'code': new_code,
3440                 'type': 'liquidity',
3441                 'user_type': line['account_type'] == 'cash' and cash_type or bank_type,
3442                 'parent_id': acc_template_ref[ref_acc_bank.id] or False,
3443                 'company_id': company_id,
3444         }
3445
3446     def _create_bank_journals_from_o2m(self, cr, uid, obj_wizard, company_id, acc_template_ref, context=None):
3447         '''
3448         This function creates bank journals and its accounts for each line encoded in the field bank_accounts_id of the
3449         wizard.
3450
3451         :param obj_wizard: the current wizard that generates the COA from the templates.
3452         :param company_id: the id of the company for which the wizard is running.
3453         :param acc_template_ref: the dictionary containing the mapping between the ids of account templates and the ids
3454             of the accounts that have been generated from them.
3455         :return: True
3456         '''
3457         obj_acc = self.pool.get('account.account')
3458         obj_journal = self.pool.get('account.journal')
3459         code_digits = obj_wizard.code_digits
3460
3461         # Build a list with all the data to process
3462         journal_data = []
3463         if obj_wizard.bank_accounts_id:
3464             for acc in obj_wizard.bank_accounts_id:
3465                 vals = {
3466                     'acc_name': acc.acc_name,
3467                     'account_type': acc.account_type,
3468                     'currency_id': acc.currency_id.id,
3469                 }
3470                 journal_data.append(vals)
3471         ref_acc_bank = obj_wizard.chart_template_id.bank_account_view_id
3472         if journal_data and not ref_acc_bank.code:
3473             raise osv.except_osv(_('Configuration Error!'), _('You have to set a code for the bank account defined on the selected chart of accounts.'))
3474
3475         current_num = 1
3476         for line in journal_data:
3477             # Seek the next available number for the account code
3478             while True:
3479                 new_code = str(ref_acc_bank.code.ljust(code_digits-len(str(current_num)), '0')) + str(current_num)
3480                 ids = obj_acc.search(cr, uid, [('code', '=', new_code), ('company_id', '=', company_id)])
3481                 if not ids:
3482                     break
3483                 else:
3484                     current_num += 1
3485             # Create the default debit/credit accounts for this bank journal
3486             vals = self._prepare_bank_account(cr, uid, line, new_code, acc_template_ref, ref_acc_bank, company_id, context=context)
3487             default_account_id  = obj_acc.create(cr, uid, vals, context=context)
3488
3489             #create the bank journal
3490             vals_journal = self._prepare_bank_journal(cr, uid, line, current_num, default_account_id, company_id, context=context)
3491             obj_journal.create(cr, uid, vals_journal)
3492             current_num += 1
3493         return True
3494
3495 wizard_multi_charts_accounts()
3496
3497 class account_bank_accounts_wizard(osv.osv_memory):
3498     _name='account.bank.accounts.wizard'
3499
3500     _columns = {
3501         'acc_name': fields.char('Account Name.', size=64, required=True),
3502         'bank_account_id': fields.many2one('wizard.multi.charts.accounts', 'Bank Account', required=True),
3503         'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
3504         'account_type': fields.selection([('cash','Cash'), ('check','Check'), ('bank','Bank')], 'Account Type', size=32),
3505     }
3506
3507 account_bank_accounts_wizard()
3508
3509 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: