Fix merge records to merge variant types publications and comments

Author: dglemos

gene2phenotype_project/gene2phenotype_app/fixtures/lgd_variant_type.json

@@ -46,5 +46,29 @@
             "unknown_inheritance": false,
             "is_deleted": 1
         }
+    },
+    {
+        "model": "gene2phenotype_app.lgdvarianttype",
+        "pk": 5,
+        "fields": {
+            "lgd": 11,
+            "variant_type_ot": 13,
+            "inherited": false,
+            "de_novo": false,
+            "unknown_inheritance": false,
+            "is_deleted": 0
+        }
+    },
+    {
+        "model": "gene2phenotype_app.lgdvarianttype",
+        "pk": 6,
+        "fields": {
+            "lgd": 10,
+            "variant_type_ot": 13,
+            "inherited": false,
+            "de_novo": false,
+            "unknown_inheritance": false,
+            "is_deleted": 0
+        }
     }
 ]

gene2phenotype_project/gene2phenotype_app/fixtures/lgd_variant_type_comment.json

@@ -22,5 +22,17 @@
             "user": 1,
             "date": "2025-05-03T11:38:52Z"
         }
+    },
+    {
+        "model": "gene2phenotype_app.lgdvarianttypecomment",
+        "pk": 3,
+        "fields": {
+            "lgd_variant_type": 6,
+            "comment": "Comment only on the source record's variant type",
+            "is_public": 0,
+            "is_deleted": 0,
+            "user": 1,
+            "date": "2025-06-01T09:00:00Z"
+        }
     }
 ]

gene2phenotype_project/gene2phenotype_app/fixtures/lgd_variant_type_publication.json

@@ -34,5 +34,23 @@
             "publication": 2,
             "is_deleted": 1
         }
+    },
+    {
+        "model": "gene2phenotype_app.lgdvarianttypepublication",
+        "pk": 5,
+        "fields": {
+            "lgd_variant_type": 5,
+            "publication": 2,
+            "is_deleted": 0
+        }
+    },
+    {
+        "model": "gene2phenotype_app.lgdvarianttypepublication",
+        "pk": 6,
+        "fields": {
+            "lgd_variant_type": 6,
+            "publication": 1,
+            "is_deleted": 0
+        }
     }
 ]

gene2phenotype_project/gene2phenotype_app/fixtures/locus_genotype_disease.json

@@ -151,5 +151,39 @@
             "is_reviewed": 1,
             "is_deleted": 0
         }
+    },
+    {
+        "model": "gene2phenotype_app.locusgenotypedisease",
+        "pk": 10,
+        "fields": {
+            "stable_id": 12,
+            "locus": 1,
+            "genotype": 9,
+            "disease": 6,
+            "mechanism": 1,
+            "mechanism_support": 17,
+            "confidence": 1,
+            "confidence_support": null,
+            "date_review": "2025-06-01T09:00:00Z",
+            "is_reviewed": 1,
+            "is_deleted": 0
+        }
+    },
+    {
+        "model": "gene2phenotype_app.locusgenotypedisease",
+        "pk": 11,
+        "fields": {
+            "stable_id": 13,
+            "locus": 1,
+            "genotype": 9,
+            "disease": 1,
+            "mechanism": 1,
+            "mechanism_support": 17,
+            "confidence": 1,
+            "confidence_support": null,
+            "date_review": "2025-06-01T09:00:00Z",
+            "is_reviewed": 1,
+            "is_deleted": 0
+        }
     }
 ]

gene2phenotype_project/gene2phenotype_app/tests/update_data/test_merge_records.py

@@ -9,6 +9,7 @@
     LocusGenotypeDisease,
     LGDVariantType,
     LGDVariantTypeComment,
+    LGDVariantTypePublication,
     LGDPublication,
     LGDMinedPublication,
 )
@@ -192,24 +193,32 @@ def test_merge_records(self):
         )
         # Check if all variant types were merged correctly
         # Note: a variant type is unique per (lgd, variant_type_ot), so the source
-        # record's "intron_variant" row is skipped during the merge since the
-        # target record already has one (with a different supporting publication)
+        # record's "intron_variant" row is not itself moved (the target already has
+        # one), but its supporting publication is merged onto the target's existing
+        # "intron_variant" row instead of being lost
         lgd_variant_type_list = LGDVariantType.objects.filter(lgd=lgd_obj.id)
         self.assertEqual(len(lgd_variant_type_list), 2)
         for variant_type in lgd_variant_type_list:
-            if (
-                variant_type.publications.filter(
-                    publication_id=1, is_deleted=0
-                ).exists()
-                and variant_type.variant_type_ot.term == "intron_variant"
-            ):
+            if variant_type.variant_type_ot.term == "intron_variant":
+                pub_ids = set(
+                    variant_type.publications.filter(is_deleted=0).values_list(
+                        "publication_id", flat=True
+                    )
+                )
+                self.assertEqual(pub_ids, {1, 2})
                 variant_type_comment_list = LGDVariantTypeComment.objects.filter(
                     lgd_variant_type=variant_type.id
                 )
                 self.assertEqual(
                     variant_type_comment_list[0].comment,
                     "Recurrent c.340C>T; other variant",
                 )
+
+        # Check the source record's duplicate "intron_variant" publication was
+        # reparented onto the target's row instead of being discarded
+        moved_pub = LGDVariantTypePublication.objects.get(pk=2)
+        self.assertEqual(moved_pub.lgd_variant_type_id, 3)
+        self.assertEqual(moved_pub.is_deleted, 0)
         # Count the number of curated publications
         lgd_publication_list = LGDPublication.objects.filter(lgd=lgd_obj.id)
         self.assertEqual(len(lgd_publication_list), 4)
@@ -284,3 +293,72 @@ def test_merge_records_different_genotype(self):
         # Check mined publications
         lgd_mined_publication_list = LGDMinedPublication.objects.filter(lgd=lgd_obj.id)
         self.assertEqual(len(lgd_mined_publication_list), 1)
+
+    def test_merge_records_variant_type_comment_migration(self):
+        """
+        Test that when a source record's variant type duplicates one already on
+        the target record, the source's LGDVariantTypeComment and
+        LGDVariantTypePublication are merged onto the target's existing row
+        instead of being discarded.
+        """
+        url_merge = reverse("merge_records")
+
+        records_to_merge = [
+            {"g2p_ids": ["G2P00012"], "final_g2p_id": "G2P00013"}
+        ]
+
+        # Login
+        user = User.objects.get(email="user5@test.ac.uk")
+        refresh = RefreshToken.for_user(user)
+        access_token = str(refresh.access_token)
+
+        # Authenticate by setting cookie on the test client
+        self.client.cookies[settings.SIMPLE_JWT["AUTH_COOKIE"]] = access_token
+
+        response = self.client.post(
+            url_merge, records_to_merge, content_type="application/json"
+        )
+        self.assertEqual(response.status_code, 200)
+
+        response_data = response.json()
+        self.assertEqual(
+            response_data["merged_records"], [["G2P00012 merged into G2P00013"]]
+        )
+
+        stable_id_obj = G2PStableID.objects.get(stable_id="G2P00013")
+        lgd_obj = LocusGenotypeDisease.objects.get(
+            stable_id=stable_id_obj.id, is_deleted=0
+        )
+
+        # Only one "missense_variant" row should survive on the target - the
+        # source's duplicate row is not moved, it is soft-deleted
+        lgd_variant_type_list = LGDVariantType.objects.filter(
+            lgd=lgd_obj.id, is_deleted=0
+        )
+        self.assertEqual(len(lgd_variant_type_list), 1)
+        surviving_variant_type = lgd_variant_type_list[0]
+        self.assertEqual(surviving_variant_type.variant_type_ot.term, "missense_variant")
+
+        # The target's own publication and the source's publication should both
+        # end up attached to the surviving row
+        pub_ids = set(
+            surviving_variant_type.publications.filter(is_deleted=0).values_list(
+                "publication_id", flat=True
+            )
+        )
+        self.assertEqual(pub_ids, {1, 2})
+
+        # The comment that only existed on the source's duplicate row should now
+        # be attached to the target's surviving row, not deleted
+        variant_type_comment_list = LGDVariantTypeComment.objects.filter(
+            lgd_variant_type=surviving_variant_type.id, is_deleted=0
+        )
+        self.assertEqual(len(variant_type_comment_list), 1)
+        self.assertEqual(
+            variant_type_comment_list[0].comment,
+            "Comment only on the source record's variant type",
+        )
+
+        # The source's duplicate variant type row itself was soft-deleted
+        source_variant_type = LGDVariantType.objects.get(pk=6)
+        self.assertEqual(source_variant_type.is_deleted, 1)

gene2phenotype_project/gene2phenotype_app/views/locus_genotype_disease.py

@@ -1918,7 +1918,7 @@ def MergeRecords(request):
                                         LGDVariantTypeDescription, lgd_obj, lgd_obj_keep
                                     )
                                     move_related_objects(
-                                        LGDComment, lgd_obj, lgd_obj_keep
+                                        LGDComment, lgd_obj, lgd_obj_keep, ["comment"]
                                     )
                                     move_related_objects(
                                         LGDMolecularMechanismSynopsis,
@@ -1937,12 +1937,8 @@ def MergeRecords(request):
                                         lgd_obj_keep,
                                         ["ccm"],
                                     )
-                                    move_related_objects(
-                                        LGDVariantType,
-                                        lgd_obj,
-                                        lgd_obj_keep,
-                                        ["variant_type_ot"],
-                                    )
+                                    # Merge the variant types and their related objects (comments, publications)
+                                    merge_lgd_variant_types(lgd_obj, lgd_obj_keep)
                                     move_related_objects(
                                         LGDMolecularMechanismEvidence,
                                         lgd_obj,
@@ -2138,6 +2134,61 @@ def delete_lgd_record(lgd_obj: Model) -> None:
     lgd_obj.save()
 
 
+@extend_schema(exclude=True)
+def merge_lgd_variant_types(lgd_obj: Model, lgd_obj_keep: Model) -> None:
+    """
+    Method to reassign LGDVariantType objects and their linked publications (LGDVariantTypePublication)
+    and comments (LGDVariantTypeComment) from a source LGD record to a target LGD record.
+
+    A variant type is unique per lgd+variant_type. When the source record has
+    a variant type that already exists on the target record, the source row itself
+    is left for delete_lgd_record() to soft-delete, but its LGDVariantTypePublication
+    and LGDVariantTypeComment children are reassigned onto the target's existing row
+    for that variant type.
+
+    Args:
+        lgd_obj (Model): The source LocusGenotypeDisease object (to merge from)
+        lgd_obj_keep (Model): The target LocusGenotypeDisease object (to merge into)
+    """
+    variant_types: QuerySet = LGDVariantType.objects.filter(lgd=lgd_obj, is_deleted=0)
+
+    for variant_type_obj in variant_types:
+        if variant_type_obj.lgd_id == lgd_obj_keep.id:
+            continue
+
+        target_variant_type = LGDVariantType.objects.filter(
+            lgd=lgd_obj_keep,
+            variant_type_ot=variant_type_obj.variant_type_ot,
+            is_deleted=0,
+        ).first()
+
+        if target_variant_type is None:
+            # If variant type not linked to the target record, move the row as-is.
+            # Its children move implicitly since they reference this row by id, not by lgd.
+            variant_type_obj.lgd = lgd_obj_keep
+            variant_type_obj.save()
+            continue
+
+        # If variant type already linked to the target record, don't move variant_type_obj itself,
+        # instead move its supporting publications/comments onto the target's existing row.
+        for pub in LGDVariantTypePublication.objects.filter(
+            lgd_variant_type=variant_type_obj, is_deleted=0
+        ):
+            if not LGDVariantTypePublication.objects.filter(
+                lgd_variant_type=target_variant_type,
+                publication=pub.publication,
+                is_deleted=0,
+            ).exists():
+                pub.lgd_variant_type = target_variant_type
+                pub.save()
+
+        for comment in LGDVariantTypeComment.objects.filter(
+            lgd_variant_type=variant_type_obj, is_deleted=0
+        ):
+            comment.lgd_variant_type = target_variant_type
+            comment.save()
+
+
 @extend_schema(exclude=True)
 def move_related_objects(
     model_class: Type[Model],