create_cr_with_bfs returns pks

5 files changed, 138 insertions, 54 deletions

diff --git a/archaeological_context_records/tests.py b/archaeological_context_records/tests.py
index 16bf6d303..daa38c26b 100644
--- a/archaeological_context_records/tests.py
+++ b/archaeological_context_records/tests.py
@@ -1441,7 +1441,7 @@ class SeleniumTestsContextRecords(SeleniumTests):
         self.assertMap(dic_base)
 
     def test_geo_items(self):
-        geo_elements = self.setUpDefaultGeoItems()
+        geo_elements, ope_pks = self.setUpDefaultGeoItems()
         poly_cr, centr_cr, pt_cr = geo_elements[1]
 
         dic_polygon = {
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index a692cfc9f..688699d3e 100644
--- a/archaeological_finds/tests.py
+++ b/archaeological_finds/tests.py
@@ -2539,16 +2539,20 @@ class GeomaticTest(FindInit, TestCase):
         point_2d_bf = GEOSGeometry("POINT({} {})".format(3.9, 2.9), srid=4326)
         xy_bf = 3.9, 2.9
 
+        pks = {'cr': {}, 'bf': {}}
+
         ope.multi_polygon = "SRID=4326;" + poly_ope
         ope.multi_polygon_source = "P"
         ope.multi_polygon_source_item = str(ope._meta.verbose_name)
         ope.spatial_reference_system = wgs84
         if geom_ope == "Point":
             ope.point = point_ope
+            ope.point_source = "P"
+            ope.point_source_item = str(ope._meta.verbose_name)
             ope.x, ope.y = xy_ope
             ope.point_2d = point_2d_ope
-            ope.save()  # needs 2 saves because point_2d is none for multi_polygon
-            ope = Operation.objects.get(pk=ope.pk)
+        ope.save()  # needs 2 saves because point_2d is none for multi_polygon
+        ope = Operation.objects.get(pk=ope.pk)
         ope.save()
         ope = Operation.objects.get(pk=ope.pk)
 
@@ -2557,21 +2561,25 @@ class GeomaticTest(FindInit, TestCase):
             "operation": ope,
         }
         cr = ContextRecord.objects.create(**default)
+        cr = ContextRecord.objects.get(pk=cr.pk)
         cr.multi_polygon = "SRID=4326;" + poly_cr
         cr.multi_polygon_source = "P"
-        cr.multi_polygon_source_item = str(ContextRecord._meta.verbose_name)
+        cr.multi_polygon_source_item = str(cr._meta.verbose_name)
         cr.spatial_reference_system = wgs84
         if geom_cr == "Point":
             cr.point = point_cr
+            cr.point_source = "P"
+            cr.point_source_item = str(cr._meta.verbose_name)
             cr.x, cr.y = xy_cr
             cr.point_2d = point_2d_cr
         cr.save()
         cr = ContextRecord.objects.get(pk=cr.pk)
+        pks['cr'][label_cr] = cr.pk
 
         bfs = []
-        for i in range(len(list_geom_bf)):
+        for bf_geom in list_geom_bf:
             default = {
-                "label": "Find " + str(i + 1) + " from " + label_cr,
+                "label": "Find " + bf_geom + " from " + label_cr,
                 "context_record": cr,
             }
             bf = models.BaseFind.objects.create(**default)
@@ -2579,23 +2587,21 @@ class GeomaticTest(FindInit, TestCase):
             bf.multi_polygon_source = "P"
             bf.multi_polygon_source_item = str(bf._meta.verbose_name)
             bf.spatial_reference_system = wgs84
-            if list_geom_bf[i] == "Point":
+            if bf_geom == "Point":
                 bf.point = point_bf
+                bf.point_source = "P"
+                bf.point_source_item = str(bf._meta.verbose_name)
                 bf.x, bf.y = xy_bf
                 bf.point_2d = point_2d_bf
             bf.save()
             bf = models.BaseFind.objects.get(pk=bf.pk)
-            bf.save()
-            bf = models.BaseFind.objects.get(pk=bf.pk)
-            bf.save()
-            bf = models.BaseFind.objects.get(pk=bf.pk)
             bfs.append(bf)
+            pks['bf'][default['label']] = bf.pk
 
-            data = {}
-            find = models.Find.objects.create(**data)
+            find = models.Find.objects.create()
             find.base_finds.add(bf)
             find.save()
-        return cr, bfs
+        return pks
 
     def test_get_geo_items(self):
         wgs84 = SpatialReferenceSystem.objects.get(srid=4326)
@@ -3301,7 +3307,7 @@ class SeleniumTestsBaseFinds(SeleniumTests):
 
     def test_geo_items(self):
         self.selenium.implicitly_wait(5)
-        geo_elements = self.setUpDefaultGeoItems()
+        geo_elements, ope_pks = self.setUpDefaultGeoItems()
         poly_bf, centr_bf, pt_bf = geo_elements[2]
 
         dic_polygon = {
diff --git a/archaeological_operations/tests.py b/archaeological_operations/tests.py
index c09e30003..1ab511458 100644
--- a/archaeological_operations/tests.py
+++ b/archaeological_operations/tests.py
@@ -4395,7 +4395,7 @@ class SeleniumTestsOperations(SeleniumTests):
         self.assertMap(dic_base)
 
     def test_geo_items(self):
-        geo_elements = self.setUpDefaultGeoItems()
+        geo_elements, ope_pks = self.setUpDefaultGeoItems()
         poly_ope, centr_ope, pt_ope = geo_elements[0]
 
         dic_poly = {
@@ -4425,3 +4425,74 @@ class SeleniumTestsOperations(SeleniumTests):
         dropdown.click()
         self.selenium.find_element_by_xpath('//div[@class="dropdown-menu show"]/a[@href="/operation_search/"]').click()
         self._test_operation(2, dic_pt, geo_elements[1], geo_elements[2]) # point based operation
+
+    def assertPt(self, item, geom):
+        #self.assertEqual(item.multi_polygon.coords, geom[0].coords)
+        #self.assertEqual(item.point_2d.coords, geom[2].coords)
+        print(item, " multi_poly:")
+        print(item.multi_polygon.coords)
+        print("geom:")
+        print(geom[0].coords)
+        print('result: ', item.multi_polygon.coords == geom[0].coords)
+        print("point_2d:")
+        print((round(item.x, 5), round(item.y, 5)))
+        print("geom:")
+        print(geom[2].coords)
+        print('result: ', (round(item.x, 5), round(item.y, 5)) == geom[2].coords)
+        print('\n')
+
+    def assertPoly(self, item, geom, real_point=None):
+        #self.assertEqual(item.multi_polygon.coords, geom[0].coords)
+        #if real_point:
+        #   self.assertEqual((round(item.x, 5), round(item.y, 5)), geom[1].coords)
+        # else:
+        #   self.assertEqual((round(item.x, 5), round(item.y, 5)), real_point.coords)
+        print(item, " multi_poly:")
+        print(item.multi_polygon.coords)
+        print("geom:")
+        print(geom[0].coords)
+        print('result: ', item.multi_polygon.coords==geom[0].coords)
+        print("point_2d:")
+        print((round(item.x, 5), round(item.y, 5)))
+        print("geom:")
+        point = geom[1].coords
+        if real_point:
+            point = real_point.coords
+        print(point)
+        print('result: ', (round(item.x, 5), round(item.y, 5)) == point)
+        print('\n')
+
+    def test_setUpDefaultItems(self):
+        from django.contrib.gis.geos import GEOSGeometry
+        from archaeological_operations.models import Operation
+        base_geoms, ope_pks = self.setUpDefaultGeoItems()
+        geoms = []
+        for geom in base_geoms:
+            poly = GEOSGeometry(json.dumps({'type': 'MultiPolygon', 'coordinates': geom[0]}))
+            centr = GEOSGeometry(json.dumps({'type': 'Point', 'coordinates': geom[1]}))
+            pt = GEOSGeometry(json.dumps({'type': 'Point', 'coordinates': geom[2]}))
+            geoms.append([poly, centr, pt])
+        ope_pt = Operation.objects.get(pk=ope_pks[0])
+        self.assertPt(ope_pt, geoms[0])
+        ope_poly = Operation.objects.get(pk=ope_pks[1])
+        self.assertPoly(ope_poly, geoms[0])
+
+        cr_poly_poly = ope_poly.context_record.all()[0]
+        self.assertPoly(cr_poly_poly, geoms[1])
+        cr_poly_pt = ope_poly.context_record.all()[1]
+        self.assertPt(cr_poly_pt, geoms[1])
+        cr_pt_poly = ope_pt.context_record.all()[0]
+        self.assertPoly(cr_pt_poly, geoms[1], geoms[0][2])
+        cr_pt_pt = ope_pt.context_record.all()[1]
+        self.assertPt(cr_pt_pt, geoms[1])
+
+        self.assertPt(cr_pt_pt.base_finds.all()[0], geoms[2])
+        self.assertPoly(cr_pt_pt.base_finds.all()[1], geoms[2], geoms[1][2])
+        self.assertPt(cr_poly_pt.base_finds.all()[0], geoms[2])
+        self.assertPoly(cr_poly_pt.base_finds.all()[1], geoms[2], geoms[1][2])
+        self.assertPt(cr_pt_poly.base_finds.all()[0], geoms[2])
+        self.assertPoly(cr_pt_poly.base_finds.all()[1], geoms[2], geoms[0][2])
+        self.assertPt(cr_poly_poly.base_finds.all()[0], geoms[2])
+        self.assertPoly(cr_poly_poly.base_finds.all()[1], geoms[2])
+
+
diff --git a/ishtar_common/static/js/ishtar-map.js b/ishtar_common/static/js/ishtar-map.js
index 4d6ebcd48..00aadfd9b 100644
--- a/ishtar_common/static/js/ishtar-map.js
+++ b/ishtar_common/static/js/ishtar-map.js
@@ -684,31 +684,23 @@ var display_geo_items = function(map_id, base_url, slug, pk,
         if (httpRequest.readyState === XMLHttpRequest.DONE) {
             if (httpRequest.status === 200) {
                 geo_items = to_geo_items(JSON.parse(httpRequest.responseText), slug, disp_cr, disp_bf)
+                console.log('geoitems')
+                console.log(geo_items)
                 if (current_test) {
                     geo_items_features[map_id] = [];
                 }
-                var feat = null;
-                for (geo_item of geo_items['base-finds']) {
-                    if (get_poly) {
-                        feat = display_associated_polys(map_id, geo_item, 'basefind');
-                    } else {
-                        feat = display_associated_points(map_id, geo_item, 'basefind');
-                    }
-                    if (current_test) {
-                        geo_items_features[map_id].push(feat);
-                    }
-                }
-                for (geo_item of geo_items['context-records']) {
-                    if (get_poly) {
-                        feat = display_associated_polys(map_id, geo_item, 'contextrecord');
-                    } else {
-                        feat = display_associated_points(map_id, geo_item, 'contextrecord');
-                    }
-                    if (current_test) {
-                        geo_items_features[map_id].push(feat);
-                    }
+                let bfs = null;
+                let crs = null;
+                if (get_poly) {
+                    bfs = display_associated_polys(map_id, geo_items['base-finds'], 'basefind');
+                    crs = display_associated_polys(map_id, geo_items['context-records'], 'contextrecord');
+                } else {
+                    bfs = display_associated_points(map_id, geo_items['base-finds'], 'basefind');
+                    crs = display_associated_points(map_id, geo_items['context-records'], 'contextrecord');
                 }
                 if (current_test) {
+                    geo_items_features[map_id].push(bfs)
+                    geo_items_features[map_id].push(crs)
                     $("#http-geo-items-ready").show();
                 }
             } else { return; }
@@ -719,21 +711,26 @@ var display_geo_items = function(map_id, base_url, slug, pk,
 };
 
 var to_geo_items = function (obj, slug, disp_cr, disp_bf) {
-    const objects = {'context-records': [], 'base-finds': []};
+    const objects = {'context-records': {'features': [], 'type': 'FeatureCollection'},
+    'base-finds': {'features': [], 'type': 'FeatureCollection'}};
     if (slug === "operation") {
         const crs = obj['properties']['context-records'];
         for (const cr of crs['features']) {
-            if (disp_bf) {
-                objects['base-finds'].push(cr['properties']['base-finds'])
+            if (disp_bf) {console.log(cr);
+                for (const bf of cr['properties']['base-finds']['features']) {
+                    objects['base-finds']['features'].push(bf)
+                }
             }
             delete cr['properties'];
-        }
-        if (disp_cr) {
-            objects['context-records'].push(crs);
+            if (disp_cr) {
+                objects['context-records']['features'].push(cr)
+            }
         }
     }
     else {
-        objects['base-finds'].push(obj['properties']['base-finds'])
+        for (const bf of obj['properties']['base-finds']['features']) {
+            objects['base-finds']['features'].push(bf)
+        }
     }
     return objects;
 }
@@ -780,9 +777,9 @@ var get_associated_context_record_style = function (feature) {
 };
 
 var display_associated_points = function (map_id, points, slug) {
-    //console.log('geo items points')
-    //console.log(points);
-    /*_point_features = geojson_format.readFeatures(points);
+    console.log('geo items points')
+    console.log(points);
+    _point_features = geojson_format.readFeatures(points);
     _cluster_source = new ol.source.Cluster({
         distance: 40,
         source: new ol.source.Vector()
@@ -799,7 +796,7 @@ var display_associated_points = function (map_id, points, slug) {
         style: style
     });
     map[map_id].addLayer(_cluster_layer);
-    return _point_features;*/
+    return _point_features;
 }
 
 // for test purpose
diff --git a/ishtar_common/tests.py b/ishtar_common/tests.py
index 9ed7394ea..ced35a672 100644
--- a/ishtar_common/tests.py
+++ b/ishtar_common/tests.py
@@ -3217,7 +3217,6 @@ class SeleniumTests(StaticLiveServerTestCase):
     from selenium.webdriver.support.wait import WebDriverWait
     from selenium.webdriver.common.by import By
     from selenium.webdriver.support import expected_conditions as EC
-    from archaeological_operations.models import Operation
 
     @classmethod
     def setUpClass(cls):
@@ -3257,10 +3256,20 @@ class SeleniumTests(StaticLiveServerTestCase):
 
         ope1 = create_operation(self.user)
         ope2 = create_operation(self.user)
-        GeomaticFindsTest.create_cr_with_bfs(ope1, "Point", "Point", ["Polygon", "Point"], "CR Pt Poly Pt")
-        GeomaticFindsTest.create_cr_with_bfs(ope1, "Point", "Polygon", ["Polygon", "Point"], "CR Poly Poly Pt")
-        GeomaticFindsTest.create_cr_with_bfs(ope2, "Polygon", "Point", ["Polygon", "Point"], "CR Pt Poly Pt")
-        GeomaticFindsTest.create_cr_with_bfs(ope2, "Polygon", "Polygon", ["Polygon", "Point"], "CR Poly Poly Pt")
+        pks = {'ope': {'Pt': ope1.pk, 'Poly': ope2.pk}, 'cr': {}, 'bf': {}}
+
+        def merge_pks(dic1, dic2):
+            for key in dic2.keys():
+                for label in dic2[key]:
+                    dic1[key][label] = dic2[key][label]
+
+        merge_pks(pks, GeomaticFindsTest.create_cr_with_bfs(ope1, "Point", "Point", ["Polygon", "Point"], "CR Pt Pt"))
+        merge_pks(pks, GeomaticFindsTest.create_cr_with_bfs(ope1, "Point", "Polygon", ["Polygon", "Point"], "CR Pt Poly"))
+        merge_pks(pks, GeomaticFindsTest.create_cr_with_bfs(ope2, "Polygon", "Point", ["Polygon", "Point"], "CR Poly Pt"))
+        merge_pks(pks, GeomaticFindsTest.create_cr_with_bfs(ope2, "Polygon", "Polygon", ["Polygon", "Point"], "CR Poly Poly"))
+
+        print('PKS AAAAAAAAAAAAAAAAA')
+        print(pks)
 
         geom_ope = [
             [[[[1, 1], [5, 1], [5, 5], [1, 5], [1, 1]], [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]]],
@@ -3271,7 +3280,7 @@ class SeleniumTests(StaticLiveServerTestCase):
         geom_cr = [
             [[[[2, 1], [5, 1], [5, 5], [1, 5], [2, 1]], [[2, 2], [2, 3], [3, 3], [3, 2], [2, 2]]],
              [[[6, 3], [9, 2], [9, 4], [6, 3]]]],
-            [3.86111, 3.02778], #TODO: change it
+            [4.17708, 3.11458],
             [3.9, 3]
         ]
         geom_bf = [
@@ -3280,7 +3289,8 @@ class SeleniumTests(StaticLiveServerTestCase):
             [4.42105, 2.73684],
             [3.9, 2.9]
         ]
-        return [geom_ope, geom_cr, geom_bf]
+        return [geom_ope, geom_cr, geom_bf], [ope1.pk, ope2.pk]
+
 
     def scroll(self, element):
         self.selenium.execute_script(