Debian Codegraph @

addons/l10n_fr_pos_cert/models/pos.py

raw
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)