mirror of
https://github.com/bringout/oca-ocb-technical.git
synced 2026-04-25 00:52:03 +02:00
205 lines
9.1 KiB
Python
205 lines
9.1 KiB
Python
import re
|
|
import datetime
|
|
import calendar
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.exceptions import ValidationError
|
|
from odoo.fields import Domain
|
|
from odoo.tools.barcode import get_barcode_check_digit
|
|
|
|
FNC1_CHAR = '\x1D'
|
|
|
|
|
|
class BarcodeNomenclature(models.Model):
|
|
_inherit = 'barcode.nomenclature'
|
|
|
|
is_gs1_nomenclature = fields.Boolean(
|
|
string="Is GS1 Nomenclature",
|
|
help="This Nomenclature use the GS1 specification, only GS1-128 encoding rules is accepted is this kind of nomenclature.")
|
|
gs1_separator_fnc1 = fields.Char(
|
|
string="FNC1 Separator", trim=False, default=r'(Alt029|#|\x1D)',
|
|
help="Alternative regex delimiter for the FNC1. The separator must not match the begin/end of any related rules pattern.")
|
|
|
|
@api.constrains('gs1_separator_fnc1')
|
|
def _check_pattern(self):
|
|
for nom in self:
|
|
if nom.is_gs1_nomenclature and nom.gs1_separator_fnc1:
|
|
try:
|
|
re.compile("(?:%s)?" % nom.gs1_separator_fnc1)
|
|
except re.error as error:
|
|
raise ValidationError(_("The FNC1 Separator Alternative is not a valid Regex: %(error)s", error))
|
|
|
|
@api.model
|
|
def gs1_date_to_date(self, gs1_date):
|
|
""" Converts a GS1 date into a datetime.date.
|
|
|
|
:param gs1_date: A year formated as yymmdd
|
|
:type gs1_date: str
|
|
:return: converted date
|
|
:rtype: datetime.date
|
|
"""
|
|
# See 7.12 Determination of century in dates:
|
|
# https://www.gs1.org/sites/default/files/docs/barcodes/GS1_General_Specifications.pdf
|
|
now = datetime.date.today()
|
|
current_century = now.year // 100
|
|
substract_year = int(gs1_date[0:2]) - (now.year % 100)
|
|
century = (51 <= substract_year <= 99 and current_century - 1) or\
|
|
(-99 <= substract_year <= -50 and current_century + 1) or\
|
|
current_century
|
|
year = century * 100 + int(gs1_date[0:2])
|
|
|
|
if gs1_date[-2:] == '00': # Day is not mandatory, when not set -> last day of the month
|
|
date = datetime.datetime.strptime(str(year) + gs1_date[2:4], '%Y%m')
|
|
date = date.replace(day=calendar.monthrange(year, int(gs1_date[2:4]))[1])
|
|
else:
|
|
try:
|
|
date = datetime.datetime.strptime(str(year) + gs1_date[2:], '%Y%m%d')
|
|
except ValueError as e:
|
|
raise ValidationError(_(
|
|
"A GS1 barcode nomenclature pattern was matched. However, the barcode failed to be converted to a valid date: '%(error_message)s'",
|
|
error_message=e
|
|
))
|
|
return date.date()
|
|
|
|
def parse_gs1_rule_pattern(self, match, rule):
|
|
result = {
|
|
'rule': rule,
|
|
'type': rule.type,
|
|
'ai': match.group(1),
|
|
'string_value': match.group(2),
|
|
}
|
|
if rule.gs1_content_type == 'measure':
|
|
try:
|
|
decimal_position = 0 # Decimal position begins at the end, 0 means no decimal.
|
|
if rule.gs1_decimal_usage:
|
|
decimal_position = int(match.group(1)[-1])
|
|
if decimal_position > 0:
|
|
result['value'] = float(match.group(2)[:-decimal_position] + "." + match.group(2)[-decimal_position:])
|
|
else:
|
|
result['value'] = int(match.group(2))
|
|
except Exception:
|
|
raise ValidationError(_(
|
|
"There is something wrong with the barcode rule \"%s\" pattern.\n"
|
|
"If this rule uses decimal, check it can't get sometime else than a digit as last char for the Application Identifier.\n"
|
|
"Check also the possible matched values can only be digits, otherwise the value can't be casted as a measure.",
|
|
rule.name))
|
|
elif rule.gs1_content_type == 'identifier':
|
|
# Check digit and remove it of the value
|
|
if match.group(2)[-1] != str(get_barcode_check_digit("0" * (18 - len(match.group(2))) + match.group(2))):
|
|
return None
|
|
result['value'] = match.group(2)
|
|
elif rule.gs1_content_type == 'date':
|
|
if len(match.group(2)) != 6:
|
|
return None
|
|
result['value'] = self.gs1_date_to_date(match.group(2))
|
|
else: # when gs1_content_type == 'alpha':
|
|
result['value'] = match.group(2)
|
|
return result
|
|
|
|
def gs1_decompose_extended(self, barcode):
|
|
"""Try to decompose the gs1 extended barcode into several unit of information using gs1 rules.
|
|
|
|
Return a ordered list of dict
|
|
"""
|
|
self.ensure_one()
|
|
separator_group = FNC1_CHAR + "?"
|
|
if self.gs1_separator_fnc1:
|
|
separator_group = "(?:%s)?" % self.gs1_separator_fnc1
|
|
# zxing-library patch, removing GS1 identifiers
|
|
for identifier in [']C1', ']e0', ']d2', ']Q3', ']J1', FNC1_CHAR]:
|
|
if barcode.startswith(identifier):
|
|
barcode = barcode.replace(identifier, '', 1)
|
|
break
|
|
results = []
|
|
gs1_rules = self.rule_ids.filtered(lambda r: r.encoding == 'gs1-128')
|
|
|
|
def find_next_rule(remaining_barcode):
|
|
for rule in gs1_rules:
|
|
match = re.search("^" + rule.pattern + separator_group, remaining_barcode)
|
|
# If match and contains 2 groups at minimun, the first one need to be the AI and the second the value
|
|
# We can't use regex nammed group because in JS, it is not the same regex syntax (and not compatible in all browser)
|
|
if match and len(match.groups()) >= 2:
|
|
res = self.parse_gs1_rule_pattern(match, rule)
|
|
if res:
|
|
return res, remaining_barcode[match.end():]
|
|
return None
|
|
|
|
while len(barcode) > 0:
|
|
res_bar = find_next_rule(barcode)
|
|
# Cannot continue -> Fail to decompose gs1 and return
|
|
if not res_bar or res_bar[1] == barcode:
|
|
return None
|
|
barcode = res_bar[1]
|
|
results.append(res_bar[0])
|
|
|
|
return results
|
|
|
|
def parse_nomenclature_barcode(self, barcode):
|
|
if self.is_gs1_nomenclature:
|
|
return self.gs1_decompose_extended(barcode)
|
|
return super().parse_nomenclature_barcode(barcode)
|
|
|
|
@api.model
|
|
def _preprocess_gs1_search_args(self, domain, barcode_types, field='barcode'):
|
|
"""Helper method to preprocess 'domain' in _search method to add support to
|
|
search with GS1 barcode result.
|
|
Cut off the padding if using GS1 and searching on barcode. If the barcode
|
|
is only digits to keep the original barcode part only.
|
|
"""
|
|
domain = Domain(domain)
|
|
nomenclature = self.env.company.nomenclature_id
|
|
if not self.env.context.get('skip_preprocess_gs1'):
|
|
def map_gs1_barcode(condition):
|
|
if condition.field_expr != field or not nomenclature.is_gs1_nomenclature:
|
|
return condition
|
|
# Check operator
|
|
# handle `in` first and check the rest
|
|
operator = condition.operator
|
|
value = condition.value
|
|
if not value:
|
|
return condition
|
|
|
|
if operator in ('in', 'not in') and len(value) > 1:
|
|
sub_domain = Domain.OR(
|
|
map_gs1_barcode(Domain(field, '=', v))
|
|
for v in value
|
|
)
|
|
if operator == 'not in':
|
|
sub_domain = ~sub_domain
|
|
return sub_domain
|
|
if operator in ('in', 'not in'):
|
|
operator = '=' if operator == 'in' else '!='
|
|
value = next(iter(value))
|
|
elif operator not in ('ilike', 'not ilike', '=', '!='):
|
|
return condition
|
|
|
|
# Parse the value
|
|
if not value:
|
|
return condition
|
|
try:
|
|
parsed_data = nomenclature.parse_barcode(value) or []
|
|
except (ValidationError, ValueError):
|
|
parsed_data = []
|
|
|
|
replacing_operator = 'ilike' if operator in ['ilike', '='] else 'not ilike'
|
|
for data in parsed_data:
|
|
data_type = data['type']
|
|
value = data['value']
|
|
if data_type in barcode_types:
|
|
if data_type == 'lot':
|
|
return Domain(field, operator, value)
|
|
match = re.match('0*([0-9]+)$', str(value))
|
|
if match:
|
|
unpadded_barcode = match.groups()[0]
|
|
return Domain(field, replacing_operator, unpadded_barcode)
|
|
break
|
|
|
|
# The barcode isn't a valid GS1 barcode, checks if it can be unpadded.
|
|
if not parsed_data:
|
|
match = re.match('0+([0-9]+)$', value)
|
|
if match:
|
|
return Domain(field, replacing_operator, match.groups()[0])
|
|
return condition
|
|
|
|
domain = domain.map_conditions(map_gs1_barcode)
|
|
return domain
|