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 usefull 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', size=128, required=True),
 175         'complete_name': fields.function(_get_full_name, type='char', string='Full Name'),
 176         'code': fields.char('Reference', select=True),
 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'),
 195         'manager_id': fields.many2one('res.users', 'Account Manager'),
 196         'date_start': fields.date('Start Date'),
 197         'date': fields.date('Date End', select=True),
 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, 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         res['value']['date_start'] = fields.date.today()
 217         res['value']['quantity_max'] = template.quantity_max
 218         res['value']['parent_id'] = template.parent_id and template.parent_id.id or False
 219         res['value']['description'] = template.description
 220         return res
 221
 222     def on_change_partner_id(self, cr, uid, ids,partner_id, name, context={}):
 223         res={}
 224         if partner_id:
 225             partner = self.pool.get('res.partner').browse(cr, uid, partner_id, context=context)
 226             if partner.user_id:
 227                 res['manager_id'] = partner.user_id.id
 228             if not name:
 229                 res['name'] = _('Contract: ') + partner.name
 230         return {'value': res}
 231
 232     def _default_company(self, cr, uid, context=None):
 233         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 234         if user.company_id:
 235             return user.company_id.id
 236         return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
 237
 238     def _get_default_currency(self, cr, uid, context=None):
 239         user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
 240         return user.company_id.currency_id.id
 241
 242     _defaults = {
 243         'type': 'normal',
 244         'company_id': _default_company,
 245         'code' : lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'account.analytic.account'),
 246         'state': 'open',
 247         'user_id': lambda self, cr, uid, ctx: uid,
 248         'partner_id': lambda self, cr, uid, ctx: ctx.get('partner_id', False),
 249         'date_start': lambda *a: time.strftime('%Y-%m-%d'),
 250         'currency_id': _get_default_currency,
 251     }
 252
 253     def check_recursion(self, cr, uid, ids, context=None, parent=None):
 254         return super(account_analytic_account, self)._check_recursion(cr, uid, ids, context=context, parent=parent)
 255
 256     _order = 'name asc'
 257     _constraints = [
 258         (check_recursion, 'Error! You cannot create recursive analytic accounts.', ['parent_id']),
 259     ]
 260
 261     def name_create(self, cr, uid, name, context=None):
 262         raise osv.except_osv(_('Warning'), _("Quick account creation disallowed."))
 263
 264     def copy(self, cr, uid, id, default=None, context=None):
 265         if not default:
 266             default = {}
 267         analytic = self.browse(cr, uid, id, context=context)
 268         default.update(
 269             code=False,
 270             line_ids=[],
 271             name=_("%s (copy)") % (analytic['name']))
 272         return super(account_analytic_account, self).copy(cr, uid, id, default, context=context)
 273
 274     def on_change_company(self, cr, uid, id, company_id):
 275         if not company_id:
 276             return {}
 277         currency = self.pool.get('res.company').read(cr, uid, [company_id], ['currency_id'])[0]['currency_id']
 278         return {'value': {'currency_id': currency}}
 279
 280     def on_change_parent(self, cr, uid, id, parent_id):
 281         if not parent_id:
 282             return {}
 283         parent = self.read(cr, uid, [parent_id], ['partner_id','code'])[0]
 284         if parent['partner_id']:
 285             partner = parent['partner_id'][0]
 286         else:
 287             partner = False
 288         res = {'value': {}}
 289         if partner:
 290             res['value']['partner_id'] = partner
 291         return res
 292
 293     def name_search(self, cr, uid, name, args=None, operator='ilike', context=None, limit=100):
 294         if not args:
 295             args=[]
 296         if context is None:
 297             context={}
 298         if context.get('current_model') == 'project.project':
 299             project_obj = self.pool.get("account.analytic.account")
 300             project_ids = project_obj.search(cr, uid, args)
 301             return self.name_get(cr, uid, project_ids, context=context)
 302         if name:
 303             account_ids = self.search(cr, uid, [('code', '=', name)] + args, limit=limit, context=context)
 304             if not account_ids:
 305                 dom = []
 306                 for name2 in name.split('/'):
 307                     name = name2.strip()
 308                     account_ids = self.search(cr, uid, dom + [('name', 'ilike', name)] + args, limit=limit, context=context)
 309                     if not account_ids: break
 310                     dom = [('parent_id','in',account_ids)]
 311         else:
 312             account_ids = self.search(cr, uid, args, limit=limit, context=context)
 313         return self.name_get(cr, uid, account_ids, context=context)
 314
 315 class account_analytic_line(osv.osv):
 316     _name = 'account.analytic.line'
 317     _description = 'Analytic Line'
 318
 319     _columns = {
 320         'name': fields.char('Description', size=256, required=True),
 321         'date': fields.date('Date', required=True, select=True),
 322         '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')),
 323         'unit_amount': fields.float('Quantity', help='Specifies the amount of quantity to count.'),
 324         'account_id': fields.many2one('account.analytic.account', 'Analytic Account', required=True, ondelete='restrict', select=True, domain=[('type','<>','view')]),
 325         'user_id': fields.many2one('res.users', 'User'),
 326         'company_id': fields.related('account_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True),
 327
 328     }
 329
 330     def _get_default_date(self, cr, uid, context=None):
 331         return fields.date.context_today(self, cr, uid, context=context)
 332
 333     def __get_default_date(self, cr, uid, context=None):
 334         return self._get_default_date(cr, uid, context=context)
 335
 336     _defaults = {
 337         'date': __get_default_date,
 338         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'account.analytic.line', context=c),
 339         'amount': 0.00
 340     }
 341
 342     _order = 'date desc'
 343
 344     def _check_no_view(self, cr, uid, ids, context=None):
 345         analytic_lines = self.browse(cr, uid, ids, context=context)
 346         for line in analytic_lines:
 347             if line.account_id.type == 'view':
 348                 return False
 349         return True
 350
 351     _constraints = [
 352         (_check_no_view, 'You cannot create analytic line on view account.', ['account_id']),
 353     ]
 354
 355 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: