673 lines
35 KiB
Python
673 lines
35 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo, Flectra. See LICENSE file for full copyright and licensing details.
|
|
|
|
from collections import defaultdict
|
|
|
|
from flectra import api, fields, models, _
|
|
from flectra.exceptions import UserError
|
|
from flectra.tools import float_compare, float_round, float_is_zero, pycompat
|
|
|
|
import logging
|
|
_logger = logging.getLogger(__name__)
|
|
|
|
|
|
class StockInventory(models.Model):
|
|
_inherit = "stock.inventory"
|
|
|
|
accounting_date = fields.Date(
|
|
'Force Accounting Date',
|
|
help="Choose the accounting date at which you want to value the stock "
|
|
"moves created by the inventory instead of the default one (the "
|
|
"inventory end date)")
|
|
|
|
@api.multi
|
|
def post_inventory(self):
|
|
acc_inventories = self.filtered(lambda inventory: inventory.accounting_date)
|
|
for inventory in acc_inventories:
|
|
res = super(StockInventory, inventory.with_context(force_period_date=inventory.accounting_date)).post_inventory()
|
|
other_inventories = self - acc_inventories
|
|
if other_inventories:
|
|
res = super(StockInventory, other_inventories).post_inventory()
|
|
return res
|
|
|
|
|
|
class StockLocation(models.Model):
|
|
_inherit = "stock.location"
|
|
|
|
valuation_in_account_id = fields.Many2one(
|
|
'account.account', 'Stock Valuation Account (Incoming)',
|
|
domain=[('internal_type', '=', 'other'), ('deprecated', '=', False)],
|
|
help="Used for real-time inventory valuation. When set on a virtual location (non internal type), "
|
|
"this account will be used to hold the value of products being moved from an internal location "
|
|
"into this location, instead of the generic Stock Output Account set on the product. "
|
|
"This has no effect for internal locations.")
|
|
valuation_out_account_id = fields.Many2one(
|
|
'account.account', 'Stock Valuation Account (Outgoing)',
|
|
domain=[('internal_type', '=', 'other'), ('deprecated', '=', False)],
|
|
help="Used for real-time inventory valuation. When set on a virtual location (non internal type), "
|
|
"this account will be used to hold the value of products being moved out of this location "
|
|
"and into an internal location, instead of the generic Stock Output Account set on the product. "
|
|
"This has no effect for internal locations.")
|
|
|
|
def _should_be_valued(self):
|
|
""" This method returns a boolean reflecting whether the products stored in `self` should
|
|
be considered when valuating the stock of a company.
|
|
"""
|
|
self.ensure_one()
|
|
if self.usage == 'internal' or (self.usage == 'transit' and self.company_id):
|
|
return True
|
|
return False
|
|
|
|
|
|
class StockMoveLine(models.Model):
|
|
_inherit = 'stock.move.line'
|
|
|
|
@api.model
|
|
def create(self, vals):
|
|
res = super(StockMoveLine, self).create(vals)
|
|
move = res.move_id
|
|
if move.state == 'done':
|
|
correction_value = move._run_valuation(res.qty_done)
|
|
if move.product_id.valuation == 'real_time' and (move._is_in() or move._is_out()):
|
|
move.with_context(force_valuation_amount=correction_value)._account_entry_move()
|
|
return res
|
|
|
|
@api.multi
|
|
def write(self, vals):
|
|
""" When editing a done stock.move.line, we impact the valuation. Users may increase or
|
|
decrease the `qty_done` field. There are three cost method available: standard, average
|
|
and fifo. We implement the logic in a similar way for standard and average: increase
|
|
or decrease the original value with the standard or average price of today. In fifo, we
|
|
have a different logic wheter the move is incoming or outgoing. If the move is incoming, we
|
|
update the value and remaining_value/qty with the unit price of the move. If the move is
|
|
outgoing and the user increases qty_done, we call _run_fifo and it'll consume layer(s) in
|
|
the stack the same way a new outgoing move would have done. If the move is outoing and the
|
|
user decreases qty_done, we either increase the last receipt candidate if one is found or
|
|
we decrease the value with the last fifo price.
|
|
"""
|
|
if 'qty_done' in vals:
|
|
moves_to_update = {}
|
|
for move_line in self.filtered(lambda ml: ml.state == 'done' and (ml.move_id._is_in() or ml.move_id._is_out())):
|
|
moves_to_update[move_line.move_id] = vals['qty_done'] - move_line.qty_done
|
|
|
|
for move_id, qty_difference in moves_to_update.items():
|
|
move_vals = {}
|
|
if move_id.product_id.cost_method in ['standard', 'average']:
|
|
correction_value = qty_difference * move_id.product_id.standard_price
|
|
if move_id._is_in():
|
|
move_vals['value'] = move_id.value + correction_value
|
|
elif move_id._is_out():
|
|
move_vals['value'] = move_id.value - correction_value
|
|
else:
|
|
if move_id._is_in():
|
|
correction_value = qty_difference * move_id.price_unit
|
|
new_remaining_value = move_id.remaining_value + correction_value
|
|
move_vals['value'] = move_id.value + correction_value
|
|
move_vals['remaining_qty'] = move_id.remaining_qty + qty_difference
|
|
move_vals['remaining_value'] = move_id.remaining_value + correction_value
|
|
elif move_id._is_out() and qty_difference > 0:
|
|
correction_value = self.env['stock.move']._run_fifo(move_id, quantity=qty_difference)
|
|
# no need to adapt `remaining_qty` and `remaining_value` as `_run_fifo` took care of it
|
|
move_vals['value'] = move_id.value - correction_value
|
|
elif move_id._is_out() and qty_difference < 0:
|
|
candidates_receipt = self.env['stock.move'].search(move_id._get_in_domain(), order='date, id desc', limit=1)
|
|
if candidates_receipt:
|
|
candidates_receipt.write({
|
|
'remaining_qty': candidates_receipt.remaining_qty + -qty_difference,
|
|
'remaining_value': candidates_receipt.remaining_value + (-qty_difference * candidates_receipt.price_unit),
|
|
})
|
|
correction_value = qty_difference * candidates_receipt.price_unit
|
|
else:
|
|
correction_value = qty_difference * move_id.product_id.standard_price
|
|
move_vals['value'] = move_id.value - correction_value
|
|
move_id.write(move_vals)
|
|
|
|
if move_id.product_id.valuation == 'real_time':
|
|
move_id.with_context(force_valuation_amount=correction_value, forced_quantity=qty_difference)._account_entry_move()
|
|
if qty_difference > 0:
|
|
move_id.product_price_update_before_done(forced_qty=qty_difference)
|
|
return super(StockMoveLine, self).write(vals)
|
|
|
|
|
|
class StockMove(models.Model):
|
|
_inherit = "stock.move"
|
|
|
|
to_refund = fields.Boolean(string="To Refund (update SO/PO)", copy=False,
|
|
help='Trigger a decrease of the delivered/received quantity in the associated Sale Order/Purchase Order')
|
|
value = fields.Float(copy=False)
|
|
remaining_qty = fields.Float(copy=False)
|
|
remaining_value = fields.Float(copy=False)
|
|
account_move_ids = fields.One2many('account.move', 'stock_move_id')
|
|
|
|
@api.multi
|
|
def action_get_account_moves(self):
|
|
self.ensure_one()
|
|
action_ref = self.env.ref('account.action_move_journal_line')
|
|
if not action_ref:
|
|
return False
|
|
action_data = action_ref.read()[0]
|
|
action_data['domain'] = [('id', 'in', self.account_move_ids.ids)]
|
|
return action_data
|
|
|
|
def _get_price_unit(self):
|
|
""" Returns the unit price to store on the quant """
|
|
return not self.company_id.currency_id.is_zero(self.price_unit) and self.price_unit or self.product_id.standard_price
|
|
|
|
@api.model
|
|
def _get_in_base_domain(self, company_id=False):
|
|
domain = [
|
|
('state', '=', 'done'),
|
|
('location_id.company_id', '=', False),
|
|
('location_dest_id.company_id', '=', company_id or self.env.user.company_id.id)
|
|
]
|
|
return domain
|
|
|
|
@api.model
|
|
def _get_all_base_domain(self, company_id=False):
|
|
domain = [
|
|
('state', '=', 'done'),
|
|
'|',
|
|
'&',
|
|
('location_id.company_id', '=', False),
|
|
('location_dest_id.company_id', '=', company_id or self.env.user.company_id.id),
|
|
'&',
|
|
('location_id.company_id', '=', company_id or self.env.user.company_id.id),
|
|
('location_dest_id.company_id', '=', False)
|
|
]
|
|
return domain
|
|
|
|
def _get_in_domain(self):
|
|
return [('product_id', '=', self.product_id.id)] + self._get_in_base_domain(company_id=self.company_id.id)
|
|
|
|
def _get_all_domain(self):
|
|
return [('product_id', '=', self.product_id.id)] + self._get_all_base_domain(company_id=self.company_id.id)
|
|
|
|
def _is_in(self):
|
|
""" Check if the move should be considered as entering the company so that the cost method
|
|
will be able to apply the correct logic.
|
|
|
|
:return: True if the move is entering the company else False
|
|
"""
|
|
for move_line in self.move_line_ids.filtered(lambda ml: not ml.owner_id):
|
|
if not move_line.location_id._should_be_valued() and move_line.location_dest_id._should_be_valued():
|
|
return True
|
|
return False
|
|
|
|
def _is_out(self):
|
|
""" Check if the move should be considered as leaving the company so that the cost method
|
|
will be able to apply the correct logic.
|
|
|
|
:return: True if the move is leaving the company else False
|
|
"""
|
|
for move_line in self.move_line_ids.filtered(lambda ml: not ml.owner_id):
|
|
if move_line.location_id._should_be_valued() and not move_line.location_dest_id._should_be_valued():
|
|
return True
|
|
return False
|
|
|
|
def _is_dropshipped(self):
|
|
""" Check if the move should be considered as a dropshipping move so that the cost method
|
|
will be able to apply the correct logic.
|
|
|
|
:return: True if the move is a dropshipping one else False
|
|
"""
|
|
return self.location_id.usage == 'supplier' and self.location_dest_id.usage == 'customer'
|
|
|
|
@api.model
|
|
def _run_fifo(self, move, quantity=None):
|
|
""" Value `move` according to the FIFO rule, meaning we consume the
|
|
oldest receipt first. Candidates receipts are marked consumed or free
|
|
thanks to their `remaining_qty` and `remaining_value` fields.
|
|
By definition, `move` should be an outgoing stock move.
|
|
|
|
:param quantity: quantity to value instead of `move.product_qty`
|
|
:returns: valued amount in absolute
|
|
"""
|
|
move.ensure_one()
|
|
|
|
# Deal with possible move lines that do not impact the valuation.
|
|
valued_move_lines = move.move_line_ids.filtered(lambda ml: ml.location_id._should_be_valued() and not ml.location_dest_id._should_be_valued() and not ml.owner_id)
|
|
valued_quantity = 0
|
|
for valued_move_line in valued_move_lines:
|
|
valued_quantity += valued_move_line.product_uom_id._compute_quantity(valued_move_line.qty_done, move.product_id.uom_id)
|
|
|
|
# Find back incoming stock moves (called candidates here) to value this move.
|
|
qty_to_take_on_candidates = quantity or valued_quantity
|
|
candidates = move.product_id._get_fifo_candidates_in_move()
|
|
new_standard_price = 0
|
|
tmp_value = 0 # to accumulate the value taken on the candidates
|
|
for candidate in candidates:
|
|
new_standard_price = candidate.price_unit
|
|
if candidate.remaining_qty <= qty_to_take_on_candidates:
|
|
qty_taken_on_candidate = candidate.remaining_qty
|
|
else:
|
|
qty_taken_on_candidate = qty_to_take_on_candidates
|
|
|
|
# As applying a landed cost do not update the unit price, naivelly doing
|
|
# something like qty_taken_on_candidate * candidate.price_unit won't make
|
|
# the additional value brought by the landed cost go away.
|
|
candidate_price_unit = candidate.remaining_value / candidate.remaining_qty
|
|
value_taken_on_candidate = qty_taken_on_candidate * candidate_price_unit
|
|
candidate_vals = {
|
|
'remaining_qty': candidate.remaining_qty - qty_taken_on_candidate,
|
|
'remaining_value': candidate.remaining_value - value_taken_on_candidate,
|
|
}
|
|
candidate.write(candidate_vals)
|
|
|
|
qty_to_take_on_candidates -= qty_taken_on_candidate
|
|
tmp_value += value_taken_on_candidate
|
|
if qty_to_take_on_candidates == 0:
|
|
break
|
|
|
|
# Update the standard price with the price of the last used candidate, if any.
|
|
if new_standard_price and move.product_id.cost_method == 'fifo':
|
|
move.product_id.sudo().standard_price = new_standard_price
|
|
|
|
# If there's still quantity to value but we're out of candidates, we fall in the
|
|
# negative stock use case. We chose to value the out move at the price of the
|
|
# last out and a correction entry will be made once `_fifo_vacuum` is called.
|
|
if qty_to_take_on_candidates == 0:
|
|
move.write({
|
|
'value': -tmp_value if not quantity else move.value or -tmp_value, # outgoing move are valued negatively
|
|
'price_unit': -tmp_value / move.product_qty,
|
|
})
|
|
elif qty_to_take_on_candidates > 0:
|
|
last_fifo_price = new_standard_price or move.product_id.standard_price
|
|
negative_stock_value = last_fifo_price * -qty_to_take_on_candidates
|
|
tmp_value += abs(negative_stock_value)
|
|
vals = {
|
|
'remaining_qty': move.remaining_qty + -qty_to_take_on_candidates,
|
|
'remaining_value': move.remaining_value + negative_stock_value,
|
|
'value': -tmp_value,
|
|
'price_unit': -1 * last_fifo_price,
|
|
}
|
|
move.write(vals)
|
|
return tmp_value
|
|
|
|
def _run_valuation(self, quantity=None):
|
|
self.ensure_one()
|
|
if self._is_in():
|
|
valued_move_lines = self.move_line_ids.filtered(lambda ml: not ml.location_id._should_be_valued() and ml.location_dest_id._should_be_valued() and not ml.owner_id)
|
|
valued_quantity = 0
|
|
for valued_move_line in valued_move_lines:
|
|
valued_quantity += valued_move_line.product_uom_id._compute_quantity(valued_move_line.qty_done, self.product_id.uom_id)
|
|
|
|
# Note: we always compute the fifo `remaining_value` and `remaining_qty` fields no
|
|
# matter which cost method is set, to ease the switching of cost method.
|
|
vals = {}
|
|
price_unit = self._get_price_unit()
|
|
value = price_unit * (quantity or valued_quantity)
|
|
vals = {
|
|
'price_unit': price_unit,
|
|
'value': value if quantity is None or not self.value else self.value,
|
|
'remaining_value': value if quantity is None else self.remaining_value + value,
|
|
}
|
|
vals['remaining_qty'] = valued_quantity if quantity is None else self.remaining_qty + quantity
|
|
|
|
if self.product_id.cost_method == 'standard':
|
|
value = self.product_id.standard_price * (quantity or valued_quantity)
|
|
vals.update({
|
|
'price_unit': self.product_id.standard_price,
|
|
'value': value if quantity is None or not self.value else self.value,
|
|
})
|
|
self.write(vals)
|
|
elif self._is_out():
|
|
valued_move_lines = self.move_line_ids.filtered(lambda ml: ml.location_id._should_be_valued() and not ml.location_dest_id._should_be_valued() and not ml.owner_id)
|
|
valued_quantity = 0
|
|
for valued_move_line in valued_move_lines:
|
|
valued_quantity += valued_move_line.product_uom_id._compute_quantity(valued_move_line.qty_done, self.product_id.uom_id)
|
|
self.env['stock.move']._run_fifo(self, quantity=quantity)
|
|
if self.product_id.cost_method in ['standard', 'average']:
|
|
curr_rounding = self.company_id.currency_id.rounding
|
|
value = -float_round(self.product_id.standard_price * (valued_quantity if quantity is None else quantity), precision_rounding=curr_rounding)
|
|
self.write({
|
|
'value': value if quantity is None else self.value + value,
|
|
'price_unit': value / valued_quantity,
|
|
})
|
|
elif self._is_dropshipped():
|
|
curr_rounding = self.company_id.currency_id.rounding
|
|
if self.product_id.cost_method in ['fifo']:
|
|
price_unit = self._get_price_unit()
|
|
# see test_dropship_fifo_perpetual_anglosaxon_ordered
|
|
self.product_id.standard_price = price_unit
|
|
else:
|
|
price_unit = self.product_id.standard_price
|
|
value = float_round(self.product_qty * price_unit, precision_rounding=curr_rounding)
|
|
# In move have a positive value, out move have a negative value, let's arbitrary say
|
|
# dropship are positive.
|
|
self.write({
|
|
'value': value,
|
|
'price_unit': price_unit,
|
|
})
|
|
|
|
def _action_done(self):
|
|
self.product_price_update_before_done()
|
|
res = super(StockMove, self)._action_done()
|
|
for move in res:
|
|
# Apply restrictions on the stock move to be able to make
|
|
# consistent accounting entries.
|
|
if move._is_in() and move._is_out():
|
|
raise UserError(_("The move lines are not in a consistent state: some are entering and other are leaving the company. "))
|
|
company_src = move.mapped('move_line_ids.location_id.company_id')
|
|
company_dst = move.mapped('move_line_ids.location_dest_id.company_id')
|
|
try:
|
|
if company_src:
|
|
company_src.ensure_one()
|
|
if company_dst:
|
|
company_dst.ensure_one()
|
|
except ValueError:
|
|
raise UserError(_("The move lines are not in a consistent states: they do not share the same origin or destination company."))
|
|
if company_src and company_dst and company_src.id != company_dst.id:
|
|
raise UserError(_("The move lines are not in a consistent states: they are doing an intercompany in a single step while they should go through the intercompany transit location."))
|
|
move._run_valuation()
|
|
for move in res.filtered(lambda m: m.product_id.valuation == 'real_time' and (m._is_in() or m._is_out() or m._is_dropshipped())):
|
|
move._account_entry_move()
|
|
return res
|
|
|
|
@api.multi
|
|
def product_price_update_before_done(self, forced_qty=None):
|
|
tmpl_dict = defaultdict(lambda: 0.0)
|
|
# adapt standard price on incomming moves if the product cost_method is 'average'
|
|
std_price_update = {}
|
|
for move in self.filtered(lambda move: move.location_id.usage in ('supplier', 'production') and move.product_id.cost_method == 'average'):
|
|
product_tot_qty_available = move.product_id.qty_available + tmpl_dict[move.product_id.id]
|
|
rounding = move.product_id.uom_id.rounding
|
|
|
|
qty_done = 0.0
|
|
if float_is_zero(product_tot_qty_available, precision_rounding=rounding):
|
|
new_std_price = move._get_price_unit()
|
|
elif float_is_zero(product_tot_qty_available + move.product_qty, precision_rounding=rounding):
|
|
new_std_price = move._get_price_unit()
|
|
else:
|
|
# Get the standard price
|
|
amount_unit = std_price_update.get((move.company_id.id, move.product_id.id)) or move.product_id.standard_price
|
|
qty_done = move.product_uom._compute_quantity(move.quantity_done, move.product_id.uom_id)
|
|
qty = forced_qty or qty_done
|
|
new_std_price = ((amount_unit * product_tot_qty_available) + (move._get_price_unit() * qty)) / (product_tot_qty_available + qty_done)
|
|
|
|
tmpl_dict[move.product_id.id] += qty_done
|
|
# Write the standard price, as SUPERUSER_ID because a warehouse manager may not have the right to write on products
|
|
move.product_id.with_context(force_company=move.company_id.id).sudo().write({'standard_price': new_std_price})
|
|
std_price_update[move.company_id.id, move.product_id.id] = new_std_price
|
|
|
|
@api.model
|
|
def _fifo_vacuum(self):
|
|
""" Every moves that need to be fixed are identifiable by having a negative `remaining_qty`.
|
|
"""
|
|
for move in self.filtered(lambda m: (m._is_in() or m._is_out()) and m.remaining_qty < 0):
|
|
domain = [
|
|
('remaining_qty', '>', 0),
|
|
'|',
|
|
('date', '>', move.date),
|
|
'&',
|
|
('date', '=', move.date),
|
|
('id', '>', move.id)
|
|
]
|
|
domain += move._get_in_domain()
|
|
candidates = self.search(domain, order='date, id')
|
|
if not candidates:
|
|
continue
|
|
qty_to_take_on_candidates = abs(move.remaining_qty)
|
|
qty_taken_on_candidates = 0
|
|
tmp_value = 0
|
|
for candidate in candidates:
|
|
if candidate.remaining_qty <= qty_to_take_on_candidates:
|
|
qty_taken_on_candidate = candidate.remaining_qty
|
|
else:
|
|
qty_taken_on_candidate = qty_to_take_on_candidates
|
|
qty_taken_on_candidates += qty_taken_on_candidate
|
|
|
|
value_taken_on_candidate = qty_taken_on_candidate * candidate.price_unit
|
|
candidate_vals = {
|
|
'remaining_qty': candidate.remaining_qty - qty_taken_on_candidate,
|
|
'remaining_value': candidate.remaining_value - value_taken_on_candidate,
|
|
}
|
|
candidate.write(candidate_vals)
|
|
|
|
qty_to_take_on_candidates -= qty_taken_on_candidate
|
|
tmp_value += value_taken_on_candidate
|
|
if qty_to_take_on_candidates == 0:
|
|
break
|
|
|
|
|
|
# When working with `price_unit`, beware that out move are negative.
|
|
move_price_unit = move.price_unit if move._is_out() else -1 * move.price_unit
|
|
# Get the estimated value we will correct.
|
|
remaining_value_before_vacuum = qty_taken_on_candidates * move_price_unit
|
|
new_remaining_qty = move.remaining_qty + qty_taken_on_candidates
|
|
new_remaining_value = new_remaining_qty * abs(move.price_unit)
|
|
|
|
corrected_value = remaining_value_before_vacuum + tmp_value
|
|
move.write({
|
|
'remaining_value': new_remaining_value,
|
|
'remaining_qty': new_remaining_qty,
|
|
'value': move.value - corrected_value,
|
|
})
|
|
|
|
if move.product_id.valuation == 'real_time':
|
|
# If `corrected_value` is 0, absolutely do *not* call `_account_entry_move`. We
|
|
# force the amount in the context, but in the case it is 0 it'll create an entry
|
|
# for the entire cost of the move. This case happens when the candidates moves
|
|
# entirely compensate the problematic move.
|
|
if not corrected_value:
|
|
continue
|
|
|
|
if move._is_in():
|
|
# If we just compensated an IN move that has a negative remaining
|
|
# quantity, it means the move has returned more items than it received.
|
|
# The correction should behave as a return too. As `_account_entry_move`
|
|
# will post the natural values for an IN move (credit IN account, debit
|
|
# OUT one), we inverse the sign to create the correct entries.
|
|
move.with_context(force_valuation_amount=-corrected_value, forced_quantity=0)._account_entry_move()
|
|
else:
|
|
move.with_context(force_valuation_amount=corrected_value, forced_quantity=0)._account_entry_move()
|
|
|
|
@api.model
|
|
def _run_fifo_vacuum(self):
|
|
# Call `_fifo_vacuum` on concerned moves
|
|
fifo_valued_products = self.env['product.product']
|
|
fifo_valued_products |= self.env['product.template'].search([('property_cost_method', '=', 'fifo')]).mapped(
|
|
'product_variant_ids')
|
|
fifo_valued_categories = self.env['product.category'].search([('property_cost_method', '=', 'fifo')])
|
|
fifo_valued_products |= self.env['product.product'].search([('categ_id', 'child_of', fifo_valued_categories.ids)])
|
|
moves_to_vacuum = self.env['stock.move']
|
|
for product in fifo_valued_products:
|
|
moves_to_vacuum |= self.search(
|
|
[('product_id', '=', product.id), ('remaining_qty', '<', 0)] + self._get_all_base_domain())
|
|
moves_to_vacuum._fifo_vacuum()
|
|
|
|
@api.multi
|
|
def _get_accounting_data_for_valuation(self):
|
|
""" Return the accounts and journal to use to post Journal Entries for
|
|
the real-time valuation of the quant. """
|
|
self.ensure_one()
|
|
accounts_data = self.product_id.product_tmpl_id.get_product_accounts()
|
|
|
|
if self.location_id.valuation_out_account_id:
|
|
acc_src = self.location_id.valuation_out_account_id.id
|
|
else:
|
|
acc_src = accounts_data['stock_input'].id
|
|
|
|
if self.location_dest_id.valuation_in_account_id:
|
|
acc_dest = self.location_dest_id.valuation_in_account_id.id
|
|
else:
|
|
acc_dest = accounts_data['stock_output'].id
|
|
|
|
acc_valuation = accounts_data.get('stock_valuation', False)
|
|
if acc_valuation:
|
|
acc_valuation = acc_valuation.id
|
|
if not accounts_data.get('stock_journal', False):
|
|
raise UserError(_('You don\'t have any stock journal defined on your product category, check if you have installed a chart of accounts'))
|
|
if not acc_src:
|
|
raise UserError(_('Cannot find a stock input account for the product %s. You must define one on the product category, or on the location, before processing this operation.') % (self.product_id.name))
|
|
if not acc_dest:
|
|
raise UserError(_('Cannot find a stock output account for the product %s. You must define one on the product category, or on the location, before processing this operation.') % (self.product_id.name))
|
|
if not acc_valuation:
|
|
raise UserError(_('You don\'t have any stock valuation account defined on your product category. You must define one before processing this operation.'))
|
|
journal_id = accounts_data['stock_journal'].id
|
|
return journal_id, acc_src, acc_dest, acc_valuation
|
|
|
|
def _prepare_account_move_line(self, qty, cost, credit_account_id, debit_account_id):
|
|
"""
|
|
Generate the account.move.line values to post to track the stock valuation difference due to the
|
|
processing of the given quant.
|
|
"""
|
|
self.ensure_one()
|
|
|
|
if self._context.get('force_valuation_amount'):
|
|
valuation_amount = self._context.get('force_valuation_amount')
|
|
else:
|
|
valuation_amount = cost
|
|
|
|
if self._context.get('forced_ref'):
|
|
ref = self._context['forced_ref']
|
|
else:
|
|
ref = self.picking_id.name
|
|
|
|
# the standard_price of the product may be in another decimal precision, or not compatible with the coinage of
|
|
# the company currency... so we need to use round() before creating the accounting entries.
|
|
debit_value = self.company_id.currency_id.round(valuation_amount)
|
|
|
|
# check that all data is correct
|
|
if self.company_id.currency_id.is_zero(debit_value):
|
|
raise UserError(_("The cost of %s is currently equal to 0. Change the cost or the configuration of your product to avoid an incorrect valuation.") % (self.product_id.name,))
|
|
credit_value = debit_value
|
|
|
|
partner_id = (self.picking_id.partner_id and self.env['res.partner']._find_accounting_partner(self.picking_id.partner_id).id) or False
|
|
debit_line_vals = {
|
|
'name': self.name,
|
|
'product_id': self.product_id.id,
|
|
'quantity': qty,
|
|
'product_uom_id': self.product_id.uom_id.id,
|
|
'ref': ref,
|
|
'partner_id': partner_id,
|
|
'debit': debit_value if debit_value > 0 else 0,
|
|
'credit': -debit_value if debit_value < 0 else 0,
|
|
'account_id': debit_account_id,
|
|
}
|
|
credit_line_vals = {
|
|
'name': self.name,
|
|
'product_id': self.product_id.id,
|
|
'quantity': qty,
|
|
'product_uom_id': self.product_id.uom_id.id,
|
|
'ref': ref,
|
|
'partner_id': partner_id,
|
|
'credit': credit_value if credit_value > 0 else 0,
|
|
'debit': -credit_value if credit_value < 0 else 0,
|
|
'account_id': credit_account_id,
|
|
}
|
|
res = [(0, 0, debit_line_vals), (0, 0, credit_line_vals)]
|
|
if credit_value != debit_value:
|
|
# for supplier returns of product in average costing method, in anglo saxon mode
|
|
diff_amount = debit_value - credit_value
|
|
price_diff_account = self.product_id.property_account_creditor_price_difference
|
|
if not price_diff_account:
|
|
price_diff_account = self.product_id.categ_id.property_account_creditor_price_difference_categ
|
|
if not price_diff_account:
|
|
raise UserError(_('Configuration error. Please configure the price difference account on the product or its category to process this operation.'))
|
|
price_diff_line = {
|
|
'name': self.name,
|
|
'product_id': self.product_id.id,
|
|
'quantity': qty,
|
|
'product_uom_id': self.product_id.uom_id.id,
|
|
'ref': ref,
|
|
'partner_id': partner_id,
|
|
'credit': diff_amount > 0 and diff_amount or 0,
|
|
'debit': diff_amount < 0 and -diff_amount or 0,
|
|
'account_id': price_diff_account.id,
|
|
}
|
|
res.append((0, 0, price_diff_line))
|
|
return res
|
|
|
|
def _create_account_move_line(self, credit_account_id, debit_account_id, journal_id):
|
|
self.ensure_one()
|
|
AccountMove = self.env['account.move']
|
|
quantity = self.env.context.get('forced_quantity', self.product_qty)
|
|
quantity = quantity if self._is_in() else -1 * quantity
|
|
|
|
# Make an informative `ref` on the created account move to differentiate between classic
|
|
# movements, vacuum and edition of past moves.
|
|
ref = self.picking_id.name
|
|
if self.env.context.get('force_valuation_amount'):
|
|
if self.env.context.get('forced_quantity') == 0:
|
|
ref = 'Revaluation of %s (negative inventory)' % ref
|
|
elif self.env.context.get('forced_quantity') is not None:
|
|
ref = 'Correction of %s (modification of past move)' % ref
|
|
|
|
move_lines = self.with_context(forced_ref=ref)._prepare_account_move_line(quantity, abs(self.value), credit_account_id, debit_account_id)
|
|
if move_lines:
|
|
date = self._context.get('force_period_date', fields.Date.context_today(self))
|
|
new_account_move = AccountMove.sudo().create({
|
|
'journal_id': journal_id,
|
|
'line_ids': move_lines,
|
|
'date': date,
|
|
'ref': ref,
|
|
'stock_move_id': self.id,
|
|
})
|
|
new_account_move.post()
|
|
|
|
def _account_entry_move(self):
|
|
""" Accounting Valuation Entries """
|
|
self.ensure_one()
|
|
if self.product_id.type != 'product':
|
|
# no stock valuation for consumable products
|
|
return False
|
|
if self.restrict_partner_id:
|
|
# if the move isn't owned by the company, we don't make any valuation
|
|
return False
|
|
|
|
location_from = self.location_id
|
|
location_to = self.location_dest_id
|
|
company_from = self._is_out() and self.mapped('move_line_ids.location_id.company_id') or False
|
|
company_to = self._is_in() and self.mapped('move_line_ids.location_dest_id.company_id') or False
|
|
|
|
# Create Journal Entry for products arriving in the company; in case of routes making the link between several
|
|
# warehouse of the same company, the transit location belongs to this company, so we don't need to create accounting entries
|
|
if self._is_in():
|
|
journal_id, acc_src, acc_dest, acc_valuation = self._get_accounting_data_for_valuation()
|
|
if location_from and location_from.usage == 'customer': # goods returned from customer
|
|
self.with_context(force_company=company_to.id)._create_account_move_line(acc_dest, acc_valuation, journal_id)
|
|
else:
|
|
self.with_context(force_company=company_to.id)._create_account_move_line(acc_src, acc_valuation, journal_id)
|
|
|
|
# Create Journal Entry for products leaving the company
|
|
if self._is_out():
|
|
journal_id, acc_src, acc_dest, acc_valuation = self._get_accounting_data_for_valuation()
|
|
if location_to and location_to.usage == 'supplier': # goods returned to supplier
|
|
self.with_context(force_company=company_from.id)._create_account_move_line(acc_valuation, acc_src, journal_id)
|
|
else:
|
|
self.with_context(force_company=company_from.id)._create_account_move_line(acc_valuation, acc_dest, journal_id)
|
|
|
|
if self.company_id.anglo_saxon_accounting and self._is_dropshipped():
|
|
# Creates an account entry from stock_input to stock_output on a dropship move. https://github.com/odoo/odoo/issues/12687
|
|
journal_id, acc_src, acc_dest, acc_valuation = self._get_accounting_data_for_valuation()
|
|
self.with_context(force_company=self.company_id.id)._create_account_move_line(acc_src, acc_dest, journal_id)
|
|
|
|
|
|
class StockReturnPicking(models.TransientModel):
|
|
_inherit = "stock.return.picking"
|
|
|
|
@api.multi
|
|
def _create_returns(self):
|
|
new_picking_id, pick_type_id = super(StockReturnPicking, self)._create_returns()
|
|
new_picking = self.env['stock.picking'].browse([new_picking_id])
|
|
for move in new_picking.move_lines:
|
|
return_picking_line = self.product_return_moves.filtered(lambda r: r.move_id == move.origin_returned_move_id)
|
|
if return_picking_line and return_picking_line.to_refund:
|
|
move.to_refund = True
|
|
return new_picking_id, pick_type_id
|
|
|
|
|
|
class StockReturnPickingLine(models.TransientModel):
|
|
_inherit = "stock.return.picking.line"
|
|
|
|
to_refund = fields.Boolean(string="To Refund (update SO/PO)", help='Trigger a decrease of the delivered/received quantity in the associated Sale Order/Purchase Order')
|
|
|
|
|
|
class ProcurementGroup(models.Model):
|
|
_inherit = 'procurement.group'
|
|
|
|
@api.model
|
|
def _run_scheduler_tasks(self, use_new_cursor=False, company_id=False):
|
|
super(ProcurementGroup, self)._run_scheduler_tasks(use_new_cursor=use_new_cursor, company_id=company_id)
|
|
self.env['stock.move']._run_fifo_vacuum()
|