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             return cr.execute("""update account_analytic_account set currency_id=%s where id=%s""", (value, account.id, ))
 163
 164     def _currency(self, cr, uid, ids, field_name, arg, context=None):
 165         result = {}
 166         for rec in self.browse(cr, uid, ids, context=context):
 167             if rec.company_id:
 168                 result[rec.id] = rec.company_id.currency_id.id
 169             else:
 170                 result[rec.id] = rec.currency_id.id
 171         return result
 172
 173     _columns = {
 174         'name': fields.char('Account/Contract Name', required=True, track_visibility='onchange'),
 175         'complete_name': fields.function(_get_full_name, type='char', string='Full Name'),
 176         'code': fields.char('Reference', select=True, track_visibility='onchange'),
 177         'type': fields.selection([('view','Analytic View'), ('normal','Analytic Account'),('contract','Contract or Project'),('template','Template of Contract')], 'Type of Account', required=True,
 178                                  help="If you select the View Type, it means you won\'t allow to create journal entries using that account.\n"\
 179                                   "The type 'Analytic account' stands for usual accounts that you only want to use in accounting.\n"\
 180                                   "If you select Contract or Project, it offers you the possibility to manage the validity and the invoicing options for this account.\n"\
 181                                   "The special type 'Template of Contract' allows you to define a template with default data that you can reuse easily."),
 182         'template_id': fields.many2one('account.analytic.account', 'Template of Contract'),
 183         'description': fields.text('Description'),
 184         'parent_id': fields.many2one('account.analytic.account', 'Parent Analytic Account', select=2),
 185         'child_ids': fields.one2many('account.analytic.account', 'parent_id', 'Child Accounts'),
 186         'child_complete_ids': fields.function(_child_compute, relation='account.analytic.account', string="Account Hierarchy", type='many2many'),
 187         'line_ids': fields.one2many('account.analytic.line', 'account_id', 'Analytic Entries'),
 188         'balance': fields.function(_debit_credit_bal_qtty, type='float', string='Balance', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 189         'debit': fields.function(_debit_credit_bal_qtty, type='float', string='Debit', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 190         'credit': fields.function(_debit_credit_bal_qtty, type='float', string='Credit', multi='debit_credit_bal_qtty', digits_compute=dp.get_precision('Account')),
 191         'quantity': fields.function(_debit_credit_bal_qtty, type='float', string='Quantity', multi='debit_credit_bal_qtty'),
 192         '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.)'),
 193         'partner_id': fields.many2one('res.partner', 'Customer'),
 194         'user_id': fields.many2one('res.users', 'Project Manager', track_visibility='onchange'),
 195         'manager_id': fields.many2one('res.users', 'Account Manager', track_visibility='onchange'),
 196         'date_start': fields.date('Start Date'),
 197         'date': fields.date('Expiration Date', select=True, track_visibility='onchange'),
 198         '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.
 199         'state': fields.selection([('template', 'Template'),('draft','New'),('open','In Progress'),('pending','To Renew'),('close','Closed'),('cancelled', 'Cancelled')], 'Status', required=True, track_visibility='onchange'),
 200         '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
 201             store = {
 202                 'res.company': (_get_analytic_account, ['currency_id'], 10),
 203             }, string='Currency', type='many2one', relation='res.currency'),
 204     }
 205
 206     def on_change_template(self, cr, uid, ids, template_id, date_start=False, context=None):
 207         if not template_id:
 208             return {}
 209         res = {'value':{}}
 210         template = self.browse(cr, uid, template_id, context=context)
 211         if template.date_start and template.date:
 212             from_dt = datetime.strptime(template.date_start, tools.DEFAULT_SERVER_DATE_FORMAT)
 213             to_dt = datetime.strptime(template.date, tools.DEFAULT_SERVER_DATE_FORMAT)
 214             timedelta = to_dt - from_dt
 215             res['value']['date'] = datetime.strftime(datetime.now() + timedelta, tools.DEFAULT_SERVER_DATE_FORMAT)
 216         if not date_start:
 217             res['value']['date_start'] = fields.date.today()
 218         res['value']['quantity_max'] = template.quantity_max
 219         res['value']['parent_id'] = template.parent_id and template.parent_id.id or False
 220         res['value']['description'] = template.description
 221         return res
 222
 223     def on_change_partner_id(self, cr, uid, ids,partner_id, name, context=None):
 224         res={}
 225         if partner_id:
 226             partner = self.pool.get('res.partner').browse(cr, uid, partner_id, context=context)
 227             if partner.user_id:
 228                 res['manager_id'] = partner.user_id.id
 229             if not name:
 230                 res['name'] = _('Contract: ') + partner.name
 231         return {'value': res}
 232
 233     def _default_company(self, cr, uid, context=None):
 234         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 235         if user.company_id:
 236             return user.company_id.id
 237         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
 238
 239     def _get_default_currency(self, cr, uid, context=None):
 240         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 241         return user.company_id.currency_id.id
 242
 243     _defaults = {
 244         'type': 'normal',
 245         'company_id': _default_company,
 246         'code' : lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'account.analytic.account'),
 247         'state': 'open',
 248         'user_id': lambda self, cr, uid, ctx: uid,
 249         'partner_id': lambda self, cr, uid, ctx: ctx.get('partner_id', False),
 250         'date_start': lambda *a: time.strftime('%Y-%m-%d'),
 251         'currency_id': _get_default_currency,
 252     }
 253
 254     def check_recursion(self, cr, uid, ids, context=None, parent=None):
 255         return super(account_analytic_account, self)._check_recursion(cr, uid, ids, context=context, parent=parent)
 256
 257     _order = 'code, name asc'
 258     _constraints = [
 259         (check_recursion, 'Error! You cannot create recursive analytic accounts.', ['parent_id']),
 260     ]
 261
 262     def name_create(self, cr, uid, name, context=None):
 263         raise osv.except_osv(_('Warning'), _("Quick account creation disallowed."))
 264
 265     def copy(self, cr, uid, id, default=None, context=None):
 266         if not default:
 267             default = {}
 268         analytic = self.browse(cr, uid, id, context=context)
 269         default.update(
 270             code=False,
 271             line_ids=[],
 272             name=_("%s (copy)") % (analytic['name']))
 273         return super(account_analytic_account, self).copy(cr, uid, id, default, context=context)
 274
 275     def on_change_company(self, cr, uid, id, company_id):
 276         if not company_id:
 277             return {}
 278         currency = self.pool.get('res.company').read(cr, uid, [company_id], ['currency_id'])[0]['currency_id']
 279         return {'value': {'currency_id': currency}}
 280
 281     def on_change_parent(self, cr, uid, id, parent_id):
 282         if not parent_id:
 283             return {}
 284         parent = self.read(cr, uid, [parent_id], ['partner_id','code'])[0]
 285         if parent['partner_id']:
 286             partner = parent['partner_id'][0]
 287         else:
 288             partner = False
 289         res = {'value': {}}
 290         if partner:
 291             res['value']['partner_id'] = partner
 292         return res
 293
 294     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
 295         if not args:
 296             args=[]
 297         if context is None:
 298             context={}
 299         if name:
 300             account_ids = self.search(cr, uid, [('code', '=', name)] + args, limit=limit, context=context)
 301             if not account_ids:
 302                 dom = []
 303                 for name2 in name.split('/'):
 304                     name = name2.strip()
 305                     account_ids = self.search(cr, uid, dom + [('name', 'ilike', name)] + args, limit=limit, context=context)
 306                     if not account_ids: break
 307                     dom = [('parent_id','in',account_ids)]
 308         else:
 309             account_ids = self.search(cr, uid, args, limit=limit, context=context)
 310         return self.name_get(cr, uid, account_ids, context=context)
 311
 312 class account_analytic_line(osv.osv):
 313     _name = 'account.analytic.line'
 314     _description = 'Analytic Line'
 315
 316     _columns = {
 317         'name': fields.char('Description', required=True),
 318         'date': fields.date('Date', required=True, select=True),
 319         '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')),
 320         'unit_amount': fields.float('Quantity', help='Specifies the amount of quantity to count.'),
 321         'account_id': fields.many2one('account.analytic.account', 'Analytic Account', required=True, ondelete='restrict', select=True, domain=[('type','<>','view')]),
 322         'user_id': fields.many2one('res.users', 'User'),
 323         'company_id': fields.related('account_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True),
 324
 325     }
 326
 327     def _get_default_date(self, cr, uid, context=None):
 328         return fields.date.context_today(self, cr, uid, context=context)
 329
 330     def __get_default_date(self, cr, uid, context=None):
 331         return self._get_default_date(cr, uid, context=context)
 332
 333     _defaults = {
 334         'date': __get_default_date,
 335         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'account.analytic.line', context=c),
 336         'amount': 0.00
 337     }
 338
 339     _order = 'date desc'
 340
 341     def _check_no_view(self, cr, uid, ids, context=None):
 342         analytic_lines = self.browse(cr, uid, ids, context=context)
 343         for line in analytic_lines:
 344             if line.account_id.type == 'view':
 345                 return False
 346         return True
 347
 348     _constraints = [
 349         (_check_no_view, 'You cannot create analytic line on view account.', ['account_id']),
 350     ]
 351
 352 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: