| 1 |
# -*- coding: utf-8 -*- |
| 2 |
# Part of Odoo. See LICENSE file for full copyright and licensing details. |
| 3 |
from hashlib import sha256 |
| 4 |
from json import dumps, loads |
| 5 |
import logging |
| 6 |
from collections import defaultdict |
| 7 |
|
| 8 |
from odoo import models, api, fields, release, _ |
| 9 |
from odoo.exceptions import UserError |
| 10 |
|
| 11 |
_logger = logging.getLogger(__name__) |
| 12 |
|
| 13 |
|
| 14 |
class PosConfig(models.Model): |
| 15 |
_inherit = 'pos.config' |
| 16 |
|
| 17 |
def open_ui(self): |
| 18 |
for config in self: |
| 19 |
if not config.company_id.country_id: |
| 20 |
raise UserError(_("You have to set a country in your company setting.")) |
| 21 |
if config.company_id._is_accounting_unalterable(): |
| 22 |
if config.current_session_id: |
| 23 |
config.current_session_id._check_session_timing() |
| 24 |
return super().open_ui() |
| 25 |
|
| 26 |
|
| 27 |
class PosSession(models.Model): |
| 28 |
_inherit = 'pos.session' |
| 29 |
|
| 30 |
def _check_session_timing(self): |
| 31 |
self.ensure_one() |
| 32 |
return True |
| 33 |
|
| 34 |
def open_frontend_cb(self): |
| 35 |
sessions_to_check = self.filtered(lambda s: s.config_id.company_id._is_accounting_unalterable()) |
| 36 |
sessions_to_check.filtered(lambda s: s.state == 'opening_control').start_at = fields.Datetime.now() |
| 37 |
for session in sessions_to_check: |
| 38 |
session._check_session_timing() |
| 39 |
return super().open_frontend_cb() |
| 40 |
|
| 41 |
|
| 42 |
ORDER_FIELDS_BEFORE_17_4 = ['date_order', 'user_id', 'lines', 'payment_ids', 'pricelist_id', 'session_id', 'pos_reference', 'sale_journal', 'fiscal_position_id', 'partner_id'] |
| 43 |
ORDER_FIELDS_FROM_17_4 = ['date_order', 'user_id', 'lines', 'payment_ids', 'pricelist_id', 'session_id', 'pos_reference', 'sale_journal', 'fiscal_position_id', 'pos_version'] |
| 44 |
LINE_FIELDS = ['notice', 'product_id', 'qty', 'price_unit', 'discount', 'tax_ids', 'tax_ids_after_fiscal_position'] |
| 45 |
|
| 46 |
|
| 47 |
class PosOrder(models.Model): |
| 48 |
_inherit = 'pos.order' |
| 49 |
|
| 50 |
l10n_fr_hash = fields.Char(string="Inalteralbility Hash", readonly=True, copy=False) |
| 51 |
l10n_fr_secure_sequence_number = fields.Integer(string="Inalteralbility No Gap Sequence #", readonly=True, copy=False) |
| 52 |
l10n_fr_string_to_hash = fields.Char(compute='_compute_string_to_hash', readonly=True, store=False) |
| 53 |
previous_order_id = fields.Many2one('pos.order', string='Previous Order', readonly=True, compute='_compute_previous_order', store=True, copy=False) |
| 54 |
pos_version = fields.Char(help="Version of Odoo that created the order", readonly=True, copy=False) |
| 55 |
|
| 56 |
@api.depends('l10n_fr_secure_sequence_number') |
| 57 |
def _compute_previous_order(self): |
| 58 |
orders_by_company = defaultdict(list) |
| 59 |
for order in self.filtered(lambda o: o.l10n_fr_secure_sequence_number): |
| 60 |
orders_by_company[order.company_id.id].append(order) |
| 61 |
|
| 62 |
for company_id, orders in orders_by_company.items(): |
| 63 |
# Since sequence number can't be zero, we don't consider |
| 64 |
# it as a posible previous sequence number |
| 65 |
prev_seq = [o.l10n_fr_secure_sequence_number - 1 for o in orders if o.l10n_fr_secure_sequence_number > 1] |
| 66 |
prev_orders = self.search([ |
| 67 |
('state', 'in', ['paid', 'done']), |
| 68 |
('company_id', '=', company_id), |
| 69 |
('l10n_fr_secure_sequence_number', 'in', prev_seq), |
| 70 |
]) |
| 71 |
prev_map = defaultdict(list) |
| 72 |
for po in prev_orders: |
| 73 |
prev_map[po.l10n_fr_secure_sequence_number].append(po) |
| 74 |
|
| 75 |
for order in orders: |
| 76 |
match = prev_map.get(order.l10n_fr_secure_sequence_number - 1, []) |
| 77 |
if len(match) > 1: |
| 78 |
raise UserError(_('An error occurred when computing the inalterability. Impossible to get the unique previous posted point of sale order.')) |
| 79 |
order.previous_order_id = match[0] if match else False |
| 80 |
|
| 81 |
def _get_new_hash(self): |
| 82 |
""" Returns the hash to write on pos orders when they get posted""" |
| 83 |
self.ensure_one() |
| 84 |
# build and return the hash |
| 85 |
computed_hash = self._compute_hash(self.previous_order_id.l10n_fr_hash if self.previous_order_id else '') |
| 86 |
_logger.info( |
| 87 |
'Computed hash for order ID %s: %s \n String to hash: %s \n Previous hash: %s', |
| 88 |
self.id, |
| 89 |
computed_hash, |
| 90 |
dumps(loads(self.l10n_fr_string_to_hash), indent=2), |
| 91 |
self.previous_order_id.l10n_fr_hash |
| 92 |
) |
| 93 |
return computed_hash |
| 94 |
|
| 95 |
def _compute_hash(self, previous_hash): |
| 96 |
""" Computes the hash of the browse_record given as self, based on the hash |
| 97 |
of the previous record in the company's securisation sequence given as parameter""" |
| 98 |
self.ensure_one() |
| 99 |
hash_string = sha256((previous_hash + self.l10n_fr_string_to_hash).encode('utf-8')) |
| 100 |
return hash_string.hexdigest() |
| 101 |
|
| 102 |
def _compute_string_to_hash(self): |
| 103 |
def _getattrstring(field_value, field_type, model_name=None): |
| 104 |
if field_type in ('many2many', 'one2many'): |
| 105 |
if field_value: |
| 106 |
sorted_ids = sorted_relational_ids.get(model_name, []) |
| 107 |
value_set = set(field_value) |
| 108 |
field_value = [id for id in sorted_ids if id in value_set] |
| 109 |
else: |
| 110 |
field_value = [] |
| 111 |
return str(field_value) |
| 112 |
|
| 113 |
def collect_sorted_relational_ids(orders_data, lines_data, order_field_defs, line_field_defs): |
| 114 |
relational_ids = defaultdict(set) |
| 115 |
|
| 116 |
for data_list, field_names, field_defs in ( |
| 117 |
(orders_data, fields_to_fetch, order_field_defs), |
| 118 |
(lines_data, LINE_FIELDS, line_field_defs), |
| 119 |
): |
| 120 |
for record in data_list: |
| 121 |
for field in field_names: |
| 122 |
field_def = field_defs.get(field) |
| 123 |
if field_def and field_def['type'] in ('many2many', 'one2many'): |
| 124 |
ids = record.get(field) or [] |
| 125 |
relational_ids[field_def['comodel']].update(ids) |
| 126 |
|
| 127 |
sorted_relational_ids = {} |
| 128 |
for model_name, ids in relational_ids.items(): |
| 129 |
if ids: |
| 130 |
# Use search() to get IDs sorted by _order the same way Odoo ORM does for relational fields |
| 131 |
sorted_relational_ids[model_name] = self.env[model_name].search([('id', 'in', list(ids))]).ids |
| 132 |
|
| 133 |
return sorted_relational_ids |
| 134 |
fields_to_fetch = list(set(ORDER_FIELDS_BEFORE_17_4) | set(ORDER_FIELDS_FROM_17_4)) |
| 135 |
orders_data = self.read(fields_to_fetch + ['id'], load='') |
| 136 |
lines_data = self.lines.read(LINE_FIELDS + ['id', 'order_id'], load='') |
| 137 |
|
| 138 |
orders_by_id = {order['id']: order for order in orders_data} |
| 139 |
lines_by_order = defaultdict(list) |
| 140 |
for line in lines_data: |
| 141 |
lines_by_order[line['order_id']].append(line) |
| 142 |
order_field_defs = { |
| 143 |
field: { |
| 144 |
'type': self._fields[field].type, |
| 145 |
'comodel': self._fields[field].comodel_name if hasattr(self._fields[field], 'comodel_name') else None |
| 146 |
} |
| 147 |
for field in fields_to_fetch |
| 148 |
} |
| 149 |
line_field_defs = { |
| 150 |
field: { |
| 151 |
'type': self.lines._fields[field].type, |
| 152 |
'comodel': self.lines._fields[field].comodel_name if hasattr(self.lines._fields[field], 'comodel_name') else None |
| 153 |
} |
| 154 |
for field in LINE_FIELDS |
| 155 |
} |
| 156 |
|
| 157 |
sorted_relational_ids = collect_sorted_relational_ids(orders_data, lines_data, order_field_defs, line_field_defs) |
| 158 |
|
| 159 |
for order in self: |
| 160 |
values = {} |
| 161 |
if order.pos_version: |
| 162 |
order_fields = ORDER_FIELDS_FROM_17_4 |
| 163 |
else: |
| 164 |
order_fields = ORDER_FIELDS_BEFORE_17_4 |
| 165 |
for field in order_fields: |
| 166 |
values[field] = _getattrstring(order, field) |
| 167 |
order_data = orders_by_id[order.id] |
| 168 |
|
| 169 |
for field in order_fields: |
| 170 |
field_def = order_field_defs[field] |
| 171 |
values[field] = _getattrstring(order_data.get(field), field_def['type'], field_def['comodel']) |
| 172 |
|
| 173 |
for line in lines_by_order[order.id]: |
| 174 |
for field in LINE_FIELDS: |
| 175 |
k = 'line_%d_%s' % (line['id'], field) |
| 176 |
field_def = line_field_defs[field] |
| 177 |
values[k] = _getattrstring(line.get(field), field_def['type'], field_def['comodel']) |
| 178 |
|
| 179 |
#make the json serialization canonical |
| 180 |
# (https://tools.ietf.org/html/draft-staykov-hu-json-canonical-form-00) |
| 181 |
order.l10n_fr_string_to_hash = dumps(values, sort_keys=True, |
| 182 |
ensure_ascii=True, indent=None, |
| 183 |
separators=(',',':')) |
| 184 |
|
| 185 |
@api.model_create_multi |
| 186 |
def create(self, vals_list): |
| 187 |
for vals in vals_list: |
| 188 |
vals['pos_version'] = release.version |
| 189 |
return super().create(vals_list) |
| 190 |
|
| 191 |
def write(self, vals): |
| 192 |
has_been_posted = False |
| 193 |
for order in self: |
| 194 |
if order.company_id._is_accounting_unalterable(): |
| 195 |
# write the hash and the secure_sequence_number when posting or invoicing an pos.order |
| 196 |
if vals.get('state') in ['paid', 'done']: |
| 197 |
has_been_posted = True |
| 198 |
|
| 199 |
# restrict the operation in case we are trying to write a forbidden field |
| 200 |
if order.pos_version: |
| 201 |
ORDER_FIELDS = ORDER_FIELDS_FROM_17_4 |
| 202 |
else: |
| 203 |
ORDER_FIELDS = ORDER_FIELDS_BEFORE_17_4 |
| 204 |
if (order.state in ['paid', 'done'] and set(vals).intersection(ORDER_FIELDS)): |
| 205 |
raise UserError(_('According to the French law, you cannot modify a point of sale order. Forbidden fields: %s.') % ', '.join(ORDER_FIELDS)) |
| 206 |
# restrict the operation in case we are trying to overwrite existing hash |
| 207 |
if (order.l10n_fr_hash and 'l10n_fr_hash' in vals) or (order.l10n_fr_secure_sequence_number and 'l10n_fr_secure_sequence_number' in vals): |
| 208 |
raise UserError(_('You cannot overwrite the values ensuring the inalterability of the point of sale.')) |
| 209 |
res = super().write(vals) |
| 210 |
# write the hash and the secure_sequence_number when posting or invoicing a pos order |
| 211 |
if has_been_posted: |
| 212 |
for order in self.filtered(lambda o: o.company_id._is_accounting_unalterable() and |
| 213 |
not (o.l10n_fr_secure_sequence_number or o.l10n_fr_hash)): |
| 214 |
new_number = order.company_id.l10n_fr_pos_cert_sequence_id.next_by_id() |
| 215 |
res |= super(PosOrder, order).write({'l10n_fr_secure_sequence_number': new_number}) |
| 216 |
res |= super(PosOrder, order).write({'l10n_fr_hash': order._get_new_hash()}) |
| 217 |
return res |
| 218 |
|
| 219 |
@api.ondelete(at_uninstall=True) |
| 220 |
def _unlink_except_pos_so(self): |
| 221 |
for order in self: |
| 222 |
if order.company_id._is_accounting_unalterable(): |
| 223 |
raise UserError(_("According to French law, you cannot delete a point of sale order.")) |
| 224 |
|
| 225 |
|
| 226 |
class PosOrderLine(models.Model): |
| 227 |
_inherit = "pos.order.line" |
| 228 |
|
| 229 |
def write(self, vals): |
| 230 |
# restrict the operation in case we are trying to write a forbidden field |
| 231 |
if set(vals).intersection(LINE_FIELDS): |
| 232 |
if any(l.company_id._is_accounting_unalterable() and (l.order_id.account_move or l.order_id.state == 'done') for l in self): |
| 233 |
raise UserError(_('According to the French law, you cannot modify a point of sale order line. Forbidden fields: %s.') % ', '.join(LINE_FIELDS)) |
| 234 |
return super(PosOrderLine, self).write(vals) |