addons/purchase/purchase.py

   1 # -*- encoding: utf-8 -*-
   2 ##############################################################################
   3 #
   4 # Copyright (c) 2004-2008 TINY SPRL. (http://tiny.be) All Rights Reserved.
   5 #
   6 # $Id$
   7 #
   8 # WARNING: This program as such is intended to be used by professional
   9 # programmers who take the whole responsability of assessing all potential
  10 # consequences resulting from its eventual inadequacies and bugs
  11 # End users who are looking for a ready-to-use solution with commercial
  12 # garantees and support are strongly adviced to contract a Free Software
  13 # Service Company
  14 #
  15 # This program is Free Software; you can redistribute it and/or
  16 # modify it under the terms of the GNU General Public License
  17 # as published by the Free Software Foundation; either version 2
  18 # of the License, or (at your option) any later version.
  19 #
  20 # This program is distributed in the hope that it will be useful,
  21 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 # GNU General Public License for more details.
  24 #
  25 # You should have received a copy of the GNU General Public License
  26 # along with this program; if not, write to the Free Software
  27 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  28 #
  29 ##############################################################################
  30
  31 from osv import fields
  32 from osv import osv
  33 import time
  34 import netsvc
  35
  36 import ir
  37 from mx import DateTime
  38 import pooler
  39 from tools import config
  40 from tools.translate import _
  41
  42 #
  43 # Model definition
  44 #
  45 class purchase_order(osv.osv):
  46     def _calc_amount(self, cr, uid, ids, prop, unknow_none, unknow_dict):
  47         res = {}
  48         for order in self.browse(cr, uid, ids):
  49             res[order.id] = 0
  50             for oline in order.order_line:
  51                 res[order.id] += oline.price_unit * oline.product_qty
  52         return res
  53
  54     def _amount_untaxed(self, cr, uid, ids, field_name, arg, context):
  55         res = {}
  56         cur_obj=self.pool.get('res.currency')
  57         for purchase in self.browse(cr, uid, ids):
  58             res[purchase.id] = 0.0
  59             for line in purchase.order_line:
  60                 res[purchase.id] += line.price_subtotal
  61             cur = purchase.pricelist_id.currency_id
  62             res[purchase.id] = cur_obj.round(cr, uid, cur, res[purchase.id])
  63
  64         return res
  65
  66     def _amount_tax(self, cr, uid, ids, field_name, arg, context):
  67         res = {}
  68         cur_obj=self.pool.get('res.currency')
  69         for order in self.browse(cr, uid, ids):
  70             val = 0.0
  71             cur=order.pricelist_id.currency_id
  72             for line in order.order_line:
  73                 for c in self.pool.get('account.tax').compute(cr, uid, line.taxes_id, line.price_unit, line.product_qty, order.partner_address_id.id, line.product_id, order.partner_id):
  74                     val+= cur_obj.round(cr, uid, cur, c['amount'])
  75             res[order.id]=cur_obj.round(cr, uid, cur, val)
  76         return res
  77
  78     def _amount_total(self, cr, uid, ids, field_name, arg, context):
  79         res = {}
  80         untax = self._amount_untaxed(cr, uid, ids, field_name, arg, context)
  81         tax = self._amount_tax(cr, uid, ids, field_name, arg, context)
  82         cur_obj=self.pool.get('res.currency')
  83         for id in ids:
  84             order=self.browse(cr, uid, [id])[0]
  85             cur=order.pricelist_id.currency_id
  86             res[id] = cur_obj.round(cr, uid, cur, untax.get(id, 0.0) + tax.get(id, 0.0))
  87         return res
  88
  89     def _set_minimum_planned_date(self, cr, uid, ids, name, value, arg, context):
  90         if not value: return False
  91         if type(ids)!=type([]):
  92             ids=[ids]
  93         for po in self.browse(cr, uid, ids, context):
  94             cr.execute("""update purchase_order_line set
  95                     date_planned=%s
  96                 where
  97                     order_id=%d and
  98                     (date_planned=%s or date_planned<%s)""", (value,po.id,po.minimum_planned_date,value))
  99         return True
 100
 101     def _minimum_planned_date(self, cr, uid, ids, field_name, arg, context):
 102         res={}
 103         purchase_obj=self.browse(cr, uid, ids, context=context)
 104         for purchase in purchase_obj:
 105             res[purchase.id] = False
 106             if purchase.order_line:
 107                 min_date=purchase.order_line[0].date_planned
 108                 for line in purchase.order_line:
 109                     if line.date_planned < min_date:
 110                         min_date=line.date_planned
 111                 res[purchase.id]=min_date
 112         return res
 113
 114     def _invoiced_rate(self, cursor, user, ids, name, arg, context=None):
 115         res = {}
 116         for purchase in self.browse(cursor, user, ids, context=context):
 117             tot = 0.0
 118             if purchase.invoice_id and purchase.invoice_id.state not in ('draft','cancel'):
 119                 tot += purchase.invoice_id.amount_untaxed
 120             if purchase.amount_untaxed:
 121                 res[purchase.id] = tot * 100.0 / purchase.amount_untaxed
 122             else:
 123                 res[purchase.id] = 0.0
 124         return res
 125
 126     def _shipped_rate(self, cr, uid, ids, name, arg, context=None):
 127         if not ids: return {}
 128         res = {}
 129         for id in ids:
 130             res[id] = [0.0,0.0]
 131         cr.execute('''SELECT
 132                 p.purchase_id,sum(m.product_qty), m.state
 133             FROM
 134                 stock_move m
 135             LEFT JOIN
 136                 stock_picking p on (p.id=m.picking_id)
 137             WHERE
 138                 p.purchase_id in ('''+','.join(map(str,ids))+''')
 139             GROUP BY m.state, p.purchase_id''')
 140         for oid,nbr,state in cr.fetchall():
 141             if state=='cancel':
 142                 continue
 143             if state=='done':
 144                 res[oid][0] += nbr or 0.0
 145                 res[oid][1] += nbr or 0.0
 146             else:
 147                 res[oid][1] += nbr or 0.0
 148         for r in res:
 149             if not res[r][1]:
 150                 res[r] = 0.0
 151             else:
 152                 res[r] = 100.0 * res[r][0] / res[r][1]
 153         return res
 154
 155     _columns = {
 156         'name': fields.char('Order Reference', size=64, required=True, select=True),
 157         'origin': fields.char('Origin', size=64,
 158             help="Reference of the document that generated this purchase order request."
 159         ),
 160         'partner_ref': fields.char('Partner Ref.', size=64),
 161         'date_order':fields.date('Date Ordered', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}),
 162         'date_approve':fields.date('Date Approved', readonly=1),
 163         'partner_id':fields.many2one('res.partner', 'Supplier', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}, change_default=True),
 164         'partner_address_id':fields.many2one('res.partner.address', 'Address', required=True, states={'posted':[('readonly',True)]}),
 165
 166         'dest_address_id':fields.many2one('res.partner.address', 'Destination Address', states={'posted':[('readonly',True)]},
 167             help="Put an address if you want to deliver directly from the supplier to the customer." \
 168                 "In this case, it will remove the warehouse link and set the customer location."
 169         ),
 170         'warehouse_id': fields.many2one('stock.warehouse', 'Warehouse', states={'posted':[('readonly',True)]}),
 171         'location_id': fields.many2one('stock.location', 'Destination', required=True),
 172
 173         'pricelist_id':fields.many2one('product.pricelist', 'Pricelist', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}, help="The pricelist sets the currency used for this purchase order. It also computes the supplier price for the selected products/quantities."),
 174
 175         'state': fields.selection([('draft', 'Request for Quotation'), ('wait', 'Waiting'), ('confirmed', 'Confirmed'), ('approved', 'Approved'),('except_picking', 'Shipping Exception'), ('except_invoice', 'Invoice Exception'), ('done', 'Done'), ('cancel', 'Cancelled')], 'Order Status', readonly=True, help="The state of the purchase order or the quotation request. A quotation is a purchase order in a 'Draft' state. Then the order has to be confirmed by the user, the state switch to 'Confirmed'. Then the supplier must confirm the order to change the state to 'Approved'. When the purchase order is paid and received, the state becomes 'Done'. If a cancel action occurs in the invoice or in the reception of goods, the state becomes in exception.", select=True),
 176         'order_line': fields.one2many('purchase.order.line', 'order_id', 'Order Lines', states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}),
 177         'validator' : fields.many2one('res.users', 'Validated by', readonly=True),
 178         'notes': fields.text('Notes'),
 179         'invoice_id': fields.many2one('account.invoice', 'Invoice', readonly=True),
 180         'picking_ids': fields.one2many('stock.picking', 'purchase_id', 'Picking List', readonly=True, help="This is the list of picking list that have been generated for this purchase"),
 181         'shipped':fields.boolean('Received', readonly=True, select=True),
 182         'shipped_rate': fields.function(_shipped_rate, method=True, string='Received', type='float'),
 183         'invoiced':fields.boolean('Invoiced & Paid', readonly=True, select=True),
 184         'invoiced_rate': fields.function(_invoiced_rate, method=True, string='Invoiced', type='float'),
 185         'invoice_method': fields.selection([('manual','Manual'),('order','From Order'),('picking','From Picking')], 'Invoicing Control', required=True,
 186             help="From Order: a draft invoice will be pre-generated based on the purchase order. The accountant " \
 187                 "will just have to validate this invoice for control.\n" \
 188                 "From Picking: a draft invoice will be pre-genearted based on validated receptions.\n" \
 189                 "Manual: no invoice will be pre-generated. The accountant will have to encode manually."
 190         ),
 191         'minimum_planned_date':fields.function(_minimum_planned_date, fnct_inv=_set_minimum_planned_date, method=True,store=True, string='Planned Date', type='datetime', help="This is computed as the minimum scheduled date of all purchase order lines' products."),
 192         'amount_untaxed': fields.function(_amount_untaxed, method=True, string='Untaxed Amount'),
 193         'amount_tax': fields.function(_amount_tax, method=True, string='Taxes'),
 194         'amount_total': fields.function(_amount_total, method=True, string='Total'),
 195     }
 196     _defaults = {
 197         'date_order': lambda *a: time.strftime('%Y-%m-%d'),
 198         'state': lambda *a: 'draft',
 199         'name': lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'purchase.order'),
 200         'shipped': lambda *a: 0,
 201         'invoice_method': lambda *a: 'order',
 202         'invoiced': lambda *a: 0,
 203         'partner_address_id': lambda self, cr, uid, context: context.get('partner_id', False) and self.pool.get('res.partner').address_get(cr, uid, [context['partner_id']], ['default'])['default'],
 204         'pricelist_id': lambda self, cr, uid, context: context.get('partner_id', False) and self.pool.get('res.partner').browse(cr, uid, context['partner_id']).property_product_pricelist_purchase.id,
 205     }
 206     _name = "purchase.order"
 207     _description = "Purchase order"
 208     _order = "name desc"
 209
 210     def button_dummy(self, cr, uid, ids, context={}):
 211         return True
 212
 213     def onchange_dest_address_id(self, cr, uid, ids, adr_id):
 214         if not adr_id:
 215             return {}
 216         part_id = self.pool.get('res.partner.address').read(cr, uid, [adr_id], ['partner_id'])[0]['partner_id'][0]
 217         loc_id = self.pool.get('res.partner').browse(cr, uid, part_id).property_stock_customer.id
 218         return {'value':{'location_id': loc_id, 'warehouse_id': False}}
 219
 220     def onchange_warehouse_id(self, cr, uid, ids, warehouse_id):
 221         if not warehouse_id:
 222             return {}
 223         res = self.pool.get('stock.warehouse').read(cr, uid, [warehouse_id], ['lot_input_id'])[0]['lot_input_id'][0]
 224         return {'value':{'location_id': res, 'dest_address_id': False}}
 225
 226     def onchange_partner_id(self, cr, uid, ids, part):
 227         if not part:
 228             return {'value':{'partner_address_id': False}}
 229         addr = self.pool.get('res.partner').address_get(cr, uid, [part], ['default'])
 230         pricelist = self.pool.get('res.partner').property_get(cr, uid,
 231                                         part,property_pref=['property_product_pricelist_purchase']).get('property_product_pricelist_purchase',False)
 232         return {'value':{'partner_address_id': addr['default'], 'pricelist_id': pricelist}}
 233
 234     def wkf_approve_order(self, cr, uid, ids):
 235         self.write(cr, uid, ids, {'state': 'approved', 'date_approve': time.strftime('%Y-%m-%d')})
 236         return True
 237
 238     def wkf_confirm_order(self, cr, uid, ids, context={}):
 239         for po in self.browse(cr, uid, ids):
 240             if self.pool.get('res.partner.event.type').check(cr, uid, 'purchase_open'):
 241                 self.pool.get('res.partner.event').create(cr, uid, {'name':'Purchase Order: '+po.name, 'partner_id':po.partner_id.id, 'date':time.strftime('%Y-%m-%d %H:%M:%S'), 'user_id':uid, 'partner_type':'retailer', 'probability': 1.0, 'planned_cost':po.amount_untaxed})
 242         current_name = self.name_get(cr, uid, ids)[0][1]
 243         for id in ids:
 244             self.write(cr, uid, [id], {'state' : 'confirmed', 'validator' : uid})
 245         return True
 246
 247     def wkf_warn_buyer(self, cr, uid, ids):
 248         self.write(cr, uid, ids, {'state' : 'wait', 'validator' : uid})
 249         request = pooler.get_pool(cr.dbname).get('res.request')
 250         for po in self.browse(cr, uid, ids):
 251             managers = []
 252             for oline in po.order_line:
 253                 manager = oline.product_id.product_manager
 254                 if manager and not (manager.id in managers):
 255                     managers.append(manager.id)
 256             for manager_id in managers:
 257                 request.create(cr, uid,
 258                       {'name' : "Purchase amount over the limit",
 259                        'act_from' : uid,
 260                        'act_to' : manager_id,
 261                        'body': 'Somebody has just confirmed a purchase with an amount over the defined limit',
 262                        'ref_partner_id': po.partner_id.id,
 263                        'ref_doc1': 'purchase.order,%d' % (po.id,),
 264                        })
 265     def inv_line_create(self,a,ol):
 266         return (0, False, {
 267                     'name': ol.name,
 268                     'account_id': a,
 269                     'price_unit': ol.price_unit or 0.0,
 270                     'quantity': ol.product_qty,
 271                     'product_id': ol.product_id.id or False,
 272                     'uos_id': ol.product_uom.id or False,
 273                     'invoice_line_tax_id': [(6, 0, [x.id for x in ol.taxes_id])],
 274                     'account_analytic_id': ol.account_analytic_id.id,
 275                 })
 276
 277     def action_invoice_create(self, cr, uid, ids, *args):
 278         res = False
 279         for o in self.browse(cr, uid, ids):
 280             il = []
 281             for ol in o.order_line:
 282
 283                 if ol.product_id:
 284                     a = ol.product_id.product_tmpl_id.property_account_expense.id
 285                     if not a:
 286                         a = ol.product_id.categ_id.property_account_expense_categ.id
 287                     if not a:
 288                         raise osv.except_osv(_('Error !'), _('There is no expense account defined for this product: "%s" (id:%d)') % (ol.product_id.name, ol.product_id.id,))
 289                 else:
 290                     a = self.pool.get('ir.property').get(cr, uid, 'property_account_expense_categ', 'product.category')
 291                 il.append(self.inv_line_create(a,ol))
 292 #               il.append((0, False, {
 293 #                   'name': ol.name,
 294 #                   'account_id': a,
 295 #                   'price_unit': ol.price_unit or 0.0,
 296 #                   'quantity': ol.product_qty,
 297 #                   'product_id': ol.product_id.id or False,
 298 #                   'uos_id': ol.product_uom.id or False,
 299 #                   'invoice_line_tax_id': [(6, 0, [x.id for x in ol.taxes_id])],
 300 #                   'account_analytic_id': ol.account_analytic_id.id,
 301 #               }))
 302
 303             a = o.partner_id.property_account_payable.id
 304             inv = {
 305                 'name': o.partner_ref or o.name,
 306                 'reference': "P%dPO%d" % (o.partner_id.id, o.id),
 307                 'account_id': a,
 308                 'type': 'in_invoice',
 309                 'partner_id': o.partner_id.id,
 310                 'currency_id': o.pricelist_id.currency_id.id,
 311                 'address_invoice_id': o.partner_address_id.id,
 312                 'address_contact_id': o.partner_address_id.id,
 313                 'origin': o.name,
 314                 'invoice_line': il,
 315             }
 316             inv_id = self.pool.get('account.invoice').create(cr, uid, inv, {'type':'in_invoice'})
 317             self.pool.get('account.invoice').button_compute(cr, uid, [inv_id], {'type':'in_invoice'}, set_total=True)
 318
 319             self.write(cr, uid, [o.id], {'invoice_id': inv_id})
 320             res = inv_id
 321         return res
 322
 323     def has_stockable_product(self,cr, uid, ids, *args):
 324         for order in self.browse(cr, uid, ids):
 325             for order_line in order.order_line:
 326                 if order_line.product_id and order_line.product_id.product_tmpl_id.type in ('product', 'consu'):
 327                     return True
 328         return False
 329
 330     def action_picking_create(self,cr, uid, ids, *args):
 331         picking_id = False
 332         for order in self.browse(cr, uid, ids):
 333             loc_id = order.partner_id.property_stock_supplier.id
 334             istate = 'none'
 335             if order.invoice_method=='picking':
 336                 istate = '2binvoiced'
 337             picking_id = self.pool.get('stock.picking').create(cr, uid, {
 338                 'origin': order.name+((order.origin and (':'+order.origin)) or ''),
 339                 'type': 'in',
 340                 'address_id': order.dest_address_id.id or order.partner_address_id.id,
 341                 'invoice_state': istate,
 342                 'purchase_id': order.id,
 343             })
 344             for order_line in order.order_line:
 345                 if not order_line.product_id:
 346                     continue
 347                 if order_line.product_id.product_tmpl_id.type in ('product', 'consu'):
 348                     dest = order.location_id.id
 349                     self.pool.get('stock.move').create(cr, uid, {
 350                         'name': 'PO:'+order_line.name,
 351                         'product_id': order_line.product_id.id,
 352                         'product_qty': order_line.product_qty,
 353                         'product_uos_qty': order_line.product_qty,
 354                         'product_uom': order_line.product_uom.id,
 355                         'product_uos': order_line.product_uom.id,
 356                         'date_planned': order_line.date_planned,
 357                         'location_id': loc_id,
 358                         'location_dest_id': dest,
 359                         'picking_id': picking_id,
 360                         'move_dest_id': order_line.move_dest_id.id,
 361                         'state': 'assigned',
 362                         'purchase_line_id': order_line.id,
 363                     })
 364                     if order_line.move_dest_id:
 365                         self.pool.get('stock.move').write(cr, uid, [order_line.move_dest_id.id], {'location_id':order.location_id.id})
 366             wf_service = netsvc.LocalService("workflow")
 367             wf_service.trg_validate(uid, 'stock.picking', picking_id, 'button_confirm', cr)
 368         return picking_id
 369     def copy(self, cr, uid, id, default=None,context={}):
 370         if not default:
 371             default = {}
 372         default.update({
 373             'state':'draft',
 374             'shipped':False,
 375             'invoiced':False,
 376             'invoice_id':False,
 377             'picking_ids':[],
 378             'name': self.pool.get('ir.sequence').get(cr, uid, 'purchase.order'),
 379         })
 380         return super(purchase_order, self).copy(cr, uid, id, default, context)
 381
 382 purchase_order()
 383
 384 class purchase_order_line(osv.osv):
 385     def _amount_line(self, cr, uid, ids, prop, unknow_none,unknow_dict):
 386         res = {}
 387         cur_obj=self.pool.get('res.currency')
 388         for line in self.browse(cr, uid, ids):
 389             cur = line.order_id.pricelist_id.currency_id
 390             res[line.id] = cur_obj.round(cr, uid, cur, line.price_unit * line.product_qty)
 391         return res
 392
 393     _columns = {
 394         'name': fields.char('Description', size=64, required=True),
 395         'product_qty': fields.float('Quantity', required=True, digits=(16,2)),
 396         'date_planned': fields.datetime('Scheduled date', required=True),
 397         'taxes_id': fields.many2many('account.tax', 'purchase_order_taxe', 'ord_id', 'tax_id', 'Taxes'),
 398         'product_uom': fields.many2one('product.uom', 'Product UOM', required=True),
 399         'product_id': fields.many2one('product.product', 'Product', domain=[('purchase_ok','=',True)], change_default=True),
 400         'move_id': fields.many2one('stock.move', 'Reservation', ondelete='set null'),
 401         'move_dest_id': fields.many2one('stock.move', 'Reservation Destination', ondelete='set null'),
 402         'price_unit': fields.float('Unit Price', required=True, digits=(16, int(config['price_accuracy']))),
 403         'price_subtotal': fields.function(_amount_line, method=True, string='Subtotal'),
 404         'notes': fields.text('Notes'),
 405         'order_id': fields.many2one('purchase.order', 'Order Ref', select=True, required=True, ondelete='cascade'),
 406         'account_analytic_id':fields.many2one('account.analytic.account', 'Analytic Account',),
 407     }
 408     _defaults = {
 409         'product_qty': lambda *a: 1.0
 410     }
 411     _table = 'purchase_order_line'
 412     _name = 'purchase.order.line'
 413     _description = 'Purchase Order lines'
 414     def copy(self, cr, uid, id, default=None,context={}):
 415         if not default:
 416             default = {}
 417         default.update({'state':'draft', 'move_id':False})
 418         return super(purchase_order_line, self).copy(cr, uid, id, default, context)
 419
 420     def product_id_change(self, cr, uid, ids, pricelist, product, qty, uom,
 421             partner_id, date_order=False):
 422         prod= self.pool.get('product.product').browse(cr, uid,product)
 423         if not pricelist:
 424             raise osv.except_osv(_('No Pricelist !'), _('You have to select a pricelist in the purchase form !\nPlease set one before choosing a product.'))
 425         if not product:
 426             return {'value': {'price_unit': 0.0, 'name':'','notes':'', 'product_uom' : False}, 'domain':{'product_uom':[]}}
 427         lang=False
 428         if partner_id:
 429             lang=self.pool.get('res.partner').read(cr, uid, partner_id)['lang']
 430         context={'lang':lang}
 431
 432         prod = self.pool.get('product.product').read(cr, uid, product, ['supplier_taxes_id','name','seller_delay','uom_po_id','description_purchase'],context=context)
 433         prod_uom_po = prod['uom_po_id'][0]
 434         if not uom:
 435             uom = prod_uom_po
 436         if not date_order:
 437             date_order = time.strftime('%Y-%m-%d')
 438         price = self.pool.get('product.pricelist').price_get(cr,uid,[pricelist],
 439                 product, qty or 1.0, partner_id, {
 440                     'uom': uom,
 441                     'date': date_order,
 442                     })[pricelist]
 443         dt = (DateTime.now() + DateTime.RelativeDateTime(days=prod['seller_delay'] or 0.0)).strftime('%Y-%m-%d %H:%M:%S')
 444         prod_name = self.pool.get('product.product').name_get(cr, uid, [product], context=context)[0][1]
 445
 446         res = {'value': {'price_unit': price, 'name':prod_name, 'taxes_id':prod['supplier_taxes_id'], 'date_planned': dt,'notes':prod['description_purchase'], 'product_uom': uom}}
 447         domain = {}
 448
 449
 450         taxes = self.pool.get('account.tax').browse(cr, uid,prod['supplier_taxes_id'])
 451         taxep = None
 452         if partner_id:
 453             taxep_id = self.pool.get('res.partner').property_get(cr, uid,partner_id,property_pref=['property_account_supplier_tax']).get('property_account_supplier_tax',False)
 454             if taxep_id:
 455                                 taxep=self.pool.get('account.tax').browse(cr, uid,taxep_id)
 456         if not taxep or not taxep.id:
 457             res['value']['taxes_id'] = [x.id for x in product.taxes_id]
 458         else:
 459             res5 = [taxep.id]
 460             for t in taxes:
 461                 if not t.tax_group==taxep.tax_group:
 462                     res5.append(t.id)
 463             res['value']['taxes_id'] = res5
 464
 465         res2 = self.pool.get('product.uom').read(cr, uid, [uom], ['category_id'])
 466         res3 = self.pool.get('product.uom').read(cr, uid, [prod_uom_po], ['category_id'])
 467         domain = {'product_uom':[('category_id','=',res2[0]['category_id'][0])]}
 468         if res2[0]['category_id'] != res3[0]['category_id']:
 469             raise osv.except_osv(_('Wrong Product UOM !'), _('You have to select a product UOM in the same category than the purchase UOM of the product'))
 470
 471         res['domain'] = domain
 472         return res
 473
 474     def product_uom_change(self, cr, uid, ids, pricelist, product, qty, uom,
 475             partner_id, date_order=False):
 476         res = self.product_id_change(cr, uid, ids, pricelist, product, qty, uom,
 477                 partner_id, date_order=date_order)
 478         if 'product_uom' in res['value']:
 479             del res['value']['product_uom']
 480         if not uom:
 481             res['value']['price_unit'] = 0.0
 482         return res
 483 purchase_order_line()
 484
 485 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:
 486