# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from collections import defaultdict
from datetime import datetime
from dateutil.relativedelta import relativedelta
from odoo.tools import float_compare
from odoo import api, fields, models, SUPERUSER_ID, _
from odoo.addons.stock.models.stock_rule import ProcurementException
from odoo.tools import groupby
class StockRule(models.Model):
_inherit = 'stock.rule'
action = fields.Selection(selection_add=[
('buy', 'Buy')
], ondelete={'buy': 'cascade'})
def _get_message_dict(self):
message_dict = super(StockRule, self)._get_message_dict()
__, destination, __, __ = self._get_message_values()
message_dict.update({
'buy': _('When products are needed in %s,
'
'a request for quotation is created to fulfill the need.
'
'Note: This rule will be used in combination with the rules
'
'of the reception route(s)', destination)
})
return message_dict
@api.depends('action')
def _compute_picking_type_code_domain(self):
remaining = self.browse()
for rule in self:
if rule.action == 'buy':
rule.picking_type_code_domain = 'incoming'
else:
remaining |= rule
super(StockRule, remaining)._compute_picking_type_code_domain()
@api.onchange('action')
def _onchange_action(self):
if self.action == 'buy':
self.location_src_id = False
@api.model
def _run_buy(self, procurements):
procurements_by_po_domain = defaultdict(list)
errors = []
for procurement, rule in procurements:
# Get the schedule date in order to find a valid seller
procurement_date_planned = fields.Datetime.from_string(procurement.values['date_planned'])
supplier = False
if procurement.values.get('supplierinfo_id'):
supplier = procurement.values['supplierinfo_id']
elif procurement.values.get('orderpoint_id') and procurement.values['orderpoint_id'].supplier_id:
supplier = procurement.values['orderpoint_id'].supplier_id
else:
supplier = procurement.product_id.with_company(procurement.company_id.id)._select_seller(
partner_id=self._get_partner_id(procurement.values, rule),
quantity=procurement.product_qty,
date=max(procurement_date_planned.date(), fields.Date.today()),
uom_id=procurement.product_uom)
# Fall back on a supplier for which no price may be defined. Not ideal, but better than
# blocking the user.
supplier = supplier or procurement.product_id._prepare_sellers(False).filtered(
lambda s: not s.company_id or s.company_id == procurement.company_id
)[:1]
if not supplier:
msg = _('There is no matching vendor price to generate the purchase order for product %s (no vendor defined, minimum quantity not reached, dates not valid, ...). Go on the product form and complete the list of vendors.', procurement.product_id.display_name)
errors.append((procurement, msg))
partner = supplier.partner_id
# we put `supplier_info` in values for extensibility purposes
procurement.values['supplier'] = supplier
procurement.values['propagate_cancel'] = rule.propagate_cancel
domain = rule._make_po_get_domain(procurement.company_id, procurement.values, partner)
procurements_by_po_domain[domain].append((procurement, rule))
if errors:
raise ProcurementException(errors)
for domain, procurements_rules in procurements_by_po_domain.items():
# Get the procurements for the current domain.
# Get the rules for the current domain. Their only use is to create
# the PO if it does not exist.
procurements, rules = zip(*procurements_rules)
# Get the set of procurement origin for the current domain.
origins = set([p.origin for p in procurements])
# Check if a PO exists for the current domain.
po = self.env['purchase.order'].sudo().search([dom for dom in domain], limit=1)
company_id = procurements[0].company_id
if not po:
positive_values = [p.values for p in procurements if float_compare(p.product_qty, 0.0, precision_rounding=p.product_uom.rounding) >= 0]
if positive_values:
# We need a rule to generate the PO. However the rule generated
# the same domain for PO and the _prepare_purchase_order method
# should only uses the common rules's fields.
vals = rules[0]._prepare_purchase_order(company_id, origins, positive_values)
# The company_id is the same for all procurements since
# _make_po_get_domain add the company in the domain.
# We use SUPERUSER_ID since we don't want the current user to be follower of the PO.
# Indeed, the current user may be a user without access to Purchase, or even be a portal user.
po = self.env['purchase.order'].with_company(company_id).with_user(SUPERUSER_ID).create(vals)
else:
# If a purchase order is found, adapt its `origin` field.
if po.origin:
missing_origins = origins - set(po.origin.split(', '))
if missing_origins:
po.write({'origin': po.origin + ', ' + ', '.join(missing_origins)})
else:
po.write({'origin': ', '.join(origins)})
procurements_to_merge = self._get_procurements_to_merge(procurements)
procurements = self._merge_procurements(procurements_to_merge)
po_lines_by_product = {}
grouped_po_lines = groupby(po.order_line.filtered(lambda l: not l.display_type and l.product_uom == l.product_id.uom_po_id), key=lambda l: l.product_id.id)
for product, po_lines in grouped_po_lines:
po_lines_by_product[product] = self.env['purchase.order.line'].concat(*po_lines)
po_line_values = []
for procurement in procurements:
po_lines = po_lines_by_product.get(procurement.product_id.id, self.env['purchase.order.line'])
po_line = po_lines._find_candidate(*procurement)
if po_line:
# If the procurement can be merge in an existing line. Directly
# write the new values on it.
vals = self._update_purchase_order_line(procurement.product_id,
procurement.product_qty, procurement.product_uom, company_id,
procurement.values, po_line)
po_line.sudo().write(vals)
else:
if float_compare(procurement.product_qty, 0, precision_rounding=procurement.product_uom.rounding) <= 0:
# If procurement contains negative quantity, don't create a new line that would contain negative qty
continue
# If it does not exist a PO line for current procurement.
# Generate the create values for it and add it to a list in
# order to create it in batch.
partner = procurement.values['supplier'].partner_id
po_line_values.append(self.env['purchase.order.line']._prepare_purchase_order_line_from_procurement(
*procurement, po))
# Check if we need to advance the order date for the new line
order_date_planned = procurement.values['date_planned'] - relativedelta(
days=procurement.values['supplier'].delay)
if fields.Date.to_date(order_date_planned) < fields.Date.to_date(po.date_order):
po.date_order = order_date_planned
self.env['purchase.order.line'].sudo().create(po_line_values)
def _get_lead_days(self, product, **values):
"""Add the company security lead time and the supplier delay to the cumulative delay
and cumulative description. The company lead time is always displayed for onboarding
purpose in order to indicate that those options are available.
"""
delays, delay_description = super()._get_lead_days(product, **values)
bypass_delay_description = self.env.context.get('bypass_delay_description')
buy_rule = self.filtered(lambda r: r.action == 'buy')
seller = 'supplierinfo' in values and values['supplierinfo'] or product.with_company(buy_rule.company_id)._select_seller(quantity=None)
if not buy_rule or not seller:
return delays, delay_description
buy_rule.ensure_one()
if not self.env.context.get('ignore_vendor_lead_time'):
supplier_delay = seller[0].delay
delays['total_delay'] += supplier_delay
delays['purchase_delay'] += supplier_delay
if not bypass_delay_description:
delay_description.append((_('Vendor Lead Time'), _('+ %d day(s)', supplier_delay)))
security_delay = buy_rule.picking_type_id.company_id.po_lead
delays['total_delay'] += security_delay
delays['security_lead_days'] += security_delay
if not bypass_delay_description:
delay_description.append((_('Purchase Security Lead Time'), _('+ %d day(s)', security_delay)))
days_to_order = buy_rule.company_id.days_to_purchase
delays['total_delay'] += days_to_order
if not bypass_delay_description:
delay_description.append((_('Days to Purchase'), _('+ %d day(s)', days_to_order)))
return delays, delay_description
@api.model
def _get_procurements_to_merge_groupby(self, procurement):
# Do not group procument from different orderpoint. 1. _quantity_in_progress
# directly depends from the orderpoint_id on the line. 2. The stock move
# generated from the order line has the orderpoint's location as
# destination location. In case of move_dest_ids those two points are not
# necessary anymore since those values are taken from destination moves.
return procurement.product_id, procurement.product_uom, procurement.values['propagate_cancel'],\
procurement.values.get('product_description_variants'),\
(procurement.values.get('orderpoint_id') and not procurement.values.get('move_dest_ids')) and procurement.values['orderpoint_id']
@api.model
def _get_procurements_to_merge(self, procurements):
""" Get a list of procurements values and create groups of procurements
that would use the same purchase order line.
params procurements_list list: procurements requests (not ordered nor
sorted).
return list: procurements requests grouped by their product_id.
"""
return [pro_g for __, pro_g in groupby(procurements, key=self._get_procurements_to_merge_groupby)]
@api.model
def _merge_procurements(self, procurements_to_merge):
""" Merge the quantity for procurements requests that could use the same
order line.
params similar_procurements list: list of procurements that have been
marked as 'alike' from _get_procurements_to_merge method.
return a list of procurements values where values of similar_procurements
list have been merged.
"""
merged_procurements = []
for procurements in procurements_to_merge:
quantity = 0
move_dest_ids = self.env['stock.move']
orderpoint_id = self.env['stock.warehouse.orderpoint']
for procurement in procurements:
if procurement.values.get('move_dest_ids'):
move_dest_ids |= procurement.values['move_dest_ids']
if not orderpoint_id and procurement.values.get('orderpoint_id'):
orderpoint_id = procurement.values['orderpoint_id']
quantity += procurement.product_qty
# The merged procurement can be build from an arbitrary procurement
# since they were mark as similar before. Only the quantity and
# some keys in values are updated.
values = dict(procurement.values)
values.update({
'move_dest_ids': move_dest_ids,
'orderpoint_id': orderpoint_id,
})
merged_procurement = self.env['procurement.group'].Procurement(
procurement.product_id, quantity, procurement.product_uom,
procurement.location_id, procurement.name, procurement.origin,
procurement.company_id, values
)
merged_procurements.append(merged_procurement)
return merged_procurements
def _update_purchase_order_line(self, product_id, product_qty, product_uom, company_id, values, line):
partner = values['supplier'].partner_id
procurement_uom_po_qty = product_uom._compute_quantity(product_qty, product_id.uom_po_id, rounding_method='HALF-UP')
seller = product_id.with_company(company_id)._select_seller(
partner_id=partner,
quantity=line.product_qty + procurement_uom_po_qty,
date=line.order_id.date_order and line.order_id.date_order.date(),
uom_id=product_id.uom_po_id)
price_unit = self.env['account.tax']._fix_tax_included_price_company(seller.price, line.product_id.supplier_taxes_id, line.sudo().taxes_id, company_id) if seller else 0.0
if price_unit and seller and line.order_id.currency_id and seller.currency_id != line.order_id.currency_id:
price_unit = seller.currency_id._convert(
price_unit, line.order_id.currency_id, line.order_id.company_id, fields.Date.today())
res = {
'product_qty': line.product_qty + procurement_uom_po_qty,
'price_unit': price_unit,
'move_dest_ids': [(4, x.id) for x in values.get('move_dest_ids', [])]
}
orderpoint_id = values.get('orderpoint_id')
if orderpoint_id:
res['orderpoint_id'] = orderpoint_id.id
return res
def _prepare_purchase_order(self, company_id, origins, values):
""" Create a purchase order for procuremets that share the same domain
returned by _make_po_get_domain.
params values: values of procurements
params origins: procuremets origins to write on the PO
"""
purchase_date = min([value.get('date_order') or fields.Datetime.from_string(value['date_planned']) - relativedelta(days=int(value['supplier'].delay)) for value in values])
# Since the procurements are grouped if they share the same domain for
# PO but the PO does not exist. In this case it will create the PO from
# the common procurements values. The common values are taken from an
# arbitrary procurement. In this case the first.
values = values[0]
partner = values['supplier'].partner_id
fpos = self.env['account.fiscal.position'].with_company(company_id)._get_fiscal_position(partner)
gpo = self.group_propagation_option
group = (gpo == 'fixed' and self.group_id.id) or \
(gpo == 'propagate' and values.get('group_id') and values['group_id'].id) or False
return {
'partner_id': partner.id,
'user_id': partner.buyer_id.id,
'picking_type_id': self.picking_type_id.id,
'company_id': company_id.id,
'currency_id': partner.with_company(company_id).property_purchase_currency_id.id or company_id.currency_id.id,
'dest_address_id': values.get('partner_id', False),
'origin': ', '.join(origins),
'payment_term_id': partner.with_company(company_id).property_supplier_payment_term_id.id,
'date_order': purchase_date,
'fiscal_position_id': fpos.id,
'group_id': group
}
def _make_po_get_domain(self, company_id, values, partner):
gpo = self.group_propagation_option
group = (gpo == 'fixed' and self.group_id) or \
(gpo == 'propagate' and 'group_id' in values and values['group_id']) or False
domain = (
('partner_id', '=', partner.id),
('state', '=', 'draft'),
('picking_type_id', '=', self.picking_type_id.id),
('company_id', '=', company_id.id),
('user_id', '=', partner.buyer_id.id),
)
delta_days = self.env['ir.config_parameter'].sudo().get_param('purchase_stock.delta_days_merge')
if values.get('orderpoint_id') and delta_days is not False:
procurement_date = fields.Date.to_date(values['date_planned']) - relativedelta(days=int(values['supplier'].delay))
delta_days = int(delta_days)
domain += (
('date_order', '<=', datetime.combine(procurement_date + relativedelta(days=delta_days), datetime.max.time())),
('date_order', '>=', datetime.combine(procurement_date - relativedelta(days=delta_days), datetime.min.time()))
)
if group:
domain += (('group_id', '=', group.id),)
return domain
def _push_prepare_move_copy_values(self, move_to_copy, new_date):
res = super(StockRule, self)._push_prepare_move_copy_values(move_to_copy, new_date)
res['purchase_line_id'] = None
if self.location_dest_id.usage == "supplier":
res['purchase_line_id'], res['partner_id'] = move_to_copy._get_purchase_line_and_partner_from_chain()
return res
def _get_partner_id(self, values, rule):
return values.get("supplierinfo_name") or (values.get("group_id") and values.get("group_id").partner_id)