Cédric Krier
24b737b229
When the value has repeating decimal, the comparison may fail for one comparison but we must consider as valid value. issue8966 review265001002
413 lines
16 KiB
Python
413 lines
16 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 decimal import Decimal
|
|
from dateutil.relativedelta import relativedelta
|
|
|
|
from sql import Column, Null
|
|
|
|
from trytond.i18n import gettext
|
|
from trytond.model import (
|
|
ModelView, ModelSQL, DeactivableMixin, fields, sequence_ordered)
|
|
from trytond import backend
|
|
from trytond.pyson import Eval
|
|
from trytond.transaction import Transaction
|
|
from trytond.pool import Pool
|
|
from trytond.wizard import Wizard, StateView, Button
|
|
from trytond.config import config
|
|
|
|
from .exceptions import PaymentTermValidationError, PaymentTermComputeError
|
|
|
|
__all__ = ['PaymentTerm', 'PaymentTermLine', 'PaymentTermLineRelativeDelta',
|
|
'TestPaymentTerm', 'TestPaymentTermView', 'TestPaymentTermViewResult']
|
|
|
|
|
|
class PaymentTerm(DeactivableMixin, ModelSQL, ModelView):
|
|
'Payment Term'
|
|
__name__ = 'account.invoice.payment_term'
|
|
name = fields.Char('Name', size=None, required=True, translate=True)
|
|
description = fields.Text('Description', translate=True)
|
|
lines = fields.One2Many('account.invoice.payment_term.line', 'payment',
|
|
'Lines')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(PaymentTerm, cls).__setup__()
|
|
cls._order.insert(0, ('name', 'ASC'))
|
|
|
|
@classmethod
|
|
def validate(cls, terms):
|
|
super(PaymentTerm, cls).validate(terms)
|
|
for term in terms:
|
|
term.check_remainder()
|
|
|
|
def check_remainder(self):
|
|
if not self.lines or not self.lines[-1].type == 'remainder':
|
|
raise PaymentTermValidationError(
|
|
gettext('account_invoice'
|
|
'.msg_payment_term_missing_last_remainder',
|
|
payment_term=self.rec_name))
|
|
|
|
def compute(self, amount, currency, date=None):
|
|
"""Calculate payment terms and return a list of tuples
|
|
with (date, amount) for each payment term line.
|
|
|
|
amount must be a Decimal used for the calculation.
|
|
If specified, date will be used as the start date, otherwise current
|
|
date will be used.
|
|
"""
|
|
# TODO implement business_days
|
|
# http://pypi.python.org/pypi/BusinessHours/
|
|
Date = Pool().get('ir.date')
|
|
|
|
sign = 1 if amount >= Decimal('0.0') else -1
|
|
res = []
|
|
if date is None:
|
|
date = Date.today()
|
|
remainder = amount
|
|
for line in self.lines:
|
|
value = line.get_value(remainder, amount, currency)
|
|
value_date = line.get_date(date)
|
|
if value is None or not value_date:
|
|
continue
|
|
if ((remainder - value) * sign) < Decimal('0.0'):
|
|
res.append((value_date, remainder))
|
|
break
|
|
if value:
|
|
res.append((value_date, value))
|
|
remainder -= value
|
|
else:
|
|
# Enforce to have at least one term
|
|
if not res:
|
|
res.append((date, Decimal(0)))
|
|
|
|
if not currency.is_zero(remainder):
|
|
raise PaymentTermComputeError(
|
|
gettext('account_invoice.msg_payment_term_missing_remainder',
|
|
payment_term=self.rec_name))
|
|
return res
|
|
|
|
|
|
class PaymentTermLine(sequence_ordered(), ModelSQL, ModelView):
|
|
'Payment Term Line'
|
|
__name__ = 'account.invoice.payment_term.line'
|
|
payment = fields.Many2One('account.invoice.payment_term', 'Payment Term',
|
|
required=True, ondelete="CASCADE")
|
|
type = fields.Selection([
|
|
('fixed', 'Fixed'),
|
|
('percent', 'Percentage on Remainder'),
|
|
('percent_on_total', 'Percentage on Total'),
|
|
('remainder', 'Remainder'),
|
|
], 'Type', required=True)
|
|
ratio = fields.Numeric('Ratio', digits=(14, 10),
|
|
states={
|
|
'invisible': ~Eval('type').in_(['percent', 'percent_on_total']),
|
|
'required': Eval('type').in_(['percent', 'percent_on_total']),
|
|
}, depends=['type'])
|
|
divisor = fields.Numeric('Divisor', digits=(10, 14),
|
|
states={
|
|
'invisible': ~Eval('type').in_(['percent', 'percent_on_total']),
|
|
'required': Eval('type').in_(['percent', 'percent_on_total']),
|
|
}, depends=['type'])
|
|
amount = fields.Numeric('Amount', digits=(16, Eval('currency_digits', 2)),
|
|
states={
|
|
'invisible': Eval('type') != 'fixed',
|
|
'required': Eval('type') == 'fixed',
|
|
}, depends=['type', 'currency_digits'])
|
|
currency = fields.Many2One('currency.currency', 'Currency',
|
|
states={
|
|
'invisible': Eval('type') != 'fixed',
|
|
'required': Eval('type') == 'fixed',
|
|
}, depends=['type'])
|
|
currency_digits = fields.Function(fields.Integer('Currency Digits'),
|
|
'on_change_with_currency_digits')
|
|
relativedeltas = fields.One2Many(
|
|
'account.invoice.payment_term.line.delta', 'line', 'Deltas')
|
|
|
|
@classmethod
|
|
def __register__(cls, module_name):
|
|
sql_table = cls.__table__()
|
|
super(PaymentTermLine, cls).__register__(module_name)
|
|
cursor = Transaction().connection.cursor()
|
|
table = cls.__table_handler__(module_name)
|
|
|
|
# Migration from 3.8: rename percentage into ratio
|
|
if table.column_exist('percentage'):
|
|
cursor.execute(*sql_table.update(
|
|
columns=[sql_table.ratio],
|
|
values=[sql_table.percentage / 100]))
|
|
table.drop_column('percentage')
|
|
|
|
@staticmethod
|
|
def default_currency_digits():
|
|
return 2
|
|
|
|
@staticmethod
|
|
def default_type():
|
|
return 'remainder'
|
|
|
|
@classmethod
|
|
def default_relativedeltas(cls):
|
|
if Transaction().user == 0:
|
|
return []
|
|
return [{}]
|
|
|
|
@fields.depends('type')
|
|
def on_change_type(self):
|
|
if self.type != 'fixed':
|
|
self.amount = Decimal('0.0')
|
|
self.currency = None
|
|
if self.type not in ('percent', 'percent_on_total'):
|
|
self.ratio = Decimal('0.0')
|
|
self.divisor = Decimal('0.0')
|
|
|
|
@fields.depends('ratio')
|
|
def on_change_ratio(self):
|
|
if not self.ratio:
|
|
self.divisor = Decimal('0.0')
|
|
else:
|
|
self.divisor = self.round(1 / self.ratio,
|
|
self.__class__.divisor.digits[1])
|
|
|
|
@fields.depends('divisor')
|
|
def on_change_divisor(self):
|
|
if not self.divisor:
|
|
self.ratio = Decimal('0.0')
|
|
else:
|
|
self.ratio = self.round(1 / self.divisor,
|
|
self.__class__.ratio.digits[1])
|
|
|
|
@fields.depends('currency')
|
|
def on_change_with_currency_digits(self, name=None):
|
|
if self.currency:
|
|
return self.currency.digits
|
|
return 2
|
|
|
|
def get_date(self, date):
|
|
for relativedelta_ in self.relativedeltas:
|
|
date += relativedelta_.get()
|
|
return date
|
|
|
|
def get_value(self, remainder, amount, currency):
|
|
Currency = Pool().get('currency.currency')
|
|
if self.type == 'fixed':
|
|
fixed = Currency.compute(self.currency, self.amount, currency)
|
|
return fixed.copy_sign(amount)
|
|
elif self.type == 'percent':
|
|
return currency.round(remainder * self.ratio)
|
|
elif self.type == 'percent_on_total':
|
|
return currency.round(amount * self.ratio)
|
|
elif self.type == 'remainder':
|
|
return currency.round(remainder)
|
|
return None
|
|
|
|
@staticmethod
|
|
def round(number, digits):
|
|
quantize = Decimal(10) ** -Decimal(digits)
|
|
return Decimal(number).quantize(quantize)
|
|
|
|
@classmethod
|
|
def validate(cls, lines):
|
|
super(PaymentTermLine, cls).validate(lines)
|
|
cls.check_ratio_and_divisor(lines)
|
|
|
|
@classmethod
|
|
def check_ratio_and_divisor(cls, lines):
|
|
"Check consistency between ratio and divisor"
|
|
# Use a copy because on_change will change the records
|
|
for line in cls.browse(lines):
|
|
if line.type not in ('percent', 'percent_on_total'):
|
|
continue
|
|
if line.ratio is None or line.divisor is None:
|
|
raise PaymentTermValidationError(
|
|
gettext('account_invoice'
|
|
'.msg_payment_term_invalid_ratio_divisor',
|
|
line=line.rec_name))
|
|
if (line.ratio != round(
|
|
1 / line.divisor, cls.ratio.digits[1])
|
|
and line.divisor != round(
|
|
1 / line.ratio, cls.divisor.digits[1])):
|
|
raise PaymentTermValidationError(
|
|
gettext('account_invoice'
|
|
'.msg_payment_term_invalid_ratio_divisor',
|
|
line=line.rec_name))
|
|
|
|
|
|
class PaymentTermLineRelativeDelta(sequence_ordered(), ModelSQL, ModelView):
|
|
'Payment Term Line Relative Delta'
|
|
__name__ = 'account.invoice.payment_term.line.delta'
|
|
line = fields.Many2One('account.invoice.payment_term.line',
|
|
'Payment Term Line', required=True, ondelete='CASCADE')
|
|
day = fields.Integer('Day of Month',
|
|
domain=['OR',
|
|
('day', '=', None),
|
|
[('day', '>=', 1), ('day', '<=', 31)],
|
|
])
|
|
month = fields.Many2One('ir.calendar.month', "Month")
|
|
weekday = fields.Many2One('ir.calendar.day', "Day of Week")
|
|
months = fields.Integer('Number of Months', required=True)
|
|
weeks = fields.Integer('Number of Weeks', required=True)
|
|
days = fields.Integer('Number of Days', required=True)
|
|
|
|
@classmethod
|
|
def __register__(cls, module_name):
|
|
transaction = Transaction()
|
|
cursor = transaction.connection.cursor()
|
|
pool = Pool()
|
|
Line = pool.get('account.invoice.payment_term.line')
|
|
Month = pool.get('ir.calendar.month')
|
|
Day = pool.get('ir.calendar.day')
|
|
sql_table = cls.__table__()
|
|
line = Line.__table__()
|
|
month = Month.__table__()
|
|
day = Day.__table__()
|
|
|
|
# Migration from 4.0: rename long table
|
|
old_model_name = 'account.invoice.payment_term.line.relativedelta'
|
|
old_table = config.get(
|
|
'table', old_model_name, default=old_model_name.replace('.', '_'))
|
|
if backend.TableHandler.table_exist(old_table):
|
|
backend.TableHandler.table_rename(old_table, cls._table)
|
|
|
|
# Migration from 5.0: use ir.calendar
|
|
migrate_calendar = False
|
|
if backend.TableHandler.table_exist(cls._table):
|
|
cursor.execute(*sql_table.select(
|
|
sql_table.month, sql_table.weekday,
|
|
where=(sql_table.month != Null)
|
|
| (sql_table.weekday != Null),
|
|
limit=1))
|
|
try:
|
|
row, = cursor.fetchall()
|
|
migrate_calendar = any(isinstance(v, str) for v in row)
|
|
except ValueError:
|
|
# As we cannot know the column type
|
|
# we migrate any way as no data need to be migrated
|
|
migrate_calendar = True
|
|
if migrate_calendar:
|
|
table_h = cls.__table_handler__(module_name)
|
|
table_h.column_rename('month', '_temp_month')
|
|
table_h.column_rename('weekday', '_temp_weekday')
|
|
|
|
super(PaymentTermLineRelativeDelta, cls).__register__(module_name)
|
|
|
|
table_h = cls.__table_handler__(module_name)
|
|
line_table = Line.__table_handler__(module_name)
|
|
|
|
# Migration from 3.4
|
|
fields = ['day', 'month', 'weekday', 'months', 'weeks', 'days']
|
|
if any(line_table.column_exist(f) for f in fields):
|
|
columns = ([line.id.as_('line')]
|
|
+ [Column(line, f) for f in fields])
|
|
cursor.execute(*sql_table.insert(
|
|
columns=[sql_table.line]
|
|
+ [Column(sql_table, f) for f in fields],
|
|
values=line.select(*columns)))
|
|
for field in fields:
|
|
line_table.drop_column(field)
|
|
|
|
# Migration from 5.0: use ir.calendar
|
|
if migrate_calendar:
|
|
update = transaction.connection.cursor()
|
|
cursor.execute(*month.select(month.id, month.index))
|
|
for month_id, index in cursor:
|
|
update.execute(*sql_table.update(
|
|
[sql_table.month], [month_id],
|
|
where=sql_table._temp_month == str(index)))
|
|
table_h.drop_column('_temp_month')
|
|
cursor.execute(*day.select(day.id, day.index))
|
|
for day_id, index in cursor:
|
|
update.execute(*sql_table.update(
|
|
[sql_table.weekday], [day_id],
|
|
where=sql_table._temp_weekday == str(index)))
|
|
table_h.drop_column('_temp_weekday')
|
|
|
|
@staticmethod
|
|
def default_months():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def default_weeks():
|
|
return 0
|
|
|
|
@staticmethod
|
|
def default_days():
|
|
return 0
|
|
|
|
def get(self):
|
|
"Return the relativedelta"
|
|
return relativedelta(
|
|
day=self.day,
|
|
month=int(self.month.index) if self.month else None,
|
|
days=self.days,
|
|
weeks=self.weeks,
|
|
months=self.months,
|
|
weekday=int(self.weekday.index) if self.weekday else None,
|
|
)
|
|
|
|
|
|
class TestPaymentTerm(Wizard):
|
|
'Test Payment Term'
|
|
__name__ = 'account.invoice.payment_term.test'
|
|
start_state = 'test'
|
|
test = StateView('account.invoice.payment_term.test',
|
|
'account_invoice.payment_term_test_view_form',
|
|
[Button('Close', 'end', 'tryton-close', default=True)])
|
|
|
|
def default_test(self, fields):
|
|
context = Transaction().context
|
|
default = {}
|
|
if context['active_model'] == 'account.invoice.payment_term':
|
|
default['payment_term'] = context['active_id']
|
|
return default
|
|
|
|
|
|
class TestPaymentTermView(ModelView):
|
|
'Test Payment Term'
|
|
__name__ = 'account.invoice.payment_term.test'
|
|
payment_term = fields.Many2One('account.invoice.payment_term',
|
|
'Payment Term', required=True)
|
|
date = fields.Date('Date')
|
|
amount = fields.Numeric('Amount', required=True,
|
|
digits=(16, Eval('currency_digits', 2)), depends=['currency_digits'])
|
|
currency = fields.Many2One('currency.currency', 'Currency', required=True)
|
|
currency_digits = fields.Integer('Currency Digits')
|
|
result = fields.One2Many('account.invoice.payment_term.test.result',
|
|
None, 'Result', readonly=True)
|
|
|
|
@staticmethod
|
|
def default_currency():
|
|
pool = Pool()
|
|
Company = pool.get('company.company')
|
|
company = Transaction().context.get('company')
|
|
if company:
|
|
return Company(company).currency.id
|
|
|
|
@fields.depends('currency')
|
|
def on_change_with_currency_digits(self):
|
|
if self.currency:
|
|
return self.currency.digits
|
|
return 2
|
|
|
|
@fields.depends('payment_term', 'date', 'amount', 'currency', 'result')
|
|
def on_change_with_result(self):
|
|
pool = Pool()
|
|
Result = pool.get('account.invoice.payment_term.test.result')
|
|
result = []
|
|
if (self.payment_term and self.amount and self.currency):
|
|
for date, amount in self.payment_term.compute(
|
|
self.amount, self.currency, self.date):
|
|
result.append(Result(
|
|
date=date, amount=amount,
|
|
currency_digits=self.currency.digits))
|
|
self.result = result
|
|
return self._changed_values.get('result', [])
|
|
|
|
|
|
class TestPaymentTermViewResult(ModelView):
|
|
'Test Payment Term'
|
|
__name__ = 'account.invoice.payment_term.test.result'
|
|
date = fields.Date('Date', readonly=True)
|
|
amount = fields.Numeric('Amount', readonly=True,
|
|
digits=(16, Eval('currency_digits', 2)), depends=['currency_digits'])
|
|
currency_digits = fields.Integer('Currency Digits')
|