addons/account/account.py

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