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