delete relations that were deleted from a resource-instance dt tile

arches/app/datatypes/datatypes.py

@@ -2094,14 +2094,28 @@ def pre_tile_save(self, tile, nodeid):
 
     def post_tile_save(self, tile, nodeid, request):
         ret = False
-        sql = """
+        create_sql = """
             SELECT * FROM __arches_create_resource_x_resource_relationships('%s') as t;
         """ % (
             tile.pk
         )
+        if tile.data[nodeid] and len(tile.data[nodeid]) > 0:
+            delete_sql = """
+                DELETE FROM resource_x_resource WHERE tileid = '%s' AND resourcexid NOT IN (%s);
+                """ % (
+                tile.pk,
+                ",".join(
+                    [
+                        "'%s'" % relationship["resourceXresourceId"]
+                        for relationship in tile.data[nodeid]
+                    ]
+                ),
+            )
 
         with connection.cursor() as cursor:
-            cursor.execute(sql)
+            if tile.data[nodeid] and len(tile.data[nodeid]) > 0:
+                cursor.execute(delete_sql)
+            cursor.execute(create_sql)
             ret = cursor.fetchone()
         return ret
 

tests/models/resource_test.py

@@ -488,3 +488,88 @@ def test_self_referring_resource_instance_descriptor(self):
 
         # Until 7.4, a RecursionError was caught after this value was repeated many times.
         self.assertEqual(r.displayname(), "test value ")
+
+    def test_resource_instance_tile_update(self):
+        user = User.objects.get(username="admin")
+        graph_a = Graph.new(name="Graph A", is_resource=True)
+        node_group_a = models.NodeGroup()
+        node_group_a.save()
+        resource_instance_node = models.Node(
+            graph=graph_a,
+            nodegroup=node_group_a,
+            name="Resource Node",
+            datatype="resource-instance-list",
+            istopnode=False,
+        )
+        resource_instance_node.save()
+        graph_a.add_node(resource_instance_node)
+        graph_a.add_edge(
+            {
+                "domainnode_id": graph_a.root.pk,
+                "rangenode_id": resource_instance_node.pk,
+                "ontologyproperty": None,
+            }
+        )
+        graph_a.save()
+        graph_a.refresh_from_database()
+        graph_a.publish(user=user)
+        graph_b = Graph.new(name="Graph B", is_resource=True)
+        node_group_b = models.NodeGroup()
+        node_group_b.save()
+        string_node = models.Node(
+            graph=graph_b,
+            nodegroup=node_group_b,
+            name="String Node",
+            datatype="non-localized-string",
+            istopnode=False,
+        )
+        string_node.save()
+        graph_b.add_node(string_node)
+        graph_b.add_edge(
+            {
+                "domainnode_id": graph_b.root.pk,
+                "rangenode_id": string_node.pk,
+                "ontologyproperty": None,
+            }
+        )
+        graph_b.save()
+        graph_b.refresh_from_database()
+        graph_b.publish(user=user)
+
+        resource_b_1 = models.ResourceInstance.objects.create(graph=graph_b)
+        tile_b_1 = Tile.get_blank_tile(
+            str(string_node.pk), resourceid=str(resource_b_1.pk)
+        )
+        tile_b_1.data[str(string_node.pk)] = "Test Value"
+        tile_b_1.save()
+
+        resource_b_2 = models.ResourceInstance.objects.create(graph=graph_b)
+        tile_b_2 = Tile.get_blank_tile(
+            str(string_node.pk), resourceid=str(resource_b_2.pk)
+        )
+        tile_b_2.data[str(string_node.pk)] = "Test Value"
+        tile_b_2.save()
+
+        resource_a = models.ResourceInstance.objects.create(graph=graph_a)
+        tile_a = Tile.get_blank_tile(str(resource_a.pk), resourceid=str(resource_a.pk))
+        tile_a.data[str(resource_instance_node.pk)] = [
+            {
+                "resourceId": str(resource_b_1.pk),
+                "ontologyProperty": "",
+                "inverseOntologyProperty": "",
+            },
+            {
+                "resourceId": str(resource_b_2.pk),
+                "ontologyProperty": "",
+                "inverseOntologyProperty": "",
+            },
+        ]
+        tile_a.save()
+        relations = models.ResourceXResource.objects.filter(tileid=tile_a.pk)
+        original_count = relations.count()
+        self.assertEqual(original_count, 2)
+        tile_a.data[str(resource_instance_node.pk)].pop()
+        tile_a.save()
+        relations_revised = models.ResourceXResource.objects.filter(tileid=tile_a.pk)
+        revised_count = relations_revised.count()
+        self.assertEqual(revised_count, 1)