get_geo_items for operations and tests

3 files changed, 258 insertions, 133 deletions

diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 38a125b9f..c16482d36 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -2503,25 +2503,74 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(base_find.point_source, "P")
 
     def test_get_geo_items(self):
+        wgs84 = SpatialReferenceSystem.objects.get(srid=4326)
         profile = get_current_profile()
         profile.mapping = True
         profile.save()
-
-        find = self.finds[0]
-        base_find_pt = find.base_finds.all()[0]
-        srs, __ = SpatialReferenceSystem.objects.get_or_create(
-            txt_idx="wgs84",
-            defaults={"srid": 4326, "label": "WGS84", "auth_name": "EPSG"},
+        base_find = models.BaseFind.objects.all()[0]
+        context_record = ContextRecord.objects.get(pk=base_find.context_record.pk)
+        operation = self.create_operation()[0]
+        ope = self.create_operation()[1]
+        limit = (
+            "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),"
+            "((6 3,9 2,9 4,6 3)))"
         )
-
-        base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk)
+        geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326)
+        geom_2d = GEOSGeometry("POINT({} {})".format(2, 43), srid=4326)
+        xy = 2, 43
+
+        def create_cr_with_bfs(operat, geom_cr, list_geom_bf, label_cr):
+            default = {
+                "label": label_cr,
+                "history_modifier": context_record.history_modifier,
+                "operation": operat,
+            }
+            cr = ContextRecord.objects.create(**default)
+            if geom_cr == "Point":
+                cr.point = geom
+                cr.multi_polygon = None
+                cr.multi_polygon_source = None
+                cr.multi_polygon_source_item = None
+                cr.x, cr.y = xy
+                cr.point_2d = geom_2d
+                cr.spatial_reference_system = wgs84
+            else:
+                cr.multi_polygon = "SRID=4326;" + limit
+                cr.multi_polygon_source = "P"
+                cr.multi_polygon_source_item = str(ContextRecord._meta.verbose_name)
+            cr.save()
+            cr = ContextRecord.objects.get(pk=cr.pk)
+
+            bfs = []
+            for i in range(len(list_geom_bf)):
+                default = {
+                    "label": "Find " + str(i + 1) + " from " + label_cr,
+                    "history_modifier": base_find.history_modifier,
+                    "context_record": cr,
+                }
+                bf = models.BaseFind.objects.create(**default)
+                if list_geom_bf[i] == "Point":
+                    bf.point = geom
+                    bf.multi_polygon = None
+                    bf.multi_polygon_source = None
+                    bf.multi_polygon_source_item = None
+                    bf.x, bf.y = xy
+                    bf.point_2d = geom_2d
+                    bf.spatial_reference_system = wgs84
+                else:
+                    bf.multi_polygon = "SRID=4326;" + limit
+                    bf.point_source = None
+                    bf.point_2d = None
+                    bf.point = None
+                bf.save()
+                bf = models.BaseFind.objects.get(pk=bf.pk)
+                bfs.append(bf)
+            return cr, bfs
 
         # with point
-        geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326)
-        base_find_pt.point = geom
-        base_find_pt.multi_polygon = None
-        base_find_pt.save()
-        base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk)
+        cr_pt_pt, bfs = create_cr_with_bfs(operation, "Point", ["Point"], "CR Pt Pt")
+        base_find_pt = bfs[0]
+
         dic_pt_t = {
             "type": "Feature",
             "geometry": {"type": "MultiPolygon", "coordinates": []},
@@ -2536,30 +2585,27 @@ class GeomaticTest(FindInit, TestCase):
         # test API with point
         response = self.client.get(reverse("api-get-geo-point", kwargs={"pk": 0}))
         self.assertEqual(response.status_code, 404)
-        response = self.client.get(reverse("api-get-geo-point", kwargs={"pk": base_find_pt.pk}))
+        response = self.client.get(
+            reverse("api-get-geo-point", kwargs={"pk": base_find_pt.pk})
+        )
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_pt_f).encode("utf-8"), response.content)
 
         # test context record with point as base find
-        cr_pt_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk)
-        pk = cr_pt_pt.pk
-        cr_pt_pt.point = geom
-        cr_pt_pt.multi_polygon = None
-        cr_pt_pt.multi_polygon_source = None
-        cr_pt_pt.multi_polygon_source_item = None
-        cr_pt_pt.save()
-        cr_pt_pt = ContextRecord.objects.get(pk=pk)
-
         dic_pt_f_copy = copy.deepcopy(dic_pt_f)
         dic_pt_pt_f = copy.deepcopy(dic_pt_f)
-        dic_pt_pt_f["properties"] = {"associated base finds": {"Find 1": dic_pt_f_copy}}
+        dic_pt_pt_f["properties"] = {
+            "associated base finds": {"Find 1 from CR Pt Pt": dic_pt_f_copy}
+        }
         self.assertEqual(dic_pt_pt_f, cr_pt_pt.get_geo_items(False))
 
         dic_pt_t_copy = copy.deepcopy(dic_pt_t)
         dic_pt_pt_t = {
             "type": "Feature",
             "geometry": {"type": "MultiPolygon", "coordinates": []},
-            "properties": {"associated base finds": {"Find 1": dic_pt_t_copy}},
+            "properties": {
+                "associated base finds": {"Find 1 from CR Pt Pt": dic_pt_t_copy}
+            },
         }
         self.assertEqual(dic_pt_pt_t, cr_pt_pt.get_geo_items(True))
 
@@ -2570,7 +2616,8 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_pt_pt.pk}
+                "api-get-geo-points-from-context",
+                kwargs={"context_record_pk": cr_pt_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
@@ -2584,17 +2631,18 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_pt_pt.pk}
+                "api-get-geo-polygons-from-context",
+                kwargs={"context_record_pk": cr_pt_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_pt_pt_t).encode("utf-8"), response.content)
 
         # the context record is a multi-polygon
-        limit = (
-            "MULTIPOLYGON(((1 1,5 1,5 5,1 5,1 1),(2 2,2 3,3 3,3 2,2 2)),"
-            "((6 3,9 2,9 4,6 3)))"
+        cr_poly_pt, bfs = create_cr_with_bfs(
+            operation, "Polygon", ["Point"], "CR Poly Pt"
         )
+        base_find_pt = bfs[0]
         dic_poly_t = {
             "type": "Feature",
             "geometry": {
@@ -2609,16 +2657,10 @@ class GeomaticTest(FindInit, TestCase):
             },
         }
 
-        cr_poly_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk)
-        pk = cr_poly_pt.pk
-        cr_poly_pt.multi_polygon = "SRID=4326;" + limit
-        cr_poly_pt.multi_polygon_source = "P"
-        cr_poly_pt.multi_polygon_source_item = str(ContextRecord._meta.verbose_name)
-        cr_poly_pt.save()
-        cr_poly_pt = ContextRecord.objects.get(pk=pk)
-
         dic_poly_pt_t = copy.deepcopy(dic_poly_t)
-        dic_poly_pt_t["properties"] = {"associated base finds": {"Find 1": dic_pt_t}}
+        dic_poly_pt_t["properties"] = {
+            "associated base finds": {"Find 1 from CR Poly Pt": dic_pt_t}
+        }
         self.assertEqual(dic_poly_pt_t, cr_poly_pt.get_geo_items(True))
 
         dic_poly_f = {
@@ -2628,7 +2670,7 @@ class GeomaticTest(FindInit, TestCase):
         dic_pt_f_copy = copy.deepcopy(dic_pt_f)
         dic_poly_pt_f = copy.deepcopy(dic_poly_f)
         dic_poly_pt_f["properties"] = {
-            "associated base finds": {"Find 1": dic_pt_f_copy}
+            "associated base finds": {"Find 1 from CR Poly Pt": dic_pt_f_copy}
         }
         self.assertEqual(dic_poly_pt_f, cr_poly_pt.get_geo_items(False))
 
@@ -2639,13 +2681,12 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_poly_pt.pk}
+                "api-get-geo-points-from-context",
+                kwargs={"context_record_pk": cr_poly_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(
-            json.dumps(dic_poly_pt_f).encode("utf-8"), response.content
-        )
+        self.assertIn(json.dumps(dic_poly_pt_f).encode("utf-8"), response.content)
 
         response = self.client.get(
             reverse(
@@ -2655,25 +2696,18 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_poly_pt.pk}
+                "api-get-geo-polygons-from-context",
+                kwargs={"context_record_pk": cr_poly_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_poly_pt_t).encode("utf-8"), response.content)
 
         # we add a base find which is a multi-polygon
-        default = {
-            "label": "Find 2",
-            "history_modifier": base_find_pt.history_modifier,
-            "context_record": base_find_pt.context_record,
-        }
-        base_find_poly = models.BaseFind.objects.create(**default)
-        base_find_poly.multi_polygon = "SRID=4326;" + limit
-        base_find_poly.point_source = None
-        base_find_poly.point_2d = None
-        base_find_poly.point = None
-        base_find_poly.save()
-        base_find_poly = models.BaseFind.objects.get(pk=base_find_poly.pk)
+        cr_poly_poly_and_pt, bfs = create_cr_with_bfs(
+            ope, "Polygon", ["Polygon", "Point"], "CR Poly Poly Pt"
+        )
+        base_find_poly, base_find_pt = bfs
 
         res_poly = base_find_poly.get_geo_items(get_polygons=True)
         self.assertEqual(dic_poly_t, res_poly)
@@ -2702,44 +2736,32 @@ class GeomaticTest(FindInit, TestCase):
 
         # context record is a polygon
         # (and one base find is a point and the other is a polygon)
-        self.assertEqual(base_find_pt.context_record.pk, base_find_poly.context_record.pk)
-        cr_poly_poly_and_pt = ContextRecord.objects.get(pk=base_find_pt.context_record.pk)
-        pk = cr_poly_poly_and_pt.pk
-        cr_poly_poly_and_pt.multi_polygon = "SRID=4326;" + limit
-        cr_poly_poly_and_pt.multi_polygon_source = "P"
-        cr_poly_poly_and_pt.multi_polygon_source_item = str(ContextRecord._meta.verbose_name)
-        cr_poly_poly_and_pt.save()
-        cr_poly_poly_and_pt = ContextRecord.objects.get(pk=pk)
-
+        self.assertEqual(
+            base_find_pt.context_record.pk, base_find_poly.context_record.pk
+        )
         dic_poly_t_copy = copy.deepcopy(dic_poly_t)
         dic_poly_poly_and_pt_t = copy.deepcopy(dic_poly_t)
         dic_poly_poly_and_pt_t["properties"] = {
             "associated base finds": {
-                "Find 1": dic_pt_t_copy,
-                "Find 2": dic_poly_t_copy,
+                "Find 1 from CR Poly Poly Pt": dic_poly_t_copy,
+                "Find 2 from CR Poly Poly Pt": dic_pt_t_copy,
             }
         }
-        dic_poly_poly_and_pt_t_2 = copy.deepcopy(dic_poly_poly_and_pt_t)
-        dic_poly_poly_and_pt_t_2['properties']['associated base finds'] = {
-            "Find 2": dic_poly_t_copy,
-            "Find 1": dic_pt_t_copy,
-        }
-        self.assertEqual(dic_poly_poly_and_pt_t, cr_poly_poly_and_pt.get_geo_items(True))
+        self.assertEqual(
+            dic_poly_poly_and_pt_t, cr_poly_poly_and_pt.get_geo_items(True)
+        )
 
         dic_poly_f_copy = copy.deepcopy(dic_poly_f)
         dic_poly_poly_and_pt_f = copy.deepcopy(dic_poly_f)
         dic_poly_poly_and_pt_f["properties"] = {
             "associated base finds": {
-                "Find 1": dic_pt_f_copy,
-                "Find 2": dic_poly_f_copy,
+                "Find 1 from CR Poly Poly Pt": dic_poly_f_copy,
+                "Find 2 from CR Poly Poly Pt": dic_pt_f_copy,
             }
         }
-        dic_poly_poly_and_pt_f_2 = copy.deepcopy(dic_poly_poly_and_pt_f)
-        dic_poly_poly_and_pt_f_2['properties']['associated base finds'] = {
-            "Find 2": dic_poly_f_copy,
-            "Find 1": dic_pt_f_copy,
-        }
-        self.assertEqual(dic_poly_poly_and_pt_f, cr_poly_poly_and_pt.get_geo_items(False))
+        self.assertEqual(
+            dic_poly_poly_and_pt_f, cr_poly_poly_and_pt.get_geo_items(False)
+        )
 
         # test of API for multipolygon context record with a multipolygon and a point as base find
         response = self.client.get(
@@ -2748,14 +2770,12 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_poly_poly_and_pt.pk}
+                "api-get-geo-points-from-context",
+                kwargs={"context_record_pk": cr_poly_poly_and_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        try:
-            self.assertIn(json.dumps(dic_poly_poly_and_pt_f).encode("utf-8"), response.content)
-        except:
-            self.assertIn(json.dumps(dic_poly_poly_and_pt_f_2).encode("utf-8"), response.content)
+        self.assertEqual(dic_poly_poly_and_pt_f, json.loads(response.content))
 
         response = self.client.get(
             reverse(
@@ -2765,51 +2785,35 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_poly_poly_and_pt.pk}
+                "api-get-geo-polygons-from-context",
+                kwargs={"context_record_pk": cr_poly_poly_and_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        try:
-            self.assertIn(json.dumps(dic_poly_poly_and_pt_t).encode("utf-8"), response.content)
-        except:
-            self.assertIn(json.dumps(dic_poly_poly_and_pt_t_2).encode("utf-8"), response.content)
+        self.assertEqual(dic_poly_poly_and_pt_t, json.loads(response.content))
 
         # context record is a point, base find 1 a point and base find 2 a polygon
-        cr_pt_poly_and_pt = ContextRecord.objects.get(pk=base_find_poly.context_record.pk)
-        pk = cr_pt_poly_and_pt.pk
-        cr_pt_poly_and_pt.point = geom
-        cr_pt_poly_and_pt.multi_polygon = None
-        cr_pt_poly_and_pt.multi_polygon_source = None
-        cr_pt_poly_and_pt.multi_polygon_source_item = None
-        cr_pt_poly_and_pt.save()
-        cr_pt_poly_and_pt = ContextRecord.objects.get(pk=pk)
+        cr_pt_poly_and_pt, bfs = create_cr_with_bfs(
+            ope, "Point", ["Polygon", "Point"], "CR Pt Poly Pt"
+        )
+        base_find_poly, base_find_pt = bfs
 
         dic_pt_poly_and_pt_t = copy.deepcopy(dic_pt_pt_t)
         dic_pt_poly_and_pt_t["properties"] = {
             "associated base finds": {
-                "Find 2": dic_poly_t_copy,
-                "Find 1": dic_pt_t_copy,
+                "Find 1 from CR Pt Poly Pt": dic_poly_t_copy,
+                "Find 2 from CR Pt Poly Pt": dic_pt_t_copy,
             }
         }
-        dic_pt_poly_and_pt_t_2 = copy.deepcopy(dic_pt_poly_and_pt_t)
-        dic_pt_poly_and_pt_t["properties"]["associated base finds"] = {
-            "Find 1": dic_pt_t_copy,
-            "Find 2": dic_poly_t_copy,
-        }
         self.assertEqual(dic_pt_poly_and_pt_t, cr_pt_poly_and_pt.get_geo_items(True))
 
         dic_pt_poly_and_pt_f = copy.deepcopy(dic_pt_pt_f)
         dic_pt_poly_and_pt_f["properties"] = {
             "associated base finds": {
-                "Find 1": dic_pt_f_copy,
-                "Find 2": dic_poly_f_copy,
+                "Find 1 from CR Pt Poly Pt": dic_poly_f_copy,
+                "Find 2 from CR Pt Poly Pt": dic_pt_f_copy,
             }
         }
-        dic_pt_poly_and_pt_f_2 = copy.deepcopy(dic_pt_poly_and_pt_f)
-        dic_pt_poly_and_pt_f["properties"]["associated base finds"] = {
-            "Find 2": dic_poly_f_copy,
-            "Find 1": dic_pt_f_copy,
-        }
         self.assertEqual(dic_pt_poly_and_pt_f, cr_pt_poly_and_pt.get_geo_items(False))
 
         # test of API for point context record with multipolygon as base find
@@ -2819,14 +2823,12 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_pt_poly_and_pt.pk}
+                "api-get-geo-points-from-context",
+                kwargs={"context_record_pk": cr_pt_poly_and_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        try:
-            self.assertIn(json.dumps(dic_pt_poly_and_pt_f).encode("utf-8"), response.content)
-        except:
-            self.assertIn(json.dumps(dic_pt_poly_and_pt_f_2).encode("utf-8"), response.content)
+        self.assertEqual(dic_pt_poly_and_pt_f, json.loads(response.content))
 
         response = self.client.get(
             reverse(
@@ -2836,14 +2838,126 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_pt_poly_and_pt.pk}
+                "api-get-geo-polygons-from-context",
+                kwargs={"context_record_pk": cr_pt_poly_and_pt.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        try:
-            self.assertIn(json.dumps(dic_pt_poly_and_pt_t).encode("utf-8"), response.content)
-        except:
-            self.assertIn(json.dumps(dic_pt_poly_and_pt_t_2).encode("utf-8"), response.content)
+        self.assertEqual(dic_pt_poly_and_pt_t, json.loads(response.content))
+
+        # test of operation
+
+        dic_pt_pt_and_poly_pt_and_poly_f = copy.deepcopy(dic_pt_f)
+        dic_pt_pt_and_poly_pt_and_poly_f["properties"] = {
+            "associated context records": {
+                "CR Pt Poly Pt": dic_pt_poly_and_pt_f,
+                "CR Poly Poly Pt": dic_poly_poly_and_pt_f,
+            }
+        }
+        dic_pt_pt_and_poly_pt_and_poly_t = copy.deepcopy(dic_pt_t)
+        dic_pt_pt_and_poly_pt_and_poly_t["properties"] = {
+            "associated context records": {
+                "CR Pt Poly Pt": dic_pt_poly_and_pt_t,
+                "CR Poly Poly Pt": dic_poly_poly_and_pt_t,
+            }
+        }
+        dic_poly_pt_and_poly_pt_and_poly_f = copy.deepcopy(dic_poly_f)
+        dic_poly_pt_and_poly_pt_and_poly_f["properties"] = {
+            "associated context records": {
+                "CR Pt Poly Pt": dic_pt_poly_and_pt_f,
+                "CR Poly Poly Pt": dic_poly_poly_and_pt_f,
+            }
+        }
+        dic_poly_pt_and_poly_pt_and_poly_t = copy.deepcopy(dic_poly_t)
+        dic_poly_pt_and_poly_pt_and_poly_t["properties"] = {
+            "associated context records": {
+                "CR Pt Poly Pt": dic_pt_poly_and_pt_t,
+                "CR Poly Poly Pt": dic_poly_poly_and_pt_t,
+            }
+        }
+
+        ope_pt = Operation.objects.get(pk=ope.pk)
+        ope_pt.point = geom
+        ope_pt.multi_polygon = None
+        ope_pt.multi_polygon_source = None
+        ope_pt.multi_polygon_source_item = None
+        ope_pt.x, ope_pt.y = xy
+        ope_pt.point_2d = geom_2d
+        ope_pt.spatial_reference_system = wgs84
+        ope_pt.save()
+        ope_pt = Operation.objects.get(pk=ope_pt.pk)
+        self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_f, ope_pt.get_geo_items(False))
+        self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_t, ope_pt.get_geo_items(True))
+
+        response = self.client.get(
+            reverse("api-get-geo-polygons-from-operation", kwargs={"operation_pk": 0})
+        )
+        self.assertEqual(response.status_code, 404)
+        response = self.client.get(
+            reverse(
+                "api-get-geo-polygons-from-operation",
+                kwargs={"operation_pk": ope_pt.pk},
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_t, json.loads(response.content))
+
+        response = self.client.get(
+            reverse("api-get-geo-points-from-operation", kwargs={"operation_pk": 0})
+        )
+        self.assertEqual(response.status_code, 404)
+        response = self.client.get(
+            reverse(
+                "api-get-geo-points-from-operation", kwargs={"operation_pk": ope_pt.pk}
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_f, json.loads(response.content))
+
+        # ope is now a multipolygon
+        ope_poly = Operation.objects.get(pk=ope.pk)
+        ope_poly.multi_polygon = "SRID=4326;" + limit
+        ope_poly.point_source = None
+        ope_poly.point_2d = None
+        ope_poly.point = None
+        ope_poly.save()
+        ope_poly = Operation.objects.get(pk=ope_poly.pk)
+
+        self.assertEqual(
+            dic_poly_pt_and_poly_pt_and_poly_f, ope_poly.get_geo_items(False)
+        )
+        self.assertEqual(
+            dic_poly_pt_and_poly_pt_and_poly_t, ope_poly.get_geo_items(True)
+        )
+
+        response = self.client.get(
+            reverse("api-get-geo-polygons-from-operation", kwargs={"operation_pk": 0})
+        )
+        self.assertEqual(response.status_code, 404)
+        response = self.client.get(
+            reverse(
+                "api-get-geo-polygons-from-operation",
+                kwargs={"operation_pk": ope_pt.pk},
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            dic_poly_pt_and_poly_pt_and_poly_t, json.loads(response.content)
+        )
+
+        response = self.client.get(
+            reverse("api-get-geo-points-from-operation", kwargs={"operation_pk": 0})
+        )
+        self.assertEqual(response.status_code, 404)
+        response = self.client.get(
+            reverse(
+                "api-get-geo-points-from-operation", kwargs={"operation_pk": ope_pt.pk}
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            dic_poly_pt_and_poly_pt_and_poly_f, json.loads(response.content)
+        )
 
 
 
diff --git a/archaeological_operations/models.py b/archaeological_operations/models.py
index f1368abc2..29b3eac91 100644
--- a/archaeological_operations/models.py
+++ b/archaeological_operations/models.py
@@ -1608,19 +1608,24 @@ class Operation(
     def get_geo_items(self, get_polygons, rounded=True):
         dict = super(Operation, self).get_geo_items(get_polygons, rounded)
         associated_geo_items = {"associated context records": {}}
-        ContextRecord = apps.get_model("archaeological_context_records", "ContextRecord")
-        for label in self._get_associated_cached_labels():
+        ContextRecord = apps.get_model(
+            "archaeological_context_records", "ContextRecord"
+        )
+        for (
+            cr
+        ) in (
+            self._get_associated_cached_labels()
+        ):  # malgré le nom, ce ne sont pas des labels ?
             try:
-                cr = ContextRecord.objects.get(label=label)
                 associated_geo_items["associated context records"][
-                    str(label)
+                    str(cr.label)
                 ] = cr.get_geo_items(get_polygons, rounded)
             except ContextRecord.DoesNotExist:
+                print("except")
                 pass
         dict["properties"] = associated_geo_items
         return dict
 
-
     def context_record_relations_q(self):
         from archaeological_context_records.models import RecordRelations as CRRL
 
@@ -2795,8 +2800,11 @@ class Parcel(LightHistorizedItem):
 
     @property
     def short_label(self):
-        items = [str(item) for item in [self.section, self.parcel_number, self.address]
-                 if item]
+        items = [
+            str(item)
+            for item in [self.section, self.parcel_number, self.address]
+            if item
+        ]
         if self.public_domain:
             items.append(str(_("Public domain")))
         return settings.JOINT.join(items)
diff --git a/ishtar_common/models_common.py b/ishtar_common/models_common.py
index a58ec37ab..fcd252577 100644
--- a/ishtar_common/models_common.py
+++ b/ishtar_common/models_common.py
@@ -2875,8 +2875,11 @@ class GeoItem(models.Model):
                     self.multi_polygon.centroid, rounded
                 )
             else:
-                x, y = self.display_coordinates
-                dict["geometry"]["coordinates"] = [x, y]
+                try:
+                    x, y = self.display_coordinates
+                    dict["geometry"]["coordinates"] = [x, y]
+                except ValueError:
+                    dict["geometry"]["coordinates"] = []
         return dict
 
     def convert_coordinates(self, point_2d, rounded):