From 0bc2a87a78c770dd511ec4e2856fc8500cae4e7b Mon Sep 17 00:00:00 2001
From: QuentinAndre <quentin.andre@imt-atlantique.net>
Date: Mon, 26 Jul 2021 14:43:05 +0200
Subject: url with get and display geo items

---
 .../templates/ishtar/sheet_contextrecord.html      |   1 +
 archaeological_finds/tests.py                      | 152 +++++----------------
 archaeological_finds/urls.py                       |  38 +-----
 archaeological_finds/views.py                      |  12 +-
 .../templates/ishtar/sheet_operation.html          |   1 +
 ishtar_common/static/js/ishtar-map.js              | 109 ++++++++++++++-
 .../templates/ishtar/blocks/sheet_geo_items.html   |  48 +++++++
 .../templates/ishtar/blocks/sheet_simple_map.html  |  56 ++++++--
 ishtar_common/urls.py                              |   1 +
 9 files changed, 244 insertions(+), 174 deletions(-)
 create mode 100644 ishtar_common/templates/ishtar/blocks/sheet_geo_items.html

diff --git a/archaeological_context_records/templates/ishtar/sheet_contextrecord.html b/archaeological_context_records/templates/ishtar/sheet_contextrecord.html
index 62454d6f6..05a6962b3 100644
--- a/archaeological_context_records/templates/ishtar/sheet_contextrecord.html
+++ b/archaeological_context_records/templates/ishtar/sheet_contextrecord.html
@@ -156,6 +156,7 @@
             <div class="col-12 col-lg-6 flex-wrap">
                 {% field_flex_multiple_full "Towns" item.operation.towns %}
                 {% include "ishtar/blocks/sheet_coordinates.html"%}
+                {% include "ishtar/blocks/sheet_geo_items.html"%}
             </div>
             {% endwith %}
         </div>
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 34d7e1b91..c3b4a8c41 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -2602,11 +2602,11 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(dic_pt_f, res)
 
         # test API with point
-        response = self.client.get(reverse("api-get-geo-point", kwargs={"pk": 0}))
+        url_pts = reverse("api-get-geo-points")
+        url_polys = reverse("api-get-geo-polygons")
+        response = self.client.get(url_pts + "?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(url_pts + "?pk=" + str(base_find_pt.pk))
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_pt_f).encode("utf-8"), response.content)
 
@@ -2634,31 +2634,15 @@ class GeomaticTest(FindInit, TestCase):
         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(
-            reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0})
-        )
+        response = self.client.get(url_pts + "?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_pt_pt.pk},
-            )
-        )
+        response = self.client.get(url_pts + "?context_record_pk=" + str(cr_pt_pt.pk))
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_pt_pt_f).encode("utf-8"), response.content)
 
-        response = self.client.get(
-            reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": 0}
-            )
-        )
+        response = self.client.get(url_polys + "?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_pt_pt.pk},
-            )
-        )
+        response = self.client.get(url_polys + "?context_record_pk=" + str(cr_pt_pt.pk))
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_pt_pt_t).encode("utf-8"), response.content)
 
@@ -2712,30 +2696,16 @@ class GeomaticTest(FindInit, TestCase):
         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(
-            reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0})
-        )
+        response = self.client.get(url_pts + "?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_poly_pt.pk},
-            )
-        )
+        response = self.client.get(url_pts + "?context_record_pk=" + str(cr_poly_pt.pk))
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_poly_pt_f).encode("utf-8"), response.content)
 
-        response = self.client.get(
-            reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": 0}
-            )
-        )
+        response = self.client.get(url_polys + "?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_poly_pt.pk},
-            )
+            url_polys + "?context_record_pk=" + str(cr_poly_pt.pk)
         )
         self.assertEqual(response.status_code, 200)
         self.assertIn(json.dumps(dic_poly_pt_t).encode("utf-8"), response.content)
@@ -2757,22 +2727,12 @@ class GeomaticTest(FindInit, TestCase):
         self.assertEqual(dic_poly_f_from_poly, res_centroid)
 
         # test API with polygon
-        response = self.client.get(reverse("api-get-geo-polygons", kwargs={"pk": 0}))
+        response = self.client.get(url_polys + "?pk=0")
         self.assertEqual(response.status_code, 404)
-        response = self.client.get(
-            reverse(
-                "api-get-geo-polygons",
-                kwargs={"pk": base_find_poly.pk},
-            )
-        )
+        response = self.client.get(url_polys + "?pk=" + str(base_find_poly.pk))
         self.assertEqual(response.status_code, 200)
         self.assertEqual(dic_poly_t_from_poly, json.loads(response.content))
-        response = self.client.get(
-            reverse(
-                "api-get-geo-point",
-                kwargs={"pk": base_find_poly.pk},
-            )
-        )
+        response = self.client.get(url_pts + "?pk=" + str(base_find_poly.pk))
         self.assertEqual(response.status_code, 200)
         self.assertEqual(dic_poly_f_from_poly, json.loads(response.content))
 
@@ -2821,30 +2781,18 @@ class GeomaticTest(FindInit, TestCase):
         )
 
         # 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})
-        )
+        response = self.client.get(url_pts + "?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_poly_poly_and_pt.pk},
-            )
+            url_pts + "?context_record_pk=" + str(cr_poly_poly_and_pt.pk)
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(dic_poly_poly_and_pt_f, json.loads(response.content))
 
-        response = self.client.get(
-            reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": 0}
-            )
-        )
+        response = self.client.get(url_polys + "?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_poly_poly_and_pt.pk},
-            )
+            url_polys + "?context_record_pk=" + str(cr_poly_poly_and_pt.pk)
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(dic_poly_poly_and_pt_t, json.loads(response.content))
@@ -2891,30 +2839,18 @@ class GeomaticTest(FindInit, TestCase):
         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
-        response = self.client.get(
-            reverse("api-get-geo-points-from-context", kwargs={"context_record_pk": 0})
-        )
+        response = self.client.get(url_pts + "?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_pt_poly_and_pt.pk},
-            )
+            url_pts + "?context_record_pk=" + str(cr_pt_poly_and_pt.pk)
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(dic_pt_poly_and_pt_f, json.loads(response.content))
 
-        response = self.client.get(
-            reverse(
-                "api-get-geo-polygons-from-context", kwargs={"context_record_pk": 0}
-            )
-        )
+        response = self.client.get(url_polys + "?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_pt_poly_and_pt.pk},
-            )
+            url_polys + "?context_record_pk=" + str(cr_pt_poly_and_pt.pk)
         )
         self.assertEqual(response.status_code, 200)
         self.assertEqual(dic_pt_poly_and_pt_t, json.loads(response.content))
@@ -2979,28 +2915,15 @@ class GeomaticTest(FindInit, TestCase):
         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})
-        )
+        response = self.client.get(url_polys + "?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},
-            )
-        )
+        response = self.client.get(url_polys + "?operation_pk=" + str(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})
-        )
+        response = self.client.get(url_pts + "?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}
-            )
-        )
+        response = self.client.get(url_pts + "?operation_pk=" + str(ope_pt.pk))
         self.assertEqual(response.status_code, 200)
         self.assertEqual(dic_pt_pt_and_poly_pt_and_poly_f, json.loads(response.content))
 
@@ -3020,30 +2943,17 @@ class GeomaticTest(FindInit, TestCase):
             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})
-        )
+        response = self.client.get(url_polys + "?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},
-            )
-        )
+        response = self.client.get(url_polys + "?operation_pk=" + str(ope_poly.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})
-        )
+        response = self.client.get(url_pts + "?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}
-            )
-        )
+        response = self.client.get(url_pts + "?operation_pk=" + str(ope_poly.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_finds/urls.py b/archaeological_finds/urls.py
index 2e2278d87..a374c4d41 100644
--- a/archaeological_finds/urls.py
+++ b/archaeological_finds/urls.py
@@ -573,7 +573,7 @@ urlpatterns = [
     ),
     url(r"api/public/find/$", views.PublicFindAPI.as_view(), name="api-public-find"),
     url(
-        r"api/ishtar/base-finds/geo/polygons/?pk=(?P<pk>[0-9]+)/?$",
+        r"api/ishtar/base-finds/geo/polygons$",
         check_rights(["view_find", "view_own_find"])(
             views.get_geo_items,
         ),
@@ -581,43 +581,11 @@ urlpatterns = [
         kwargs={"get_polygons": True},
     ),
     url(
-        r"api/ishtar/base-finds/geo/point/?pk=(?P<pk>[0-9]+)/$",
+        r"api/ishtar/base-finds/geo/points$",
         check_rights(["view_find", "view_own_find"])(
             views.get_geo_items,
         ),
-        name="api-get-geo-point",
-        kwargs={"get_polygons": False},
-    ),
-    url(
-        r"api/ishtar/base-finds/geo/polygons/?context-record=(?P<context_record_pk>[0-9]+)/$",
-        check_rights(["view_find", "view_own_find"])(
-            views.get_geo_items,
-        ),
-        name="api-get-geo-polygons-from-context",
-        kwargs={"get_polygons": True},
-    ),
-    url(
-        r"api/ishtar/base-finds/geo/points/?context-record=(?P<context_record_pk>[0-9]+)/$",
-        check_rights(["view_find", "view_own_find"])(
-            views.get_geo_items,
-        ),
-        name="api-get-geo-points-from-context",
-        kwargs={"get_polygons": False},
-    ),
-    url(
-        r"api/ishtar/base-finds/geo/polygons/?operation=(?P<operation_pk>[0-9]+)/$",
-        check_rights(["view_find", "view_own_find"])(
-            views.get_geo_items,
-        ),
-        name="api-get-geo-polygons-from-operation",
-        kwargs={"get_polygons": True},
-    ),
-    url(
-        r"api/ishtar/base-finds/geo/points/?operation=(?P<operation_pk>[0-9]+)/$",
-        check_rights(["view_find", "view_own_find"])(
-            views.get_geo_items,
-        ),
-        name="api-get-geo-points-from-operation",
+        name="api-get-geo-points",
         kwargs={"get_polygons": False},
     ),
 ]
diff --git a/archaeological_finds/views.py b/archaeological_finds/views.py
index 06bbfe632..7dae92827 100644
--- a/archaeological_finds/views.py
+++ b/archaeological_finds/views.py
@@ -1320,14 +1320,10 @@ class PublicFindAPI(APIView):
         return Response(serializer.data)
 
 
-def get_geo_items(
-    request,
-    get_polygons,
-    pk=None,
-    context_record_pk=None,
-    operation_pk=None,
-    current_right=None,
-):
+def get_geo_items(request, get_polygons, current_right=None):
+    operation_pk = request.GET.get("operation_pk")
+    context_record_pk = request.GET.get("context_record_pk")
+    pk = request.GET.get("pk")
     if operation_pk:
         try:
             bf = Operation.objects.get(pk=operation_pk)
diff --git a/archaeological_operations/templates/ishtar/sheet_operation.html b/archaeological_operations/templates/ishtar/sheet_operation.html
index 88fa2356a..caf5f4234 100644
--- a/archaeological_operations/templates/ishtar/sheet_operation.html
+++ b/archaeological_operations/templates/ishtar/sheet_operation.html
@@ -289,6 +289,7 @@
                 {% field_flex "Complement" item.associated_file.address_complement %}
                 {% field_flex "Postal code" item.associated_file.postal_code %}
                 {% endif %}
+                {% include "ishtar/blocks/sheet_geo_items.html"%}
             </div>
             {% endwith %}
         </div>
diff --git a/ishtar_common/static/js/ishtar-map.js b/ishtar_common/static/js/ishtar-map.js
index a93813e61..b22467668 100644
--- a/ishtar_common/static/js/ishtar-map.js
+++ b/ishtar_common/static/js/ishtar-map.js
@@ -285,7 +285,9 @@ var enable_clustering = function(map_id){
 };
 
 var reinit_clustering = function(map_id){
-    cluster_source[map_id].getSource().clear();
+    if (map_id in cluster_source) {
+        cluster_source[map_id].getSource().clear();
+    }
     _styleCache = {};
 };
 
@@ -642,3 +644,108 @@ var display_lines_and_polys = function(map_id, lines_and_polys){
         map_view[map_id].fit(vector_source[map_id].getExtent());
     }
 };
+
+var disp_geo_items = function(map_id, base_url, slug, pk, display_both) {
+    var url = base_url;
+    if (slug === "operation") {
+        url += "?operation_pk=";
+    }
+    else {
+        url += "?context_record_pk=";
+    }
+    url += pk;
+
+    httpRequest = new XMLHttpRequest();
+    if (!httpRequest) { return; }
+    httpRequest.onreadystatechange = function() {
+        if (httpRequest.readyState === XMLHttpRequest.DONE) {
+            if (httpRequest.status === 200) {
+                geo_items = to_geo_items(JSON.parse(httpRequest.responseText), slug, display_both)
+                for (geo_item of geo_items['base-finds']) {
+                    display_associated_polys(map_id, geo_item, 'basefind');
+                }
+                for (geo_item of geo_items['context-records']) {
+                    display_associated_polys(map_id, geo_item, 'contextrecord');
+                }
+            } else { return; }
+        }
+    };
+    httpRequest.open('GET', url, true);
+    httpRequest.send();
+};
+
+var to_geo_items = function (obj, slug, display_both) {
+    var objects = {'context-records': [], 'base-finds': []};
+    if (slug === "operation") {
+        var crs = obj['properties']['context-records'];
+        for (cr of crs['features']) {
+            if (display_both) {
+                objects['base-finds'].push(cr['properties']['base-finds'])
+            }
+            delete cr['properties'];
+        }
+        objects['context-records'].push(crs);
+    }
+    else {
+        objects['base-finds'].push(obj['properties']['base-finds'])
+    }
+    return objects;
+}
+
+var display_associated_polys = function (map_id, polys, slug) {
+    _vector_features = geojson_format.readFeatures(polys);
+    _vector_source = new ol.source.Vector();
+    _vector_source.addFeatures(_vector_features);
+    style = get_associated_base_find_style;
+    if (slug === 'contextrecord') {
+        style = get_associated_context_record_style;
+    }
+    _vector_layer = new ol.layer.Vector({
+        source: _vector_source,
+        style: style
+    });
+    map[map_id].addLayer(_vector_layer);
+}
+
+var get_associated_base_find_style = function (feature) {
+    return new ol.style.Style({
+        stroke: new ol.style.Stroke({
+            color: 'rgba(0, 0, 0, 1)',
+            width: 2
+        }),
+        fill: new ol.style.Fill({
+            color: 'rgba(O, O, O, 0.2)'
+        })
+    });
+};
+
+var get_associated_context_record_style = function (feature) {
+    return new ol.style.Style({
+        stroke: new ol.style.Stroke({
+            color: 'rgba(255, 255, 255, 1)',
+            width: 2
+        }),
+        fill: new ol.style.Fill({
+            color: 'rgba(255, 255, 255, 0.2)'
+        })
+    });
+};
+
+var display_associated_points = function (map_id, points, slug) {
+    _point_features = geojson_format.readFeatures(points);
+    _cluster_source = new ol.source.Cluster({
+        distance: 40,
+        source: new ol.source.Vector()
+    });
+    style = get_associated_base_find_style;
+    if (slug === 'contextrecord') {
+        style = get_associated_context_record_style;
+    }
+    _cluster_layer = new ol.layer.Vector({
+        name: 'Cluster',
+        source: _cluster_source,
+        style: style
+    });
+    map[map_id].addLayer(_cluster_layer);
+    _cluster_source.getSource().addFeatures(_point_features);
+}
\ No newline at end of file
diff --git a/ishtar_common/templates/ishtar/blocks/sheet_geo_items.html b/ishtar_common/templates/ishtar/blocks/sheet_geo_items.html
new file mode 100644
index 000000000..451453d59
--- /dev/null
+++ b/ishtar_common/templates/ishtar/blocks/sheet_geo_items.html
@@ -0,0 +1,48 @@
+{% load i18n window_field %}{% if PROFILE.mapping %}
+{% if geo_item.point_2d or geo_item.multi_polygon %}
+<dl class="col-12">
+    <dt>{% trans "Display geo items" %}</dt>
+    <dd>
+        <label for="display-geo-items">{% trans "Display associated features: " %}</label>
+        <select name="display-geo-items" id="display-geo-items">
+            <option value="" selected="selected">{% trans "None" %}</option>
+            <option id="disp-context-records" value="contextrecords">{% trans "Context records" %}</option>
+            <option value="basefinds">{% trans "Base finds" %}</option>
+        </select>
+    </dd>
+    <dd>
+        <label for="get-polygons" id="label-get-polygons">{% trans "Geometry: " %}</label>
+        <select name="get-polygons" id="get-polygons">
+            <option value="polygons" selected="selected">{% trans "Display polygons" %}</option>
+            <option value="points">{% trans "Display points" %}</option>
+        </select>
+    </dd>
+</dl>
+<script>
+var hide_context_records = function() {
+    if ("{{geo_item.SLUG}}" === "contextrecord") {
+        const disp_cr = $("#disp-context-records")[0];
+        disp_cr.hidden = true;
+    }
+}
+hide_context_records();
+
+var hide_get_polygons = function() {
+    const disp = $("#display-geo-items")[0];
+    const get_poly = $("#get-polygons")[0];
+    const label = $("#label-get-polygons")[0];
+    get_poly.hidden = true;
+    label.hidden = true;
+    disp.addEventListener('change', (event) => {
+        if (event.target.value === "") {
+            get_poly.hidden = true;
+            label.hidden = true;
+            get_poly.value = "";
+        } else { get_poly.hidden = false;
+            label.hidden = false;}
+    })
+}
+hide_get_polygons();
+</script>
+{% endif %}
+{% endif %}
\ No newline at end of file
diff --git a/ishtar_common/templates/ishtar/blocks/sheet_simple_map.html b/ishtar_common/templates/ishtar/blocks/sheet_simple_map.html
index d755fe531..b475e7343 100644
--- a/ishtar_common/templates/ishtar/blocks/sheet_simple_map.html
+++ b/ishtar_common/templates/ishtar/blocks/sheet_simple_map.html
@@ -6,15 +6,53 @@
 <div id="map-content-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}"></div>
 </div>
 <script type="text/javascript">
-var html = render_map("map-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}", false, true);
-$("#map-content-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}").html(html);
-{% if geo_item.most_precise_geo == 'point' %}
-var {{geo_item.SLUG}}{{geo_item.pk}} = {{geo_item.point_2d_geojson|safe}};
-display_map("map-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}", {{geo_item.SLUG}}{{geo_item.pk}});
-{% else %}
-var {{geo_item.SLUG}}{{geo_item.pk}} = {{geo_item.multi_polygon_geojson|safe}};
-display_map("map-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}", null, {{geo_item.SLUG}}{{geo_item.pk}});
-{% endif %}
+var disp_map = function() {
+    var html = render_map("map-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}", false, true);
+    $("#map-content-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}").html(html);
+    {% if geo_item.most_precise_geo == 'point' %}
+    var {{geo_item.SLUG}}{{geo_item.pk}} = {{geo_item.point_2d_geojson|safe}};
+    display_map("map-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}", {{geo_item.SLUG}}{{geo_item.pk}});
+    {% else %}
+    var {{geo_item.SLUG}}{{geo_item.pk}} = {{geo_item.multi_polygon_geojson|safe}};
+    display_map("map-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}", null, {{geo_item.SLUG}}{{geo_item.pk}});
+    {% endif %}
+}
+disp_map();
+
+if ("{{geo_item.SLUG}}" === 'contextrecord' || "{{geo_item.SLUG}}" === 'operation') {
+    var display_geo_items = function(disp, get_polygons) {
+        var display_both = false;
+        if ((disp === "basefinds") && ("{{geo_item.SLUG}}" === "operation")) {
+            display_both = true;
+        }
+        var url = null;
+        if (get_polygons === "Points") {
+            url = "{% url 'archaeological_finds:api-get-geo-points' %}";
+        }
+        else {
+            url = "{% url 'archaeological_finds:api-get-geo-polygons' %}";
+        }
+        disp_geo_items("map-{{window_id}}-{{geo_item.SLUG}}-{{geo_item.pk}}", url, "{{geo_item.SLUG}}", "{{geo_item.pk}}", display_both);
+    }
+
+    var geo_items_displayed_once = false;
+    var disp = $("#display-geo-items")[0];
+    var get_polygons = $("#get-polygons")[0];
+    disp.addEventListener('change', (event) => {
+        if (geo_items_displayed_once) {
+            disp_map();
+        }
+        if (disp.value !== "") {
+            console.log("geo items");
+            display_geo_items(disp.value, get_polygons.value);
+            geo_items_displayed_once = true;
+        }
+    })
+    get_polygons.addEventListener('change', (event) => {
+        disp_map();
+        display_geo_items(disp.value, get_polygons.value);
+    })
+}
 </script>
 {% endif %}
 {% endif %}
diff --git a/ishtar_common/urls.py b/ishtar_common/urls.py
index 9266a7a9a..7fe905c33 100644
--- a/ishtar_common/urls.py
+++ b/ishtar_common/urls.py
@@ -559,6 +559,7 @@ urlpatterns += [
         views.QANotAvailable.as_view(),
         name="qa-not-available",
     ),
+    url(r"^", include("archaeological_finds.urls", namespace="archaeological_finds")),
 ]
 
 urlpatterns += get_urls_for_model(models.Document, views, own=True)
-- 
cgit v1.2.3