fix(spp_import_match): multiple match error, missing field error, async context, jobworker

- Restore ValidationError on multiple matches instead of returning first
- Add UserError when selected match config fields are missing from import file
- Skip matching on empty field values to avoid false matches
- Fix async import context: move import_match_ids to before sync/async branch
- Simplify jobworker: rely on runner's 5-min auto-discovery instead of polling
- Stop jobworker during resetdb to avoid DB lock issues
- Remove forced jobworker restart from spp CLI start command

Author: emjay0921

docker-compose.yml

@@ -170,6 +170,8 @@ services:
 
   # Job Worker - background service for processing async queue jobs
   # Runs alongside openspp/openspp-dev to execute delayed imports, etc.
+  # The runner auto-discovers databases every 5 minutes, so after installing
+  # new modules, jobs will be picked up within 5 minutes (or restart to force).
   jobworker:
     image: openspp-dev
     profiles:

spp

@@ -726,8 +726,8 @@ def cmd_resetdb(args):
     # Ensure db is running
     run(docker_compose("up", "-d", "db"))
 
-    # Stop Odoo but keep db
-    run(docker_compose("stop", "openspp", "openspp-dev"), check=False)
+    # Stop Odoo and job worker but keep db
+    run(docker_compose("stop", "openspp", "openspp-dev", "jobworker"), check=False)
 
     # Wait for db to be ready
     print("Waiting for database...")

spp_import_match/README.rst

@@ -46,15 +46,15 @@ Key Capabilities
 Key Models
 ~~~~~~~~~~
 
-+-----------------------------+----------------------------------------+
-| Model                       | Description                            |
-+=============================+========================================+
-| ``spp.import.match``        | Matching rule configuration for a      |
-|                             | specific model                         |
-+-----------------------------+----------------------------------------+
-| ``spp.import.match.fields`` | Individual field in a rule, with       |
-|                             | optional sub-field                     |
-+-----------------------------+----------------------------------------+
++-----------------------------+---------------------------------------+
+| Model                       | Description                           |
++=============================+=======================================+
+| ``spp.import.match``        | Matching rule configuration for a     |
+|                             | specific model                        |
++-----------------------------+---------------------------------------+
+| ``spp.import.match.fields`` | Individual field in a rule, with      |
+|                             | optional sub-field                    |
++-----------------------------+---------------------------------------+
 
 Configuration
 ~~~~~~~~~~~~~

spp_import_match/models/base.py

@@ -2,7 +2,8 @@
 import logging
 import threading
 
-from odoo import api, models
+from odoo import _, api, models
+from odoo.exceptions import UserError
 
 _logger = logging.getLogger(__name__)
 
@@ -19,11 +20,30 @@ def load(self, fields, data):
         if "import_match_ids" not in self.env.context:
             return super().load(fields, data)
 
+        import_match_ids = self.env.context.get("import_match_ids", [])
         usable, field_to_match = self.env["spp.import.match"]._usable_rules(
             self._name,
             fields,
-            option_config_ids=self.env.context.get("import_match_ids", []),
+            option_config_ids=import_match_ids,
         )
+
+        # Error if user selected match configs but their fields aren't in the file
+        if import_match_ids and not usable:
+            selected_configs = self.env["spp.import.match"].browse(import_match_ids)
+            config_names = selected_configs.mapped("name")
+            required_fields = set()
+            for config in selected_configs:
+                for field_line in config.field_ids:
+                    required_fields.add(field_line.field_id.field_description)
+            raise UserError(
+                _(
+                    "The selected import match configuration(s) %(configs)s require field(s) "
+                    "%(fields)s, but none of these fields are present in the imported file.",
+                    configs=", ".join(filter(None, config_names)),
+                    fields=", ".join(sorted(required_fields)),
+                )
+            )
+
         # If overwrite_match is explicitly set via UI (context), use that.
         # Otherwise fall back to config records' overwrite_match setting.
         if "overwrite_match" in self.env.context:

spp_import_match/models/base_import.py

@@ -66,10 +66,12 @@ def execute_import(self, fields, columns, options, dryrun=False):
         overwrite_match = options.get("overwrite_match", False)
         _import_match_local.counts = None
 
+        # Set import match context early so both sync and async paths have it
+        if import_match_ids:
+            self = self.with_context(import_match_ids=import_match_ids, overwrite_match=overwrite_match)
+
         if dryrun or len(input_file_data) <= 100:
             _logger.info("Doing %s import", "dry-run" if dryrun else "normal")
-            if import_match_ids:
-                self = self.with_context(import_match_ids=import_match_ids, overwrite_match=overwrite_match)
             result = super().execute_import(fields, columns, options, dryrun=dryrun)
             counts = getattr(_import_match_local, "counts", None)
             if counts:

spp_import_match/models/import_match.py

@@ -73,6 +73,10 @@ def _match_find(self, model, converted_row, imported_row):
                         break
                 if field.field_id.name in converted_row:
                     row_value = converted_row[field.field_id.name]
+                    # Skip matching on empty values to avoid false matches
+                    if not row_value:
+                        combination_valid = False
+                        break
                     field_value = field.field_id.name
                     add_to_domain = True
                     if field.sub_field_id:
@@ -86,8 +90,12 @@ def _match_find(self, model, converted_row, imported_row):
                         domain.append((field_value, "=", row_value))
             if not combination_valid:
                 continue
+            if not domain:
+                continue
             match = model.search(domain)
-            if len(match) >= 1:
+            if len(match) > 1:
+                raise ValidationError(_("Multiple records found for matching criteria: %s") % domain)
+            if len(match) == 1:
                 return match[0]
 
         return model

spp_import_match/static/description/index.html

@@ -395,8 +395,8 @@ <h1>Key Capabilities</h1>
 <h1>Key Models</h1>
 <table border="1" class="docutils">
 <colgroup>
-<col width="42%" />
-<col width="58%" />
+<col width="43%" />
+<col width="57%" />
 </colgroup>
 <thead valign="bottom">
 <tr><th class="head">Model</th>

spp_import_match/tests/test_import_match_model.py

@@ -86,17 +86,17 @@ def test_match_find_no_match(self):
         # Should return the model (empty recordset)
         self.assertFalse(result.id)
 
-    def test_match_find_multiple_matches_returns_first(self):
-        """Test _match_find returns first match when multiple found."""
-        partner1 = self.env["res.partner"].create({"name": "DuplicateMatchTest"})
+    def test_match_find_multiple_matches_raises(self):
+        """Test _match_find raises ValidationError when multiple matches found."""
+        self.env["res.partner"].create({"name": "DuplicateMatchTest"})
         self.env["res.partner"].create({"name": "DuplicateMatchTest"})
         match = self._create_match_rule([{"field_id": self.name_field.id}])
-        result = match._match_find(
-            self.env["res.partner"],
-            {"name": "DuplicateMatchTest"},
-            {"name": "DuplicateMatchTest", "id": None},
-        )
-        self.assertEqual(result, partner1)
+        with self.assertRaises(ValidationError):
+            match._match_find(
+                self.env["res.partner"],
+                {"name": "DuplicateMatchTest"},
+                {"name": "DuplicateMatchTest", "id": None},
+            )
 
     def test_match_find_conditional_skip(self):
         """Test _match_find skips rule when conditional value doesn't match."""