Fix/update mappings inside concept without concept changes (#819)

* fix(graphql): align search behavior with REST for HEAD versions

* Adopt a permissive base QuerySet for textual GraphQL searches to rely on Elasticsearch's version filtering logic.

* Apply the same Elasticsearch filters as REST (source_version=HEAD and is_latest_version=True).

* Use strict 'id = versioned_object_id' filtering only when listing without search terms.

* Remove SQL fallback logic to ensure consistent ES-only behavior across REST and GraphQL search flows.

* fix(concepts): allow mapping-only patches without duplicate checks

* Introduce skip_duplicate_version_check in SourceChildMixin and pass it for mappings-only payloads so concept PATCH requests that only modify mappings bypass duplicate-version prevention.

* Add an integration test covering mapping upsert and delete during concept PATCH, asserting expected versioning behavior and mapping counts.

* chore: revert graphql updates on this branch

Author: filiperochalopes

core/common/mixins.py

@@ -893,6 +893,7 @@ def save_as_new_version(self, user, **kwargs):  # pylint: disable=too-many-branc
         parent_concept_uris = kwargs.pop('parent_concept_uris', None)
         add_prev_version_children = kwargs.pop('add_prev_version_children', True)
         _hierarchy_processing = kwargs.pop('_hierarchy_processing', False)
+        skip_duplicate_version_check = kwargs.pop('skip_duplicate_version_check', False)
         errors = {}
         self.created_by = self.updated_by = user
         self.version = self.version or generate_temp_version()
@@ -919,7 +920,7 @@ def save_as_new_version(self, user, **kwargs):  # pylint: disable=too-many-branc
                             self.set_checksums()
                         if Toggle.get(
                                 'PREVENT_DUPLICATE_VERSION_TOGGLE'
-                        ) and not _hierarchy_processing:
+                        ) and not _hierarchy_processing and not skip_duplicate_version_check:
                             standard_checksum = prev_latest.checksums.get('standard')
                             if not standard_checksum:
                                 standard_checksum = prev_latest.get_checksums(recalculate=True).get('standard')

core/concepts/models.py

@@ -566,7 +566,8 @@ def create_new_version_for(
             create_parent_version=create_parent_version,
             parent_concept_uris=parent_concept_uris,
             add_prev_version_children=add_prev_version_children,
-            _hierarchy_processing=_hierarchy_processing
+            _hierarchy_processing=_hierarchy_processing,
+            skip_duplicate_version_check=bool(mappings_payload)
         )
 
         if errors or mappings_payload is None:

core/integration_tests/tests_concepts.py

@@ -631,6 +631,70 @@ def test_put_200_with_mappings_upsert_and_delete(self):
         )
         self.assertEqual(concept.get_unidirectional_mappings().filter(retired=False).count(), 2)
 
+    def test_patch_200_with_mappings_only_upsert_and_delete(self):
+        concept = ConceptFactory(
+            parent=self.source,
+            names=[ConceptNameFactory.build(locale='en', locale_preferred=True)]
+        )
+        concepts_url = f"/orgs/{self.organization.mnemonic}/sources/{self.source.mnemonic}/concepts/{concept.mnemonic}/"
+        update_target = ConceptFactory(parent=self.source)
+        update_target_new = ConceptFactory(parent=self.source)
+        delete_target = ConceptFactory(parent=self.source)
+        new_target = ConceptFactory(parent=self.source)
+
+        mapping_to_update = MappingFactory(
+            parent=self.source, from_concept=concept, to_concept=update_target, map_type='Same As'
+        ).versioned_object
+        mapping_to_delete = MappingFactory(
+            parent=self.source, from_concept=concept, to_concept=delete_target, map_type='BROADER-THAN'
+        ).versioned_object
+
+        initial_versions_count = concept.versions.count()
+
+        response = self.client.patch(
+            concepts_url,
+            {
+                'mappings': [
+                    {
+                        'id': mapping_to_update.mnemonic,
+                        'map_type': 'NARROWER-THAN',
+                        'update_comment': 'updated map type',
+                        'to_concept_url': update_target_new.url
+                    },
+                    {
+                        'to_concept_url': new_target.url,
+                        'map_type': 'Same As'
+                    },
+                    {
+                        'id': mapping_to_delete.mnemonic,
+                        'action': '__delete',
+                        'update_comment': 'Deleted from concept patch'
+                    }
+                ]
+            },
+            HTTP_AUTHORIZATION='Token ' + self.token,
+            format='json'
+        )
+
+        self.assertEqual(response.status_code, 200, response.data)
+        mapping_to_update.refresh_from_db()
+        mapping_to_delete.refresh_from_db()
+        concept.refresh_from_db()
+
+        self.assertEqual(mapping_to_update.map_type, 'NARROWER-THAN')
+        self.assertEqual(mapping_to_update.to_concept_id, update_target_new.id)
+        self.assertEqual(mapping_to_update.versions.count(), 2)
+        self.assertTrue(mapping_to_delete.retired)
+        self.assertEqual(concept.versions.count(), initial_versions_count + 1)
+        self.assertTrue(
+            concept.get_unidirectional_mappings().filter(
+                to_concept_id=new_target.id,
+                map_type='Same As',
+                retired=False
+            ).exists()
+        )
+        self.assertEqual(concept.get_unidirectional_mappings().filter(retired=False).count(), 2)
+
     def test_put_400_with_mappings_everything_or_nothing(self):
         concept = ConceptFactory(parent=self.source)
         concepts_url = f"/orgs/{self.organization.mnemonic}/sources/{self.source.mnemonic}/concepts/{concept.mnemonic}/"