addons/account/account.py

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