better tests and beginning operations

2 files changed, 184 insertions, 171 deletions

diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index f6d436ebe..b04fa085a 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -2526,13 +2526,13 @@ class GeomaticTest(FindInit, TestCase):
         profile.save()
 
         find = self.finds[0]
-        base_find = find.base_finds.all()[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_pt = models.BaseFind.objects.get(pk=base_find.pk)
+        base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk)
 
         # with point
         geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326)
@@ -2540,46 +2540,46 @@ class GeomaticTest(FindInit, TestCase):
         base_find_pt.multi_polygon = None
         base_find_pt.save()
         base_find_pt = models.BaseFind.objects.get(pk=base_find_pt.pk)
-        dic = {
+        dic_pt_t = {
             "type": "Feature",
             "geometry": {"type": "MultiPolygon", "coordinates": []},
         }
         res = base_find_pt.get_geo_items(get_polygons=True)
-        self.assertEqual(dic, res)
-        dic["geometry"] = {"type": "Point", "coordinates": [2.0, 43.0]}
+        self.assertEqual(dic_pt_t, res)
+        dic_pt_f = copy.deepcopy(dic_pt_t)
+        dic_pt_f["geometry"] = {"type": "Point", "coordinates": [2.0, 43.0]}
         res = base_find_pt.get_geo_items(get_polygons=False)
-        self.assertEqual(dic, res)
+        self.assertEqual(dic_pt_f, res)
 
         # test API with point
-        find = models.BaseFind.objects.all()[0]
         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": find.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).encode("utf-8"), response.content)
-
-        # test context record with point for base find
-        cr = ContextRecord.objects.get(pk=base_find_pt.context_record.pk)
-        pk = cr.pk
-        cr.point = geom
-        cr.multi_polygon = None
-        cr.multi_polygon_source = None
-        cr.multi_polygon_source_item = None
-        cr.save()
-        cr = ContextRecord.objects.get(pk=pk)
-
-        dic_copy = copy.deepcopy(dic)
-        dic["properties"] = {"associated base finds": {"Find 1": dic_copy}}
-        self.assertEqual(dic, cr.get_geo_items(False))
-
-        dic2_copy = copy.deepcopy(dic_copy)
-        dic2_copy["geometry"] = {"type": "MultiPolygon", "coordinates": []}
-        dic2 = {
+        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}}
+        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": dic2_copy}},
+            "properties": {"associated base finds": {"Find 1": dic_pt_t_copy}},
         }
-        self.assertEqual(dic2, cr.get_geo_items(True))
+        self.assertEqual(dic_pt_pt_t, cr_pt_pt.get_geo_items(True))
 
         # test of API for point context record with point as base find
         response = self.client.get(
@@ -2588,11 +2588,11 @@ 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.pk}
+                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_pt_pt.pk}
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dic).encode("utf-8"), response.content)
+        self.assertIn(json.dumps(dic_pt_pt_f).encode("utf-8"), response.content)
 
         response = self.client.get(
             reverse(
@@ -2602,18 +2602,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.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(dic2).encode("utf-8"), response.content)
+        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)))"
         )
-        dict_poly = {
+        dic_poly_t = {
             "type": "Feature",
             "geometry": {
                 "type": "MultiPolygon",
@@ -2627,27 +2627,28 @@ class GeomaticTest(FindInit, TestCase):
             },
         }
 
-        cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
-        pk = cr.pk
-        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=pk)
+        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_based = copy.deepcopy(dict_poly)
-        dic_poly_based["properties"] = {"associated base finds": {"Find 1": dic2_copy}}
-        self.assertEqual(dic_poly_based, cr.get_geo_items(True))
+        dic_poly_pt_t = copy.deepcopy(dic_poly_t)
+        dic_poly_pt_t["properties"] = {"associated base finds": {"Find 1": dic_pt_t}}
+        self.assertEqual(dic_poly_pt_t, cr_poly_pt.get_geo_items(True))
 
-        dict_centroid = {
+        dic_poly_f = {
             "type": "Feature",
             "geometry": {"type": "Point", "coordinates": [3.86111, 3.02778]},
         }
-        dic_poly_centroid_based = copy.deepcopy(dict_centroid)
-        dic_poly_centroid_based["properties"] = {
-            "associated base finds": {"Find 1": dic_copy}
+        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}
         }
-        self.assertEqual(dic_poly_centroid_based, cr.get_geo_items(False))
+        self.assertEqual(dic_poly_pt_f, cr_poly_pt.get_geo_items(False))
 
         # test of API for point context record with multipolygon as base find
         response = self.client.get(
@@ -2656,12 +2657,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.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_centroid_based).encode("utf-8"), response.content
+            json.dumps(dic_poly_pt_f).encode("utf-8"), response.content
         )
 
         response = self.client.get(
@@ -2672,26 +2673,30 @@ 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.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_based).encode("utf-8"), response.content)
+        self.assertIn(json.dumps(dic_poly_pt_t).encode("utf-8"), response.content)
 
-        # with multi-polygon for base find
-        base_find = models.BaseFind.objects.get(pk=base_find.pk)
-        base_find.multi_polygon = "SRID=4326;" + limit
-        base_find.point_source = None
-        base_find.point_2d = None
-        base_find.point = None
-        base_find.save()
-
-        base_find = models.BaseFind.objects.get(pk=base_find.pk)
-
-        res_poly = base_find.get_geo_items(get_polygons=True)
-        self.assertEqual(dict_poly, res_poly)
-        res_centroid = base_find.get_geo_items(get_polygons=False)
-        self.assertEqual(dict_centroid, res_centroid)
+        # 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)
+
+        res_poly = base_find_poly.get_geo_items(get_polygons=True)
+        self.assertEqual(dic_poly_t, res_poly)
+        res_centroid = base_find_poly.get_geo_items(get_polygons=False)
+        self.assertEqual(dic_poly_f, res_centroid)
 
         # test API with polygon
         response = self.client.get(reverse("api-get-geo-polygons", kwargs={"pk": 0}))
@@ -2699,94 +2704,76 @@ class GeomaticTest(FindInit, TestCase):
         response = self.client.get(
             reverse(
                 "api-get-geo-polygons",
-                kwargs={"pk": base_find.pk},
+                kwargs={"pk": base_find_poly.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dict_poly).encode("utf-8"), response.content)
+        self.assertIn(json.dumps(dic_poly_t).encode("utf-8"), response.content)
         response = self.client.get(
             reverse(
                 "api-get-geo-point",
-                kwargs={"pk": base_find.pk},
+                kwargs={"pk": base_find_poly.pk},
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dict_centroid).encode("utf-8"), response.content)
-
-        # context record is a polygon (and base find also)
-        cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
-        pk = cr.pk
-        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=pk)
-
-        dict_poly_copy = copy.deepcopy(dict_poly)
-        dict_poly["properties"] = {"associated base finds": {"Find 1": dict_poly_copy}}
-        self.assertEqual(dict_poly, cr.get_geo_items(True))
-
-        dict_centroid_copy = copy.deepcopy(dict_centroid)
-        dict_centroid["properties"] = {
-            "associated base finds": {"Find 1": dict_centroid_copy}
+        self.assertIn(json.dumps(dic_poly_f).encode("utf-8"), response.content)
+
+        # 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)
+
+        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,
+            }
         }
-        self.assertEqual(dict_centroid, cr.get_geo_items(False))
-
-        # test of API for multipolygon context record with multipolygon as base find
-        response = self.client.get(
-            reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0})
-        )
-        self.assertEqual(response.status_code, 404)
-        response = self.client.get(
-            reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr.pk}
-            )
-        )
-        self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dict_centroid).encode("utf-8"), response.content)
-
-        response = self.client.get(
-            reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": 0}
-            )
-        )
-        self.assertEqual(response.status_code, 404)
-        response = self.client.get(
-            reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr.pk}
-            )
-        )
-        self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dict_poly).encode("utf-8"), response.content)
-
-        # context record is a point (and base find a polygon)
-        cr = ContextRecord.objects.get(pk=base_find_pt.context_record.pk)
-        pk = cr.pk
-        cr.point = geom
-        cr.multi_polygon = None
-        cr.multi_polygon_source = None
-        cr.multi_polygon_source_item = None
-        cr.save()
-        cr = ContextRecord.objects.get(pk=pk)
-
-        dic2["properties"] = {"associated base finds": {"Find 1": dict_poly_copy}}
-        self.assertEqual(dic2, cr.get_geo_items(True))
+        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))
 
-        dic["properties"] = {"associated base finds": {"Find 1": dict_centroid_copy}}
-        self.assertEqual(dic, cr.get_geo_items(False))
+        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,
+            }
+        }
+        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))
 
-        # test of API for point context record with multipolygon as base find
+        # test of API for multipolygon context record with a multipolygon and a point as base find
         response = self.client.get(
             reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0})
         )
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr.pk}
+                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_poly_poly_and_pt.pk}
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dic).encode("utf-8"), response.content)
+        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)
 
         response = self.client.get(
             reverse(
@@ -2796,61 +2783,68 @@ 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.pk}
+                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_poly_poly_and_pt.pk}
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dic2).encode("utf-8"), response.content)
-
-        # context record is a polygon, one base find is a polygon and the other a point
-        cr = ContextRecord.objects.get(pk=base_find.context_record.pk)
-        pk = cr.pk
-        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=pk)
-
-        default = {
-            "label": "Find 2",
-            "history_modifier": base_find.history_modifier,
-            "context_record": base_find.context_record,
-        }
-        base_find_pt = models.BaseFind.objects.create(**default)
-        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)
-        self.base_finds.append(base_find_pt)
-
-        dict_poly["properties"] = {
+        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)
+
+        # 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)
+
+        dic_pt_poly_and_pt_t = copy.deepcopy(dic_pt_pt_t)
+        dic_pt_poly_and_pt_t["properties"] = {
             "associated base finds": {
-                "Find 2": dic2_copy,
-                "Find 1": dict_poly_copy,
+                "Find 2": dic_poly_t_copy,
+                "Find 1": dic_pt_t_copy,
             }
         }
-        self.assertEqual(dict_poly, cr.get_geo_items(True))
+        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))
 
-        dict_centroid["properties"] = {
+        dic_pt_poly_and_pt_f = copy.deepcopy(dic_pt_pt_f)
+        dic_pt_poly_and_pt_f["properties"] = {
             "associated base finds": {
-                "Find 2": dic_copy,
-                "Find 1": dict_centroid_copy,
+                "Find 1": dic_pt_f_copy,
+                "Find 2": dic_poly_f_copy,
             }
         }
-        self.assertEqual(dict_centroid, cr.get_geo_items(False))
+        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 multipolygon context record with a multipolygon and a point as base find
+        # test of API for point context record with multipolygon as base find
         response = self.client.get(
             reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0})
         )
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
             reverse(
-                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr.pk}
+                "api-get-geo-points-from-context", kwargs={"context_record_pk": cr_pt_poly_and_pt.pk}
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dict_centroid).encode("utf-8"), response.content)
+        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)
 
         response = self.client.get(
             reverse(
@@ -2860,11 +2854,14 @@ 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.pk}
+                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": cr_pt_poly_and_pt.pk}
             )
         )
         self.assertEqual(response.status_code, 200)
-        self.assertIn(json.dumps(dict_poly).encode("utf-8"), response.content)
+        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)
 
 
 
diff --git a/archaeological_operations/models.py b/archaeological_operations/models.py
index 05c1d6336..36f31322e 100644
--- a/archaeological_operations/models.py
+++ b/archaeological_operations/models.py
@@ -1605,6 +1605,22 @@ class Operation(
             return None
         return q.all()[0].poly, self._meta.verbose_name
 
+    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():
+            try:
+                cr = ContextRecord.objects.get(label=label)
+                associated_geo_items["associated context records"][
+                    str(label)
+                ] = cr.get_geo_items(get_polygons, rounded)
+            except ContextRecord.DoesNotExist:
+                pass
+        dict["properties"] = associated_geo_items
+        return dict
+
+
     def context_record_relations_q(self):
         from archaeological_context_records.models import RecordRelations as CRRL