Files
tryton/trytond/ir/sequence.py
T

376 lines
13 KiB
Python
Raw Normal View History

2014-12-02 12:54:01 +01:00
# This file is part of Tryton. The COPYRIGHT file at the top level of
# this repository contains the full copyright notices and license terms.
2008-05-19 10:43:59 +02:00
from string import Template
2010-09-02 17:31:51 +02:00
import time
2018-06-26 19:11:19 +02:00
from sql import Literal, For
2013-09-06 22:32:37 +02:00
2020-07-21 14:38:36 +02:00
from trytond import backend
2018-12-29 14:19:08 +01:00
from trytond.exceptions import UserError
2020-07-21 14:38:36 +02:00
from trytond.i18n import gettext
from trytond.model import ModelView, ModelSQL, DeactivableMixin, fields, Check
2018-12-29 14:19:08 +01:00
from trytond.model.exceptions import ValidationError
2020-07-21 14:38:36 +02:00
from trytond.pool import Pool
from trytond.pyson import Eval, And
from trytond.transaction import Transaction
2012-09-24 22:16:53 +02:00
2019-12-06 17:33:47 +01:00
sql_sequence = backend.Database.has_sequence()
2007-12-10 01:04:13 +01:00
2018-12-29 14:19:08 +01:00
class AffixError(ValidationError):
pass
class MissingError(UserError):
pass
class LastTimestampError(ValidationError):
pass
class SequenceType(ModelSQL, ModelView):
2007-12-10 01:04:13 +01:00
"Sequence type"
2012-09-24 22:16:53 +02:00
__name__ = 'ir.sequence.type'
name = fields.Char('Sequence Name', required=True, translate=True)
code = fields.Char('Sequence Code', required=True)
2007-12-10 01:04:13 +01:00
class Sequence(DeactivableMixin, ModelSQL, ModelView):
2007-12-10 01:04:13 +01:00
"Sequence"
2012-09-24 22:16:53 +02:00
__name__ = 'ir.sequence'
_strict = False
name = fields.Char('Sequence Name', required=True, translate=True)
2010-09-02 17:31:51 +02:00
code = fields.Selection('code_get', 'Sequence Code', required=True,
2011-08-21 11:19:06 +02:00
states={
'readonly': Eval('context', {}).contains('code'),
})
prefix = fields.Char('Prefix')
suffix = fields.Char('Suffix')
2010-09-02 17:31:51 +02:00
type = fields.Selection([
('incremental', 'Incremental'),
('decimal timestamp', 'Decimal Timestamp'),
('hexadecimal timestamp', 'Hexadecimal Timestamp'),
], 'Type')
number_next_internal = fields.Integer('Next Number',
2011-08-21 11:19:06 +02:00
states={
'invisible': ~Eval('type').in_(['incremental']),
'required': And(Eval('type').in_(['incremental']),
not sql_sequence),
2010-09-02 17:31:51 +02:00
}, depends=['type'])
number_next = fields.Function(number_next_internal, 'get_number_next',
'set_number_next')
2010-09-02 17:31:51 +02:00
number_increment = fields.Integer('Increment Number',
2011-08-21 11:19:06 +02:00
states={
'invisible': ~Eval('type').in_(['incremental']),
'required': Eval('type').in_(['incremental']),
2010-09-02 17:31:51 +02:00
}, depends=['type'])
padding = fields.Integer('Number padding',
2011-08-21 11:19:06 +02:00
states={
'invisible': ~Eval('type').in_(['incremental']),
'required': Eval('type').in_(['incremental']),
2010-09-02 17:31:51 +02:00
}, depends=['type'])
timestamp_rounding = fields.Float('Timestamp Rounding', required=True,
2011-08-21 11:19:06 +02:00
states={
'invisible': ~Eval('type').in_(
['decimal timestamp', 'hexadecimal timestamp']),
2010-09-02 17:31:51 +02:00
}, depends=['type'])
timestamp_offset = fields.Float('Timestamp Offset', required=True,
2011-08-21 11:19:06 +02:00
states={
'invisible': ~Eval('type').in_(
['decimal timestamp', 'hexadecimal timestamp']),
2010-09-02 17:31:51 +02:00
}, depends=['type'])
last_timestamp = fields.Integer('Last Timestamp',
2011-08-21 11:19:06 +02:00
states={
'invisible': ~Eval('type').in_(
['decimal timestamp', 'hexadecimal timestamp']),
'required': Eval('type').in_(
['decimal timestamp', 'hexadecimal timestamp']),
2010-09-02 17:31:51 +02:00
}, depends=['type'])
2012-09-24 22:16:53 +02:00
@classmethod
def __setup__(cls):
super(Sequence, cls).__setup__()
table = cls.__table__()
2012-09-24 22:16:53 +02:00
cls._sql_constraints += [
('check_timestamp_rounding',
Check(table, table.timestamp_rounding > 0),
'Timestamp rounding should be greater than 0'),
]
2008-05-19 10:43:59 +02:00
2012-09-24 22:16:53 +02:00
@staticmethod
def default_type():
2010-09-02 17:31:51 +02:00
return 'incremental'
2012-09-24 22:16:53 +02:00
@staticmethod
def default_number_increment():
return 1
2012-09-24 22:16:53 +02:00
@staticmethod
def default_number_next():
return 1
2012-09-24 22:16:53 +02:00
@staticmethod
def default_padding():
return 0
2007-12-10 01:04:13 +01:00
2012-09-24 22:16:53 +02:00
@staticmethod
def default_timestamp_rounding():
2010-09-02 17:31:51 +02:00
return 1.0
2012-09-24 22:16:53 +02:00
@staticmethod
def default_timestamp_offset():
2012-04-01 23:08:15 +02:00
return 946681200.0 # Offset for 2000-01-01
2010-09-02 17:31:51 +02:00
2012-09-24 22:16:53 +02:00
@staticmethod
def default_last_timestamp():
return 0
2010-09-02 17:31:51 +02:00
2012-09-24 22:16:53 +02:00
@staticmethod
def default_code():
2012-03-27 10:41:40 +02:00
return Transaction().context.get('code')
2012-09-24 22:16:53 +02:00
def get_number_next(self, name):
if self.type != 'incremental':
return
transaction = Transaction()
2012-09-24 22:16:53 +02:00
if sql_sequence and not self._strict:
return transaction.database.sequence_next_number(
transaction.connection, self._sql_sequence_name)
2012-09-24 22:16:53 +02:00
else:
return self.number_next_internal
2012-09-24 22:16:53 +02:00
@classmethod
def set_number_next(cls, sequences, name, value):
super(Sequence, cls).write(sequences, {
'number_next_internal': value,
})
2015-03-09 19:40:41 +01:00
@classmethod
def view_attributes(cls):
return [
('//group[@id="incremental"]', 'states', {
'invisible': ~Eval('type').in_(['incremental']),
}),
('//group[@id="timestamp"]', 'states', {
'invisible': ~Eval('type').in_(
['decimal timestamp', 'hexadecimal timestamp']),
}),
]
2012-09-24 22:16:53 +02:00
@classmethod
2013-01-06 22:18:13 +01:00
def create(cls, vlist):
sequences = super(Sequence, cls).create(vlist)
2018-06-26 19:11:19 +02:00
for sequence, values in zip(sequences, vlist):
2013-01-06 22:18:13 +01:00
if sql_sequence and not cls._strict:
sequence.update_sql_sequence(values.get('number_next',
cls.default_number_next()))
return sequences
2012-09-24 22:16:53 +02:00
@classmethod
2013-12-19 14:44:01 +01:00
def write(cls, sequences, values, *args):
super(Sequence, cls).write(sequences, values, *args)
2012-09-24 22:16:53 +02:00
if sql_sequence and not cls._strict:
2013-12-19 14:44:01 +01:00
actions = iter((sequences, values) + args)
for sequences, values in zip(actions, actions):
for sequence in sequences:
sequence.update_sql_sequence(values.get('number_next'))
2012-09-24 22:16:53 +02:00
@classmethod
def delete(cls, sequences):
if sql_sequence and not cls._strict:
for sequence in sequences:
2012-09-24 22:16:53 +02:00
sequence.delete_sql_sequence()
return super(Sequence, cls).delete(sequences)
2012-09-24 22:16:53 +02:00
@classmethod
def code_get(cls):
2011-07-03 13:20:58 +02:00
pool = Pool()
2012-09-24 22:16:53 +02:00
SequenceType = pool.get('ir.sequence.type')
sequence_types = SequenceType.search([])
return [(x.code, x.name) for x in sequence_types]
@classmethod
def validate(cls, sequences):
super(Sequence, cls).validate(sequences)
2018-12-29 14:19:08 +01:00
cls.check_affixes(sequences)
cls.check_last_timestamp(sequences)
2012-09-24 22:16:53 +02:00
@classmethod
2018-12-29 14:19:08 +01:00
def check_affixes(cls, sequences):
2008-05-19 10:43:59 +02:00
"Check prefix and suffix"
2012-09-24 22:16:53 +02:00
for sequence in sequences:
2018-12-29 14:19:08 +01:00
for affix, error_message in [
(sequence.prefix, 'msg_sequence_invalid_prefix'),
(sequence.suffix, 'msg_sequence_invalid_suffix')]:
try:
2018-12-29 14:19:08 +01:00
cls._process(affix)
except (TypeError, ValueError) as exc:
raise AffixError(gettext('ir.%s' % error_message,
affix=affix,
sequence=sequence.rec_name)) from exc
2008-05-19 10:43:59 +02:00
2012-09-24 22:16:53 +02:00
@classmethod
def check_last_timestamp(cls, sequences):
2010-09-02 17:31:51 +02:00
"Check last_timestamp"
2012-09-24 22:16:53 +02:00
for sequence in sequences:
next_timestamp = cls._timestamp(sequence)
if (sequence.last_timestamp is not None
and sequence.last_timestamp > next_timestamp):
2018-12-29 14:19:08 +01:00
raise LastTimestampError(
gettext('ir.msg_sequence_last_timestamp_future'))
2010-09-02 17:31:51 +02:00
2012-09-24 22:16:53 +02:00
@property
def _sql_sequence_name(self):
'Return SQL sequence name'
2012-09-24 22:16:53 +02:00
return '%s_%s' % (self._table, self.id)
2012-09-24 22:16:53 +02:00
def create_sql_sequence(self, number_next=None):
'Create the SQL sequence'
transaction = Transaction()
2012-09-24 22:16:53 +02:00
if self.type != 'incremental':
return
if number_next is None:
2012-09-24 22:16:53 +02:00
number_next = self.number_next
if sql_sequence:
transaction.database.sequence_create(transaction.connection,
self._sql_sequence_name, self.number_increment, number_next)
2012-09-24 22:16:53 +02:00
def update_sql_sequence(self, number_next=None):
'Update the SQL sequence'
transaction = Transaction()
exist = transaction.database.sequence_exist(
transaction.connection, self._sql_sequence_name)
2012-09-24 22:16:53 +02:00
if self.type != 'incremental':
if exist:
2012-09-24 22:16:53 +02:00
self.delete_sql_sequence()
return
if not exist:
2012-09-24 22:16:53 +02:00
self.create_sql_sequence(number_next)
return
if number_next is None:
2012-09-24 22:16:53 +02:00
number_next = self.number_next
transaction.database.sequence_update(transaction.connection,
self._sql_sequence_name, self.number_increment, number_next)
2012-09-24 22:16:53 +02:00
def delete_sql_sequence(self):
'Delete the SQL sequence'
transaction = Transaction()
2012-09-24 22:16:53 +02:00
if self.type != 'incremental':
return
transaction.database.sequence_delete(
transaction.connection, self._sql_sequence_name)
@classmethod
def _process(cls, string, date=None):
return Template(string or '').substitute(
**cls._get_substitutions(date))
@classmethod
def _get_substitutions(cls, date):
'''
Returns a dictionary with the keys and values of the substitutions
available to format the sequence
'''
2011-07-03 13:20:58 +02:00
pool = Pool()
2012-09-24 22:16:53 +02:00
Date = pool.get('ir.date')
if not date:
2012-09-24 22:16:53 +02:00
date = Date.today()
return {
2018-10-31 18:15:57 +01:00
'year': date.strftime('%Y'),
'month': date.strftime('%m'),
'day': date.strftime('%d'),
}
2007-12-10 01:04:13 +01:00
2012-09-24 22:16:53 +02:00
@staticmethod
def _timestamp(sequence):
2010-09-02 17:31:51 +02:00
return int((time.time() - sequence.timestamp_offset)
/ sequence.timestamp_rounding)
2012-09-24 22:16:53 +02:00
@classmethod
def _get_sequence(cls, sequence):
2010-09-02 17:31:51 +02:00
if sequence.type == 'incremental':
2012-09-24 22:16:53 +02:00
if sql_sequence and not cls._strict:
cursor = Transaction().connection.cursor()
cursor.execute('SELECT nextval(\'"%s"\')'
2012-09-24 22:16:53 +02:00
% sequence._sql_sequence_name)
number_next, = cursor.fetchone()
else:
2014-12-02 12:54:01 +01:00
# Pre-fetch number_next
number_next = sequence.number_next_internal
2010-09-02 17:31:51 +02:00
2014-09-17 21:43:53 +02:00
cls.write([sequence], {
'number_next_internal': (number_next
+ sequence.number_increment),
})
2010-09-02 17:31:51 +02:00
return '%%0%sd' % sequence.padding % number_next
elif sequence.type in ('decimal timestamp', 'hexadecimal timestamp'):
timestamp = sequence.last_timestamp
while timestamp == sequence.last_timestamp:
2012-09-24 22:16:53 +02:00
timestamp = cls._timestamp(sequence)
2014-09-17 21:43:53 +02:00
cls.write([sequence], {
'last_timestamp': timestamp,
})
2010-09-02 17:31:51 +02:00
if sequence.type == 'decimal timestamp':
return '%d' % timestamp
else:
return hex(timestamp)[2:].upper()
return ''
2012-09-24 22:16:53 +02:00
@classmethod
2017-01-25 23:21:57 +01:00
def get_id(cls, domain, _lock=False):
'''
Return sequence value for the domain
'''
2012-09-24 22:16:53 +02:00
if isinstance(domain, cls):
domain = domain.id
2018-06-26 19:11:19 +02:00
if isinstance(domain, int):
domain = [('id', '=', domain)]
2010-01-19 12:23:19 +01:00
# bypass rules on sequences
2014-09-17 21:43:53 +02:00
with Transaction().set_context(user=False, _check_access=False):
2010-08-19 22:01:12 +02:00
with Transaction().set_user(0):
2012-09-24 22:16:53 +02:00
try:
sequence, = cls.search(domain, limit=1)
except TypeError:
2018-12-29 14:19:08 +01:00
raise MissingError(gettext('ir.msg_sequence_missing'))
2017-01-25 23:21:57 +01:00
if _lock:
transaction = Transaction()
database = transaction.database
connection = transaction.connection
if not database.has_select_for():
database.lock(connection, cls._table)
else:
table = cls.__table__()
query = table.select(Literal(1),
where=table.id == sequence.id,
for_=For('UPDATE', nowait=True))
cursor = connection.cursor()
cursor.execute(*query)
2014-09-17 21:43:53 +02:00
date = Transaction().context.get('date')
return '%s%s%s' % (
cls._process(sequence.prefix, date=date),
cls._get_sequence(sequence),
cls._process(sequence.suffix, date=date),
)
2007-12-10 01:04:13 +01:00
2012-09-24 22:16:53 +02:00
@classmethod
def get(cls, code):
return cls.get_id([('code', '=', code)])
class SequenceStrict(Sequence):
"Sequence Strict"
2012-09-24 22:16:53 +02:00
__name__ = 'ir.sequence.strict'
2016-08-27 01:39:30 +02:00
_table = None # Needed to reset Sequence._table
_strict = True
2012-09-24 22:16:53 +02:00
@classmethod
def get_id(cls, clause):
2017-01-25 23:21:57 +01:00
return super(SequenceStrict, cls).get_id(clause, _lock=True)