1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from odoo import fields, models, api
from odoo.tools import float_compare, float_is_zero
from odoo.tools.misc import groupby
class AccountMove(models.Model):
_inherit = 'account.move'
def _stock_account_prepare_anglo_saxon_in_lines_vals(self):
''' Prepare values used to create the journal items (account.move.line) corresponding to the price difference
lines for vendor bills. It only concerns the quantities that have been delivered before the bill
Example:
Buy a product having a cost of 9 and a supplier price of 10 and being a storable product and having a perpetual
valuation in FIFO. Deliver the product and then post the bill. The vendor bill's journal entries looks like:
Account | Debit | Credit
---------------------------------------------------------------
101120 Stock Interim Account (Received) | 10.0 |
---------------------------------------------------------------
101100 Account Payable | | 10.0
---------------------------------------------------------------
This method computes values used to make two additional journal items:
---------------------------------------------------------------
101120 Stock Interim Account (Received) | | 1.0
---------------------------------------------------------------
xxxxxx Expenses | 1.0 |
---------------------------------------------------------------
:return: A list of Python dictionary to be passed to env['account.move.line'].create.
'''
lines_vals_list = []
price_unit_prec = self.env['decimal.precision'].precision_get('Product Price')
for move in self:
if move.move_type not in ('in_invoice', 'in_refund', 'in_receipt') or not move.company_id.anglo_saxon_accounting:
continue
move = move.with_company(move.company_id)
for line in move.invoice_line_ids:
# Filter out lines being not eligible for price difference.
# Moreover, this function is used for standard cost method only.
if not line._eligible_for_cogs() or line.product_id.cost_method != 'standard':
continue
# Retrieve accounts needed to generate the price difference.
debit_pdiff_account = False
if line.product_id.cost_method == 'standard':
debit_pdiff_account = line.product_id.property_account_creditor_price_difference \
or line.product_id.categ_id.property_account_creditor_price_difference_categ
debit_pdiff_account = move.fiscal_position_id.map_account(debit_pdiff_account)
else:
debit_pdiff_account = line.product_id.product_tmpl_id.get_product_accounts(fiscal_pos=move.fiscal_position_id)['expense']
if not debit_pdiff_account:
continue
price_unit_val_dif, relevant_qty = line._get_price_unit_val_dif_and_relevant_qty()
price_subtotal = relevant_qty * price_unit_val_dif
# We consider there is a price difference if the subtotal is not zero. In case a
# discount has been applied, we can't round the price unit anymore, and hence we
# can't compare them.
if (
not move.currency_id.is_zero(price_subtotal)
and float_compare(line["price_unit"], line.price_unit, precision_digits=price_unit_prec) == 0
):
# Add price difference account line.
vals = {
'name': line.name[:64],
'move_id': move.id,
'partner_id': line.partner_id.id or move.commercial_partner_id.id,
'currency_id': line.currency_id.id,
'product_id': line.product_id.id,
'product_uom_id': line.product_uom_id.id,
'quantity': relevant_qty,
'price_unit': price_unit_val_dif,
'price_subtotal': relevant_qty * price_unit_val_dif,
'amount_currency': relevant_qty * price_unit_val_dif * line.move_id.direction_sign,
'balance': line.currency_id._convert(
relevant_qty * price_unit_val_dif * line.move_id.direction_sign,
line.company_currency_id,
line.company_id, fields.Date.today(),
),
'account_id': debit_pdiff_account.id,
'analytic_distribution': line.analytic_distribution,
'display_type': 'cogs',
}
lines_vals_list.append(vals)
# Correct the amount of the current line.
vals = {
'name': line.name[:64],
'move_id': move.id,
'partner_id': line.partner_id.id or move.commercial_partner_id.id,
'currency_id': line.currency_id.id,
'product_id': line.product_id.id,
'product_uom_id': line.product_uom_id.id,
'quantity': relevant_qty,
'price_unit': -price_unit_val_dif,
'price_subtotal': relevant_qty * -price_unit_val_dif,
'amount_currency': relevant_qty * -price_unit_val_dif * line.move_id.direction_sign,
'balance': line.currency_id._convert(
relevant_qty * -price_unit_val_dif * line.move_id.direction_sign,
line.company_currency_id,
line.company_id, fields.Date.today(),
),
'account_id': line.account_id.id,
'analytic_distribution': line.analytic_distribution,
'display_type': 'cogs',
}
lines_vals_list.append(vals)
return lines_vals_list
def _post(self, soft=True):
if not self._context.get('move_reverse_cancel'):
self.env['account.move.line'].create(self._stock_account_prepare_anglo_saxon_in_lines_vals())
# Create correction layer and impact accounts if invoice price is different
stock_valuation_layers = self.env['stock.valuation.layer'].sudo()
valued_lines = self.env['account.move.line'].sudo()
for invoice in self:
if invoice.sudo().stock_valuation_layer_ids:
continue
if invoice.move_type in ('in_invoice', 'in_refund', 'in_receipt'):
valued_lines |= invoice.invoice_line_ids.filtered(
lambda l: l.product_id and l.product_id.cost_method != 'standard')
if valued_lines:
svls, _amls = valued_lines._apply_price_difference()
stock_valuation_layers |= svls
for (product, company), dummy in groupby(stock_valuation_layers, key=lambda svl: (svl.product_id, svl.company_id)):
product = product.with_company(company.id)
if not float_is_zero(product.quantity_svl, precision_rounding=product.uom_id.rounding):
product.sudo().with_context(disable_auto_svl=True).write({'standard_price': product.value_svl / product.quantity_svl})
for (lot, company), dummy in groupby(stock_valuation_layers, key=lambda svl: (svl.lot_id, svl.company_id)):
if not lot:
continue
lot = lot.with_company(company.id)
if not float_is_zero(lot.quantity_svl, precision_rounding=lot.product_id.uom_id.rounding):
lot.sudo().with_context(disable_auto_svl=True).write({'standard_price': lot.value_svl / lot.quantity_svl})
posted = super(AccountMove, self.with_context(skip_cogs_reconciliation=True))._post(soft)
# The invoice reference is set during the super call
for layer in stock_valuation_layers:
description = f"{layer.account_move_line_id.move_id.display_name} - {layer.product_id.display_name}"
layer.description = description
if stock_valuation_layers:
stock_valuation_layers._validate_accounting_entries()
self._stock_account_anglo_saxon_reconcile_valuation()
return posted
def _stock_account_get_last_step_stock_moves(self):
""" Overridden from stock_account.
Returns the stock moves associated to this invoice."""
rslt = super(AccountMove, self)._stock_account_get_last_step_stock_moves()
for invoice in self.filtered(lambda x: x.move_type == 'in_invoice'):
rslt += invoice.mapped('invoice_line_ids.purchase_line_id.move_ids').filtered(lambda x: x.state == 'done' and x.location_id.usage == 'supplier')
for invoice in self.filtered(lambda x: x.move_type == 'in_refund'):
rslt += invoice.mapped('invoice_line_ids.purchase_line_id.move_ids').filtered(lambda x: x.state == 'done' and x.location_dest_id.usage == 'supplier')
return rslt
@api.depends('purchase_id')
def _compute_incoterm_location(self):
super()._compute_incoterm_location()
for move in self:
purchase_locations = move.line_ids.purchase_line_id.order_id.mapped('incoterm_location')
incoterm_res = next((incoterm for incoterm in purchase_locations if incoterm), False)
# if multiple purchase order we take an incoterm that is not false
if incoterm_res:
move.incoterm_location = incoterm_res
|
