1 # -*- coding: utf-8 -*-
2 ##############################################################################
4 # OpenERP, Open Source Management Solution
5 # Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
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.
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.
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/>.
20 ##############################################################################
24 from openerp import SUPERUSER_ID, workflow
25 from datetime import datetime
26 from dateutil.relativedelta import relativedelta
27 from operator import attrgetter
29 from openerp.osv import fields, osv
30 from openerp.tools.translate import _
31 import openerp.addons.decimal_precision as dp
32 from openerp.osv.orm import browse_record, browse_null
33 from openerp.tools import DEFAULT_SERVER_DATE_FORMAT, DEFAULT_SERVER_DATETIME_FORMAT, DATETIME_FORMATS_MAP
35 class purchase_order(osv.osv):
37 def _amount_all(self, cr, uid, ids, field_name, arg, context=None):
39 cur_obj=self.pool.get('res.currency')
40 for order in self.browse(cr, uid, ids, context=context):
42 'amount_untaxed': 0.0,
47 cur = order.pricelist_id.currency_id
48 for line in order.order_line:
49 val1 += line.price_subtotal
50 for c in self.pool.get('account.tax').compute_all(cr, uid, line.taxes_id, line.price_unit, line.product_qty, line.product_id, order.partner_id)['taxes']:
51 val += c.get('amount', 0.0)
52 res[order.id]['amount_tax']=cur_obj.round(cr, uid, cur, val)
53 res[order.id]['amount_untaxed']=cur_obj.round(cr, uid, cur, val1)
54 res[order.id]['amount_total']=res[order.id]['amount_untaxed'] + res[order.id]['amount_tax']
57 def _set_minimum_planned_date(self, cr, uid, ids, name, value, arg, context=None):
58 if not value: return False
59 if type(ids)!=type([]):
61 for po in self.browse(cr, uid, ids, context=context):
63 cr.execute("""update purchase_order_line set
67 (date_planned=%s or date_planned<%s)""", (value,po.id,po.minimum_planned_date,value))
68 cr.execute("""update purchase_order set
69 minimum_planned_date=%s where id=%s""", (value, po.id))
72 def _minimum_planned_date(self, cr, uid, ids, field_name, arg, context=None):
74 purchase_obj=self.browse(cr, uid, ids, context=context)
75 for purchase in purchase_obj:
76 res[purchase.id] = False
77 if purchase.order_line:
78 min_date=purchase.order_line[0].date_planned
79 for line in purchase.order_line:
80 if line.date_planned < min_date:
81 min_date=line.date_planned
82 res[purchase.id]=min_date
86 def _invoiced_rate(self, cursor, user, ids, name, arg, context=None):
88 for purchase in self.browse(cursor, user, ids, context=context):
90 for invoice in purchase.invoice_ids:
91 if invoice.state not in ('draft','cancel'):
92 tot += invoice.amount_untaxed
93 if purchase.amount_untaxed:
94 res[purchase.id] = tot * 100.0 / purchase.amount_untaxed
96 res[purchase.id] = 0.0
99 def _shipped_rate(self, cr, uid, ids, name, arg, context=None):
100 if not ids: return {}
105 p.purchase_id,sum(m.product_qty), m.state
109 stock_picking p on (p.id=m.picking_id)
111 p.purchase_id IN %s GROUP BY m.state, p.purchase_id''',(tuple(ids),))
112 for oid,nbr,state in cr.fetchall():
116 res[oid][0] += nbr or 0.0
117 res[oid][1] += nbr or 0.0
119 res[oid][1] += nbr or 0.0
124 res[r] = 100.0 * res[r][0] / res[r][1]
127 def _get_order(self, cr, uid, ids, context=None):
129 for line in self.pool.get('purchase.order.line').browse(cr, uid, ids, context=context):
130 result[line.order_id.id] = True
133 def _invoiced(self, cursor, user, ids, name, arg, context=None):
135 for purchase in self.browse(cursor, user, ids, context=context):
136 res[purchase.id] = all(line.invoiced for line in purchase.order_line)
139 def _get_journal(self, cr, uid, context=None):
142 user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
143 company_id = context.get('company_id', user.company_id.id)
144 journal_obj = self.pool.get('account.journal')
145 res = journal_obj.search(cr, uid, [('type', '=', 'purchase'),
146 ('company_id', '=', company_id)],
148 return res and res[0] or False
151 ('draft', 'Draft PO'),
152 ('sent', 'RFQ Sent'),
153 ('confirmed', 'Waiting Approval'),
154 ('approved', 'Purchase Order'),
155 ('except_picking', 'Shipping Exception'),
156 ('except_invoice', 'Invoice Exception'),
158 ('cancel', 'Cancelled')
162 'purchase.mt_rfq_confirmed': lambda self, cr, uid, obj, ctx=None: obj.state == 'confirmed',
163 'purchase.mt_rfq_approved': lambda self, cr, uid, obj, ctx=None: obj.state == 'approved',
164 'purchase.mt_rfq_done': lambda self, cr, uid, obj, ctx=None: obj.state == 'done',
168 '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."),
169 'origin': fields.char('Source Document', size=64,
170 help="Reference of the document that generated this purchase order request; a sales order or an internal procurement request."
172 'partner_ref': fields.char('Supplier Reference', states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]}, size=64,
173 help="Reference of the sales order or quotation sent by your supplier. It's mainly used to do the matching when you receive the products as this reference is usually written on the delivery order sent by your supplier."),
174 'date_order':fields.date('Order Date', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}, select=True, help="Date on which this document has been created."),
175 'date_approve':fields.date('Date Approved', readonly=1, select=True, help="Date on which purchase order has been approved"),
176 'partner_id':fields.many2one('res.partner', 'Supplier', required=True, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]},
177 change_default=True, track_visibility='always'),
178 'dest_address_id':fields.many2one('res.partner', 'Customer Address (Direct Delivery)',
179 states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]},
180 help="Put an address if you want to deliver directly from the supplier to the customer. " \
181 "Otherwise, keep empty to deliver to your own company."
183 'warehouse_id': fields.many2one('stock.warehouse', 'Destination Warehouse'),
184 'location_id': fields.many2one('stock.location', 'Destination', required=True, domain=[('usage','<>','view')], states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)],'done':[('readonly',True)]} ),
185 '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."),
186 'currency_id': fields.many2one('res.currency','Currency', readonly=True, required=True,states={'draft': [('readonly', False)],'sent': [('readonly', False)]}),
187 'state': fields.selection(STATE_SELECTION, 'Status', readonly=True, help="The status of the purchase order or the quotation request. A quotation is a purchase order in a 'Draft' status. Then the order has to be confirmed by the user, the status switch to 'Confirmed'. Then the supplier must confirm the order to change the status to 'Approved'. When the purchase order is paid and received, the status becomes 'Done'. If a cancel action occurs in the invoice or in the reception of goods, the status becomes in exception.", select=True),
188 'order_line': fields.one2many('purchase.order.line', 'order_id', 'Order Lines', states={'approved':[('readonly',True)],'done':[('readonly',True)]}),
189 'validator' : fields.many2one('res.users', 'Validated by', readonly=True),
190 'notes': fields.text('Terms and Conditions'),
191 'invoice_ids': fields.many2many('account.invoice', 'purchase_invoice_rel', 'purchase_id', 'invoice_id', 'Invoices', help="Invoices generated for a purchase order"),
192 'picking_ids': fields.one2many('stock.picking.in', 'purchase_id', 'Picking List', readonly=True, help="This is the list of incoming shipments that have been generated for this purchase order."),
193 'shipped':fields.boolean('Received', readonly=True, select=True, help="It indicates that a picking has been done"),
194 'shipped_rate': fields.function(_shipped_rate, string='Received Ratio', type='float'),
195 'invoiced': fields.function(_invoiced, string='Invoice Received', type='boolean', help="It indicates that an invoice has been paid"),
196 'invoiced_rate': fields.function(_invoiced_rate, string='Invoiced', type='float'),
197 'invoice_method': fields.selection([('manual','Based on Purchase Order lines'),('order','Based on generated draft invoice'),('picking','Based on incoming shipments')], 'Invoicing Control', required=True,
198 readonly=True, states={'draft':[('readonly',False)], 'sent':[('readonly',False)]},
199 help="Based on Purchase Order lines: place individual lines in 'Invoice Control / On Purchase Order lines' from where you can selectively create an invoice.\n" \
200 "Based on generated invoice: create a draft invoice you can validate later.\n" \
201 "Based on incoming shipments: let you create an invoice when receptions are validated."
203 'minimum_planned_date':fields.function(_minimum_planned_date, fnct_inv=_set_minimum_planned_date, string='Expected Date', type='date', select=True, help="This is computed as the minimum scheduled date of all purchase order lines' products.",
205 'purchase.order.line': (_get_order, ['date_planned'], 10),
208 'amount_untaxed': fields.function(_amount_all, digits_compute= dp.get_precision('Account'), string='Untaxed Amount',
210 'purchase.order.line': (_get_order, None, 10),
211 }, multi="sums", help="The amount without tax", track_visibility='always'),
212 'amount_tax': fields.function(_amount_all, digits_compute= dp.get_precision('Account'), string='Taxes',
214 'purchase.order.line': (_get_order, None, 10),
215 }, multi="sums", help="The tax amount"),
216 'amount_total': fields.function(_amount_all, digits_compute= dp.get_precision('Account'), string='Total',
218 'purchase.order.line': (_get_order, None, 10),
219 }, multi="sums",help="The total amount"),
220 'fiscal_position': fields.many2one('account.fiscal.position', 'Fiscal Position'),
221 'payment_term_id': fields.many2one('account.payment.term', 'Payment Term'),
222 'product_id': fields.related('order_line','product_id', type='many2one', relation='product.product', string='Product'),
223 'create_uid': fields.many2one('res.users', 'Responsible'),
224 'company_id': fields.many2one('res.company','Company',required=True,select=1, states={'confirmed':[('readonly',True)], 'approved':[('readonly',True)]}),
225 'journal_id': fields.many2one('account.journal', 'Journal'),
228 'date_order': fields.date.context_today,
230 'name': lambda obj, cr, uid, context: '/',
232 'invoice_method': 'order',
234 '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,
235 'company_id': lambda self,cr,uid,c: self.pool.get('res.company')._company_default_get(cr, uid, 'purchase.order', context=c),
236 'journal_id': _get_journal,
237 'currency_id': lambda self, cr, uid, context: self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.currency_id.id
240 ('name_uniq', 'unique(name, company_id)', 'Order Reference must be unique per Company!'),
242 _name = "purchase.order"
243 _inherit = ['mail.thread', 'ir.needaction_mixin']
244 _description = "Purchase Order"
245 _order = 'date_order desc, id desc'
247 def create(self, cr, uid, vals, context=None):
248 if vals.get('name','/')=='/':
249 vals['name'] = self.pool.get('ir.sequence').get(cr, uid, 'purchase.order') or '/'
252 context.update({'mail_create_nolog': True})
253 order = super(purchase_order, self).create(cr, uid, vals, context=context)
254 self.message_post(cr, uid, [order], body=_("RFQ created"), context=context)
257 def unlink(self, cr, uid, ids, context=None):
258 purchase_orders = self.read(cr, uid, ids, ['state'], context=context)
260 for s in purchase_orders:
261 if s['state'] in ['draft','cancel']:
262 unlink_ids.append(s['id'])
264 raise osv.except_osv(_('Invalid Action!'), _('In order to delete a purchase order, you must cancel it first.'))
266 # automatically sending subflow.delete upon deletion
267 self.signal_purchase_cancel(cr, uid, unlink_ids)
269 return super(purchase_order, self).unlink(cr, uid, unlink_ids, context=context)
271 def button_dummy(self, cr, uid, ids, context=None):
274 def onchange_pricelist(self, cr, uid, ids, pricelist_id, context=None):
277 return {'value': {'currency_id': self.pool.get('product.pricelist').browse(cr, uid, pricelist_id, context=context).currency_id.id}}
279 def onchange_dest_address_id(self, cr, uid, ids, address_id):
282 address = self.pool.get('res.partner')
283 values = {'warehouse_id': False}
284 supplier = address.browse(cr, uid, address_id)
286 location_id = supplier.property_stock_customer.id
287 values.update({'location_id': location_id})
288 return {'value':values}
290 def onchange_warehouse_id(self, cr, uid, ids, warehouse_id):
293 warehouse = self.pool.get('stock.warehouse').browse(cr, uid, warehouse_id)
294 return {'value':{'location_id': warehouse.lot_input_id.id, 'dest_address_id': False}}
296 def onchange_partner_id(self, cr, uid, ids, partner_id):
297 partner = self.pool.get('res.partner')
300 'fiscal_position': False,
301 'payment_term_id': False,
303 supplier_address = partner.address_get(cr, uid, [partner_id], ['default'])
304 supplier = partner.browse(cr, uid, partner_id)
306 'pricelist_id': supplier.property_product_pricelist_purchase.id,
307 'fiscal_position': supplier.property_account_position and supplier.property_account_position.id or False,
308 'payment_term_id': supplier.property_supplier_payment_term.id or False,
311 def invoice_open(self, cr, uid, ids, context=None):
312 mod_obj = self.pool.get('ir.model.data')
313 act_obj = self.pool.get('ir.actions.act_window')
315 result = mod_obj.get_object_reference(cr, uid, 'account', 'action_invoice_tree2')
316 id = result and result[1] or False
317 result = act_obj.read(cr, uid, [id], context=context)[0]
319 for po in self.browse(cr, uid, ids, context=context):
320 inv_ids+= [invoice.id for invoice in po.invoice_ids]
322 raise osv.except_osv(_('Error!'), _('Please create Invoices.'))
323 #choose the view_mode accordingly
325 result['domain'] = "[('id','in',["+','.join(map(str, inv_ids))+"])]"
327 res = mod_obj.get_object_reference(cr, uid, 'account', 'invoice_supplier_form')
328 result['views'] = [(res and res[1] or False, 'form')]
329 result['res_id'] = inv_ids and inv_ids[0] or False
332 def view_invoice(self, cr, uid, ids, context=None):
334 This function returns an action that display existing invoices of given sales order ids. It can either be a in a list or in a form view, if there is only one invoice to show.
336 mod_obj = self.pool.get('ir.model.data')
337 wizard_obj = self.pool.get('purchase.order.line_invoice')
338 #compute the number of invoices to display
340 for po in self.browse(cr, uid, ids, context=context):
341 if po.invoice_method == 'manual':
342 if not po.invoice_ids:
343 context.update({'active_ids' : [line.id for line in po.order_line]})
344 wizard_obj.makeInvoices(cr, uid, [], context=context)
346 for po in self.browse(cr, uid, ids, context=context):
347 inv_ids+= [invoice.id for invoice in po.invoice_ids]
348 res = mod_obj.get_object_reference(cr, uid, 'account', 'invoice_supplier_form')
349 res_id = res and res[1] or False
352 'name': _('Supplier Invoices'),
356 'res_model': 'account.invoice',
357 'context': "{'type':'in_invoice', 'journal_type': 'purchase'}",
358 'type': 'ir.actions.act_window',
361 'res_id': inv_ids and inv_ids[0] or False,
364 def view_picking(self, cr, uid, ids, context=None):
366 This function returns an action that display existing pîcking orders of given purchase order ids.
368 mod_obj = self.pool.get('ir.model.data')
370 for po in self.browse(cr, uid, ids, context=context):
371 pick_ids += [picking.id for picking in po.picking_ids]
373 action_model, action_id = tuple(mod_obj.get_object_reference(cr, uid, 'stock', 'action_picking_tree4'))
374 action = self.pool[action_model].read(cr, uid, action_id, context=context)
375 ctx = eval(action['context'])
377 'search_default_purchase_id': ids[0]
379 if pick_ids and len(pick_ids) == 1:
380 form_view_ids = [view_id for view_id, view in action['views'] if view == 'form']
381 view_id = form_view_ids and form_view_ids[0] or False
386 'res_id': pick_ids[0]
394 def wkf_approve_order(self, cr, uid, ids, context=None):
395 self.write(cr, uid, ids, {'state': 'approved', 'date_approve': fields.date.context_today(self,cr,uid,context=context)})
398 def print_confirm(self,cr,uid,ids,context=None):
401 def print_double(self,cr,uid,ids,context=None):
402 print "double Approval"
404 def print_router(self,cr,uid,ids,context=None):
407 def wkf_send_rfq(self, cr, uid, ids, context=None):
409 This function opens a window to compose an email, with the edi purchase template message loaded by default
411 ir_model_data = self.pool.get('ir.model.data')
413 template_id = ir_model_data.get_object_reference(cr, uid, 'purchase', 'email_template_edi_purchase')[1]
417 compose_form_id = ir_model_data.get_object_reference(cr, uid, 'mail', 'email_compose_message_wizard_form')[1]
419 compose_form_id = False
422 'default_model': 'purchase.order',
423 'default_res_id': ids[0],
424 'default_use_template': bool(template_id),
425 'default_template_id': template_id,
426 'default_composition_mode': 'comment',
429 'name': _('Compose Email'),
430 'type': 'ir.actions.act_window',
433 'res_model': 'mail.compose.message',
434 'views': [(compose_form_id, 'form')],
435 'view_id': compose_form_id,
440 def print_quotation(self, cr, uid, ids, context=None):
442 This function prints the request for quotation and mark it as sent, so that we can see more easily the next step of the workflow
444 assert len(ids) == 1, 'This option should only be used for a single id at a time'
445 self.signal_send_rfq(cr, uid, ids)
446 return self.pool['report'].get_action(cr, uid, ids, 'purchase.report_purchasequotation', context=context)
448 #TODO: implement messages system
449 def wkf_confirm_order(self, cr, uid, ids, context=None):
451 for po in self.browse(cr, uid, ids, context=context):
452 if not po.order_line:
453 raise osv.except_osv(_('Error!'),_('You cannot confirm a purchase order without any purchase order line.'))
454 for line in po.order_line:
455 if line.state=='draft':
458 self.pool.get('purchase.order.line').action_confirm(cr, uid, todo, context)
460 self.write(cr, uid, [id], {'state' : 'confirmed', 'validator' : uid})
463 def _choose_account_from_po_line(self, cr, uid, po_line, context=None):
464 fiscal_obj = self.pool.get('account.fiscal.position')
465 property_obj = self.pool.get('ir.property')
466 if po_line.product_id:
467 acc_id = po_line.product_id.property_account_expense.id
469 acc_id = po_line.product_id.categ_id.property_account_expense_categ.id
471 raise osv.except_osv(_('Error!'), _('Define an expense account for this product: "%s" (id:%d).') % (po_line.product_id.name, po_line.product_id.id,))
473 acc_id = property_obj.get(cr, uid, 'property_account_expense_categ', 'product.category', context=context).id
474 fpos = po_line.order_id.fiscal_position or False
475 return fiscal_obj.map_account(cr, uid, fpos, acc_id)
477 def _prepare_inv_line(self, cr, uid, account_id, order_line, context=None):
478 """Collects require data from purchase order line that is used to create invoice line
479 for that purchase order line
480 :param account_id: Expense account of the product of PO line if any.
481 :param browse_record order_line: Purchase order line browse record
482 :return: Value for fields of invoice lines.
486 'name': order_line.name,
487 'account_id': account_id,
488 'price_unit': order_line.price_unit or 0.0,
489 'quantity': order_line.product_qty,
490 'product_id': order_line.product_id.id or False,
491 'uos_id': order_line.product_uom.id or False,
492 'invoice_line_tax_id': [(6, 0, [x.id for x in order_line.taxes_id])],
493 'account_analytic_id': order_line.account_analytic_id.id or False,
494 'purchase_line_id': order_line.id,
497 def _prepare_invoice(self, cr, uid, order, line_ids, context=None):
498 """Prepare the dict of values to create the new invoice for a
499 purchase order. This method may be overridden to implement custom
500 invoice generation (making sure to call super() to establish
501 a clean extension chain).
503 :param browse_record order: purchase.order record to invoice
504 :param list(int) line_ids: list of invoice line IDs that must be
505 attached to the invoice
506 :return: dict of value to create() the invoice
508 journal_ids = self.pool['account.journal'].search(
509 cr, uid, [('type', '=', 'purchase'),
510 ('company_id', '=', order.company_id.id)],
513 raise osv.except_osv(
515 _('Define purchase journal for this company: "%s" (id:%d).') % \
516 (order.company_id.name, order.company_id.id))
518 'name': order.partner_ref or order.name,
519 'reference': order.partner_ref or order.name,
520 'account_id': order.partner_id.property_account_payable.id,
521 'type': 'in_invoice',
522 'partner_id': order.partner_id.id,
523 'currency_id': order.currency_id.id,
524 'journal_id': len(journal_ids) and journal_ids[0] or False,
525 'invoice_line': [(6, 0, line_ids)],
526 'origin': order.name,
527 'fiscal_position': order.fiscal_position.id or False,
528 'payment_term': order.payment_term_id.id or False,
529 'company_id': order.company_id.id,
532 def action_cancel_draft(self, cr, uid, ids, context=None):
535 self.write(cr, uid, ids, {'state':'draft','shipped':0})
537 # Deleting the existing instance of workflow for PO
538 self.delete_workflow(cr, uid, [p_id]) # TODO is it necessary to interleave the calls?
539 self.create_workflow(cr, uid, [p_id])
542 def action_invoice_create(self, cr, uid, ids, context=None):
543 """Generates invoice for given ids of purchase orders and links that invoice ID to purchase order.
544 :param ids: list of ids of purchase orders.
545 :return: ID of created invoice.
551 inv_obj = self.pool.get('account.invoice')
552 inv_line_obj = self.pool.get('account.invoice.line')
555 uid_company_id = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id.id
556 for order in self.browse(cr, uid, ids, context=context):
557 context.pop('force_company', None)
558 if order.company_id.id != uid_company_id:
559 #if the company of the document is different than the current user company, force the company in the context
560 #then re-do a browse to read the property fields for the good company.
561 context['force_company'] = order.company_id.id
562 order = self.browse(cr, uid, order.id, context=context)
564 # generate invoice line correspond to PO line and link that to created invoice (inv_id) and PO line
566 for po_line in order.order_line:
567 acc_id = self._choose_account_from_po_line(cr, uid, po_line, context=context)
568 inv_line_data = self._prepare_inv_line(cr, uid, acc_id, po_line, context=context)
569 inv_line_id = inv_line_obj.create(cr, uid, inv_line_data, context=context)
570 inv_lines.append(inv_line_id)
571 po_line.write({'invoice_lines': [(4, inv_line_id)]}, context=context)
573 # get invoice data and create invoice
574 inv_data = self._prepare_invoice(cr, uid, order, inv_lines, context=context)
575 inv_id = inv_obj.create(cr, uid, inv_data, context=context)
577 # compute the invoice
578 inv_obj.button_compute(cr, uid, [inv_id], context=context, set_total=True)
580 # Link this new invoice to related purchase order
581 order.write({'invoice_ids': [(4, inv_id)]}, context=context)
585 def invoice_done(self, cr, uid, ids, context=None):
586 self.write(cr, uid, ids, {'state':'approved'}, context=context)
589 def has_stockable_product(self, cr, uid, ids, *args):
590 for order in self.browse(cr, uid, ids):
591 for order_line in order.order_line:
592 if order_line.product_id and order_line.product_id.type in ('product', 'consu'):
596 def action_cancel(self, cr, uid, ids, context=None):
597 for purchase in self.browse(cr, uid, ids, context=context):
598 for pick in purchase.picking_ids:
599 if pick.state not in ('draft','cancel'):
600 raise osv.except_osv(
601 _('Unable to cancel this purchase order.'),
602 _('First cancel all receptions related to this purchase order.'))
603 self.pool.get('stock.picking') \
604 .signal_button_cancel(cr, uid, map(attrgetter('id'), purchase.picking_ids))
605 for inv in purchase.invoice_ids:
606 if inv and inv.state not in ('cancel','draft'):
607 raise osv.except_osv(
608 _('Unable to cancel this purchase order.'),
609 _('You must first cancel all invoices related to this purchase order.'))
610 self.pool.get('account.invoice') \
611 .signal_invoice_cancel(cr, uid, map(attrgetter('id'), purchase.invoice_ids))
612 self.write(cr,uid,ids,{'state':'cancel'})
614 self.signal_purchase_cancel(cr, uid, ids)
617 def date_to_datetime(self, cr, uid, userdate, context=None):
618 """ Convert date values expressed in user's timezone to
619 server-side UTC timestamp, assuming a default arbitrary
620 time of 12:00 AM - because a time is needed.
622 :param str userdate: date string in in user time zone
623 :return: UTC datetime string for server-side use
625 # TODO: move to fields.datetime in server after 7.0
626 user_date = datetime.strptime(userdate, DEFAULT_SERVER_DATE_FORMAT)
627 if context and context.get('tz'):
628 tz_name = context['tz']
630 tz_name = self.pool.get('res.users').read(cr, SUPERUSER_ID, uid, ['tz'])['tz']
632 utc = pytz.timezone('UTC')
633 context_tz = pytz.timezone(tz_name)
634 user_datetime = user_date + relativedelta(hours=12.0)
635 local_timestamp = context_tz.localize(user_datetime, is_dst=False)
636 user_datetime = local_timestamp.astimezone(utc)
637 return user_datetime.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
638 return user_date.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
640 def _prepare_order_picking(self, cr, uid, order, context=None):
642 'name': self.pool.get('ir.sequence').get(cr, uid, 'stock.picking.in'),
643 'origin': order.name + ((order.origin and (':' + order.origin)) or ''),
644 'date': self.date_to_datetime(cr, uid, order.date_order, context),
645 'partner_id': order.partner_id.id,
646 'invoice_state': '2binvoiced' if order.invoice_method == 'picking' else 'none',
648 'purchase_id': order.id,
649 'company_id': order.company_id.id,
653 def _prepare_order_line_move(self, cr, uid, order, order_line, picking_id, context=None):
654 ''' prepare the stock move data from the PO line '''
656 'name': order_line.name or '',
657 'product_id': order_line.product_id.id,
658 'product_qty': order_line.product_qty,
659 'product_uos_qty': order_line.product_qty,
660 'product_uom': order_line.product_uom.id,
661 'product_uos': order_line.product_uom.id,
662 'date': self.date_to_datetime(cr, uid, order.date_order, context),
663 'date_expected': self.date_to_datetime(cr, uid, order_line.date_planned, context),
664 'location_id': order.partner_id.property_stock_supplier.id,
665 'location_dest_id': order.location_id.id,
666 'picking_id': picking_id,
667 'partner_id': order.dest_address_id.id or order.partner_id.id,
668 'move_dest_id': order_line.move_dest_id.id,
671 'purchase_line_id': order_line.id,
672 'company_id': order.company_id.id,
673 'price_unit': order_line.price_unit
676 def _create_pickings(self, cr, uid, order, order_lines, picking_id=False, context=None):
677 """Creates pickings and appropriate stock moves for given order lines, then
678 confirms the moves, makes them available, and confirms the picking.
680 If ``picking_id`` is provided, the stock moves will be added to it, otherwise
681 a standard outgoing picking will be created to wrap the stock moves, as returned
682 by :meth:`~._prepare_order_picking`.
684 Modules that wish to customize the procurements or partition the stock moves over
685 multiple stock pickings may override this method and call ``super()`` with
686 different subsets of ``order_lines`` and/or preset ``picking_id`` values.
688 :param browse_record order: purchase order to which the order lines belong
689 :param list(browse_record) order_lines: purchase order line records for which picking
690 and moves should be created.
691 :param int picking_id: optional ID of a stock picking to which the created stock moves
692 will be added. A new picking will be created if omitted.
693 :return: list of IDs of pickings used/created for the given order lines (usually just one)
695 stock_picking = self.pool.get('stock.picking')
697 picking_id = stock_picking.create(cr, uid, self._prepare_order_picking(cr, uid, order, context=context))
699 stock_move = self.pool.get('stock.move')
700 for order_line in order_lines:
701 if not order_line.product_id:
703 if order_line.product_id.type in ('product', 'consu'):
704 move = stock_move.create(cr, uid, self._prepare_order_line_move(cr, uid, order, order_line, picking_id, context=context))
705 if order_line.move_dest_id and order_line.move_dest_id.state != 'done':
706 order_line.move_dest_id.write({'location_id': order.location_id.id})
707 todo_moves.append(move)
708 stock_move.action_confirm(cr, uid, todo_moves)
709 stock_move.force_assign(cr, uid, todo_moves)
710 stock_picking.signal_button_confirm(cr, uid, [picking_id])
713 def action_picking_create(self, cr, uid, ids, context=None):
715 for order in self.browse(cr, uid, ids):
716 picking_ids.extend(self._create_pickings(cr, uid, order, order.order_line, None, context=context))
718 # Must return one unique picking ID: the one to connect in the subflow of the purchase order.
719 # In case of multiple (split) pickings, we should return the ID of the critical one, i.e. the
720 # one that should trigger the advancement of the purchase workflow.
721 # By default we will consider the first one as most important, but this behavior can be overridden.
722 return picking_ids[0] if picking_ids else False
724 def picking_done(self, cr, uid, ids, context=None):
725 self.write(cr, uid, ids, {'shipped':1,'state':'approved'}, context=context)
726 self.message_post(cr, uid, ids, body=_("Products received"), context=context)
729 def copy(self, cr, uid, id, default=None, context=None):
739 'name': self.pool.get('ir.sequence').get(cr, uid, 'purchase.order'),
741 return super(purchase_order, self).copy(cr, uid, id, default, context)
743 def do_merge(self, cr, uid, ids, context=None):
745 To merge similar type of purchase orders.
746 Orders will only be merged if:
747 * Purchase Orders are in draft
748 * Purchase Orders belong to the same partner
749 * Purchase Orders are have same stock location, same pricelist
750 Lines will only be merged if:
751 * Order lines are exactly the same except for the quantity and unit
753 @param self: The object pointer.
754 @param cr: A database cursor
755 @param uid: ID of the user currently logged in
756 @param ids: the ID or list of IDs
757 @param context: A standard dictionary
759 @return: new purchase order id
762 #TOFIX: merged order line should be unlink
763 def make_key(br, fields):
766 field_val = getattr(br, field)
767 if field in ('product_id', 'move_dest_id', 'account_analytic_id'):
770 if isinstance(field_val, browse_record):
771 field_val = field_val.id
772 elif isinstance(field_val, browse_null):
774 elif isinstance(field_val, list):
775 field_val = ((6, 0, tuple([v.id for v in field_val])),)
776 list_key.append((field, field_val))
778 return tuple(list_key)
783 # Compute what the new orders should contain
787 for porder in [order for order in self.browse(cr, uid, ids, context=context) if order.state == 'draft']:
788 order_key = make_key(porder, ('partner_id', 'location_id', 'pricelist_id'))
789 new_order = new_orders.setdefault(order_key, ({}, []))
790 new_order[1].append(porder.id)
791 order_infos = new_order[0]
794 'origin': porder.origin,
795 'date_order': porder.date_order,
796 'partner_id': porder.partner_id.id,
797 'dest_address_id': porder.dest_address_id.id,
798 'warehouse_id': porder.warehouse_id.id,
799 'location_id': porder.location_id.id,
800 'pricelist_id': porder.pricelist_id.id,
803 'notes': '%s' % (porder.notes or '',),
804 'fiscal_position': porder.fiscal_position and porder.fiscal_position.id or False,
807 if porder.date_order < order_infos['date_order']:
808 order_infos['date_order'] = porder.date_order
810 order_infos['notes'] = (order_infos['notes'] or '') + ('\n%s' % (porder.notes,))
812 order_infos['origin'] = (order_infos['origin'] or '') + ' ' + porder.origin
814 for order_line in porder.order_line:
815 line_key = make_key(order_line, ('name', 'date_planned', 'taxes_id', 'price_unit', 'product_id', 'move_dest_id', 'account_analytic_id'))
816 o_line = order_infos['order_line'].setdefault(line_key, {})
818 # merge the line with an existing line
819 o_line['product_qty'] += order_line.product_qty * order_line.product_uom.factor / o_line['uom_factor']
821 # append a new "standalone" line
822 for field in ('product_qty', 'product_uom'):
823 field_val = getattr(order_line, field)
824 if isinstance(field_val, browse_record):
825 field_val = field_val.id
826 o_line[field] = field_val
827 o_line['uom_factor'] = order_line.product_uom and order_line.product_uom.factor or 1.0
833 for order_key, (order_data, old_ids) in new_orders.iteritems():
834 # skip merges with only one order
836 allorders += (old_ids or [])
839 # cleanup order line data
840 for key, value in order_data['order_line'].iteritems():
841 del value['uom_factor']
842 value.update(dict(key))
843 order_data['order_line'] = [(0, 0, value) for value in order_data['order_line'].itervalues()]
845 # create the new order
846 context.update({'mail_create_nolog': True})
847 neworder_id = self.create(cr, uid, order_data)
848 self.message_post(cr, uid, [neworder_id], body=_("RFQ created"), context=context)
849 orders_info.update({neworder_id: old_ids})
850 allorders.append(neworder_id)
852 # make triggers pointing to the old orders point to the new order
853 for old_id in old_ids:
854 self.redirect_workflow(cr, uid, [(old_id, neworder_id)])
855 self.signal_purchase_cancel(cr, uid, [old_id]) # TODO Is it necessary to interleave the calls?
859 class purchase_order_line(osv.osv):
860 def _amount_line(self, cr, uid, ids, prop, arg, context=None):
862 cur_obj=self.pool.get('res.currency')
863 tax_obj = self.pool.get('account.tax')
864 for line in self.browse(cr, uid, ids, context=context):
865 taxes = tax_obj.compute_all(cr, uid, line.taxes_id, line.price_unit, line.product_qty, line.product_id, line.order_id.partner_id)
866 cur = line.order_id.pricelist_id.currency_id
867 res[line.id] = cur_obj.round(cr, uid, cur, taxes['total'])
870 def _get_uom_id(self, cr, uid, context=None):
872 proxy = self.pool.get('ir.model.data')
873 result = proxy.get_object_reference(cr, uid, 'product', 'product_uom_unit')
875 except Exception, ex:
879 'name': fields.text('Description', required=True),
880 'product_qty': fields.float('Quantity', digits_compute=dp.get_precision('Product Unit of Measure'), required=True),
881 'date_planned': fields.date('Scheduled Date', required=True, select=True),
882 'taxes_id': fields.many2many('account.tax', 'purchase_order_taxe', 'ord_id', 'tax_id', 'Taxes'),
883 'product_uom': fields.many2one('product.uom', 'Product Unit of Measure', required=True),
884 'product_id': fields.many2one('product.product', 'Product', domain=[('purchase_ok','=',True)], change_default=True),
885 'move_ids': fields.one2many('stock.move', 'purchase_line_id', 'Reservation', readonly=True, ondelete='set null'),
886 'move_dest_id': fields.many2one('stock.move', 'Reservation Destination', ondelete='set null'),
887 'price_unit': fields.float('Unit Price', required=True, digits_compute= dp.get_precision('Product Price')),
888 'price_subtotal': fields.function(_amount_line, string='Subtotal', digits_compute= dp.get_precision('Account')),
889 'order_id': fields.many2one('purchase.order', 'Order Reference', select=True, required=True, ondelete='cascade'),
890 'account_analytic_id':fields.many2one('account.analytic.account', 'Analytic Account',),
891 'company_id': fields.related('order_id','company_id',type='many2one',relation='res.company',string='Company', store=True, readonly=True),
892 'state': fields.selection([('draft', 'Draft'), ('confirmed', 'Confirmed'), ('done', 'Done'), ('cancel', 'Cancelled')], 'Status', required=True, readonly=True,
893 help=' * The \'Draft\' status is set automatically when purchase order in draft status. \
894 \n* The \'Confirmed\' status is set automatically as confirm when purchase order in confirm status. \
895 \n* The \'Done\' status is set automatically when purchase order is set as done. \
896 \n* The \'Cancelled\' status is set automatically when user cancel purchase order.'),
897 'invoice_lines': fields.many2many('account.invoice.line', 'purchase_order_line_invoice_rel', 'order_line_id', 'invoice_id', 'Invoice Lines', readonly=True),
898 'invoiced': fields.boolean('Invoiced', readonly=True),
899 'partner_id': fields.related('order_id','partner_id',string='Partner',readonly=True,type="many2one", relation="res.partner", store=True),
900 'date_order': fields.related('order_id','date_order',string='Order Date',readonly=True,type="date"),
904 'product_uom' : _get_uom_id,
905 'product_qty': lambda *a: 1.0,
906 'state': lambda *args: 'draft',
907 'invoiced': lambda *a: 0,
909 _table = 'purchase_order_line'
910 _name = 'purchase.order.line'
911 _description = 'Purchase Order Line'
913 def copy_data(self, cr, uid, id, default=None, context=None):
916 default.update({'state':'draft', 'move_ids':[],'invoiced':0,'invoice_lines':[]})
917 return super(purchase_order_line, self).copy_data(cr, uid, id, default, context)
919 def unlink(self, cr, uid, ids, context=None):
920 procurement_ids_to_cancel = []
921 for line in self.browse(cr, uid, ids, context=context):
922 if line.move_dest_id:
923 procurement_ids_to_cancel.extend(procurement.id for procurement in line.move_dest_id.procurements)
924 if procurement_ids_to_cancel:
925 self.pool['procurement.order'].action_cancel(cr, uid, procurement_ids_to_cancel)
926 return super(purchase_order_line, self).unlink(cr, uid, ids, context=context)
928 def onchange_product_uom(self, cr, uid, ids, pricelist_id, product_id, qty, uom_id,
929 partner_id, date_order=False, fiscal_position_id=False, date_planned=False,
930 name=False, price_unit=False, context=None):
932 onchange handler of product_uom.
937 return {'value': {'price_unit': price_unit or 0.0, 'name': name or '', 'product_uom' : uom_id or False}}
938 context = dict(context, purchase_uom_check=True)
939 return self.onchange_product_id(cr, uid, ids, pricelist_id, product_id, qty, uom_id,
940 partner_id, date_order=date_order, fiscal_position_id=fiscal_position_id, date_planned=date_planned,
941 name=name, price_unit=price_unit, context=context)
943 def _get_date_planned(self, cr, uid, supplier_info, date_order_str, context=None):
944 """Return the datetime value to use as Schedule Date (``date_planned``) for
945 PO Lines that correspond to the given product.supplierinfo,
946 when ordered at `date_order_str`.
948 :param browse_record | False supplier_info: product.supplierinfo, used to
949 determine delivery delay (if False, default delay = 0)
950 :param str date_order_str: date of order, as a string in
951 DEFAULT_SERVER_DATE_FORMAT
953 :return: desired Schedule Date for the PO line
955 supplier_delay = int(supplier_info.delay) if supplier_info else 0
956 return datetime.strptime(date_order_str, DEFAULT_SERVER_DATE_FORMAT) + relativedelta(days=supplier_delay)
958 def _check_product_uom_group(self, cr, uid, context=None):
959 group_uom = self.pool.get('ir.model.data').get_object(cr, uid, 'product', 'group_uom')
960 res = [user for user in group_uom.users if user.id == uid]
961 return len(res) and True or False
964 def onchange_product_id(self, cr, uid, ids, pricelist_id, product_id, qty, uom_id,
965 partner_id, date_order=False, fiscal_position_id=False, date_planned=False,
966 name=False, price_unit=False, context=None):
968 onchange handler of product_id.
973 res = {'value': {'price_unit': price_unit or 0.0, 'name': name or '', 'product_uom' : uom_id or False}}
977 product_product = self.pool.get('product.product')
978 product_uom = self.pool.get('product.uom')
979 res_partner = self.pool.get('res.partner')
980 product_pricelist = self.pool.get('product.pricelist')
981 account_fiscal_position = self.pool.get('account.fiscal.position')
982 account_tax = self.pool.get('account.tax')
984 # - check for the presence of partner_id and pricelist_id
986 # raise osv.except_osv(_('No Partner!'), _('Select a partner in purchase order to choose a product.'))
987 #if not pricelist_id:
988 # raise osv.except_osv(_('No Pricelist !'), _('Select a price list in the purchase order form before choosing a product.'))
990 # - determine name and notes based on product in partner lang.
991 context_partner = context.copy()
993 lang = res_partner.browse(cr, uid, partner_id).lang
994 context_partner.update( {'lang': lang, 'partner_id': partner_id} )
995 product = product_product.browse(cr, uid, product_id, context=context_partner)
996 #call name_get() with partner in the context to eventually match name and description in the seller_ids field
997 dummy, name = product_product.name_get(cr, uid, product_id, context=context_partner)[0]
998 if product.description_purchase:
999 name += '\n' + product.description_purchase
1000 res['value'].update({'name': name})
1002 # - set a domain on product_uom
1003 res['domain'] = {'product_uom': [('category_id','=',product.uom_id.category_id.id)]}
1005 # - check that uom and product uom belong to the same category
1006 product_uom_po_id = product.uom_po_id.id
1008 uom_id = product_uom_po_id
1010 if product.uom_id.category_id.id != product_uom.browse(cr, uid, uom_id, context=context).category_id.id:
1011 if context.get('purchase_uom_check') and self._check_product_uom_group(cr, uid, context=context):
1012 res['warning'] = {'title': _('Warning!'), 'message': _('Selected Unit of Measure does not belong to the same category as the product Unit of Measure.')}
1013 uom_id = product_uom_po_id
1015 res['value'].update({'product_uom': uom_id})
1017 # - determine product_qty and date_planned based on seller info
1019 date_order = fields.date.context_today(self,cr,uid,context=context)
1022 supplierinfo = False
1023 for supplier in product.seller_ids:
1024 if partner_id and (supplier.name.id == partner_id):
1025 supplierinfo = supplier
1026 if supplierinfo.product_uom.id != uom_id:
1027 res['warning'] = {'title': _('Warning!'), 'message': _('The selected supplier only sells this product by %s') % supplierinfo.product_uom.name }
1028 min_qty = product_uom._compute_qty(cr, uid, supplierinfo.product_uom.id, supplierinfo.min_qty, to_uom_id=uom_id)
1029 if (qty or 0.0) < min_qty: # If the supplier quantity is greater than entered from user, set minimal.
1031 res['warning'] = {'title': _('Warning!'), 'message': _('The selected supplier has a minimal quantity set to %s %s, you should not purchase less.') % (supplierinfo.min_qty, supplierinfo.product_uom.name)}
1033 dt = self._get_date_planned(cr, uid, supplierinfo, date_order, context=context).strftime(DEFAULT_SERVER_DATETIME_FORMAT)
1035 res['value'].update({'date_planned': date_planned or dt})
1037 res['value'].update({'product_qty': qty})
1039 # - determine price_unit and taxes_id
1041 price = product_pricelist.price_get(cr, uid, [pricelist_id],
1042 product.id, qty or 1.0, partner_id or False, {'uom': uom_id, 'date': date_order})[pricelist_id]
1044 price = product.standard_price
1046 taxes = account_tax.browse(cr, uid, map(lambda x: x.id, product.supplier_taxes_id))
1047 fpos = fiscal_position_id and account_fiscal_position.browse(cr, uid, fiscal_position_id, context=context) or False
1048 taxes_ids = account_fiscal_position.map_tax(cr, uid, fpos, taxes)
1049 res['value'].update({'price_unit': price, 'taxes_id': taxes_ids})
1053 product_id_change = onchange_product_id
1054 product_uom_change = onchange_product_uom
1056 def action_confirm(self, cr, uid, ids, context=None):
1057 self.write(cr, uid, ids, {'state': 'confirmed'}, context=context)
1061 class procurement_order(osv.osv):
1062 _inherit = 'procurement.order'
1064 'purchase_id': fields.many2one('purchase.order', 'Purchase Order'),
1067 def check_buy(self, cr, uid, ids, context=None):
1068 ''' return True if the supply method of the mto product is 'buy'
1070 user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1071 for procurement in self.browse(cr, uid, ids, context=context):
1072 if procurement.product_id.supply_method <> 'buy':
1076 def check_supplier_info(self, cr, uid, ids, context=None):
1077 partner_obj = self.pool.get('res.partner')
1078 user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
1079 for procurement in self.browse(cr, uid, ids, context=context):
1081 partner = procurement.product_id.seller_id #Taken Main Supplier of Product of Procurement.
1083 if not procurement.product_id.seller_ids:
1084 message = _('No supplier defined for this product !')
1086 message = _('No default supplier defined for this product')
1087 elif not partner_obj.address_get(cr, uid, [partner.id], ['delivery'])['delivery']:
1088 message = _('No address defined for the supplier')
1091 if procurement.message != message:
1092 cr.execute('update procurement_order set message=%s where id=%s', (message, procurement.id))
1095 if user.company_id and user.company_id.partner_id:
1096 if partner.id == user.company_id.partner_id.id:
1097 raise osv.except_osv(_('Configuration Error!'), _('The product "%s" has been defined with your company as reseller which seems to be a configuration error!' % procurement.product_id.name))
1102 def action_po_assign(self, cr, uid, ids, context=None):
1103 """ This is action which call from workflow to assign purchase order to procurements
1106 res = self.make_po(cr, uid, ids, context=context)
1108 return len(res) and res[0] or 0 #TO CHECK: why workflow is generated error if return not integer value
1110 def create_procurement_purchase_order(self, cr, uid, procurement, po_vals, line_vals, context=None):
1111 """Create the purchase order from the procurement, using
1112 the provided field values, after adding the given purchase
1113 order line in the purchase order.
1115 :params procurement: the procurement object generating the purchase order
1116 :params dict po_vals: field values for the new purchase order (the
1117 ``order_line`` field will be overwritten with one
1118 single line, as passed in ``line_vals``).
1119 :params dict line_vals: field values of the single purchase order line that
1120 the purchase order will contain.
1121 :return: id of the newly created purchase order
1124 po_vals.update({'order_line': [(0,0,line_vals)]})
1125 return self.pool.get('purchase.order').create(cr, uid, po_vals, context=context)
1127 def _get_purchase_schedule_date(self, cr, uid, procurement, company, context=None):
1128 """Return the datetime value to use as Schedule Date (``date_planned``) for the
1129 Purchase Order Lines created to satisfy the given procurement.
1131 :param browse_record procurement: the procurement for which a PO will be created.
1132 :param browse_report company: the company to which the new PO will belong to.
1134 :return: the desired Schedule Date for the PO lines
1136 procurement_date_planned = datetime.strptime(procurement.date_planned, DEFAULT_SERVER_DATETIME_FORMAT)
1137 schedule_date = (procurement_date_planned - relativedelta(days=company.po_lead))
1138 return schedule_date
1140 def _get_purchase_order_date(self, cr, uid, procurement, company, schedule_date, context=None):
1141 """Return the datetime value to use as Order Date (``date_order``) for the
1142 Purchase Order created to satisfy the given procurement.
1144 :param browse_record procurement: the procurement for which a PO will be created.
1145 :param browse_report company: the company to which the new PO will belong to.
1146 :param datetime schedule_date: desired Scheduled Date for the Purchase Order lines.
1148 :return: the desired Order Date for the PO
1150 seller_delay = int(procurement.product_id.seller_delay)
1151 return schedule_date - relativedelta(days=seller_delay)
1153 def _get_warehouse(self, procurement, user_company):
1155 Return the warehouse containing the procurment stock location (or one of it ancestors)
1156 If none match, returns then first warehouse of the company
1158 # TODO refactor the domain once we implement the "parent_of" domain operator
1159 # NOTE This method has been copied in the `purchase_requisition` module to ensure
1160 # retro-compatibility. This code duplication will be deleted in next stable version.
1161 # Do not forget to update both version in case of modification.
1162 company_id = (procurement.company_id or user_company).id
1165 '&', ('company_id', '=', company_id),
1166 '|', '&', ('lot_stock_id.parent_left', '<', procurement.location_id.parent_left),
1167 ('lot_stock_id.parent_right', '>', procurement.location_id.parent_right),
1168 ('lot_stock_id', '=', procurement.location_id.id)
1170 [('company_id', '=', company_id)]
1173 cr, uid = procurement._cr, procurement._uid
1174 context = procurement._context
1175 Warehouse = self.pool['stock.warehouse']
1176 for domain in domains:
1177 ids = Warehouse.search(cr, uid, domain, context=context)
1182 def make_po(self, cr, uid, ids, context=None):
1183 """ Make purchase order from procurement
1184 @return: New created Purchase Orders procurement wise
1189 company = self.pool.get('res.users').browse(cr, uid, uid, context=context).company_id
1190 partner_obj = self.pool.get('res.partner')
1191 uom_obj = self.pool.get('product.uom')
1192 pricelist_obj = self.pool.get('product.pricelist')
1193 prod_obj = self.pool.get('product.product')
1194 acc_pos_obj = self.pool.get('account.fiscal.position')
1195 seq_obj = self.pool.get('ir.sequence')
1196 for procurement in self.browse(cr, uid, ids, context=context):
1197 res_id = procurement.move_id.id
1198 partner = procurement.product_id.seller_id # Taken Main Supplier of Product of Procurement.
1199 seller_qty = procurement.product_id.seller_qty
1200 partner_id = partner.id
1201 address_id = partner_obj.address_get(cr, uid, [partner_id], ['delivery'])['delivery']
1202 pricelist_id = partner.property_product_pricelist_purchase.id
1203 uom_id = procurement.product_id.uom_po_id.id
1205 qty = uom_obj._compute_qty(cr, uid, procurement.product_uom.id, procurement.product_qty, uom_id)
1207 qty = max(qty,seller_qty)
1209 price = pricelist_obj.price_get(cr, uid, [pricelist_id], procurement.product_id.id, qty, partner_id, {'uom': uom_id})[pricelist_id]
1211 schedule_date = self._get_purchase_schedule_date(cr, uid, procurement, company, context=context)
1212 purchase_date = self._get_purchase_order_date(cr, uid, procurement, company, schedule_date, context=context)
1214 #Passing partner_id to context for purchase order line integrity of Line name
1215 new_context = context.copy()
1216 new_context.update({'lang': partner.lang, 'partner_id': partner_id})
1218 product = prod_obj.browse(cr, uid, procurement.product_id.id, context=new_context)
1219 taxes_ids = procurement.product_id.supplier_taxes_id
1220 taxes = acc_pos_obj.map_tax(cr, uid, partner.property_account_position, taxes_ids)
1222 name = product.partner_ref
1223 if product.description_purchase:
1224 name += '\n'+ product.description_purchase
1228 'product_id': procurement.product_id.id,
1229 'product_uom': uom_id,
1230 'price_unit': price or 0.0,
1231 'date_planned': schedule_date.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
1232 'move_dest_id': res_id,
1233 'taxes_id': [(6,0,taxes)],
1235 name = seq_obj.get(cr, uid, 'purchase.order') or _('PO: %s') % procurement.name
1238 'origin': procurement.origin,
1239 'partner_id': partner_id,
1240 'location_id': procurement.location_id.id,
1241 'warehouse_id': self._get_warehouse(procurement, company),
1242 'pricelist_id': pricelist_id,
1243 'date_order': purchase_date.strftime(DEFAULT_SERVER_DATETIME_FORMAT),
1244 'company_id': procurement.company_id.id,
1245 'fiscal_position': partner.property_account_position and partner.property_account_position.id or False,
1246 'payment_term_id': partner.property_supplier_payment_term.id or False,
1248 res[procurement.id] = self.create_procurement_purchase_order(cr, uid, procurement, po_vals, line_vals, context=new_context)
1249 self.write(cr, uid, [procurement.id], {'state': 'running', 'purchase_id': res[procurement.id]})
1250 self.message_post(cr, uid, ids, body=_("Draft Purchase Order created"), context=context)
1253 def _product_virtual_get(self, cr, uid, order_point):
1254 procurement = order_point.procurement_id
1255 if procurement and procurement.state != 'exception' and procurement.purchase_id and procurement.purchase_id.state in ('draft', 'confirmed'):
1257 return super(procurement_order, self)._product_virtual_get(cr, uid, order_point)
1260 class mail_mail(osv.Model):
1262 _inherit = 'mail.mail'
1264 def _postprocess_sent_message(self, cr, uid, mail, context=None, mail_sent=True):
1265 if mail_sent and mail.model == 'purchase.order':
1266 self.pool.get('purchase.order').signal_send_rfq(cr, uid, [mail.res_id])
1267 return super(mail_mail, self)._postprocess_sent_message(cr, uid, mail=mail, context=context, mail_sent=mail_sent)
1270 class product_template(osv.Model):
1271 _name = 'product.template'
1272 _inherit = 'product.template'
1274 'purchase_ok': fields.boolean('Can be Purchased', help="Specify if the product can be selected in a purchase order line."),
1281 class mail_compose_message(osv.Model):
1282 _inherit = 'mail.compose.message'
1284 def send_mail(self, cr, uid, ids, context=None):
1285 context = context or {}
1286 if context.get('default_model') == 'purchase.order' and context.get('default_res_id'):
1287 context = dict(context, mail_post_autofollow=True)
1288 self.pool.get('purchase.order').signal_send_rfq(cr, uid, [context['default_res_id']])
1289 return super(mail_compose_message, self).send_mail(cr, uid, ids, context=context)
1292 class account_invoice(osv.Model):
1293 """ Override account_invoice to add Chatter messages on the related purchase
1294 orders, logging the invoice reception or payment. """
1295 _inherit = 'account.invoice'
1297 def invoice_validate(self, cr, uid, ids, context=None):
1298 res = super(account_invoice, self).invoice_validate(cr, uid, ids, context=context)
1299 purchase_order_obj = self.pool.get('purchase.order')
1300 # read access on purchase.order object is not required
1301 if not purchase_order_obj.check_access_rights(cr, uid, 'read', raise_exception=False):
1302 user_id = SUPERUSER_ID
1305 po_ids = purchase_order_obj.search(cr, user_id, [('invoice_ids', 'in', ids)], context=context)
1306 for order in purchase_order_obj.browse(cr, uid, po_ids, context=context):
1307 purchase_order_obj.message_post(cr, user_id, order.id, body=_("Invoice received"), context=context)
1309 for po_line in order.order_line:
1310 if any(line.invoice_id.state not in ['draft', 'cancel'] for line in po_line.invoice_lines):
1311 invoiced.append(po_line.id)
1313 self.pool['purchase.order.line'].write(cr, uid, invoiced, {'invoiced': True})
1314 workflow.trg_write(uid, 'purchase.order', order.id, cr)
1317 def confirm_paid(self, cr, uid, ids, context=None):
1318 res = super(account_invoice, self).confirm_paid(cr, uid, ids, context=context)
1319 purchase_order_obj = self.pool.get('purchase.order')
1320 # read access on purchase.order object is not required
1321 if not purchase_order_obj.check_access_rights(cr, uid, 'read', raise_exception=False):
1322 user_id = SUPERUSER_ID
1325 po_ids = purchase_order_obj.search(cr, user_id, [('invoice_ids', 'in', ids)], context=context)
1326 for po_id in po_ids:
1327 purchase_order_obj.message_post(cr, user_id, po_id, body=_("Invoice paid"), context=context)
1330 class account_invoice_line(osv.Model):
1331 """ Override account_invoice_line to add the link to the purchase order line it is related to"""
1332 _inherit = 'account.invoice.line'
1334 'purchase_line_id': fields.many2one('purchase.order.line',
1335 'Purchase Order Line', ondelete='set null', select=True,
1339 # vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4: