Geo display: clean old code - manage bad data

1 files changed, 66 insertions, 69 deletions

diff --git a/archaeological_operations/models.py b/archaeological_operations/models.py
index 69f8d4fdc..69b24fecd 100644
--- a/archaeological_operations/models.py
+++ b/archaeological_operations/models.py
@@ -30,6 +30,7 @@ from django.contrib.gis.db import models
 from django.contrib.gis.db.models.aggregates import Union
 from django.contrib.gis.db.models.functions import Centroid
 from django.contrib.postgres.indexes import GinIndex
+from django.contrib.sites.models import Site
 from django.db import IntegrityError, transaction
 from django.db.models import Q, Count, Sum, Max, Avg
 from django.db.models.signals import post_save, m2m_changed, post_delete
@@ -1729,92 +1730,88 @@ class Operation(
         q = self.towns.filter(limit__isnull=False).annotate(poly=Union("limit")).all()
         if not q.count():
             return None
-        return q.all()[0].poly, self._meta.verbose_namea
-
-    """
-    def _get_child_geodata(self, query, cr_list, collection_context_records_id,
-                           current_geodata):
-        childs = []
-        for cr in query.exclude(id__in=cr_list).values(
-                "main_geodata", "id").distinct().all():
-            childs.append(cr["id"])
-            geodata_id = cr["main_geodata"]
-            if geodata_id not in collection_context_records_id \
-                    and geodata_id not in current_geodata:
-                collection_context_records_id.append(geodata_id)
-        cr_list += childs
-        return childs
-    """
-
-    def get_geo_items(self, rounded=True):
-        dct = super(Operation, self).get_geo_items(rounded=rounded)
-        ContextRecord = apps.get_model(
-            "archaeological_context_records", "ContextRecord"
-        )
-
-        q = self.context_record.filter(main_geodata__isnull=False)
-
-        """
-        included = q.filter(
-            right_relations__relation_type__txt_idx='is_included')
-        q_upper = q.exclude(id__in=set(included.values_list("id", flat=True)))
-        cr_list = []
-
-        childs = self._get_child_geodata(
-            q_upper, cr_list, collection_context_records_id,
-            current_geodata)
-        while childs:
-            new_childs = []
-            for child_id in childs:
-                q_lower = q.filter(
-                    right_relations__relation_type__txt_idx='is_included',
-                    right_relations__right_record_id=child_id
-                )
-                new_childs += self._get_child_geodata(
-                    q_lower, cr_list, collection_context_records_id,
-                    current_geodata)
-            childs = new_childs
-
+        return q.all()[0].poly, self._meta.verbose_name
 
-        
-        """
 
-        collection_context_records_id = []
-        current_geodata = self.geodata.values_list("id", flat=True)
+    def _get_geo_item_list(self, q, current_geodata, url, precision, rounded):
+        collection_id = []
+        items_id = []
         q = q.values("main_geodata", "id")
-        for cr in q.distinct().all():
-            geodata_id = cr["main_geodata"]
-            if geodata_id not in collection_context_records_id \
-                    and geodata_id not in current_geodata:
-                collection_context_records_id.append(geodata_id)
-
-        collection_context_records = []
-        for cr_id in collection_context_records_id:
-            geo = json.loads(GeoVectorData.objects.get(pk=cr_id).geojson)
+        for item in q.distinct().all():
+            geodata_id = item["main_geodata"]
+            if geodata_id not in current_geodata:
+                collection_id.append(geodata_id)
+                items_id.append(item["id"])
+                current_geodata.append(geodata_id)
+
+        collection = []
+        for idx in range(len(collection_id)):
+            geo = json.loads(GeoVectorData.objects.get(pk=collection_id[idx]).geojson)
             geo_type = geo.get("type", None)
+            url_geo = url.format(items_id[idx])
             if geo_type == "FeatureCollection":
-                collection_context_records += geo["features"]
+                for feat in geo["features"]:
+                    if "properties" in feat:
+                        feat["properties"]["url"] = url_geo
+                collection += geo["features"]
             elif geo_type:
-                collection_context_records.append(geo)
+                if "properties" in geo:
+                    geo["properties"]["url"] = url_geo
+                collection.append(geo)
 
-        profile = get_current_profile()
-        precision = profile.point_precision
         if not precision and rounded:
-            precision = 5
-        if precision is not None:
-            r = re.compile(r"(\d+)\.(\d{6})(\d*)")
-            for feat in collection_context_records:
-                geom_type = feat["geometry"].get("type", None)
-                if geom_type == "Point":
+            precision = 6
+        r = re.compile(r"(\d+)\.(\d{6})(\d*)")
+        new_collection = []
+        for feat in collection:
+            geom_type = feat["geometry"].get("type", None)
+            if geom_type == "Point":
+                if precision is not None:
                     feat["geometry"]["coordinates"] = [
                         round(feat["geometry"]["coordinates"][0], precision),
                         round(feat["geometry"]["coordinates"][1], precision),
                     ]
+                if not (-90 <= feat["geometry"]["coordinates"][1] <= 90) or not (
+                        -180 <= feat["geometry"]["coordinates"][0] <= 180):
+                    # probably a bad projection
+                    continue
+            new_collection.append(feat)
+        return new_collection
+
+
+    def get_geo_items(self, rounded=True):
+        dct = super(Operation, self).get_geo_items(rounded=rounded)
+        site = Site.objects.get_current()
+        scheme = "https" if settings.ISHTAR_SECURE else "http"
+        base_url = scheme + "://" + site.domain
+
+        profile = get_current_profile()
+        precision = profile.point_precision
+
+        current_geodata = list(self.geodata.values_list("id", flat=True))
+
+        q = self.context_record.filter(main_geodata__isnull=False)
+        url = base_url + "/show-contextrecord/{}/"
+        collection_context_records = self._get_geo_item_list(
+            q, current_geodata, url, precision, rounded
+        )
+
+        BaseFind = apps.get_model("archaeological_finds", "BaseFind")
+        q = BaseFind.objects.filter(context_record__operation_id=self.pk,
+                                    main_geodata__isnull=False)
+        url = base_url + "/show-basefind/{}/"
+        collection_finds = self._get_geo_item_list(
+            q, current_geodata, url, precision, rounded
+        )
 
         dct["context-records"] = {
             "type": "FeatureCollection",
             "features": collection_context_records,
         }
+        dct["finds"] = {
+            "type": "FeatureCollection",
+            "features": collection_finds,
+        }
         return dct
 
     def context_record_relations_q(self):