addons/analytic/analytic.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
  24 from osv import fields, osv
  25 from tools.translate import _
  26 import decimal_precision as dp
  27
  28 class account_analytic_account(osv.osv):
  29     _name = 'account.analytic.account'
  30     _description = 'Analytic Account'
  31
  32     def _compute_level_tree(self, cr, uid, ids, child_ids, res, field_names, context=None):
  33         currency_obj = self.pool.get('res.currency')
  34         recres = {}
  35         def recursive_computation(account):
  36             result2 = res[account.id].copy()
  37             for son in account.child_ids:
  38                 result = recursive_computation(son)
  39                 for field in field_names:
  40                     if (account.currency_id.id != son.currency_id.id) and (field!='quantity'):
  41                         result[field] = currency_obj.compute(cr, uid, son.currency_id.id, account.currency_id.id, result[field], context=context)
  42                     result2[field] += result[field]
  43             return result2
  44         for account in self.browse(cr, uid, ids, context=context):
  45             if account.id not in child_ids:
  46                 continue
  47             recres[account.id] = recursive_computation(account)
  48         return recres
  49
  50     def _debit_credit_bal_qtty(self, cr, uid, ids, name, arg, context=None):
  51         res = {}
  52         if context is None:
  53             context = {}
  54         child_ids = tuple(self.search(cr, uid, [('parent_id', 'child_of', ids)]))
  55         for i in child_ids:
  56             res[i] =  {}
  57             for n in name:
  58                 res[i][n] = 0.0
  59
  60         if not child_ids:
  61             return res
  62
  63         where_date = ''
  64         where_clause_args = [tuple(child_ids)]
  65         if context.get('from_date', False):
  66             where_date += " AND l.date >= %s"
  67             where_clause_args  += [context['from_date']]
  68         if context.get('to_date', False):
  69             where_date += " AND l.date <= %s"
  70             where_clause_args += [context['to_date']]
  71         cr.execute("""
  72               SELECT a.id,
  73                      sum(
  74                          CASE WHEN l.amount > 0
  75                          THEN l.amount
  76                          ELSE 0.0
  77                          END
  78                           ) as debit,
  79                      sum(
  80                          CASE WHEN l.amount < 0
  81                          THEN -l.amount
  82                          ELSE 0.0
  83                          END
  84                           ) as credit,
  85                      COALESCE(SUM(l.amount),0) AS balance,
  86                      COALESCE(SUM(l.unit_amount),0) AS quantity
  87               FROM account_analytic_account a
  88                   LEFT JOIN account_analytic_line l ON (a.id = l.account_id)
  89               WHERE a.id IN %s
  90               """ + where_date + """
  91               GROUP BY a.id""", where_clause_args)
  92         for ac_id, debit, credit, balance, quantity in cr.fetchall():
  93             res[ac_id] = {'debit': debit, 'credit': credit, 'balance': balance, 'quantity': quantity}
  94         return self._compute_level_tree(cr, uid, ids, child_ids, res, ['debit', 'credit', 'balance', 'quantity'], context)
  95
  96     def name_get(self, cr, uid, ids, context=None):
  97         if not ids:
  98             return []
  99         res = []
 100         for account in self.browse(cr, uid, ids, context=context):
 101             data = []
 102             acc = account
 103             while acc:
 104                 data.insert(0, acc.name)
 105                 acc = acc.parent_id
 106             data = ' / '.join(data)
 107             res.append((account.id, data))
 108         return res
 109
 110     def _complete_name_calc(self, cr, uid, ids, prop, unknow_none, unknow_dict):
 111         res = self.name_get(cr, uid, ids)
 112         return dict(res)
 113
 114     def _child_compute(self, cr, uid, ids, name, arg, context=None):
 115         result = {}
 116         if context is None:
 117             context = {}
 118
 119         for account in self.browse(cr, uid, ids, context=context):
 120             result[account.id] = map(lambda x: x.id, [child for child in account.child_ids if child.state != 'template'])
 121
 122         return result
 123
 124     def _get_analytic_account(self, cr, uid, ids, context=None):
 125         company_obj = self.pool.get('res.company')
 126         analytic_obj = self.pool.get('account.analytic.account')
 127         accounts = []
 128         for company in company_obj.browse(cr, uid, ids, context=context):
 129             accounts += analytic_obj.search(cr, uid, [('company_id', '=', company.id)])
 130         return accounts
 131
 132     def _set_company_currency(self, cr, uid, ids, name, value, arg, context=None):
 133         if type(ids) != type([]):
 134             ids=[ids]
 135         for account in self.browse(cr, uid, ids, context=context):
 136             if account.company_id:
 137                 if account.company_id.currency_id.id != value:
 138                     raise osv.except_osv(_('Error !'), _("If you set a company, the currency selected has to be the same as it's currency. \nYou can remove the company belonging, and thus change the currency, only on analytic account of type 'view'. This can be really usefull for consolidation purposes of several companies charts with different currencies, for example."))
 139         return cr.execute("""update account_analytic_account set currency_id=%s where id=%s""", (value, account.id, ))
 140
 141     def _currency(self, cr, uid, ids, field_name, arg, context=None):
 142         result = {}
 143         for rec in self.browse(cr, uid, ids, context=context):
 144             if rec.company_id:
 145                 result[rec.id] = rec.company_id.currency_id.id
 146             else:
 147                 result[rec.id] = rec.currency_id.id
 148         return result
 149
 150     _columns = {
 151         'name': fields.char('Account Name', size=128, required=True),
 152         'complete_name': fields.function(_complete_name_calc, type='char', string='Full Account Name'),
 153         'code': fields.char('Code/Reference', size=24, select=True),
 154         'type': fields.selection([('view','View'), ('normal','Normal')], 'Account Type', help='If you select the View Type, it means you won\'t allow to create journal entries using that account.'),
 155         'description': fields.text('Description'),
 156         'parent_id': fields.many2one('account.analytic.account', 'Parent Analytic Account', select=2),
 157         'child_ids': fields.one2many('account.analytic.account', 'parent_id', 'Child Accounts'),
 158         'child_complete_ids': fields.function(_child_compute, relation='account.analytic.account', string="Account Hierarchy", type='many2many'),
 159         'line_ids': fields.one2many('account.analytic.line', 'account_id', 'Analytic Entries'),
 160         'balance': fields.function(_debit_credit_bal_qtty, type='float', string='Balance', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 161         'debit': fields.function(_debit_credit_bal_qtty, type='float', string='Debit', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 162         'credit': fields.function(_debit_credit_bal_qtty, type='float', string='Credit', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 163         'quantity': fields.function(_debit_credit_bal_qtty, type='float', string='Quantity', multi='debit_credit_bal_qtty'),
 164         'quantity_max': fields.float('Maximum Time', help='Sets the higher limit of time to work on the contract.'),
 165         'partner_id': fields.many2one('res.partner', 'Partner'),
 166         'contact_id': fields.many2one('res.partner.address', 'Contact'),
 167         'user_id': fields.many2one('res.users', 'Account Manager'),
 168         'date_start': fields.date('Date Start'),
 169         'date': fields.date('Date End', select=True),
 170         'company_id': fields.many2one('res.company', 'Company', required=False), #not required because we want to allow different companies to use the same chart of account, except for leaf accounts.
 171         'state': fields.selection([('template', 'Template'),('draft','New'),('open','Open'), ('pending','Pending'),('cancelled', 'Cancelled'),('close','Closed')], 'State', required=True,
 172                                   help='* When an account is created its in \'Draft\' state.\
 173                                   \n* If any associated partner is there, it can be in \'Open\' state.\
 174                                   \n* If any pending balance is there it can be in \'Pending\'. \
 175                                   \n* And finally when all the transactions are over, it can be in \'Close\' state. \
 176                                   \n* The project can be in either if the states \'Template\' and \'Running\'.\n If it is template then we can make projects based on the template projects. If its in \'Running\' state it is a normal project.\
 177                                  \n If it is to be reviewed then the state is \'Pending\'.\n When the project is completed the state is set to \'Done\'.'),
 178         'currency_id': fields.function(_currency, fnct_inv=_set_company_currency,
 179             store = {
 180                 'res.company': (_get_analytic_account, ['currency_id'], 10),
 181             }, string='Currency', type='many2one', relation='res.currency'),
 182     }
 183
 184     def _default_company(self, cr, uid, context=None):
 185         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 186         if user.company_id:
 187             return user.company_id.id
 188         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
 189
 190     def _get_default_currency(self, cr, uid, context=None):
 191         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 192         return user.company_id.currency_id.id
 193
 194     _defaults = {
 195         'type': 'normal',
 196         'company_id': _default_company,
 197         'state': 'open',
 198         'user_id': lambda self, cr, uid, ctx: uid,
 199         'partner_id': lambda self, cr, uid, ctx: ctx.get('partner_id', False),
 200         'contact_id': lambda self, cr, uid, ctx: ctx.get('contact_id', False),
 201         'date_start': lambda *a: time.strftime('%Y-%m-%d'),
 202         'currency_id': _get_default_currency,
 203     }
 204
 205     def check_recursion(self, cr, uid, ids, context=None, parent=None):
 206         return super(account_analytic_account, self)._check_recursion(cr, uid, ids, context=context, parent=parent)
 207
 208     _order = 'name asc'
 209     _constraints = [
 210         (check_recursion, 'Error! You can not create recursive analytic accounts.', ['parent_id']),
 211     ]
 212
 213     def copy(self, cr, uid, id, default=None, context=None):
 214         if not default:
 215             default = {}
 216         default['code'] = False
 217         default['line_ids'] = []
 218         return super(account_analytic_account, self).copy(cr, uid, id, default, context=context)
 219
 220     def on_change_partner_id(self, cr, uid, id, partner_id, context={}):
 221         if not partner_id:
 222             return {'value': {'contact_id': False}}
 223         addr = self.pool.get('res.partner').address_get(cr, uid, [partner_id], ['invoice'])
 224         return {'value': {'contact_id': addr.get('invoice', False)}}
 225
 226     def on_change_company(self, cr, uid, id, company_id):
 227         if not company_id:
 228             return {}
 229         currency = self.pool.get('res.company').read(cr, uid, [company_id], ['currency_id'])[0]['currency_id']
 230         return {'value': {'currency_id': currency}}
 231
 232     def on_change_parent(self, cr, uid, id, parent_id):
 233         if not parent_id:
 234             return {}
 235         parent = self.read(cr, uid, [parent_id], ['partner_id','code'])[0]
 236         if parent['partner_id']:
 237             partner = parent['partner_id'][0]
 238         else:
 239             partner = False
 240         res = {'value': {}}
 241         if partner:
 242             res['value']['partner_id'] = partner
 243         return res
 244
 245     def onchange_partner_id(self, cr, uid, ids, partner, context=None):
 246         partner_obj = self.pool.get('res.partner')
 247         if not partner:
 248             return {'value':{'contact_id': False}}
 249         address = partner_obj.address_get(cr, uid, [partner], ['contact'])
 250         return {'value':{'contact_id': address['contact']}}
 251
 252     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
 253         if not args:
 254             args=[]
 255         if context is None:
 256             context={}
 257         if context.get('current_model') == 'project.project':
 258             cr.execute("select analytic_account_id from project_project")
 259             project_ids = [x[0] for x in cr.fetchall()]
 260             return self.name_get(cr, uid, project_ids, context=context)
 261         if name:
 262             account = self.search(cr, uid, [('code', '=', name)] + args, limit=limit, context=context)
 263             if not account:
 264                 names=map(lambda i : i.strip(),name.split('/'))
 265                 for i in range(len(names)):
 266                     dom=[('name', operator, names[i])]
 267                     if i>0:
 268                         dom+=[('id','child_of',account)]
 269                     account = self.search(cr, uid, dom, limit=limit, context=context)
 270                 newacc = account
 271                 while newacc:
 272                     newacc = self.search(cr, uid, [('parent_id', 'in', newacc)], limit=limit, context=context)
 273                     account += newacc
 274                 if args:
 275                     account = self.search(cr, uid, [('id', 'in', account)] + args, limit=limit, context=context)
 276         else:
 277             account = self.search(cr, uid, args, limit=limit, context=context)
 278         return self.name_get(cr, uid, account, context=context)
 279
 280 account_analytic_account()
 281
 282
 283 class account_analytic_line(osv.osv):
 284     _name = 'account.analytic.line'
 285     _description = 'Analytic Line'
 286
 287     _columns = {
 288         'name': fields.char('Description', size=256, required=True),
 289         'date': fields.date('Date', required=True, select=True),
 290         'amount': fields.float('Amount', required=True, help='Calculated by multiplying the quantity and the price given in the Product\'s cost price. Always expressed in the company main currency.', digits_compute=dp.get_precision('Account')),
 291         'unit_amount': fields.float('Quantity', help='Specifies the amount of quantity to count.'),
 292         'account_id': fields.many2one('account.analytic.account', 'Analytic Account', required=True, ondelete='cascade', select=True, domain=[('type','<>','view')]),
 293         'user_id': fields.many2one('res.users', 'User'),
 294         'company_id': fields.related('account_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True),
 295
 296     }
 297     _defaults = {
 298         'date': lambda *a: time.strftime('%Y-%m-%d'),
 299         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'account.analytic.line', context=c),
 300         'amount': 0.00
 301     }
 302
 303     _order = 'date desc'
 304
 305     def _check_no_view(self, cr, uid, ids, context=None):
 306         analytic_lines = self.browse(cr, uid, ids, context=context)
 307         for line in analytic_lines:
 308             if line.account_id.type == 'view':
 309                 return False
 310         return True
 311
 312     _constraints = [
 313         (_check_no_view, 'You can not create analytic line on view account.', ['account_id']),
 314     ]
 315
 316 account_analytic_line()
 317
 318 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: