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
|
|
|
|
2017-10-02 17:48:23 +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
|
|
|
|
|
|
|
|
|
|
|
2009-02-28 16:56:54 +01:00
|
|
|
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'
|
|
|
|
|
|
2008-11-11 23:20:02 +01:00
|
|
|
name = fields.Char('Sequence Name', required=True, translate=True)
|
2008-06-04 01:25:22 +02:00
|
|
|
code = fields.Char('Sequence Code', required=True)
|
2007-12-10 01:04:13 +01:00
|
|
|
|
|
|
|
|
|
2018-03-26 14:07:45 +02: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'
|
|
|
|
|
|
2011-08-09 12:35:32 +02:00
|
|
|
_strict = False
|
2008-11-11 23:20:02 +01:00
|
|
|
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'),
|
2008-11-25 12:36:51 +01:00
|
|
|
})
|
2008-06-04 01:25:22 +02:00
|
|
|
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')
|
2011-08-09 12:35:32 +02:00
|
|
|
number_next_internal = fields.Integer('Next Number',
|
2011-08-21 11:19:06 +02:00
|
|
|
states={
|
|
|
|
|
'invisible': ~Eval('type').in_(['incremental']),
|
2012-03-23 17:52:36 +01:00
|
|
|
'required': And(Eval('type').in_(['incremental']),
|
|
|
|
|
not sql_sequence),
|
2010-09-02 17:31:51 +02:00
|
|
|
}, depends=['type'])
|
2011-08-09 12:35:32 +02:00
|
|
|
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']),
|
2012-03-23 17:52:36 +01:00
|
|
|
'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']),
|
2012-03-23 17:52:36 +01:00
|
|
|
'required': Eval('type').in_(['incremental']),
|
2010-09-02 17:31:51 +02:00
|
|
|
}, depends=['type'])
|
2011-06-08 13:06:22 -04:00
|
|
|
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'])
|
2012-03-23 17:52:36 +01:00
|
|
|
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']),
|
2012-03-23 17:52:36 +01:00
|
|
|
'required': Eval('type').in_(
|
|
|
|
|
['decimal timestamp', 'hexadecimal timestamp']),
|
2010-09-02 17:31:51 +02:00
|
|
|
}, depends=['type'])
|
2008-02-26 16:23:05 +01:00
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
@classmethod
|
|
|
|
|
def __setup__(cls):
|
|
|
|
|
super(Sequence, cls).__setup__()
|
2015-06-22 16:57:06 +02:00
|
|
|
table = cls.__table__()
|
2012-09-24 22:16:53 +02:00
|
|
|
cls._sql_constraints += [
|
2015-06-22 16:57:06 +02:00
|
|
|
('check_timestamp_rounding',
|
|
|
|
|
Check(table, table.timestamp_rounding > 0),
|
2012-03-23 17:52:36 +01:00
|
|
|
'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():
|
2008-02-26 16:23:05 +01:00
|
|
|
return 1
|
|
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
@staticmethod
|
|
|
|
|
def default_number_next():
|
2008-02-26 16:23:05 +01:00
|
|
|
return 1
|
|
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
@staticmethod
|
|
|
|
|
def default_padding():
|
2008-02-26 16:23:05 +01:00
|
|
|
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():
|
2016-07-26 23:07:18 +02:00
|
|
|
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')
|
2008-11-25 12:36:51 +01:00
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
def get_number_next(self, name):
|
2016-03-16 22:03:41 +01:00
|
|
|
if self.type != 'incremental':
|
|
|
|
|
return
|
2017-10-02 17:48:23 +02:00
|
|
|
|
|
|
|
|
transaction = Transaction()
|
2012-09-24 22:16:53 +02:00
|
|
|
if sql_sequence and not self._strict:
|
2017-10-02 17:48:23 +02:00
|
|
|
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
|
2011-08-09 12:35:32 +02:00
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
@classmethod
|
|
|
|
|
def set_number_next(cls, sequences, name, value):
|
|
|
|
|
super(Sequence, cls).write(sequences, {
|
2011-08-09 12:35:32 +02:00
|
|
|
'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
|
2011-08-09 12:35:32 +02:00
|
|
|
|
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'))
|
2011-08-09 12:35:32 +02:00
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
@classmethod
|
|
|
|
|
def delete(cls, sequences):
|
|
|
|
|
if sql_sequence and not cls._strict:
|
2011-08-09 12:35:32 +02:00
|
|
|
for sequence in sequences:
|
2012-09-24 22:16:53 +02:00
|
|
|
sequence.delete_sql_sequence()
|
|
|
|
|
return super(Sequence, cls).delete(sequences)
|
2011-08-09 12:35:32 +02:00
|
|
|
|
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([])
|
2008-11-11 23:20:02 +01:00
|
|
|
return [(x.code, x.name) for x in sequence_types]
|
2008-02-12 15:17:35 +01:00
|
|
|
|
2013-03-07 16:53:19 +01:00
|
|
|
@classmethod
|
|
|
|
|
def validate(cls, sequences):
|
|
|
|
|
super(Sequence, cls).validate(sequences)
|
2018-12-29 14:19:08 +01:00
|
|
|
cls.check_affixes(sequences)
|
2013-03-07 16:53:19 +01:00
|
|
|
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')]:
|
2013-03-07 16:53:19 +01:00
|
|
|
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)
|
2016-07-26 23:07:18 +02:00
|
|
|
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):
|
2011-08-09 12:35:32 +02:00
|
|
|
'Return SQL sequence name'
|
2012-09-24 22:16:53 +02:00
|
|
|
return '%s_%s' % (self._table, self.id)
|
2011-08-09 12:35:32 +02:00
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
def create_sql_sequence(self, number_next=None):
|
2011-08-09 12:35:32 +02:00
|
|
|
'Create the SQL sequence'
|
2017-10-02 17:48:23 +02:00
|
|
|
transaction = Transaction()
|
|
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
if self.type != 'incremental':
|
2011-08-09 12:35:32 +02:00
|
|
|
return
|
|
|
|
|
if number_next is None:
|
2012-09-24 22:16:53 +02:00
|
|
|
number_next = self.number_next
|
2017-10-02 17:48:23 +02:00
|
|
|
if sql_sequence:
|
|
|
|
|
transaction.database.sequence_create(transaction.connection,
|
|
|
|
|
self._sql_sequence_name, self.number_increment, number_next)
|
2011-08-09 12:35:32 +02:00
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
def update_sql_sequence(self, number_next=None):
|
2011-08-09 12:35:32 +02:00
|
|
|
'Update the SQL sequence'
|
2017-10-02 17:48:23 +02:00
|
|
|
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':
|
2011-08-09 12:35:32 +02:00
|
|
|
if exist:
|
2012-09-24 22:16:53 +02:00
|
|
|
self.delete_sql_sequence()
|
2011-08-09 12:35:32 +02:00
|
|
|
return
|
|
|
|
|
if not exist:
|
2012-09-24 22:16:53 +02:00
|
|
|
self.create_sql_sequence(number_next)
|
2011-08-09 12:35:32 +02:00
|
|
|
return
|
|
|
|
|
if number_next is None:
|
2012-09-24 22:16:53 +02:00
|
|
|
number_next = self.number_next
|
2017-10-02 17:48:23 +02:00
|
|
|
transaction.database.sequence_update(transaction.connection,
|
|
|
|
|
self._sql_sequence_name, self.number_increment, number_next)
|
2011-08-09 12:35:32 +02:00
|
|
|
|
2012-09-24 22:16:53 +02:00
|
|
|
def delete_sql_sequence(self):
|
2011-08-09 12:35:32 +02:00
|
|
|
'Delete the SQL sequence'
|
2017-10-02 17:48:23 +02:00
|
|
|
transaction = Transaction()
|
2012-09-24 22:16:53 +02:00
|
|
|
if self.type != 'incremental':
|
2011-08-09 12:35:32 +02:00
|
|
|
return
|
2017-10-02 17:48:23 +02:00
|
|
|
transaction.database.sequence_delete(
|
|
|
|
|
transaction.connection, self._sql_sequence_name)
|
2011-08-09 12:35:32 +02:00
|
|
|
|
2016-05-24 11:16:24 +02:00
|
|
|
@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')
|
2008-09-12 11:52:57 +02:00
|
|
|
if not date:
|
2012-09-24 22:16:53 +02:00
|
|
|
date = Date.today()
|
2016-05-24 11:16:24 +02:00
|
|
|
return {
|
2018-10-31 18:15:57 +01:00
|
|
|
'year': date.strftime('%Y'),
|
|
|
|
|
'month': date.strftime('%m'),
|
|
|
|
|
'day': date.strftime('%d'),
|
2016-05-24 11:16:24 +02:00
|
|
|
}
|
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:
|
2016-03-03 21:51:57 +01:00
|
|
|
cursor = Transaction().connection.cursor()
|
2011-08-09 12:35:32 +02:00
|
|
|
cursor.execute('SELECT nextval(\'"%s"\')'
|
2012-09-24 22:16:53 +02:00
|
|
|
% sequence._sql_sequence_name)
|
2011-08-09 12:35:32 +02:00
|
|
|
number_next, = cursor.fetchone()
|
|
|
|
|
else:
|
2014-12-02 12:54:01 +01:00
|
|
|
# Pre-fetch number_next
|
2011-08-09 12:35:32 +02:00
|
|
|
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):
|
2008-11-25 00:14:14 +01:00
|
|
|
'''
|
|
|
|
|
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):
|
2008-11-25 00:14:14 +01:00
|
|
|
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)])
|
2008-09-10 17:41:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
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
|
2011-08-09 12:35:32 +02:00
|
|
|
_strict = True
|
2008-09-10 17:41:36 +02:00
|
|
|
|
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)
|