api for geo_get_items for context records + tests

1 files changed, 211 insertions, 22 deletions

diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index ae8540f85..8bb61a044 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -16,7 +16,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # See the file COPYING for details.
-
+import copy
 from copy import deepcopy
 import csv
 import json
@@ -2532,45 +2532,87 @@ class GeomaticTest(FindInit, TestCase):
             defaults={"srid": 4326, "label": "WGS84", "auth_name": "EPSG"},
         )
 
-        base_find = models.BaseFind.objects.get(pk=base_find.pk)
+        base_find_pt = models.BaseFind.objects.get(pk=base_find.pk)
 
         # with point
         geom = GEOSGeometry("POINT({} {} {})".format(2, 43, 1), srid=4326)
-        base_find.point = geom
-        base_find.multi_polygon = None
-        base_find.save()
-        base_find = models.BaseFind.objects.get(pk=base_find.pk)
+        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)
         dic = {
             "type": "Feature",
             "geometry": {"type": "MultiPolygon", "coordinates": []},
         }
-        res = base_find.get_geo_items(get_polygons=True)
+        res = base_find_pt.get_geo_items(get_polygons=True)
         self.assertEqual(dic, res)
         dic["geometry"] = {"type": "Point", "coordinates": [2.0, 43.0]}
-        res = base_find.get_geo_items(get_polygons=False)
+        res = base_find_pt.get_geo_items(get_polygons=False)
         self.assertEqual(dic, res)
 
-        # test API
-        find = base_find.find.all()[0]
+        # test API with point
+        find = base_find_pt.find.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}))
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic).encode("utf-8"), response.content)
 
-        # with multi-polygon
-        base_find = models.BaseFind.objects.get(pk=base_find.pk)
+        # 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 = {
+            "type": "Feature",
+            "geometry": {"type": "MultiPolygon", "coordinates": []},
+            "properties": {"associated base finds": {"Find 1": dic2_copy}},
+        }
+        self.assertEqual(dic2, cr.get_geo_items(True))
+
+        # test of API for point context record with 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}
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(json.dumps(dic).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(dic2).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)))"
         )
-        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)
         dict_poly = {
             "type": "Feature",
             "geometry": {
@@ -2584,16 +2626,74 @@ class GeomaticTest(FindInit, TestCase):
                 ],
             },
         }
-        res_poly = base_find.get_geo_items(get_polygons=True)
-        self.assertEqual(dict_poly, res_poly)
+
+        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)
+
+        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))
+
         dict_centroid = {
             "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}
+        }
+        self.assertEqual(dic_poly_centroid_based, cr.get_geo_items(False))
+
+        # 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}
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(
+            json.dumps(dic_poly_centroid_based).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(dic_poly_based).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)
 
-        # test API
+        # test API with polygon
         response = self.client.get(reverse("api-get-geo-polygons", kwargs={"pk": 0}))
         self.assertEqual(response.status_code, 404)
         response = self.client.get(
@@ -2613,6 +2713,95 @@ class GeomaticTest(FindInit, TestCase):
         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.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["properties"] = {"associated base finds": {"Find 1": dict_centroid_copy}}
+        self.assertEqual(dic, cr.get_geo_items(False))
+
+        # 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}
+            )
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertIn(json.dumps(dic).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(dic2).encode("utf-8"), response.content)
+
 
 
 class AutocompleteTest(AutocompleteTestBase, TestCase):