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