Repository navigation
Expand file tree
/
Copy pathfields_numeric.py
More file actions
290 lines (229 loc) · 11.8 KB
/
Copy pathfields_numeric.py
File metadata and controls
290 lines (229 loc) · 11.8 KB
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
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
from __future__ import annotations
import typing
from operator import attrgetter
from xmlrpc.client import MAXINT # TODO change this
from odoo.exceptions import AccessError
from odoo.tools import float_compare, float_is_zero, float_repr, float_round
from odoo.tools.misc import SENTINEL, Sentinel
from .fields import Field
if typing.TYPE_CHECKING:
from .types import BaseModel, Environment
class Integer(Field[int]):
""" Encapsulates an :class:`int`. """
type = 'integer'
_column_type = ('int4', 'int4')
falsy_value = 0
aggregator = 'sum'
def _get_attrs(self, model_class, name):
res = super()._get_attrs(model_class, name)
# The default aggregator is None for sequence fields
if 'aggregator' not in res and name == 'sequence':
res['aggregator'] = None
return res
def convert_to_column(self, value, record, values=None, validate=True):
return int(value or 0)
def convert_to_cache(self, value, record, validate=True):
if isinstance(value, dict):
# special case, when an integer field is used as inverse for a one2many
return value.get('id', None)
return int(value or 0)
def convert_to_record(self, value, record):
return value or 0
def convert_to_read(self, value, record, use_display_name=True):
# Integer values greater than 2^31-1 are not supported in pure XMLRPC,
# so we have to pass them as floats :-(
if value and value > MAXINT:
return float(value)
return value
def _update_inverse(self, records: BaseModel, value: BaseModel):
self._update_cache(records, value.id or 0)
def convert_to_export(self, value, record):
if value or value == 0:
return value
return ''
class Float(Field[float]):
""" Encapsulates a :class:`float`.
The precision digits are given by the (optional) ``digits`` attribute.
:param digits: a pair (total, decimal) or a string referencing a
:class:`~odoo.addons.base.models.decimal_precision.DecimalPrecision` record name.
:type digits: tuple(int,int) or str
When a float is a quantity associated with an unit of measure, it is important
to use the right tool to compare or round values with the correct precision.
The Float class provides some static methods for this purpose:
:func:`~odoo.fields.Float.round()` to round a float with the given precision.
:func:`~odoo.fields.Float.is_zero()` to check if a float equals zero at the given precision.
:func:`~odoo.fields.Float.compare()` to compare two floats at the given precision.
.. admonition:: Example
To round a quantity with the precision of the unit of measure::
fields.Float.round(self.product_uom_qty, precision_rounding=self.product_uom_id.rounding)
To check if the quantity is zero with the precision of the unit of measure::
fields.Float.is_zero(self.product_uom_qty, precision_rounding=self.product_uom_id.rounding)
To compare two quantities::
field.Float.compare(self.product_uom_qty, self.qty_done, precision_rounding=self.product_uom_id.rounding)
The compare helper uses the __cmp__ semantics for historic purposes, therefore
the proper, idiomatic way to use this helper is like so:
if result == 0, the first and second floats are equal
if result < 0, the first float is lower than the second
if result > 0, the first float is greater than the second
"""
type = 'float'
_digits: str | tuple[int, int] | None = None # digits argument passed to class initializer
falsy_value = 0.0
aggregator = 'sum'
def __init__(self, string: str | Sentinel = SENTINEL, digits: str | tuple[int, int] | Sentinel | None = SENTINEL, **kwargs):
super().__init__(string=string, _digits=digits, **kwargs)
@property
def _column_type(self):
# Explicit support for "falsy" digits (0, False) to indicate a NUMERIC
# field with no fixed precision. The values are saved in the database
# with all significant digits.
# FLOAT8 type is still the default when there is no precision because it
# is faster for most operations (sums, etc.)
return ('numeric', 'numeric') if self._digits is not None else \
('float8', 'double precision')
def get_digits(self, env: Environment) -> tuple[int, int] | None:
if isinstance(self._digits, str):
precision = env['decimal.precision'].precision_get(self._digits)
return 16, precision
else:
return self._digits
_related__digits = property(attrgetter('_digits'))
def _description_digits(self, env: Environment) -> tuple[int, int] | None:
return self.get_digits(env)
def convert_to_column(self, value, record, values=None, validate=True):
value_float = value = float(value or 0.0)
if digits := self.get_digits(record.env):
_precision, scale = digits
value_float = float_round(value, precision_digits=scale)
value = float_repr(value_float, precision_digits=scale)
if self.company_dependent:
return value_float
return value
def convert_to_cache(self, value, record, validate=True):
# apply rounding here, otherwise value in cache may be wrong!
value = float(value or 0.0)
digits = self.get_digits(record.env)
return float_round(value, precision_digits=digits[1]) if digits else value
def convert_to_record(self, value, record):
return value or 0.0
def convert_to_export(self, value, record):
if value or value == 0.0:
return value
return ''
round = staticmethod(float_round)
is_zero = staticmethod(float_is_zero)
compare = staticmethod(float_compare)
class Monetary(Field[float]):
""" Encapsulates a :class:`float` expressed in a given
:class:`res_currency<odoo.addons.base.models.res_currency.Currency>`.
The decimal precision and currency symbol are taken from the ``currency_field`` attribute.
:param str currency_field: name of the :class:`Many2one` field
holding the :class:`res_currency <odoo.addons.base.models.res_currency.Currency>`
this monetary field is expressed in (default: `\'currency_id\'`)
"""
type = 'monetary'
write_sequence = 10
_column_type = ('numeric', 'numeric')
falsy_value = 0.0
currency_field: Field | None = None
aggregator = 'sum'
def __init__(self, string: str | Sentinel = SENTINEL, currency_field: str | Sentinel = SENTINEL, **kwargs):
super().__init__(string=string, currency_field=currency_field, **kwargs)
def _description_currency_field(self, env: Environment) -> str | None:
return self.get_currency_field(env[self.model_name])
def _description_aggregator(self, env: Environment):
model = env[self.model_name]
query = model._as_query(ordered=False)
currency_field_name = self.get_currency_field(model)
currency_field = model._fields[currency_field_name]
# The currency field needs to be aggregable too
if not currency_field.column_type or not currency_field.store:
try:
model._read_group_select(f"{currency_field_name}:array_agg_distinct", query)
except (ValueError, AccessError):
return None
return super()._description_aggregator(env)
def get_currency_field(self, model: BaseModel) -> str | None:
""" Return the name of the currency field. """
return self.currency_field or (
'currency_id' if 'currency_id' in model._fields else
'x_currency_id' if 'x_currency_id' in model._fields else
None
)
def setup_nonrelated(self, model):
super().setup_nonrelated(model)
assert self.get_currency_field(model) in model._fields, \
"Field %s with unknown currency_field %r" % (self, self.get_currency_field(model))
def setup_related(self, model):
super().setup_related(model)
if self.inherited:
self.currency_field = self.related_field.get_currency_field(model.env[self.related_field.model_name])
assert self.get_currency_field(model) in model._fields, \
"Field %s with unknown currency_field %r" % (self, self.get_currency_field(model))
def convert_to_column_insert(self, value, record, values=None, validate=True):
# retrieve currency from values or record
currency_field_name = self.get_currency_field(record)
currency_field = record._fields[currency_field_name]
if values and currency_field_name in values:
dummy = record.new({currency_field_name: values[currency_field_name]})
currency = dummy[currency_field_name]
elif values and currency_field.related and currency_field.related.split('.')[0] in values:
related_field_name = currency_field.related.split('.')[0]
dummy = record.new({related_field_name: values[related_field_name]})
currency = dummy[currency_field_name]
else:
# Note: this is wrong if 'record' is several records with different
# currencies, which is functional nonsense and should not happen
# BEWARE: do not prefetch other fields, because 'value' may be in
# cache, and would be overridden by the value read from database!
currency = record[:1].sudo().with_context(prefetch_fields=False)[currency_field_name]
currency = currency.with_env(record.env)
value = float(value or 0.0)
if currency:
return float_repr(currency.round(value), currency.decimal_places)
return value
def convert_to_cache(self, value, record, validate=True):
# cache format: float
value = float(value or 0.0)
if value and validate:
# FIXME @rco-odoo: currency may not be already initialized if it is
# a function or related field!
# BEWARE: do not prefetch other fields, because 'value' may be in
# cache, and would be overridden by the value read from database!
currency_field = self.get_currency_field(record)
currency = record.sudo().with_context(prefetch_fields=False)[currency_field]
if len(currency) > 1:
raise ValueError("Got multiple currencies while assigning values of monetary field %s" % str(self))
elif currency:
value = currency.with_env(record.env).round(value)
return value
def convert_to_record(self, value, record):
return value or 0.0
def convert_to_read(self, value, record, use_display_name=True):
return value
def convert_to_write(self, value, record):
return value
def convert_to_export(self, value, record):
if value or value == 0.0:
return value
return ''
def _filter_not_equal(self, records: BaseModel, cache_value: typing.Any) -> BaseModel:
records = super()._filter_not_equal(records, cache_value)
if not records:
return records
# check that the values were rounded properly when put in cache
# see fix odoo/odoo#177200 (commit 7164d5295904b08ec3a0dc1fb54b217671ff531c)
env = records.env
field_cache = self._get_cache(env)
currency_field = records._fields[self.get_currency_field(records)]
return records.browse(
record_id
for record_id, record_sudo in zip(
records._ids, records.sudo().with_context(prefetch_fields=False)
)
if not (
(value := field_cache.get(record_id))
and (currency := currency_field.__get__(record_sudo))
and currency.with_env(env).round(value) == cache_value
)
)