fix: keep preview extraction state consistent

Author: Florian Wunderlich

models/account_move.py

@@ -360,29 +360,32 @@ def _ai_check_prerequisites(self):
 
         return api_key, attachment
 
-    def action_ai_extract(self):
-        """Button: Digitize with AI."""
-        self.ensure_one()
+    def _ai_clear_extraction_cache(self):
+        """Drop cached extraction data for this invoice."""
+        self.ai_last_extraction_data = False
+        self.ai_last_extraction_attachment_id = False
 
+    def _ai_extract_from_button(self, force_refresh=False):
+        """Shared implementation for the extract and re-extract buttons."""
         api_key, attachment = self._ai_check_prerequisites()
         if api_key is None:
             return attachment  # attachment is the error action dict
 
         # --- Cache check: reuse previous extraction if same attachment ------
-        if self.ai_last_extraction_data and self.ai_last_extraction_attachment_id == attachment:
+        if not force_refresh and self.ai_last_extraction_data and self.ai_last_extraction_attachment_id == attachment:
             _logger.info('Using cached extraction data for move %s', self.id)
             try:
                 data = json.loads(self.ai_last_extraction_data)
             except (json.JSONDecodeError, TypeError):
                 _logger.warning('Cached extraction data is invalid JSON for move %s', self.id)
-                self.ai_last_extraction_data = False
+                self._ai_clear_extraction_cache()
             else:
                 return self._ai_open_preview_wizard(data)
 
-        # Invalidate cache if attachment changed
+        # Invalidate cache if attachment changed. For force-refresh on the same
+        # attachment, keep the old cache until the new extraction succeeds.
         if self.ai_last_extraction_attachment_id and self.ai_last_extraction_attachment_id != attachment:
-            self.ai_last_extraction_data = False
-            self.ai_last_extraction_attachment_id = False
+            self._ai_clear_extraction_cache()
 
         # --- Async mode: queue for background processing -------------------
         if self._ai_get_bool_param('ai_async_extraction'):
@@ -399,6 +402,11 @@ def action_ai_extract(self):
         # --- Run extraction in preview mode (synchronous) ------------------
         return self._ai_extract_sync(api_key, attachment)
 
+    def action_ai_extract(self):
+        """Button: Digitize with AI."""
+        self.ensure_one()
+        return self._ai_extract_from_button()
+
     def _ai_extract_sync(self, api_key, attachment):
         """Run extraction synchronously and open the preview wizard."""
         self.ai_extraction_status = 'processing'
@@ -434,6 +442,10 @@ def _ai_extract_sync(self, api_key, attachment):
                 notif_type='success',
             )
 
+        # The synchronous preview is ready immediately, so reserve "processing"
+        # for actual async/background work and leave the move in a re-openable
+        # preview state.
+        self.ai_extraction_status = 'pending'
         return self._ai_open_preview_wizard(data)
 
     def _ai_open_preview_wizard(self, data):
@@ -468,11 +480,9 @@ def _ai_open_preview_wizard(self, data):
         }
 
     def action_ai_re_extract(self):
-        """Button: force re-extraction (clear cache and extract again)."""
+        """Button: force a fresh extraction without reusing the cached result."""
         self.ensure_one()
-        self.ai_last_extraction_data = False
-        self.ai_last_extraction_attachment_id = False
-        return self.action_ai_extract()
+        return self._ai_extract_from_button(force_refresh=True)
 
     def action_ai_view_results(self):
         """Button: open preview wizard from cached extraction data."""
@@ -484,4 +494,3 @@ def action_ai_view_results(self):
         except (json.JSONDecodeError, TypeError):
             return False
         return self._ai_open_preview_wizard(data)
-

static/src/js/extraction_status_widget.js

@@ -2,7 +2,7 @@
 
 import { registry } from "@web/core/registry";
 import { standardFieldProps } from "@web/views/fields/standard_field_props";
-import { Component, onMounted, onWillUnmount, onPatched } from "@odoo/owl";
+import { Component, onMounted, onWillUnmount, onPatched, useState } from "@odoo/owl";
 import { useService } from "@web/core/utils/hooks";
 
 const POLL_INTERVAL_MS = 5000;
@@ -15,17 +15,25 @@ class AiExtractionStatusWidget extends Component {
         this.orm = useService("orm");
         this.action = useService("action");
         this.notification = useService("notification");
+        this.state = useState({ terminalStatus: false });
         this._intervalId = null;
 
         onMounted(() => this._checkAndStartPolling());
         onPatched(() => this._checkAndStartPolling());
         onWillUnmount(() => this._stopPolling());
     }
 
-    get currentStatus() {
+    get recordStatus() {
         return this.props.record.data[this.props.name] || false;
     }
 
+    get currentStatus() {
+        if (this.recordStatus === "processing" && this.state.terminalStatus) {
+            return this.state.terminalStatus;
+        }
+        return this.recordStatus;
+    }
+
     get isProcessing() {
         return this.currentStatus === "processing";
     }
@@ -39,6 +47,9 @@ class AiExtractionStatusWidget extends Component {
     }
 
     _checkAndStartPolling() {
+        if (this.recordStatus === "processing" && this.state.terminalStatus) {
+            this.state.terminalStatus = false;
+        }
         if (this.isProcessing && !this._intervalId) {
             this._startPolling();
         } else if (!this.isProcessing && this._intervalId) {
@@ -57,6 +68,16 @@ class AiExtractionStatusWidget extends Component {
         }
     }
 
+    async _reloadRecordIfSafe() {
+        // Reload only when the form is clean. In Odoo's relational model,
+        // reloading a dirty record discards in-progress edits.
+        if (await this.props.record.isDirty()) {
+            return false;
+        }
+        await this.props.record.load();
+        return true;
+    }
+
     async _poll() {
         const recordId = this.props.record.resId;
         if (!recordId) return;
@@ -71,13 +92,21 @@ class AiExtractionStatusWidget extends Component {
 
             const newStatus = result[0].ai_extraction_status;
 
+            if (newStatus === "processing") {
+                return;
+            }
+
+            this._stopPolling();
+            this.state.terminalStatus = newStatus || false;
+            if (await this._reloadRecordIfSafe()) {
+                this.state.terminalStatus = false;
+            }
+
             if (newStatus === "done") {
-                this._stopPolling();
                 this.notification.add(
                     "AI extraction complete. Opening results...",
                     { type: "success" },
                 );
-                // Trigger view results action
                 await this.action.doActionButton({
                     type: "object",
                     name: "action_ai_view_results",
@@ -91,8 +120,6 @@ class AiExtractionStatusWidget extends Component {
                     "AI extraction failed. Please try again.",
                     { type: "danger" },
                 );
-                // Reload to show updated status
-                await this.props.record.load();
             }
         } catch (error) {
             console.warn("Extraction polling error:", error);

tests/test_async_extraction.py

@@ -175,8 +175,8 @@ def test_cron_batch_size_limit(self):
         self.assertEqual(len(done), 5)
         self.assertEqual(len(still_queued), 2)
 
-    def test_re_extract_clears_cache(self):
-        """action_ai_re_extract should clear cached data and re-trigger."""
+    def test_re_extract_bypasses_cache(self):
+        """action_ai_re_extract should force a fresh extraction instead of reusing cache."""
         move = self._create_invoice_with_attachment()
         move.ai_last_extraction_data = json.dumps({'old': True})
         move.ai_extraction_status = 'done'

tests/test_extraction_cache.py

@@ -56,6 +56,14 @@ def _create_invoice_with_attachment(self, pdf_content=b'%PDF-fake'):
         )
         return move, attachment
 
+    def _create_preview_wizard(self, move):
+        return self.env['ai.preview.wizard'].create(
+            {
+                'move_id': move.id,
+                'preview_data': json.dumps(self.mock_data),
+            }
+        )
+
     def test_cache_populated_after_extraction(self):
         """Cache fields should be populated after a successful extraction."""
         move, attachment = self._create_invoice_with_attachment()
@@ -127,8 +135,23 @@ def test_cache_invalidated_on_attachment_change(self):
         # Cache should now reference the new attachment
         self.assertEqual(move.ai_last_extraction_attachment_id, new_attachment)
 
-    def test_re_extract_clears_cache(self):
-        """action_ai_re_extract should clear cache and trigger fresh extraction."""
+    def test_sync_preview_returns_move_to_pending(self):
+        """Synchronous preview must not leave the move stuck in processing."""
+        move, attachment = self._create_invoice_with_attachment()
+
+        with patch.object(
+            type(move),
+            '_ai_trigger_extraction',
+            return_value=self.mock_data,
+        ):
+            result = move.action_ai_extract()
+
+        self.assertEqual(result.get('res_model'), 'ai.preview.wizard')
+        self.assertEqual(move.ai_extraction_status, 'pending')
+        self.assertEqual(move.ai_last_extraction_attachment_id, attachment)
+
+    def test_re_extract_bypasses_cache(self):
+        """action_ai_re_extract should force a fresh extraction for the same attachment."""
         move, attachment = self._create_invoice_with_attachment()
 
         # Populate cache
@@ -143,6 +166,21 @@ def test_re_extract_clears_cache(self):
             move.action_ai_re_extract()
             mock_trigger.assert_called_once()
 
+    def test_re_extract_blocked_keeps_cache(self):
+        """A blocked re-extract must not destroy the previously cached result."""
+        move, attachment = self._create_invoice_with_attachment()
+
+        move.ai_last_extraction_data = json.dumps(self.mock_data)
+        move.ai_last_extraction_attachment_id = attachment.id
+        move.ai_extraction_status = 'processing'
+
+        result = move.action_ai_re_extract()
+
+        self.assertEqual(result['tag'], 'display_notification')
+        self.assertEqual(move.ai_extraction_status, 'processing')
+        self.assertTrue(move.ai_last_extraction_data)
+        self.assertEqual(move.ai_last_extraction_attachment_id, attachment)
+
     def test_discard_keeps_cache(self):
         """Discarding the preview wizard should keep the cache intact."""
         move, attachment = self._create_invoice_with_attachment()
@@ -155,6 +193,24 @@ def test_discard_keeps_cache(self):
         self.assertTrue(move.ai_last_extraction_data)
         self.assertEqual(move.ai_last_extraction_attachment_id, attachment)
 
+    def test_discard_preserves_pending_status(self):
+        """Discard should not mutate the sync-preview pending state."""
+        move, _attachment = self._create_invoice_with_attachment()
+        move.ai_extraction_status = 'pending'
+
+        self._create_preview_wizard(move).action_discard()
+
+        self.assertEqual(move.ai_extraction_status, 'pending')
+
+    def test_discard_preserves_done_status(self):
+        """Discarding an already-applied preview must not downgrade done."""
+        move, _attachment = self._create_invoice_with_attachment()
+        move.ai_extraction_status = 'done'
+
+        self._create_preview_wizard(move).action_discard()
+
+        self.assertEqual(move.ai_extraction_status, 'done')
+
     def test_cache_not_populated_on_failure(self):
         """Cache should not be populated when extraction fails."""
         move, attachment = self._create_invoice_with_attachment()

wizards/ai_preview_wizard.py

@@ -164,7 +164,6 @@ def action_apply(self):
         }
 
     def action_discard(self):
-        """Discard the extraction and close the wizard."""
+        """Close the preview without mutating the invoice state."""
         self.ensure_one()
-        self.move_id.ai_extraction_status = 'pending'
         return {'type': 'ir.actions.act_window_close'}