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