fix(spp_import_match): validation, default import behavior, and job worker

- Add @api.constrains for duplicate field and name validation on save
- Multiple matches now return first match instead of raising error
- Skip import matching when no config selected (use default Odoo import)
- Add jobworker service to docker-compose for async import processing
- Update tests to reflect new behavior

Author: emjay0921

docker-compose.yml

@@ -168,6 +168,44 @@ services:
     networks:
       - openspp
 
+  # Job Worker - background service for processing async queue jobs
+  # Runs alongside openspp/openspp-dev to execute delayed imports, etc.
+  jobworker:
+    image: openspp-dev
+    profiles:
+      - dev
+      - ui
+    depends_on:
+      db:
+        condition: service_healthy
+    environment:
+      DB_HOST: db
+      DB_PORT: "5432"
+      DB_USER: odoo
+      DB_PASSWORD: odoo
+      DB_NAME: ${ODOO_DB_NAME:-openspp}
+      DB_FILTER: "^${ODOO_DB_NAME:-openspp}$$"
+      LIST_DB: "False"
+      ODOO_ADMIN_PASSWD: admin
+      ODOO_WORKERS: "0"
+      ODOO_CRON_THREADS: "0"
+      LOG_LEVEL: info
+      PROXY_MODE: "False"
+      QUEUE_JOB_CONCURRENCY: "2"
+    volumes:
+      - .:/mnt/extra-addons/openspp:ro,z
+      - odoo_data:/var/lib/odoo
+    entrypoint: ["/entrypoint.sh"]
+    command:
+      [
+        "python",
+        "/mnt/extra-addons/odoo-job-worker/job_worker_runner.py",
+        "-c",
+        "/etc/odoo/odoo.conf",
+      ]
+    networks:
+      - openspp
+
   # Unit Test Runner - one-off container for running module tests
   # Usage: docker compose run --rm test <module_name> [options]
   # Note: Uses same image as odoo/odoo-dev - build any of them to update

spp_import_match/models/base.py

@@ -15,6 +15,10 @@ class Base(models.AbstractModel):
 
     @api.model
     def load(self, fields, data):
+        # Only apply import matching when explicitly selected via UI context
+        if "import_match_ids" not in self.env.context:
+            return super().load(fields, data)
+
         usable, field_to_match = self.env["spp.import.match"]._usable_rules(
             self._name,
             fields,

spp_import_match/models/import_match.py

@@ -39,6 +39,26 @@ def _onchange_model_id(self):
         for rec in self:
             rec.field_ids = None
 
+    @api.constrains("name")
+    def _check_duplicate_name(self):
+        """Prevent duplicate match rule names."""
+        for rec in self:
+            if rec.name and self.search_count([("name", "=", rec.name), ("id", "!=", rec.id)]):
+                raise ValidationError(_("A match rule with the name '%s' already exists!") % rec.name)
+
+    @api.constrains("field_ids")
+    def _check_duplicate_fields(self):
+        """Prevent duplicate non-relational fields in the same match rule."""
+        for rec in self:
+            seen = []
+            for field_line in rec.field_ids:
+                if field_line.field_id.ttype in ("many2many", "one2many", "many2one"):
+                    continue
+                key = field_line.field_id.id
+                if key in seen:
+                    raise ValidationError(_("Field '%s', already exists!") % field_line.field_id.field_description)
+                seen.append(key)
+
     @api.model
     def _match_find(self, model, converted_row, imported_row):
         usable, field_to_match = self._usable_rules(model._name, converted_row)
@@ -67,10 +87,8 @@ def _match_find(self, model, converted_row, imported_row):
             if not combination_valid:
                 continue
             match = model.search(domain)
-            if len(match) == 1:
-                return match
-            elif len(match) > 1:
-                raise ValidationError(_("Multiple matches found for '%s'!") % match[0].name)
+            if len(match) >= 1:
+                return match[0]
 
         return model
 

spp_import_match/tests/test_base_load.py

@@ -33,11 +33,25 @@ def _create_match_rule(self, field_ids_data, overwrite=True):
             self.env["spp.import.match.fields"].create(data)
         return match
 
-    def test_load_no_usable_rules(self):
-        """When no usable rules exist, load() passes through to super()."""
+    def test_load_no_context_passes_through(self):
+        """When import_match_ids not in context, load() passes through to default Odoo import."""
         result = self.env["res.partner"].load(
             ["name", "email"],
-            [["NoRuleTest99xyz", "norule@test.com"]],
+            [["NoCtxTest99xyz", "noctx@test.com"]],
+        )
+        self.assertFalse(result["messages"])
+        partner = self.env["res.partner"].search([("name", "=", "NoCtxTest99xyz")])
+        self.assertEqual(len(partner), 1)
+
+    def test_load_no_usable_rules(self):
+        """When import_match_ids in context but no usable rules, load() passes through."""
+        result = (
+            self.env["res.partner"]
+            .with_context(import_match_ids=[])
+            .load(
+                ["name", "email"],
+                [["NoRuleTest99xyz", "norule@test.com"]],
+            )
         )
         self.assertFalse(result["messages"])
         partner = self.env["res.partner"].search([("name", "=", "NoRuleTest99xyz")])
@@ -46,10 +60,14 @@ def test_load_no_usable_rules(self):
     def test_load_match_overwrite_true(self):
         """Match found + overwrite=True -> record updated."""
         partner = self.env["res.partner"].create({"name": "OverwriteTrue99xyz", "email": "old@test.com"})
-        self._create_match_rule([{"field_id": self.name_field.id}], overwrite=True)
-        result = self.env["res.partner"].load(
-            ["name", "email"],
-            [["OverwriteTrue99xyz", "new@test.com"]],
+        match = self._create_match_rule([{"field_id": self.name_field.id}], overwrite=True)
+        result = (
+            self.env["res.partner"]
+            .with_context(import_match_ids=[match.id])
+            .load(
+                ["name", "email"],
+                [["OverwriteTrue99xyz", "new@test.com"]],
+            )
         )
         self.assertFalse(result["messages"])
         partner.invalidate_recordset()
@@ -58,20 +76,28 @@ def test_load_match_overwrite_true(self):
     def test_load_match_overwrite_false(self):
         """Match found + overwrite=False -> record skipped."""
         partner = self.env["res.partner"].create({"name": "OverwriteFalse99xyz", "email": "original@test.com"})
-        self._create_match_rule([{"field_id": self.name_field.id}], overwrite=False)
-        self.env["res.partner"].load(
-            ["name", "email"],
-            [["OverwriteFalse99xyz", "changed@test.com"]],
+        match = self._create_match_rule([{"field_id": self.name_field.id}], overwrite=False)
+        (
+            self.env["res.partner"]
+            .with_context(import_match_ids=[match.id])
+            .load(
+                ["name", "email"],
+                [["OverwriteFalse99xyz", "changed@test.com"]],
+            )
         )
         partner.invalidate_recordset()
         self.assertEqual(partner.email, "original@test.com")
 
     def test_load_no_match_creates_record(self):
         """No match found -> new record created."""
-        self._create_match_rule([{"field_id": self.name_field.id}])
-        result = self.env["res.partner"].load(
-            ["name", "email"],
-            [["BrandNewPartner99xyz", "brandnew@test.com"]],
+        match = self._create_match_rule([{"field_id": self.name_field.id}])
+        result = (
+            self.env["res.partner"]
+            .with_context(import_match_ids=[match.id])
+            .load(
+                ["name", "email"],
+                [["BrandNewPartner99xyz", "brandnew@test.com"]],
+            )
         )
         self.assertFalse(result["messages"])
         partner = self.env["res.partner"].search([("name", "=", "BrandNewPartner99xyz")])
@@ -81,13 +107,17 @@ def test_load_no_match_creates_record(self):
     def test_load_multiple_records_mixed(self):
         """Mix of matched and new records in one import."""
         self.env["res.partner"].create({"name": "ExistingMixed99xyz", "email": "existing@test.com"})
-        self._create_match_rule([{"field_id": self.name_field.id}], overwrite=True)
-        result = self.env["res.partner"].load(
-            ["name", "email"],
-            [
-                ["ExistingMixed99xyz", "updated@test.com"],
-                ["NewMixed99xyz", "newmixed@test.com"],
-            ],
+        match = self._create_match_rule([{"field_id": self.name_field.id}], overwrite=True)
+        result = (
+            self.env["res.partner"]
+            .with_context(import_match_ids=[match.id])
+            .load(
+                ["name", "email"],
+                [
+                    ["ExistingMixed99xyz", "updated@test.com"],
+                    ["NewMixed99xyz", "newmixed@test.com"],
+                ],
+            )
         )
         self.assertFalse(result["messages"])
         existing = self.env["res.partner"].search([("name", "=", "ExistingMixed99xyz")])
@@ -117,11 +147,15 @@ def test_load_with_import_match_ids_context(self):
 
     def test_load_appends_id_field(self):
         """Auto-appends 'id' when not in fields list."""
-        self._create_match_rule([{"field_id": self.name_field.id}])
+        match = self._create_match_rule([{"field_id": self.name_field.id}])
         fields = ["name", "email"]
-        self.env["res.partner"].load(
-            fields,
-            [["AppendIdTest99xyz", "appendid@test.com"]],
+        (
+            self.env["res.partner"]
+            .with_context(import_match_ids=[match.id])
+            .load(
+                fields,
+                [["AppendIdTest99xyz", "appendid@test.com"]],
+            )
         )
         self.assertIn("id", fields)
 

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_raises(self):
-        """Test _match_find raises ValidationError on multiple matches."""
-        self.env["res.partner"].create({"name": "DuplicateMatchTest"})
+    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"})
         self.env["res.partner"].create({"name": "DuplicateMatchTest"})
         match = self._create_match_rule([{"field_id": self.name_field.id}])
-        with self.assertRaises(ValidationError):
-            match._match_find(
-                self.env["res.partner"],
-                {"name": "DuplicateMatchTest"},
-                {"name": "DuplicateMatchTest", "id": None},
-            )
+        result = match._match_find(
+            self.env["res.partner"],
+            {"name": "DuplicateMatchTest"},
+            {"name": "DuplicateMatchTest", "id": None},
+        )
+        self.assertEqual(result, partner1)
 
     def test_match_find_conditional_skip(self):
         """Test _match_find skips rule when conditional value doesn't match."""
@@ -211,6 +211,36 @@ def test_match_find_sub_field(self):
         )
         self.assertEqual(result, parent)
 
+    def test_constrains_duplicate_name(self):
+        """_check_duplicate_name raises on duplicate rule names."""
+        self.env["spp.import.match"].create({"name": "DuplicateNameTest", "model_id": self.res_partner_model.id})
+        with self.assertRaises(ValidationError):
+            self.env["spp.import.match"].create({"name": "DuplicateNameTest", "model_id": self.res_partner_model.id})
+
+    def test_constrains_duplicate_non_relational_field(self):
+        """_check_duplicate_fields raises on duplicate non-relational fields on save."""
+        with self.assertRaises(ValidationError):
+            self._create_match_rule(
+                [
+                    {"field_id": self.name_field.id},
+                    {"field_id": self.name_field.id},
+                ]
+            )
+
+    def test_constrains_allows_duplicate_relational_field(self):
+        """_check_duplicate_fields allows duplicate relational fields."""
+        parent_id_field = self.env["ir.model.fields"].search(
+            [("name", "=", "parent_id"), ("model_id", "=", self.res_partner_model.id)],
+            limit=1,
+        )
+        match = self._create_match_rule(
+            [
+                {"field_id": parent_id_field.id},
+                {"field_id": parent_id_field.id},
+            ]
+        )
+        self.assertEqual(len(match.field_ids), 2)
+
     def test_match_find_multiple_combinations(self):
         """_match_find iterates rules; first matching single result wins."""
         partner = self.env["res.partner"].create({"name": "MultiCombo99xyz", "email": "multicombo@test.com"})

spp_import_match/tests/test_res_partner_import_match.py

@@ -110,21 +110,23 @@ def create_matching_name(self):
 
     def test_01_res_partner_change_email_by_name(self):
         """Change email based on given_name, family_name."""
-        self.create_matching_given_family_name()
+        import_match = self.create_matching_given_family_name()
         file_path = self.get_file_path_2()
         record = self._base_import_record("res.partner", file_path)
-        record.execute_import(["given_name", "family_name", "name", "email"], [], OPTIONS)
+        options = dict(OPTIONS, import_match_ids=[import_match.id], overwrite_match=True)
+        record.execute_import(["given_name", "family_name", "name", "email"], [], options)
 
         self._test_applicant.env.cache.invalidate()
         self.assertEqual(self._test_applicant.email, "rufinorenaud@gmail.com")
 
     def test_02_res_partner_change_email_by_group_name(self):
         """Change email based on name."""
-        self.create_matching_name()
+        import_match = self.create_matching_name()
         file_path = self.get_file_path_1()
         record = self._base_import_record("res.partner", file_path)
 
-        record.execute_import(["name", "email"], ["name", "email"], OPTIONS)
+        options = dict(OPTIONS, import_match_ids=[import_match.id], overwrite_match=True)
+        record.execute_import(["name", "email"], ["name", "email"], options)
         self._test_hh.env.cache.invalidate()
         self.assertEqual(self._test_hh.email, "renaudhh@gmail.com")