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     _inherit = ['mail.thread']
  31     _description = 'Analytic Account'
  32
  33     def _compute_level_tree(self, cr, uid, ids, child_ids, res, field_names, context=None):
  34         currency_obj = self.pool.get('res.currency')
  35         recres = {}
  36         def recursive_computation(account):
  37             result2 = res[account.id].copy()
  38             for son in account.child_ids:
  39                 result = recursive_computation(son)
  40                 for field in field_names:
  41                     if (account.currency_id.id != son.currency_id.id) and (field!='quantity'):
  42                         result[field] = currency_obj.compute(cr, uid, son.currency_id.id, account.currency_id.id, result[field], context=context)
  43                     result2[field] += result[field]
  44             return result2
  45         for account in self.browse(cr, uid, ids, context=context):
  46             if account.id not in child_ids:
  47                 continue
  48             recres[account.id] = recursive_computation(account)
  49         return recres
  50
  51     def _debit_credit_bal_qtty(self, cr, uid, ids, fields, arg, context=None):
  52         res = {}
  53         if context is None:
  54             context = {}
  55         child_ids = tuple(self.search(cr, uid, [('parent_id', 'child_of', ids)]))
  56         for i in child_ids:
  57             res[i] =  {}
  58             for n in fields:
  59                 res[i][n] = 0.0
  60
  61         if not child_ids:
  62             return res
  63
  64         where_date = ''
  65         where_clause_args = [tuple(child_ids)]
  66         if context.get('from_date', False):
  67             where_date += " AND l.date >= %s"
  68             where_clause_args  += [context['from_date']]
  69         if context.get('to_date', False):
  70             where_date += " AND l.date <= %s"
  71             where_clause_args += [context['to_date']]
  72         cr.execute("""
  73               SELECT a.id,
  74                      sum(
  75                          CASE WHEN l.amount > 0
  76                          THEN l.amount
  77                          ELSE 0.0
  78                          END
  79                           ) as debit,
  80                      sum(
  81                          CASE WHEN l.amount < 0
  82                          THEN -l.amount
  83                          ELSE 0.0
  84                          END
  85                           ) as credit,
  86                      COALESCE(SUM(l.amount),0) AS balance,
  87                      COALESCE(SUM(l.unit_amount),0) AS quantity
  88               FROM account_analytic_account a
  89                   LEFT JOIN account_analytic_line l ON (a.id = l.account_id)
  90               WHERE a.id IN %s
  91               """ + where_date + """
  92               GROUP BY a.id""", where_clause_args)
  93         for row in cr.dictfetchall():
  94             res[row['id']] = {}
  95             for field in fields:
  96                 res[row['id']][field] = row[field]
  97         return self._compute_level_tree(cr, uid, ids, child_ids, res, fields, context)
  98
  99     def _complete_name_calc(self, cr, uid, ids, prop, unknow_none, unknow_dict):
 100         res = self.name_get(cr, uid, ids)
 101         return dict(res)
 102
 103     def _child_compute(self, cr, uid, ids, name, arg, context=None):
 104         result = {}
 105         if context is None:
 106             context = {}
 107
 108         for account in self.browse(cr, uid, ids, context=context):
 109             result[account.id] = map(lambda x: x.id, [child for child in account.child_ids if child.state != 'template'])
 110
 111         return result
 112
 113     def _get_analytic_account(self, cr, uid, ids, context=None):
 114         company_obj = self.pool.get('res.company')
 115         analytic_obj = self.pool.get('account.analytic.account')
 116         accounts = []
 117         for company in company_obj.browse(cr, uid, ids, context=context):
 118             accounts += analytic_obj.search(cr, uid, [('company_id', '=', company.id)])
 119         return accounts
 120
 121     def _set_company_currency(self, cr, uid, ids, name, value, arg, context=None):
 122         if isinstance(ids, (int, long)):
 123             ids=[ids]
 124         for account in self.browse(cr, uid, ids, context=context):
 125             if account.company_id:
 126                 if account.company_id.currency_id.id != value:
 127                     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."))
 128         if value:
 129             return cr.execute("""update account_analytic_account set currency_id=%s where id=%s""", (value, account.id, ))
 130
 131     def _currency(self, cr, uid, ids, field_name, arg, context=None):
 132         result = {}
 133         for rec in self.browse(cr, uid, ids, context=context):
 134             if rec.company_id:
 135                 result[rec.id] = rec.company_id.currency_id.id
 136             else:
 137                 result[rec.id] = rec.currency_id.id
 138         return result
 139
 140     _columns = {
 141         'name': fields.char('Account/Contract Name', size=128, required=True),
 142         'complete_name': fields.function(_complete_name_calc, type='char', string='Full Account Name'),
 143         'code': fields.char('Reference', size=24, select=True),
 144         'type': fields.selection([('view','Analytic View'), ('normal','Analytic Account'),('contract','Contract or Project'),('template','Template of Project')], 'Type of Account', required=True,
 145                                  help="If you select the View Type, it means you won\'t allow to create journal entries using that account.\n"\
 146                                   "The type 'Analytic account' stands for usual accounts that you only want to use in accounting.\n"\
 147                                   "If you select Contract or Project, it offers you the possibility to manage the validity and the invoicing options for this account.\n"\
 148                                   "The special type 'Template of Project' allows you to define a template with default data that you can reuse easily."),
 149         'template_id': fields.many2one('account.analytic.account', 'Template of Contract'),
 150         'description': fields.text('Description'),
 151         'parent_id': fields.many2one('account.analytic.account', 'Parent Analytic Account', select=2),
 152         'child_ids': fields.one2many('account.analytic.account', 'parent_id', 'Child Accounts'),
 153         'child_complete_ids': fields.function(_child_compute, relation='account.analytic.account', string="Account Hierarchy", type='many2many'),
 154         'line_ids': fields.one2many('account.analytic.line', 'account_id', 'Analytic Entries'),
 155         'balance': fields.function(_debit_credit_bal_qtty, type='float', string='Balance', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 156         'debit': fields.function(_debit_credit_bal_qtty, type='float', string='Debit', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 157         'credit': fields.function(_debit_credit_bal_qtty, type='float', string='Credit', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 158         'quantity': fields.function(_debit_credit_bal_qtty, type='float', string='Quantity', multi='debit_credit_bal_qtty'),
 159         'quantity_max': fields.float('Prepaid Units', help='Sets the higher limit of time to work on the contract, based on the timesheet.'),
 160         'partner_id': fields.many2one('res.partner', 'Customer'),
 161         'user_id': fields.many2one('res.users', 'Project Manager'),
 162         'manager_id': fields.many2one('res.users', 'Account Manager'),
 163         'date_start': fields.date('Date Start'),
 164         'date': fields.date('Date End', select=True),
 165         '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.
 166         'state': fields.selection([('template', 'Template'),('draft','New'),('open','In Progress'), ('cancelled', 'Cancelled'),('pending','To Renew'),('close','Closed')], 'Status', required=True,),
 167         'currency_id': fields.function(_currency, fnct_inv=_set_company_currency, #the currency_id field is readonly except if it's a view account and if there is no company
 168             store = {
 169                 'res.company': (_get_analytic_account, ['currency_id'], 10),
 170             }, string='Currency', type='many2one', relation='res.currency'),
 171     }
 172
 173     def on_change_template(self, cr, uid, ids, template_id, context=None):
 174         if not template_id:
 175             return {}
 176         res = {'value':{}}
 177         template = self.browse(cr, uid, template_id, context=context)
 178         res['value']['date_start'] = template.date_start
 179         res['value']['date'] = template.date
 180         res['value']['quantity_max'] = template.quantity_max
 181         res['value']['description'] = template.description
 182         return res
 183
 184     def on_change_partner_id(self, cr, uid, ids,partner_id, name, context={}):
 185         res={}
 186         if partner_id:
 187             partner = self.pool.get('res.partner').browse(cr, uid, partner_id, context=context)
 188             if partner.user_id:
 189                 res['manager_id'] = partner.user_id.id
 190             if not name:
 191                 res['name'] = _('Contract: ') + partner.name
 192         return {'value': res}
 193
 194     def _default_company(self, cr, uid, context=None):
 195         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 196         if user.company_id:
 197             return user.company_id.id
 198         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
 199
 200     def _get_default_currency(self, cr, uid, context=None):
 201         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 202         return user.company_id.currency_id.id
 203
 204     _defaults = {
 205         'type': 'normal',
 206         'company_id': _default_company,
 207         'code' : lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'account.analytic.account'),
 208         'state': 'open',
 209         'user_id': lambda self, cr, uid, ctx: uid,
 210         'partner_id': lambda self, cr, uid, ctx: ctx.get('partner_id', False),
 211         'date_start': lambda *a: time.strftime('%Y-%m-%d'),
 212         'currency_id': _get_default_currency,
 213     }
 214
 215     def check_recursion(self, cr, uid, ids, context=None, parent=None):
 216         return super(account_analytic_account, self)._check_recursion(cr, uid, ids, context=context, parent=parent)
 217
 218     _order = 'name asc'
 219     _constraints = [
 220         (check_recursion, 'Error! You cannot create recursive analytic accounts.', ['parent_id']),
 221     ]
 222
 223     def copy(self, cr, uid, id, default=None, context=None):
 224         if not default:
 225             default = {}
 226         analytic = self.browse(cr, uid, id, context=context)
 227         default.update(
 228             code=False,
 229             line_ids=[],
 230             name=_("%s (copy)") % (analytic['name']))
 231         return super(account_analytic_account, self).copy(cr, uid, id, default, context=context)
 232
 233     def on_change_company(self, cr, uid, id, company_id):
 234         if not company_id:
 235             return {}
 236         currency = self.pool.get('res.company').read(cr, uid, [company_id], ['currency_id'])[0]['currency_id']
 237         return {'value': {'currency_id': currency}}
 238
 239     def on_change_parent(self, cr, uid, id, parent_id):
 240         if not parent_id:
 241             return {}
 242         parent = self.read(cr, uid, [parent_id], ['partner_id','code'])[0]
 243         if parent['partner_id']:
 244             partner = parent['partner_id'][0]
 245         else:
 246             partner = False
 247         res = {'value': {}}
 248         if partner:
 249             res['value']['partner_id'] = partner
 250         return res
 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             project_obj = self.pool.get("account.analytic.account")
 259             project_ids = project_obj.search(cr, uid, args)
 260             return self.name_get(cr, uid, project_ids, context=context)
 261         if name:
 262             account_ids = self.search(cr, uid, [('code', '=', name)] + args, limit=limit, context=context)
 263             if not account_ids:
 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_ids)]
 269                     account_ids = self.search(cr, uid, dom, limit=limit, context=context)
 270                 newacc = account_ids
 271                 while newacc:
 272                     newacc = self.search(cr, uid, [('parent_id', 'in', newacc)], limit=limit, context=context)
 273                     account_ids += newacc
 274                 if args:
 275                     account_ids = self.search(cr, uid, [('id', 'in', account_ids)] + args, limit=limit, context=context)
 276         else:
 277             account_ids = self.search(cr, uid, args, limit=limit, context=context)
 278         return self.name_get(cr, uid, account_ids, context=context)
 279
 280     def create(self, cr, uid, vals, context=None):
 281         contract =  super(account_analytic_account, self).create(cr, uid, vals, context=context)
 282         if contract:
 283             self.create_send_note(cr, uid, [contract], context=context)
 284         return contract
 285
 286     def create_send_note(self, cr, uid, ids, context=None):
 287         for obj in self.browse(cr, uid, ids, context=context):
 288             self.message_post(cr, uid, [obj.id], body=_("Contract for <em>%s</em> has been <b>created</b>.") % (obj.partner_id.name),
 289                 subtype="analytic.mt_account_status", context=context)
 290
 291 account_analytic_account()
 292
 293
 294 class account_analytic_line(osv.osv):
 295     _name = 'account.analytic.line'
 296     _description = 'Analytic Line'
 297
 298     _columns = {
 299         'name': fields.char('Description', size=256, required=True),
 300         'date': fields.date('Date', required=True, select=True),
 301         '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')),
 302         'unit_amount': fields.float('Quantity', help='Specifies the amount of quantity to count.'),
 303         'account_id': fields.many2one('account.analytic.account', 'Analytic Account', required=True, ondelete='cascade', select=True, domain=[('type','<>','view')]),
 304         'user_id': fields.many2one('res.users', 'User'),
 305         'company_id': fields.related('account_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True),
 306
 307     }
 308     _defaults = {
 309         'date': lambda *a: time.strftime('%Y-%m-%d'),
 310         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'account.analytic.line', context=c),
 311         'amount': 0.00
 312     }
 313
 314     _order = 'date desc'
 315
 316     def _check_no_view(self, cr, uid, ids, context=None):
 317         analytic_lines = self.browse(cr, uid, ids, context=context)
 318         for line in analytic_lines:
 319             if line.account_id.type == 'view':
 320                 return False
 321         return True
 322
 323     _constraints = [
 324         (_check_no_view, 'You cannot create analytic line on view account.', ['account_id']),
 325     ]
 326
 327 account_analytic_line()
 328
 329 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: