460 lines
15 KiB
Python
460 lines
15 KiB
Python
# This file is part of Tryton. The COPYRIGHT file at the top level of
|
|
# this repository contains the full copyright notices and license terms.
|
|
|
|
from trytond.i18n import gettext
|
|
from trytond.model import ModelSQL, ModelView, Workflow, fields
|
|
from trytond.pool import Pool, PoolMeta
|
|
from trytond.pyson import Eval, If, Bool
|
|
|
|
from trytond.modules.product import price_digits
|
|
|
|
from .exceptions import AmendmentValidateError
|
|
|
|
|
|
class Sale(metaclass=PoolMeta):
|
|
__name__ = 'sale.sale'
|
|
|
|
amendments = fields.One2Many(
|
|
'sale.amendment', 'sale', "Amendments",
|
|
states={
|
|
'invisible': ((Eval('state') != 'processing')
|
|
| ~Eval('amendments')),
|
|
'readonly': Eval('state') != 'processing',
|
|
},
|
|
depends=['state'])
|
|
|
|
@classmethod
|
|
def copy(cls, sales, default=None):
|
|
if default is None:
|
|
default = {}
|
|
else:
|
|
default = default.copy()
|
|
default.setdefault('amendments')
|
|
return super().copy(sales, default=default)
|
|
|
|
|
|
class Amendment(Workflow, ModelSQL, ModelView):
|
|
"Sale Amendment"
|
|
__name__ = 'sale.amendment'
|
|
|
|
sale = fields.Many2One(
|
|
'sale.sale', "Sale", required=True, select=True,
|
|
domain=[
|
|
('state', 'in', ['processing', 'done']),
|
|
],
|
|
states={
|
|
'readonly': (Eval('state') != 'draft') | Eval('lines', [0]),
|
|
},
|
|
depends=['state'])
|
|
date = fields.Date(
|
|
"Date", required=True,
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
},
|
|
depends=['state'])
|
|
description = fields.Char(
|
|
"Description",
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
},
|
|
depends=['state'])
|
|
state = fields.Selection([
|
|
('draft', "Draft"),
|
|
('validated', "Validated"),
|
|
], "State", readonly=True, required=True)
|
|
lines = fields.One2Many(
|
|
'sale.amendment.line', 'amendment', "Lines",
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
},
|
|
depends=['state'])
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(Amendment, cls).__setup__()
|
|
cls._order = [
|
|
('date', 'DESC'),
|
|
('id', 'DESC'),
|
|
]
|
|
cls._transitions |= {
|
|
('draft', 'validated'),
|
|
}
|
|
cls._buttons.update({
|
|
'validate_amendment': {
|
|
'invisible': Eval('state') != 'draft',
|
|
'depends': ['state'],
|
|
},
|
|
})
|
|
|
|
@classmethod
|
|
def default_date(cls):
|
|
return Pool().get('ir.date').today()
|
|
|
|
@classmethod
|
|
def default_state(cls):
|
|
return 'draft'
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
@Workflow.transition('validated')
|
|
def validate_amendment(cls, amendments):
|
|
pool = Pool()
|
|
Sale = pool.get('sale.sale')
|
|
sales = set()
|
|
for amendment in amendments:
|
|
sale = amendment.sale
|
|
if sale in sales:
|
|
raise AmendmentValidateError(
|
|
gettext('sale_amendment.msg_one_sale_at_time',
|
|
sale=sale.rec_name))
|
|
sales.add(sale)
|
|
sale.revision += 1
|
|
for line in amendment.lines:
|
|
line.apply(sale)
|
|
# Force saved lines
|
|
sale.lines = sale.lines
|
|
# Force recompute cache
|
|
sale.untaxed_amount_cache = None
|
|
sale.tax_amount_cache = None
|
|
sale.total_amount_cache = None
|
|
|
|
Sale.save(sales)
|
|
Sale.store_cache(sales)
|
|
cls._clear_sale(sales)
|
|
Sale.__queue__.process(sales)
|
|
|
|
@classmethod
|
|
def _clear_sale(cls, sales):
|
|
pool = Pool()
|
|
Invoice = pool.get('account.invoice')
|
|
InvoiceLine = pool.get('account.invoice.line')
|
|
Shipment = pool.get('stock.shipment.out')
|
|
ShipmentReturn = pool.get('stock.shipment.out.return')
|
|
Move = pool.get('stock.move')
|
|
|
|
invoices = set()
|
|
shipments = set()
|
|
shipment_returns = set()
|
|
invoice_lines = set()
|
|
moves = set()
|
|
for sale in sales:
|
|
for invoice in sale.invoices:
|
|
if invoice.state == 'draft':
|
|
invoices.add(invoice)
|
|
for shipment in sale.shipments:
|
|
if shipment.state in ['draft', 'waiting']:
|
|
shipments.add(shipment)
|
|
for shipment_return in sale.shipment_returns:
|
|
if shipment_return.state == 'draft':
|
|
shipment_returns.add(shipment_return)
|
|
|
|
for line in sale.lines:
|
|
for invoice_line in line.invoice_lines:
|
|
if invoice_line.invoice_state == 'draft':
|
|
invoice_lines.add(invoice_line)
|
|
moves.update(cls._stock_moves(line))
|
|
|
|
shipments_waiting = [s for s in shipments if s.state == 'waiting']
|
|
Shipment.draft(shipments) # Clear inventory moves
|
|
InvoiceLine.delete(invoice_lines)
|
|
Move.delete(moves)
|
|
|
|
Invoice.update_taxes([i for i in invoices if i.lines])
|
|
Invoice.delete([i for i in invoices if not i.lines])
|
|
Shipment.wait([s for s in shipments_waiting if s.outgoing_moves])
|
|
Shipment.delete([s for s in shipments if not s.outgoing_moves])
|
|
ShipmentReturn.delete(
|
|
[s for s in shipment_returns if not s.incoming_moves])
|
|
|
|
@classmethod
|
|
def _stock_moves(cls, line):
|
|
for move in line.moves:
|
|
if move.state == 'draft':
|
|
yield move
|
|
|
|
|
|
class AmendmentLine(ModelSQL, ModelView):
|
|
"Sale Amendment Line"
|
|
__name__ = 'sale.amendment.line'
|
|
|
|
amendment = fields.Many2One(
|
|
'sale.amendment', "Amendment", required=True, ondelete='CASCADE')
|
|
state = fields.Function(fields.Selection(
|
|
'get_states', "State"), 'on_change_with_state')
|
|
action = fields.Selection([
|
|
('taxes', "Recompute Taxes"),
|
|
('payment_term', "Change Payment Term"),
|
|
('party', "Change Parties and Addresses"),
|
|
('warehouse', "Change Warehouse"),
|
|
('line', "Change Line"),
|
|
], "Action", required=True,
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
},
|
|
depends=['state'])
|
|
|
|
sale = fields.Function(fields.Many2One(
|
|
'sale.sale', "Sale"), 'on_change_with_sale')
|
|
line = fields.Many2One(
|
|
'sale.line', "Line",
|
|
domain=[
|
|
('type', '=', 'line'),
|
|
('sale', '=', Eval('sale', -1)),
|
|
],
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'line',
|
|
'required': Eval('action') == 'line',
|
|
},
|
|
depends=['state', 'sale', 'action'])
|
|
|
|
payment_term = fields.Many2One(
|
|
'account.invoice.payment_term', "Payment Term",
|
|
states={
|
|
'invisible': Eval('action') != 'payment_term',
|
|
},
|
|
depends=['action'])
|
|
|
|
party = fields.Many2One(
|
|
'party.party', "Party",
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'party',
|
|
'required': Eval('action') == 'party',
|
|
},
|
|
depends=['state', 'action'])
|
|
invoice_address = fields.Many2One(
|
|
'party.address', "Invoice Address",
|
|
domain=[
|
|
('party', '=', Eval('party')),
|
|
],
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'party',
|
|
'required': Eval('action') == 'party',
|
|
},
|
|
depends=['state', 'action', 'party'])
|
|
shipment_party = fields.Many2One(
|
|
'party.party', "Shipment Party",
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'party',
|
|
},
|
|
depends=['state', 'action'])
|
|
shipment_address = fields.Many2One(
|
|
'party.address', "Shipment Address",
|
|
domain=[
|
|
('party', '=', If(Eval('shipment_party'),
|
|
Eval('shipment_party'), Eval('party'))),
|
|
],
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'party',
|
|
'required': Eval('action') == 'party',
|
|
},
|
|
depends=['state', 'action', 'party', 'shipment_party'])
|
|
|
|
warehouse = fields.Many2One(
|
|
'stock.location', "Warehouse",
|
|
domain=[
|
|
('type', '=', 'warehouse'),
|
|
],
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'warehouse',
|
|
'required': Eval('action') == 'warehouse',
|
|
},
|
|
depends=['state', 'action'])
|
|
|
|
product = fields.Many2One(
|
|
'product.product', "Product",
|
|
domain=[
|
|
If(Eval('state') == 'draft',
|
|
('salable', '=', True),
|
|
()),
|
|
If(Eval('product_uom_category'),
|
|
('default_uom_category', '=', Eval('product_uom_category')),
|
|
()),
|
|
],
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'line',
|
|
},
|
|
depends=['action', 'state', 'product_uom_category'])
|
|
quantity = fields.Float(
|
|
"Quantity",
|
|
digits=(16, Eval('unit_digits', 2)),
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'line',
|
|
'required': Eval('action') == 'line',
|
|
},
|
|
depends=['unit_digits', 'action'])
|
|
unit = fields.Many2One(
|
|
'product.uom', "Unit", ondelete='RESTRICT',
|
|
domain=[
|
|
If(Eval('product_uom_category'),
|
|
('category', '=', Eval('product_uom_category')),
|
|
()),
|
|
],
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'line',
|
|
'required': Bool(Eval('product')),
|
|
},
|
|
depends=['state', 'product_uom_category', 'action', 'product'])
|
|
unit_price = fields.Numeric(
|
|
"Unit Price", digits=price_digits,
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'line',
|
|
'required': Eval('action') == 'line',
|
|
},
|
|
depends=['state', 'action'])
|
|
description = fields.Text(
|
|
"Description",
|
|
states={
|
|
'readonly': Eval('state') != 'draft',
|
|
'invisible': Eval('action') != 'line',
|
|
},
|
|
depends=['state', 'action'])
|
|
|
|
unit_digits = fields.Function(
|
|
fields.Integer("Unit Digits"),
|
|
'on_change_with_unit_digits')
|
|
product_uom_category = fields.Function(
|
|
fields.Many2One('product.uom.category', "Product UoM Category"),
|
|
'on_change_with_product_uom_category')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super().__setup__()
|
|
cls.__access__.add('amendment')
|
|
|
|
@fields.depends(
|
|
'amendment',
|
|
'_parent_amendment.sale',
|
|
'_parent_amendment._parent_sale.payment_term',
|
|
'_parent_amendment._parent_sale.party',
|
|
'_parent_amendment._parent_sale.invoice_address',
|
|
'_parent_amendment._parent_sale.shipment_party',
|
|
'_parent_amendment._parent_sale.shipment_address',
|
|
'_parent_amendment._parent_sale.warehouse')
|
|
def on_change_amendment(self):
|
|
if self.amendment and self.amendment.sale:
|
|
self.payment_term = self.amendment.sale.payment_term
|
|
|
|
self.party = self.amendment.sale.party
|
|
self.invoice_address = self.amendment.sale.invoice_address
|
|
self.shipment_party = self.amendment.sale.shipment_party
|
|
self.shipment_address = self.amendment.sale.shipment_address
|
|
|
|
self.warehouse = self.amendment.sale.warehouse
|
|
|
|
@fields.depends(methods=['on_change_amendment'])
|
|
def on_change_state(self):
|
|
self.on_change_amendment()
|
|
|
|
@classmethod
|
|
def get_states(cls):
|
|
pool = Pool()
|
|
Amendment = pool.get('sale.amendment')
|
|
return Amendment.fields_get(['state'])['state']['selection']
|
|
|
|
@fields.depends(
|
|
'amendment',
|
|
'_parent_amendment.state')
|
|
def on_change_with_state(self, name=None):
|
|
if self.amendment:
|
|
return self.amendment.state
|
|
|
|
@fields.depends(methods=['on_change_line', 'on_change_amendment'])
|
|
def on_change_action(self):
|
|
self.line = None
|
|
self.on_change_line()
|
|
self.on_change_amendment()
|
|
|
|
@fields.depends(
|
|
'amendment',
|
|
'_parent_amendment.sale')
|
|
def on_change_with_sale(self, name=None):
|
|
if self.amendment and self.amendment.sale:
|
|
return self.amendment.sale.id
|
|
|
|
@fields.depends('line')
|
|
def on_change_line(self):
|
|
if self.line:
|
|
self.product = self.line.product
|
|
self.quantity = self.line.quantity
|
|
self.unit = self.line.unit
|
|
self.unit_price = self.line.unit_price
|
|
self.description = self.line.description
|
|
else:
|
|
self.product = self.quantity = self.unit = self.unit_price = None
|
|
self.description = None
|
|
|
|
@fields.depends('party', 'shipment_party')
|
|
def on_change_party(self):
|
|
self.invoice_address = None
|
|
if not self.shipment_party:
|
|
self.shipment_address = None
|
|
if self.party:
|
|
self.invoice_address = self.party.address_get(type='invoice')
|
|
if not self.shipment_party:
|
|
self.shipment_address = self.party.address_get(type='delivery')
|
|
|
|
@fields.depends('party', 'shipment_party')
|
|
def on_change_shipment_party(self):
|
|
if self.shipment_party:
|
|
self.shipment_address = self.shipment_party.address_get(
|
|
type='delivery')
|
|
elif self.party:
|
|
self.shipment_address = self.party.address_get(type='delivery')
|
|
|
|
@fields.depends('unit')
|
|
def on_change_with_unit_digits(self, name=None):
|
|
if self.unit:
|
|
return self.unit.digits
|
|
|
|
@fields.depends('line')
|
|
def on_change_with_product_uom_category(self, name=None):
|
|
if self.line:
|
|
if self.line.product_uom_category:
|
|
return self.line.product_uom_category.id
|
|
elif self.line.unit:
|
|
return self.line.unit.category.id
|
|
|
|
def apply(self, sale):
|
|
assert self.sale == sale
|
|
sale_line = None
|
|
if self.line:
|
|
for line in sale.lines:
|
|
if self.line == line:
|
|
sale_line = line
|
|
break
|
|
getattr(self, '_apply_%s' % self.action)(sale, sale_line)
|
|
|
|
def _apply_taxes(self, sale, sale_line):
|
|
for line in sale.lines:
|
|
if line.product:
|
|
line.taxes = line.compute_taxes(sale.party)
|
|
|
|
def _apply_payment_term(self, sale, sale_line):
|
|
sale.payment_term = self.payment_term
|
|
|
|
def _apply_party(self, sale, sale_line):
|
|
sale.party = self.party
|
|
sale.invoice_address = self.invoice_address
|
|
sale.shipment_party = self.shipment_party
|
|
sale.shipment_address = self.shipment_address
|
|
|
|
def _apply_warehouse(self, sale, sale_line):
|
|
sale.warehouse = self.warehouse
|
|
|
|
def _apply_line(self, sale, sale_line):
|
|
sale_line.product = self.product
|
|
sale_line.quantity = self.quantity
|
|
sale_line.unit = self.unit
|
|
sale_line.unit_price = self.unit_price
|
|
sale_line.description = self.description
|