Import DGII fiscal authorizations safely

ncf_manager.py

@@ -99,9 +99,16 @@ class NCFManager(Workflow, ModelSQL, ModelView):
     app_number = fields.Char('Application Number', required=True, size=10,
                              states=_states, depends=_depends)
 
-    auth_number = fields.Char('Authorization Number', required=True, size=10,
+    auth_number = fields.Char('Legacy Authorization Number', size=10,
                               states=_states, depends=_depends)
 
+    source_filename = fields.Char('Source Filename', readonly=True)
+    source_hash = fields.Char('Source SHA-256', readonly=True)
+    source_file = fields.Binary(
+        'DGII Source File', filename='source_filename', readonly=True)
+    imported_by = fields.Many2One('res.user', 'Imported By', readonly=True)
+    imported_at = fields.DateTime('Imported At', readonly=True)
+
     ncf_sequences = fields.One2Many('ncf.manager.sequence', 'pos',
                                     'NCF Sequences', context={'company': Eval('company', -1)},
                                     states=_states, depends=_depends)
@@ -188,9 +195,16 @@ class NCFManager(Workflow, ModelSQL, ModelView):
         })
 
     def _validate_authorization(self):
-        if not self.app_number.strip() or not self.auth_number.strip():
+        if not self.app_number.strip():
             raise UserError(gettext(
                 'ncf_manager.msg_ncf_missing_authorization'))
+        for line in self.ncf_sequences:
+            if not line.auth_number:
+                if self.auth_number:
+                    line.auth_number = self.auth_number
+                else:
+                    raise UserError(gettext(
+                        'ncf_manager.msg_ncf_line_missing_authorization'))
 
     @classmethod
     @ModelView.button
@@ -229,6 +243,11 @@ class NCFManager(Workflow, ModelSQL, ModelView):
             'activated_at': None,
             'finished_by': None,
             'finished_at': None,
+            'source_filename': None,
+            'source_hash': None,
+            'source_file': None,
+            'imported_by': None,
+            'imported_at': None,
         })
         return super().copy(managers, default=default)
 
@@ -254,6 +273,23 @@ class NCFManagerSequences(Workflow, ModelSQL, ModelView):
 
     ncf_type_string = ncf_type.translated('ncf_type')
 
+    auth_number = fields.Char(
+        'Authorization Number', size=10, states=_states, depends=_depends)
+    authorization_date = fields.DateTime(
+        'Authorization Date', states=_states, depends=_depends)
+    dgii_status = fields.Char('DGII Status', readonly=True)
+    requested_quantity = fields.Integer('Requested Quantity', readonly=True)
+    approved_quantity = fields.Integer('Approved Quantity', readonly=True)
+    usage_type = fields.Char('Usage Type', readonly=True)
+    dgii_detail = fields.Text('DGII Detail', readonly=True)
+    import_fingerprint = fields.Char('Import Fingerprint', readonly=True)
+    source_filename = fields.Char('Source Filename', readonly=True)
+    source_hash = fields.Char('Source SHA-256', readonly=True)
+    source_file = fields.Binary(
+        'DGII Source File', filename='source_filename', readonly=True)
+    imported_by = fields.Many2One('res.user', 'Imported By', readonly=True)
+    imported_at = fields.DateTime('Imported At', readonly=True)
+
     company = fields.Function(
         fields.Many2One('company.company', 'Company'),
         'on_change_with_company')
@@ -309,6 +345,24 @@ class NCFManagerSequences(Workflow, ModelSQL, ModelView):
             'invisible': Eval('sequence_mode') != 'create',
         }, depends=_depends + ['sequence_mode'])
 
+    effective_from_number = fields.Function(
+        fields.Integer('Authorized From', states={
+            'invisible': Eval('sequence_mode') == 'create',
+        }), 'get_effective_sequence_values')
+    effective_until_number = fields.Function(
+        fields.Integer('Authorized Until', states={
+            'invisible': Eval('sequence_mode') == 'create',
+        }), 'get_effective_sequence_values')
+    effective_number_next = fields.Function(
+        fields.Integer('First Number to Issue', states={
+            'invisible': Eval('sequence_mode') == 'create',
+        }),
+        'get_effective_sequence_values')
+    effective_expiration_date = fields.Function(
+        fields.Date('Expiration Date', states={
+            'invisible': Eval('sequence_mode') == 'create',
+        }), 'get_effective_sequence_values')
+
     invoice_type = fields.Selection([
         ('invoice_customer', 'Customer Invoice'),
         ('invoice_supplier', 'Supplier Invoice')
@@ -364,6 +418,35 @@ class NCFManagerSequences(Workflow, ModelSQL, ModelView):
                 and self.ncf_sequences.prefix != ncf_prefix(self.ncf_type)):
             self.ncf_sequences = None
 
+    @fields.depends(
+        'ncf_sequences', 'from_number', 'until_number', 'number_next',
+        'expiration_date')
+    def on_change_ncf_sequences(self):
+        if not self.ncf_sequences:
+            return
+        self.from_number = self.ncf_sequences.from_number
+        self.until_number = self.ncf_sequences.until_number
+        self.number_next = self.ncf_sequences.number_next
+        self.expiration_date = self.ncf_sequences.expiration_date
+
+    @classmethod
+    def get_effective_sequence_values(cls, records, names):
+        values = {name: {} for name in names}
+        mapping = {
+            'effective_from_number': 'from_number',
+            'effective_until_number': 'until_number',
+            'effective_number_next': 'number_next',
+            'effective_expiration_date': 'expiration_date',
+        }
+        for record in records:
+            sequence = record.ncf_sequences
+            for name in names:
+                source = mapping[name]
+                value = (getattr(sequence, source, None) if sequence
+                    else getattr(record, source, None))
+                values[name][record.id] = value
+        return values
+
     def get_rec_name(self, name):
         if not self.ncf_type_string:
             return ''
@@ -372,9 +455,23 @@ class NCFManagerSequences(Workflow, ModelSQL, ModelView):
     @classmethod
     def validate_fields(cls, records, field_names):
         super().validate_fields(records, field_names)
-        if field_names & {'pos', 'ncf_sequences', 'ncf_type'}:
+        if field_names & {
+                'pos', 'ncf_sequences', 'ncf_type', 'auth_number'}:
             for record in records:
                 record._validate_fiscal_sequence()
+                record._validate_unique_authorization()
+
+    def _validate_unique_authorization(self):
+        if not self.auth_number or not self.pos or not self.pos.company:
+            return
+        if self.__class__.search([
+                    ('id', '!=', self.id),
+                    ('pos.company', '=', self.pos.company.id),
+                    ('auth_number', '=', self.auth_number),
+                    ], limit=1):
+            raise UserError(gettext(
+                'ncf_manager.msg_ncf_authorization_number_duplicate',
+                authorization=self.auth_number))
 
     def _validate_fiscal_sequence(self):
         sequence = self.ncf_sequences
@@ -424,7 +521,7 @@ class NCFManagerSequences(Workflow, ModelSQL, ModelView):
         sequence_type = ModelData.get_id(
             'ncf_manager', NCF_SEQUENCE_TYPE_IDS[self.ncf_type])
         sequence, = Sequence.create([{
-            'name': f'{ncf_prefix(self.ncf_type)} - {self.pos.auth_number}',
+            'name': f'{ncf_prefix(self.ncf_type)} - {self.auth_number}',
             'sequence_type': sequence_type,
             'company': self.pos.company.id,
             'prefix': ncf_prefix(self.ncf_type),