addons/purchase/purchase.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 from dateutil.relativedelta import relativedelta
  25
  26 from osv import osv, fields
  27 import netsvc
  28 import pooler
  29 from tools.translate import _
  30 import decimal_precision as dp
  31 from osv.orm import browse_record, browse_null
  32
  33 #
  34 # Model definition
  35 #
  36 class purchase_order(osv.osv):
  37
  38     def _calc_amount(self, cr, uid, ids, prop, unknow_none, unknow_dict):
  39         res = {}
  40         for order in self.browse(cr, uid, ids):
  41             res[order.id] = 0
  42             for oline in order.order_line:
  43                 res[order.id] += oline.price_unit * oline.product_qty
  44         return res
  45
  46     def _amount_all(self, cr, uid, ids, field_name, arg, context=None):
  47         res = {}
  48         cur_obj=self.pool.get('res.currency')
  49         for order in self.browse(cr, uid, ids, context=context):
  50             res[order.id] = {
  51                 'amount_untaxed': 0.0,
  52                 'amount_tax': 0.0,
  53                 'amount_total': 0.0,
  54             }
  55             val = val1 = 0.0
  56             cur = order.pricelist_id.currency_id
  57             for line in order.order_line:
  58                val1 += line.price_subtotal
  59                for c in self.pool.get('account.tax').compute_all(cr, uid, line.taxes_id, line.price_unit, line.product_qty, order.partner_address_id.id, line.product_id.id, order.partner_id)['taxes']:
  60                     val += c.get('amount', 0.0)
  61             res[order.id]['amount_tax']=cur_obj.round(cr, uid, cur, val)
  62             res[order.id]['amount_untaxed']=cur_obj.round(cr, uid, cur, val1)
  63             res[order.id]['amount_total']=res[order.id]['amount_untaxed'] + res[order.id]['amount_tax']
  64         return res
  65
  66     def _set_minimum_planned_date(self, cr, uid, ids, name, value, arg, context=None):
  67         if not value: return False
  68         if type(ids)!=type([]):
  69             ids=[ids]
  70         for po in self.browse(cr, uid, ids, context=context):
  71             cr.execute("""update purchase_order_line set
  72                     date_planned=%s
  73                 where
  74                     order_id=%s and
  75                     (date_planned=%s or date_planned<%s)""", (value,po.id,po.minimum_planned_date,value))
  76         return True
  77
  78     def _minimum_planned_date(self, cr, uid, ids, field_name, arg, context=None):
  79         res={}
  80         purchase_obj=self.browse(cr, uid, ids, context=context)
  81         for purchase in purchase_obj:
  82             res[purchase.id] = time.strftime('%Y-%m-%d %H:%M:%S')
  83             if purchase.order_line:
  84                 min_date=purchase.order_line[0].date_planned
  85                 for line in purchase.order_line:
  86                     if line.date_planned < min_date:
  87                         min_date=line.date_planned
  88                 res[purchase.id]=min_date
  89         return res
  90
  91
  92     def _invoiced_rate(self, cursor, user, ids, name, arg, context=None):
  93         res = {}
  94         for purchase in self.browse(cursor, user, ids, context=context):
  95             tot = 0.0
  96             for invoice in purchase.invoice_ids:
  97                 if invoice.state not in ('draft','cancel'):
  98                     tot += invoice.amount_untaxed
  99             if purchase.amount_untaxed:
 100                 res[purchase.id] = tot * 100.0 / purchase.amount_untaxed
 101             else:
 102                 res[purchase.id] = 0.0
 103         return res
 104
 105     def _shipped_rate(self, cr, uid, ids, name, arg, context=None):
 106         if not ids: return {}
 107         res = {}
 108         for id in ids:
 109             res[id] = [0.0,0.0]
 110         cr.execute('''SELECT
 111                 p.purchase_id,sum(m.product_qty), m.state
 112             FROM
 113                 stock_move m
 114             LEFT JOIN
 115                 stock_picking p on (p.id=m.picking_id)
 116             WHERE
 117                 p.purchase_id IN %s GROUP BY m.state, p.purchase_id''',(tuple(ids),))
 118         for oid,nbr,state in cr.fetchall():
 119             if state=='cancel':
 120                 continue
 121             if state=='done':
 122                 res[oid][0] += nbr or 0.0
 123                 res[oid][1] += nbr or 0.0
 124             else:
 125                 res[oid][1] += nbr or 0.0
 126         for r in res:
 127             if not res[r][1]:
 128                 res[r] = 0.0
 129             else:
 130                 res[r] = 100.0 * res[r][0] / res[r][1]
 131         return res
 132
 133     def _get_order(self, cr, uid, ids, context=None):
 134         result = {}
 135         for line in self.pool.get('purchase.order.line').browse(cr, uid, ids, context=context):
 136             result[line.order_id.id] = True
 137         return result.keys()
 138
 139     def _invoiced(self, cursor, user, ids, name, arg, context=None):
 140         res = {}
 141         for purchase in self.browse(cursor, user, ids, context=context):
 142             invoiced = False
 143             if purchase.invoiced_rate == 100.00:
 144                 invoiced = True
 145             res[purchase.id] = invoiced
 146         return res
 147
 148     STATE_SELECTION = [
 149         ('draft', 'Request for Quotation'),
 150         ('wait', 'Waiting'),
 151         ('confirmed', 'Waiting Supplier Ack'),
 152         ('approved', 'Approved'),
 153         ('except_picking', 'Shipping Exception'),
 154         ('except_invoice', 'Invoice Exception'),
 155         ('done', 'Done'),
 156         ('cancel', 'Cancelled')
 157     ]
 158
 159     _columns = {
 160         'name': fields.char('Order Reference', size=64, required=True, select=True, help="unique number of the purchase order,computed automatically when the purchase order is created"),
 161         'origin': fields.char('Source Document', size=64,
 162             help="Reference of the document that generated this purchase order request."
 163         ),
 164         'partner_ref': fields.char('Supplier Reference', states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]}, size=64),
 165         'date_order':fields.date('Date Ordered', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}, help="Date on which this document has been created."),
 166         'date_approve':fields.date('Date Approved', readonly=1, help="Date on which purchase order has been approved"),
 167         'partner_id':fields.many2one('res.partner', 'Supplier', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]}, change_default=True),
 168         'partner_address_id':fields.many2one('res.partner.address', 'Address', required=True,
 169             states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]},domain="[('partner_id', '=', partner_id)]"),
 170         'dest_address_id':fields.many2one('res.partner.address', 'Destination Address',
 171             states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]},
 172             help="Put an address if you want to deliver directly from the supplier to the customer." \
 173                 "In this case, it will remove the warehouse link and set the customer location."
 174         ),
 175         'warehouse_id': fields.many2one('stock.warehouse', 'Warehouse', states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]}),
 176         'location_id': fields.many2one('stock.location', 'Destination', required=True, domain=[('usage','<>','view')]),
 177         'pricelist_id':fields.many2one('product.pricelist', 'Pricelist', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]}, help="The pricelist sets the currency used for this purchase order. It also computes the supplier price for the selected products/quantities."),
 178         'state': fields.selection(STATE_SELECTION, 'State', 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),
 179         'order_line': fields.one2many('purchase.order.line', 'order_id', 'Order Lines', states={'approved':[('readonly',True)],'done':[('readonly',True)]}),
 180         'validator' : fields.many2one('res.users', 'Validated by', readonly=True),
 181         'notes': fields.text('Notes'),
 182         'invoice_ids': fields.many2many('account.invoice', 'purchase_invoice_rel', 'purchase_id', 'invoice_id', 'Invoices', help="Invoices generated for a purchase order"),
 183         '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"),
 184         'shipped':fields.boolean('Received', readonly=True, select=True, help="It indicates that a picking has been done"),
 185         'shipped_rate': fields.function(_shipped_rate, method=True, string='Received', type='float'),
 186         'invoiced': fields.function(_invoiced, method=True, string='Invoiced & Paid', type='boolean', help="It indicates that an invoice has been paid"),
 187         'invoiced_rate': fields.function(_invoiced_rate, method=True, string='Invoiced', type='float'),
 188         'invoice_method': fields.selection([('manual','Manual'),('order','From Order'),('picking','From Picking')], 'Invoicing Control', required=True,
 189             help="From Order: a draft invoice will be pre-generated based on the purchase order. The accountant " \
 190                 "will just have to validate this invoice for control.\n" \
 191                 "From Picking: a draft invoice will be pre-generated based on validated receptions.\n" \
 192                 "Manual: allows you to generate suppliers invoices by chosing in the uninvoiced lines of all manual purchase orders."
 193         ),
 194         'minimum_planned_date':fields.function(_minimum_planned_date, fnct_inv=_set_minimum_planned_date, method=True,store=True, string='Expected Date', type='date', help="This is computed as the minimum scheduled date of all purchase order lines' products."),
 195         'amount_untaxed': fields.function(_amount_all, method=True, digits_compute= dp.get_precision('Purchase Price'), string='Untaxed Amount',
 196             store={
 197                 'purchase.order.line': (_get_order, None, 10),
 198             }, multi="sums", help="The amount without tax"),
 199         'amount_tax': fields.function(_amount_all, method=True, digits_compute= dp.get_precision('Purchase Price'), string='Taxes',
 200             store={
 201                 'purchase.order.line': (_get_order, None, 10),
 202             }, multi="sums", help="The tax amount"),
 203         'amount_total': fields.function(_amount_all, method=True, digits_compute= dp.get_precision('Purchase Price'), string='Total',
 204             store={
 205                 'purchase.order.line': (_get_order, None, 10),
 206             }, multi="sums",help="The total amount"),
 207         'fiscal_position': fields.many2one('account.fiscal.position', 'Fiscal Position'),
 208         'product_id': fields.related('order_line','product_id', type='many2one', relation='product.product', string='Product'),
 209         'create_uid':  fields.many2one('res.users', 'Responsible'),
 210         'company_id': fields.many2one('res.company','Company',required=True,select=1),
 211     }
 212     _defaults = {
 213         'date_order': time.strftime('%Y-%m-%d'),
 214         'state': 'draft',
 215         'name': lambda obj, cr, uid, context: obj.pool.get('ir.sequence').get(cr, uid, 'purchase.order'),
 216         'shipped': 0,
 217         'invoice_method': 'order',
 218         'invoiced': 0,
 219         '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'],
 220         '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,
 221         'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'purchase.order', context=c),
 222     }
 223     _sql_constraints = [
 224         ('name_uniq', 'unique(name)', 'Order Reference must be unique !'),
 225     ]
 226     _name = "purchase.order"
 227     _description = "Purchase Order"
 228     _order = "name desc"
 229
 230     def unlink(self, cr, uid, ids, context=None):
 231         purchase_orders = self.read(cr, uid, ids, ['state'], context=context)
 232         unlink_ids = []
 233         for s in purchase_orders:
 234             if s['state'] in ['draft','cancel']:
 235                 unlink_ids.append(s['id'])
 236             else:
 237                 raise osv.except_osv(_('Invalid action !'), _('Cannot delete Purchase Order(s) which are in %s State!')  % _(dict(purchase_order.STATE_SELECTION).get(s['state'])))
 238
 239         # TODO: temporary fix in 5.0, to remove in 5.2 when subflows support
 240         # automatically sending subflow.delete upon deletion
 241         wf_service = netsvc.LocalService("workflow")
 242         for id in unlink_ids:
 243             wf_service.trg_validate(uid, 'purchase.order', id, 'purchase_cancel', cr)
 244
 245         return super(purchase_order, self).unlink(cr, uid, unlink_ids, context=context)
 246
 247     def button_dummy(self, cr, uid, ids, context=None):
 248         return True
 249
 250     def onchange_dest_address_id(self, cr, uid, ids, adr_id):
 251         if not adr_id:
 252             return {}
 253         part_id = self.pool.get('res.partner.address').read(cr, uid, [adr_id], ['partner_id'])[0]['partner_id'][0]
 254         loc_id = self.pool.get('res.partner').browse(cr, uid, part_id).property_stock_customer.id
 255         return {'value':{'location_id': loc_id, 'warehouse_id': False}}
 256
 257     def onchange_warehouse_id(self, cr, uid, ids, warehouse_id):
 258         if not warehouse_id:
 259             return {}
 260         res = self.pool.get('stock.warehouse').read(cr, uid, [warehouse_id], ['lot_input_id'])[0]['lot_input_id'][0]
 261         return {'value':{'location_id': res, 'dest_address_id': False}}
 262
 263     def onchange_partner_id(self, cr, uid, ids, part):
 264
 265         if not part:
 266             return {'value':{'partner_address_id': False, 'fiscal_position': False}}
 267         addr = self.pool.get('res.partner').address_get(cr, uid, [part], ['default'])
 268         part = self.pool.get('res.partner').browse(cr, uid, part)
 269         pricelist = part.property_product_pricelist_purchase.id
 270         fiscal_position = part.property_account_position and part.property_account_position.id or False
 271         return {'value':{'partner_address_id': addr['default'], 'pricelist_id': pricelist, 'fiscal_position': fiscal_position}}
 272
 273     def wkf_approve_order(self, cr, uid, ids, context=None):
 274         self.write(cr, uid, ids, {'state': 'approved', 'date_approve': time.strftime('%Y-%m-%d')})
 275         return True
 276
 277     #TODO: implement messages system
 278     def wkf_confirm_order(self, cr, uid, ids, context=None):
 279         todo = []
 280         for po in self.browse(cr, uid, ids, context=context):
 281             if not po.order_line:
 282                 raise osv.except_osv(_('Error !'),_('You can not confirm purchase order without Purchase Order Lines.'))
 283             for line in po.order_line:
 284                 if line.state=='draft':
 285                     todo.append(line.id)
 286             message = _("Purchase order '%s' is confirmed.") % (po.name,)
 287             self.log(cr, uid, po.id, message)
 288 #        current_name = self.name_get(cr, uid, ids)[0][1]
 289         self.pool.get('purchase.order.line').action_confirm(cr, uid, todo, context)
 290         for id in ids:
 291             self.write(cr, uid, [id], {'state' : 'confirmed', 'validator' : uid})
 292         return True
 293
 294     def wkf_warn_buyer(self, cr, uid, ids):
 295         self.write(cr, uid, ids, {'state' : 'wait', 'validator' : uid})
 296         request = pooler.get_pool(cr.dbname).get('res.request')
 297         for po in self.browse(cr, uid, ids):
 298             managers = []
 299             for oline in po.order_line:
 300                 manager = oline.product_id.product_manager
 301                 if manager and not (manager.id in managers):
 302                     managers.append(manager.id)
 303             for manager_id in managers:
 304                 request.create(cr, uid,{
 305                        'name' : _("Purchase amount over the limit"),
 306                        'act_from' : uid,
 307                        'act_to' : manager_id,
 308                        'body': _('Somebody has just confirmed a purchase with an amount over the defined limit'),
 309                        'ref_partner_id': po.partner_id.id,
 310                        'ref_doc1': 'purchase.order,%d' % (po.id,),
 311                 })
 312     def inv_line_create(self, cr, uid, a, ol):
 313         return (0, False, {
 314             'name': ol.name,
 315             'account_id': a,
 316             'price_unit': ol.price_unit or 0.0,
 317             'quantity': ol.product_qty,
 318             'product_id': ol.product_id.id or False,
 319             'uos_id': ol.product_uom.id or False,
 320             'invoice_line_tax_id': [(6, 0, [x.id for x in ol.taxes_id])],
 321             'account_analytic_id': ol.account_analytic_id.id or False,
 322         })
 323
 324     def action_cancel_draft(self, cr, uid, ids, *args):
 325         if not len(ids):
 326             return False
 327         self.write(cr, uid, ids, {'state':'draft','shipped':0})
 328         wf_service = netsvc.LocalService("workflow")
 329         for p_id in ids:
 330             # Deleting the existing instance of workflow for PO
 331             wf_service.trg_delete(uid, 'purchase.order', p_id, cr)
 332             wf_service.trg_create(uid, 'purchase.order', p_id, cr)
 333         for (id,name) in self.name_get(cr, uid, ids):
 334             message = _("Purchase order '%s' has been set in draft state.") % name
 335             self.log(cr, uid, id, message)
 336         return True
 337
 338     def action_invoice_create(self, cr, uid, ids, *args):
 339         res = False
 340
 341         journal_obj = self.pool.get('account.journal')
 342         for o in self.browse(cr, uid, ids):
 343             il = []
 344             todo = []
 345             for ol in o.order_line:
 346                 todo.append(ol.id)
 347                 if ol.product_id:
 348                     a = ol.product_id.product_tmpl_id.property_account_expense.id
 349                     if not a:
 350                         a = ol.product_id.categ_id.property_account_expense_categ.id
 351                     if not a:
 352                         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,))
 353                 else:
 354                     a = self.pool.get('ir.property').get(cr, uid, 'property_account_expense_categ', 'product.category').id
 355                 fpos = o.fiscal_position or False
 356                 a = self.pool.get('account.fiscal.position').map_account(cr, uid, fpos, a)
 357                 il.append(self.inv_line_create(cr, uid, a, ol))
 358
 359             a = o.partner_id.property_account_payable.id
 360             journal_ids = journal_obj.search(cr, uid, [('type', '=','purchase'),('company_id', '=', o.company_id.id)], limit=1)
 361             if not journal_ids:
 362                 raise osv.except_osv(_('Error !'),
 363                     _('There is no purchase journal defined for this company: "%s" (id:%d)') % (o.company_id.name, o.company_id.id))
 364             inv = {
 365                 'name': o.partner_ref or o.name,
 366                 'reference': "P%dPO%d" % (o.partner_id.id, o.id),
 367                 'account_id': a,
 368                 'type': 'in_invoice',
 369                 'partner_id': o.partner_id.id,
 370                 'currency_id': o.pricelist_id.currency_id.id,
 371                 'address_invoice_id': o.partner_address_id.id,
 372                 'address_contact_id': o.partner_address_id.id,
 373                 'journal_id': len(journal_ids) and journal_ids[0] or False,
 374                 'origin': o.name,
 375                 'invoice_line': il,
 376                 'fiscal_position': o.fiscal_position.id or o.partner_id.property_account_position.id,
 377                 'payment_term': o.partner_id.property_payment_term and o.partner_id.property_payment_term.id or False,
 378                 'company_id': o.company_id.id,
 379             }
 380             inv_id = self.pool.get('account.invoice').create(cr, uid, inv, {'type':'in_invoice'})
 381             self.pool.get('account.invoice').button_compute(cr, uid, [inv_id], {'type':'in_invoice'}, set_total=True)
 382             self.pool.get('purchase.order.line').write(cr, uid, todo, {'invoiced':True})
 383             self.write(cr, uid, [o.id], {'invoice_ids': [(4, inv_id)]})
 384             res = inv_id
 385         return res
 386
 387     def has_stockable_product(self,cr, uid, ids, *args):
 388         for order in self.browse(cr, uid, ids):
 389             for order_line in order.order_line:
 390                 if order_line.product_id and order_line.product_id.product_tmpl_id.type in ('product', 'consu'):
 391                     return True
 392         return False
 393
 394     def action_cancel(self, cr, uid, ids, context=None):
 395         for purchase in self.browse(cr, uid, ids, context=context):
 396             for pick in purchase.picking_ids:
 397                 if pick.state not in ('draft','cancel'):
 398                     raise osv.except_osv(
 399                         _('Could not cancel purchase order !'),
 400                         _('You must first cancel all picking attached to this purchase order.'))
 401             for pick in purchase.picking_ids:
 402                 wf_service = netsvc.LocalService("workflow")
 403                 wf_service.trg_validate(uid, 'stock.picking', pick.id, 'button_cancel', cr)
 404             for inv in purchase.invoice_ids:
 405                 if inv and inv.state not in ('cancel','draft'):
 406                     raise osv.except_osv(
 407                         _('Could not cancel this purchase order !'),
 408                         _('You must first cancel all invoices attached to this purchase order.'))
 409                 if inv:
 410                     wf_service = netsvc.LocalService("workflow")
 411                     wf_service.trg_validate(uid, 'account.invoice', inv.id, 'invoice_cancel', cr)
 412         self.write(cr,uid,ids,{'state':'cancel'})
 413         for (id,name) in self.name_get(cr, uid, ids):
 414             message = _("Purchase order '%s' is cancelled.") % name
 415             self.log(cr, uid, id, message)
 416         return True
 417
 418     def action_picking_create(self,cr, uid, ids, *args):
 419         picking_id = False
 420         for order in self.browse(cr, uid, ids):
 421             loc_id = order.partner_id.property_stock_supplier.id
 422             istate = 'none'
 423             if order.invoice_method=='picking':
 424                 istate = '2binvoiced'
 425             pick_name = self.pool.get('ir.sequence').get(cr, uid, 'stock.picking.in')
 426             picking_id = self.pool.get('stock.picking').create(cr, uid, {
 427                 'name': pick_name,
 428                 'origin': order.name+((order.origin and (':'+order.origin)) or ''),
 429                 'type': 'in',
 430                 'address_id': order.dest_address_id.id or order.partner_address_id.id,
 431                 'invoice_state': istate,
 432                 'purchase_id': order.id,
 433                 'company_id': order.company_id.id,
 434                 'move_lines' : [],
 435             })
 436             todo_moves = []
 437             for order_line in order.order_line:
 438                 if not order_line.product_id:
 439                     continue
 440                 if order_line.product_id.product_tmpl_id.type in ('product', 'consu'):
 441                     dest = order.location_id.id
 442                     move = self.pool.get('stock.move').create(cr, uid, {
 443                         'name': 'PO:'+order_line.name,
 444                         'product_id': order_line.product_id.id,
 445                         'product_qty': order_line.product_qty,
 446                         'product_uos_qty': order_line.product_qty,
 447                         'product_uom': order_line.product_uom.id,
 448                         'product_uos': order_line.product_uom.id,
 449                         'date': order_line.date_planned,
 450                         'date_expected': order_line.date_planned,
 451                         'location_id': loc_id,
 452                         'location_dest_id': dest,
 453                         'picking_id': picking_id,
 454                         'move_dest_id': order_line.move_dest_id.id,
 455                         'state': 'draft',
 456                         'purchase_line_id': order_line.id,
 457                         'company_id': order.company_id.id,
 458                     })
 459                     if order_line.move_dest_id:
 460                         self.pool.get('stock.move').write(cr, uid, [order_line.move_dest_id.id], {'location_id':order.location_id.id})
 461                     todo_moves.append(move)
 462             self.pool.get('stock.move').action_confirm(cr, uid, todo_moves)
 463             self.pool.get('stock.move').force_assign(cr, uid, todo_moves)
 464             wf_service = netsvc.LocalService("workflow")
 465             wf_service.trg_validate(uid, 'stock.picking', picking_id, 'button_confirm', cr)
 466         return picking_id
 467
 468     def copy(self, cr, uid, id, default=None, context=None):
 469         if not default:
 470             default = {}
 471         default.update({
 472             'state':'draft',
 473             'shipped':False,
 474             'invoiced':False,
 475             'invoice_ids': [],
 476             'picking_ids': [],
 477             'name': self.pool.get('ir.sequence').get(cr, uid, 'purchase.order'),
 478         })
 479         return super(purchase_order, self).copy(cr, uid, id, default, context)
 480
 481
 482     def do_merge(self, cr, uid, ids, context=None):
 483         """
 484         To merge similar type of purchase orders.
 485         Orders will only be merged if:
 486         * Purchase Orders are in draft
 487         * Purchase Orders belong to the same partner
 488         * Purchase Orders are have same stock location, same pricelist
 489         Lines will only be merged if:
 490         * Order lines are exactly the same except for the quantity and unit
 491
 492          @param self: The object pointer.
 493          @param cr: A database cursor
 494          @param uid: ID of the user currently logged in
 495          @param ids: the ID or list of IDs
 496          @param context: A standard dictionary
 497
 498          @return: new purchase order id
 499
 500         """
 501         wf_service = netsvc.LocalService("workflow")
 502         def make_key(br, fields):
 503             list_key = []
 504             for field in fields:
 505                 field_val = getattr(br, field)
 506                 if field in ('product_id', 'move_dest_id', 'account_analytic_id'):
 507                     if not field_val:
 508                         field_val = False
 509                 if isinstance(field_val, browse_record):
 510                     field_val = field_val.id
 511                 elif isinstance(field_val, browse_null):
 512                     field_val = False
 513                 elif isinstance(field_val, list):
 514                     field_val = ((6, 0, tuple([v.id for v in field_val])),)
 515                 list_key.append((field, field_val))
 516             list_key.sort()
 517             return tuple(list_key)
 518
 519     # compute what the new orders should contain
 520
 521         new_orders = {}
 522
 523         for porder in [order for order in self.browse(cr, uid, ids, context=context) if order.state == 'draft']:
 524             order_key = make_key(porder, ('partner_id', 'location_id', 'pricelist_id'))
 525             new_order = new_orders.setdefault(order_key, ({}, []))
 526             new_order[1].append(porder.id)
 527             order_infos = new_order[0]
 528             if not order_infos:
 529                 order_infos.update({
 530                     'origin': porder.origin,
 531                     'date_order': time.strftime('%Y-%m-%d'),
 532                     'partner_id': porder.partner_id.id,
 533                     'partner_address_id': porder.partner_address_id.id,
 534                     'dest_address_id': porder.dest_address_id.id,
 535                     'warehouse_id': porder.warehouse_id.id,
 536                     'location_id': porder.location_id.id,
 537                     'pricelist_id': porder.pricelist_id.id,
 538                     'state': 'draft',
 539                     'order_line': {},
 540                     'notes': '%s' % (porder.notes or '',),
 541                     'fiscal_position': porder.fiscal_position and porder.fiscal_position.id or False,
 542                 })
 543             else:
 544                 if porder.notes:
 545                     order_infos['notes'] = (order_infos['notes'] or '') + ('\n%s' % (porder.notes,))
 546                 if porder.origin:
 547                     order_infos['origin'] = (order_infos['origin'] or '') + ' ' + porder.origin
 548
 549             for order_line in porder.order_line:
 550                 line_key = make_key(order_line, ('name', 'date_planned', 'taxes_id', 'price_unit', 'notes', 'product_id', 'move_dest_id', 'account_analytic_id'))
 551                 o_line = order_infos['order_line'].setdefault(line_key, {})
 552                 if o_line:
 553                     # merge the line with an existing line
 554                     o_line['product_qty'] += order_line.product_qty * order_line.product_uom.factor / o_line['uom_factor']
 555                 else:
 556                     # append a new "standalone" line
 557                     for field in ('product_qty', 'product_uom'):
 558                         field_val = getattr(order_line, field)
 559                         if isinstance(field_val, browse_record):
 560                             field_val = field_val.id
 561                         o_line[field] = field_val
 562                     o_line['uom_factor'] = order_line.product_uom and order_line.product_uom.factor or 1.0
 563
 564
 565
 566         allorders = []
 567         orders_info = {}
 568         for order_key, (order_data, old_ids) in new_orders.iteritems():
 569             # skip merges with only one order
 570             if len(old_ids) < 2:
 571                 allorders += (old_ids or [])
 572                 continue
 573
 574             # cleanup order line data
 575             for key, value in order_data['order_line'].iteritems():
 576                 del value['uom_factor']
 577                 value.update(dict(key))
 578             order_data['order_line'] = [(0, 0, value) for value in order_data['order_line'].itervalues()]
 579
 580             # create the new order
 581             neworder_id = self.create(cr, uid, order_data)
 582             orders_info.update({neworder_id: old_ids})
 583             allorders.append(neworder_id)
 584
 585             # make triggers pointing to the old orders point to the new order
 586             for old_id in old_ids:
 587                 wf_service.trg_redirect(uid, 'purchase.order', old_id, neworder_id, cr)
 588                 wf_service.trg_validate(uid, 'purchase.order', old_id, 'purchase_cancel', cr)
 589         return orders_info
 590
 591 purchase_order()
 592
 593 class purchase_order_line(osv.osv):
 594     def _amount_line(self, cr, uid, ids, prop, arg, context=None):
 595         res = {}
 596         cur_obj=self.pool.get('res.currency')
 597         tax_obj = self.pool.get('account.tax')
 598         for line in self.browse(cr, uid, ids, context=context):
 599             taxes = tax_obj.compute_all(cr, uid, line.taxes_id, line.price_unit, line.product_qty)
 600             cur = line.order_id.pricelist_id.currency_id
 601             res[line.id] = cur_obj.round(cr, uid, cur, taxes['total'])
 602         return res
 603
 604     _columns = {
 605         'name': fields.char('Description', size=256, required=True),
 606         'product_qty': fields.float('Quantity', required=True, digits=(16,2)),
 607         'date_planned': fields.date('Scheduled Date', required=True),
 608         'taxes_id': fields.many2many('account.tax', 'purchase_order_taxe', 'ord_id', 'tax_id', 'Taxes'),
 609         'product_uom': fields.many2one('product.uom', 'Product UOM', required=True),
 610         'product_id': fields.many2one('product.product', 'Product', domain=[('purchase_ok','=',True)], change_default=True),
 611         'move_ids': fields.one2many('stock.move', 'purchase_line_id', 'Reservation', readonly=True, ondelete='set null'),
 612         'move_dest_id': fields.many2one('stock.move', 'Reservation Destination', ondelete='set null'),
 613         'price_unit': fields.float('Unit Price', required=True, digits_compute= dp.get_precision('Purchase Price')),
 614         'price_subtotal': fields.function(_amount_line, method=True, string='Subtotal', digits_compute= dp.get_precision('Purchase Price')),
 615         'notes': fields.text('Notes'),
 616         'order_id': fields.many2one('purchase.order', 'Order Reference', select=True, required=True, ondelete='cascade'),
 617         'account_analytic_id':fields.many2one('account.analytic.account', 'Analytic Account',),
 618         'company_id': fields.related('order_id','company_id',type='many2one',relation='res.company',string='Company'),
 619         'state': fields.selection([('draft', 'Draft'), ('confirmed', 'Confirmed'), ('done', 'Done'), ('cancel', 'Cancelled')], 'State', required=True, readonly=True,
 620                                   help=' * The \'Draft\' state is set automatically when purchase order in draft state. \
 621                                        \n* The \'Confirmed\' state is set automatically as confirm when purchase order in confirm state. \
 622                                        \n* The \'Done\' state is set automatically when purchase order is set as done. \
 623                                        \n* The \'Cancelled\' state is set automatically when user cancel purchase order.'),
 624         'invoice_lines': fields.many2many('account.invoice.line', 'purchase_order_line_invoice_rel', 'order_line_id', 'invoice_id', 'Invoice Lines', readonly=True),
 625         'invoiced': fields.boolean('Invoiced', readonly=True),
 626         'partner_id': fields.related('order_id','partner_id',string='Partner',readonly=True,type="many2one", relation="res.partner", store=True),
 627         'date_order': fields.related('order_id','date_order',string='Order Date',readonly=True,type="date")
 628
 629     }
 630     _defaults = {
 631         'product_qty': lambda *a: 1.0,
 632         'state': lambda *args: 'draft',
 633         'invoiced': lambda *a: 0,
 634     }
 635     _table = 'purchase_order_line'
 636     _name = 'purchase.order.line'
 637     _description = 'Purchase Order Line'
 638
 639     def copy_data(self, cr, uid, id, default=None, context=None):
 640         if not default:
 641             default = {}
 642         default.update({'state':'draft', 'move_ids':[],'invoiced':0,'invoice_lines':[]})
 643         return super(purchase_order_line, self).copy_data(cr, uid, id, default, context)
 644
 645     def product_id_change(self, cr, uid, ids, pricelist, product, qty, uom,
 646             partner_id, date_order=False, fiscal_position=False, date_planned=False,
 647             name=False, price_unit=False, notes=False):
 648         if not pricelist:
 649             raise osv.except_osv(_('No Pricelist !'), _('You have to select a pricelist or a supplier in the purchase form !\nPlease set one before choosing a product.'))
 650         if not  partner_id:
 651             raise osv.except_osv(_('No Partner!'), _('You have to select a partner in the purchase form !\nPlease set one partner before choosing a product.'))
 652         if not product:
 653             return {'value': {'price_unit': price_unit or 0.0, 'name': name or '',
 654                 'notes': notes or'', 'product_uom' : uom or False}, 'domain':{'product_uom':[]}}
 655         res = {}
 656         prod= self.pool.get('product.product').browse(cr, uid, product)
 657
 658         product_uom_pool = self.pool.get('product.uom')
 659         lang=False
 660         if partner_id:
 661             lang=self.pool.get('res.partner').read(cr, uid, partner_id, ['lang'])['lang']
 662         context={'lang':lang}
 663         context['partner_id'] = partner_id
 664
 665         prod = self.pool.get('product.product').browse(cr, uid, product, context=context)
 666         prod_uom_po = prod.uom_po_id.id
 667         if not uom:
 668             uom = prod_uom_po
 669         if not date_order:
 670             date_order = time.strftime('%Y-%m-%d')
 671         qty = qty or 1.0
 672         seller_delay = 0
 673
 674         prod_name = self.pool.get('product.product').name_get(cr, uid, [prod.id], context=context)[0][1]
 675         res = {}
 676         for s in prod.seller_ids:
 677             if s.name.id == partner_id:
 678                 seller_delay = s.delay
 679                 if s.product_uom:
 680                     temp_qty = product_uom_pool._compute_qty(cr, uid, s.product_uom.id, s.min_qty, to_uom_id=prod.uom_id.id)
 681                     uom = s.product_uom.id #prod_uom_po
 682                 temp_qty = s.min_qty # supplier _qty assigned to temp
 683                 if qty < temp_qty: # If the supplier quantity is greater than entered from user, set minimal.
 684                     qty = temp_qty
 685                     res.update({'warning': {'title': _('Warning'), 'message': _('The selected supplier has a minimal quantity set to %s, you cannot purchase less.') % qty}})
 686         qty_in_product_uom = product_uom_pool._compute_qty(cr, uid, uom, qty, to_uom_id=prod.uom_id.id)
 687         price = self.pool.get('product.pricelist').price_get(cr,uid,[pricelist],
 688                     product, qty_in_product_uom or 1.0, partner_id, {
 689                         'uom': uom,
 690                         'date': date_order,
 691                         })[pricelist]
 692         dt = (datetime.now() + relativedelta(days=int(seller_delay) or 0.0)).strftime('%Y-%m-%d %H:%M:%S')
 693
 694
 695         res.update({'value': {'price_unit': price, 'name': name or prod_name,
 696             'taxes_id':map(lambda x: x.id, prod.supplier_taxes_id),
 697             'date_planned': date_planned or dt,'notes': notes or prod.description_purchase,
 698             'product_qty': qty,
 699             'product_uom': uom}})
 700         domain = {}
 701
 702         taxes = self.pool.get('account.tax').browse(cr, uid,map(lambda x: x.id, prod.supplier_taxes_id))
 703         fpos = fiscal_position and self.pool.get('account.fiscal.position').browse(cr, uid, fiscal_position) or False
 704         res['value']['taxes_id'] = self.pool.get('account.fiscal.position').map_tax(cr, uid, fpos, taxes)
 705
 706         res2 = self.pool.get('product.uom').read(cr, uid, [uom], ['category_id'])
 707         res3 = prod.uom_id.category_id.id
 708         domain = {'product_uom':[('category_id','=',res2[0]['category_id'][0])]}
 709         if res2[0]['category_id'][0] != res3:
 710             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'))
 711
 712         res['domain'] = domain
 713         return res
 714
 715     def product_uom_change(self, cr, uid, ids, pricelist, product, qty, uom,
 716             partner_id, date_order=False,fiscal_position=False):
 717         res = self.product_id_change(cr, uid, ids, pricelist, product, qty, uom,
 718                 partner_id, date_order=date_order,fiscal_position=fiscal_position)
 719         if 'product_uom' in res['value']:
 720             if uom and uom != res['value']['product_uom']:
 721                 seller_uom_name = self.pool.get('product.uom').read(cr, uid, [res['value']['product_uom']], ['name'])[0]['name']
 722                 res.update({'warning': {'title': _('Warning'), 'message': _('The selected supplier only sells this product by %s') % seller_uom_name }})
 723             del res['value']['product_uom']
 724         if not uom:
 725             res['value']['price_unit'] = 0.0
 726         return res
 727
 728     def action_confirm(self, cr, uid, ids, context=None):
 729         self.write(cr, uid, ids, {'state': 'confirmed'}, context=context)
 730         return True
 731
 732 purchase_order_line()
 733
 734 class procurement_order(osv.osv):
 735     _inherit = 'procurement.order'
 736     _columns = {
 737         'purchase_id': fields.many2one('purchase.order', 'Purchase Order'),
 738     }
 739
 740     def action_po_assign(self, cr, uid, ids, context=None):
 741         """ This is action which call from workflow to assign purchase order to procurements
 742         @return: True
 743         """
 744         res = self.make_po(cr, uid, ids, context=context)
 745         res = res.values()
 746         return len(res) and res[0] or 0 #TO CHECK: why workflow is generated error if return not integer value
 747
 748     def make_po(self, cr, uid, ids, context=None):
 749         """ Make purchase order from procurement
 750         @return: New created Purchase Orders procurement wise
 751         """
 752         res = {}
 753         if context is None:
 754             context = {}
 755         company = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id
 756         partner_obj = self.pool.get('res.partner')
 757         uom_obj = self.pool.get('product.uom')
 758         pricelist_obj = self.pool.get('product.pricelist')
 759         prod_obj = self.pool.get('product.product')
 760         acc_pos_obj = self.pool.get('account.fiscal.position')
 761         po_obj = self.pool.get('purchase.order')
 762         for procurement in self.browse(cr, uid, ids, context=context):
 763             res_id = procurement.move_id.id
 764             partner = procurement.product_id.seller_id # Taken Main Supplier of Product of Procurement.
 765             seller_qty = procurement.product_id.seller_qty
 766             seller_delay = int(procurement.product_id.seller_delay)
 767             partner_id = partner.id
 768             address_id = partner_obj.address_get(cr, uid, [partner_id], ['delivery'])['delivery']
 769             pricelist_id = partner.property_product_pricelist_purchase.id
 770
 771             uom_id = procurement.product_id.uom_po_id.id
 772
 773             qty = uom_obj._compute_qty(cr, uid, procurement.product_uom.id, procurement.product_qty, uom_id)
 774             if seller_qty:
 775                 qty = max(qty,seller_qty)
 776
 777             price = pricelist_obj.price_get(cr, uid, [pricelist_id], procurement.product_id.id, qty, False, {'uom': uom_id})[pricelist_id]
 778
 779             newdate = datetime.strptime(procurement.date_planned, '%Y-%m-%d %H:%M:%S')
 780             newdate = (newdate - relativedelta(days=company.po_lead)) - relativedelta(days=seller_delay)
 781
 782             #Passing partner_id to context for purchase order line integrity of Line name
 783             context.update({'lang': partner.lang, 'partner_id': partner_id})
 784
 785             product = prod_obj.browse(cr, uid, procurement.product_id.id, context=context)
 786
 787             line = {
 788                 'name': product.partner_ref,
 789                 'product_qty': qty,
 790                 'product_id': procurement.product_id.id,
 791                 'product_uom': uom_id,
 792                 'price_unit': price,
 793                 'date_planned': newdate.strftime('%Y-%m-%d %H:%M:%S'),
 794                 'move_dest_id': res_id,
 795                 'notes': product.description_purchase,
 796             }
 797
 798             taxes_ids = procurement.product_id.product_tmpl_id.supplier_taxes_id
 799             taxes = acc_pos_obj.map_tax(cr, uid, partner.property_account_position, taxes_ids)
 800             line.update({
 801                 'taxes_id': [(6,0,taxes)]
 802             })
 803             purchase_id = po_obj.create(cr, uid, {
 804                 'origin': procurement.origin,
 805                 'partner_id': partner_id,
 806                 'partner_address_id': address_id,
 807                 'location_id': procurement.location_id.id,
 808                 'pricelist_id': pricelist_id,
 809                 'order_line': [(0,0,line)],
 810                 'company_id': procurement.company_id.id,
 811                 'fiscal_position': partner.property_account_position and partner.property_account_position.id or False
 812             })
 813             res[procurement.id] = purchase_id
 814             self.write(cr, uid, [procurement.id], {'state': 'running', 'purchase_id': purchase_id})
 815         return res
 816
 817 procurement_order()
 818
 819 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: