api for geo_get_items for context records + tests

5 files changed, 341 insertions, 70 deletions

diff --git a/archaeological_context_records/models.py b/archaeological_context_records/models.py
index 5dfaa427a..01eb6e27b 100644
--- a/archaeological_context_records/models.py
+++ b/archaeological_context_records/models.py
@@ -23,11 +23,13 @@ import uuid
 from django.apps import apps
 from django.conf import settings
 from django.contrib.gis.db import models
+from django.contrib.gis.geos import Point
 from django.contrib.postgres.indexes import GinIndex
 from django.core.urlresolvers import reverse
 from django.db import connection
 from django.db.models import Q
 from django.db.models.signals import post_delete, post_save, m2m_changed
+
 from ishtar_common.utils import ugettext_lazy as _, pgettext_lazy, pgettext
 from django.utils.text import slugify
 
@@ -35,7 +37,7 @@ from ishtar_common.utils import (
     cached_label_changed,
     m2m_historization_changed,
     post_save_geo,
-    task
+    task,
 )
 
 from ishtar_common.models import (
@@ -62,7 +64,7 @@ from ishtar_common.models import (
     DocumentItem,
     MainItem,
     QuickAction,
-    RelationsViews
+    RelationsViews,
 )
 from ishtar_common.models_common import HistoricalRecords
 from archaeological_operations.models import (
@@ -856,6 +858,21 @@ class ContextRecord(
                 return precise_poly
         return self.operation.get_precise_polygons()
 
+    def get_geo_items(self, get_polygons, rounded=True):
+        dict = super(ContextRecord, self).get_geo_items(get_polygons, rounded)
+        associated_geo_items = {"associated base finds": {}}
+        BaseFind = apps.get_model("archaeological_finds", "BaseFind")
+        for find_label in self._get_associated_cached_labels():
+            try:
+                bf = BaseFind.objects.get(label=find_label)
+                associated_geo_items["associated base finds"][
+                    str(find_label)
+                ] = bf.get_geo_items(get_polygons, rounded)
+            except BaseFind.DoesNotExist:
+                pass
+        dict["properties"] = associated_geo_items
+        return dict
+
     @classmethod
     def cached_label_bulk_update(
         cls, operation_id=None, parcel_id=None, transaction_id=None
@@ -1385,21 +1402,23 @@ class ContextRecordTree(RelationsViews):
     );
     CREATE INDEX {table}_id ON {table} (cr_id);
     CREATE INDEX {table}_parent_id ON {table} (cr_parent_id);
-    """.format(table="context_records_tree",
-               fk_table="archaeological_context_records_contextrecord")
+    """.format(
+        table="context_records_tree",
+        fk_table="archaeological_context_records_contextrecord",
+    )
 
     key = models.TextField(primary_key=True)
     cr = models.ForeignKey(
         "archaeological_context_records.ContextRecord",
         verbose_name=_("Context record"),
         related_name="context_record_tree_parent",
-        on_delete=models.CASCADE
+        on_delete=models.CASCADE,
     )
     cr_parent = models.ForeignKey(
         "archaeological_context_records.ContextRecord",
         verbose_name=_("Context record parent"),
         related_name="context_record_tree_child",
-        on_delete=models.CASCADE
+        on_delete=models.CASCADE,
     )
 
     class Meta:
@@ -1414,7 +1433,8 @@ class ContextRecordTree(RelationsViews):
                 if child_id != parent_id:
                     cls.objects.get_or_create(
                         key=f"{child_id}_{parent_id}",
-                        cr_id=child_id, cr_parent_id=parent_id
+                        cr_id=child_id,
+                        cr_parent_id=parent_id,
                     )
                     keys.append((child_id, parent_id))
         return keys
@@ -1422,17 +1442,20 @@ class ContextRecordTree(RelationsViews):
     @classmethod
     def _get_base_relations(cls):
         return RelationType.objects.filter(
-            logical_relation__in=('included', 'equal')).values_list("id", flat=True)
+            logical_relation__in=("included", "equal")
+        ).values_list("id", flat=True)
 
     @classmethod
     def _get_base_equal_relations(cls):
-        return RelationType.objects.filter(
-            logical_relation='equal').values_list("id", flat=True)
+        return RelationType.objects.filter(logical_relation="equal").values_list(
+            "id", flat=True
+        )
 
     @classmethod
     def _get_base_included_relations(cls):
-        return RelationType.objects.filter(
-            logical_relation='included').values_list("id", flat=True)
+        return RelationType.objects.filter(logical_relation="included").values_list(
+            "id", flat=True
+        )
 
     @classmethod
     def _get_base_children(cls):
@@ -1441,9 +1464,11 @@ class ContextRecordTree(RelationsViews):
     @classmethod
     def _update_child(cls, parent_id, tree, rel_types):
         whole_tree = set()
-        children = list(RecordRelations.objects.values_list(
-            "left_record_id", flat=True).filter(
-            right_record_id=parent_id, relation_type_id__in=rel_types))
+        children = list(
+            RecordRelations.objects.values_list("left_record_id", flat=True).filter(
+                right_record_id=parent_id, relation_type_id__in=rel_types
+            )
+        )
         to_be_pop = []
         for idx, c in enumerate(children[:]):
             if c in tree:  # cyclic
@@ -1459,8 +1484,8 @@ class ContextRecordTree(RelationsViews):
     @classmethod
     def _get_parent_trees(cls, child_id, trees, rel_types, deep=0):
         parents = RecordRelations.objects.values_list(
-            "right_record_id", flat=True).filter(
-            left_record_id=child_id, relation_type_id__in=rel_types)
+            "right_record_id", flat=True
+        ).filter(left_record_id=child_id, relation_type_id__in=rel_types)
         if not parents:
             return trees
         new_trees = []
@@ -1475,14 +1500,14 @@ class ContextRecordTree(RelationsViews):
     def _get_equals(cls, item_id, equal_rel_types, exclude=None):
         if not exclude:
             exclude = [item_id]
-        q = RecordRelations.objects.values_list(
-            "right_record_id", flat=True).filter(
-            left_record_id=item_id, relation_type_id__in=equal_rel_types)
+        q = RecordRelations.objects.values_list("right_record_id", flat=True).filter(
+            left_record_id=item_id, relation_type_id__in=equal_rel_types
+        )
         q = q.exclude(right_record_id__in=exclude)
         equals = list(q)
-        q = RecordRelations.objects.values_list(
-            "left_record_id", flat=True).filter(
-            right_record_id=item_id, relation_type_id__in=equal_rel_types)
+        q = RecordRelations.objects.values_list("left_record_id", flat=True).filter(
+            right_record_id=item_id, relation_type_id__in=equal_rel_types
+        )
         q = q.exclude(left_record_id__in=exclude)
         equals += list(q)
         exclude += equals
@@ -1496,13 +1521,11 @@ class ContextRecordTree(RelationsViews):
         for equal_id in equals:
             if item_id != equal_id:
                 cls.objects.get_or_create(
-                    key=f"{item_id}_{equal_id}",
-                    cr_id=item_id, cr_parent_id=equal_id
+                    key=f"{item_id}_{equal_id}", cr_id=item_id, cr_parent_id=equal_id
                 )
                 keys.append((item_id, equal_id))
                 cls.objects.get_or_create(
-                    key=f"{equal_id}_{item_id}",
-                    cr_id=equal_id, cr_parent_id=item_id
+                    key=f"{equal_id}_{item_id}", cr_id=equal_id, cr_parent_id=item_id
                 )
                 keys.append((equal_id, item_id))
         return keys
@@ -1518,7 +1541,8 @@ class ContextRecordTree(RelationsViews):
                 if alt_child != child_id:
                     cls.objects.get_or_create(
                         key=f"{alt_child}_{parent_id}",
-                        cr_id=alt_child, cr_parent_id=parent_id
+                        cr_id=alt_child,
+                        cr_parent_id=parent_id,
                     )
                     keys.append((alt_child, parent_id))
             equals_parent = set(cls._get_equals(parent_id, equal_rel_types))
@@ -1527,7 +1551,8 @@ class ContextRecordTree(RelationsViews):
                 if alt_parent != parent_id:
                     cls.objects.get_or_create(
                         key=f"{child_id}_{alt_parent}",
-                        cr_id=child_id, cr_parent_id=alt_parent
+                        cr_id=child_id,
+                        cr_parent_id=alt_parent,
                     )
                     keys.append((child_id, alt_parent))
 
@@ -1535,7 +1560,8 @@ class ContextRecordTree(RelationsViews):
                         if alt_child != child_id:
                             cls.objects.get_or_create(
                                 key=f"{alt_child}_{alt_parent}",
-                                cr_id=alt_child, cr_parent_id=alt_parent
+                                cr_id=alt_child,
+                                cr_parent_id=alt_parent,
                             )
                             keys.append((alt_child, alt_parent))
         return set(keys)
@@ -1545,8 +1571,7 @@ class ContextRecordTree(RelationsViews):
         all_relations = set()
         # add self relation
         cls.objects.get_or_create(
-            key=f"{item_id}_{item_id}",
-            cr_id=item_id, cr_parent_id=item_id
+            key=f"{item_id}_{item_id}", cr_id=item_id, cr_parent_id=item_id
         )
         all_relations.add((item_id, item_id))
         current_relations_as_child = list(
@@ -1561,8 +1586,9 @@ class ContextRecordTree(RelationsViews):
 
         # get first parents
         parent_ids = [
-            tree[-1] for tree in cls._get_parent_trees(item_id, [[item_id]],
-                                                       inc_rel_types)]
+            tree[-1]
+            for tree in cls._get_parent_trees(item_id, [[item_id]], inc_rel_types)
+        ]
         if not parent_ids:
             parent_ids = [item_id]
 
@@ -1580,15 +1606,19 @@ class ContextRecordTree(RelationsViews):
         if not already_updated:
             already_updated = [item_id]
         for parent_id in current_relations_as_child:
-            if (item_id, parent_id) not in all_relations and \
-                    parent_id not in already_updated:
+            if (
+                item_id,
+                parent_id,
+            ) not in all_relations and parent_id not in already_updated:
                 # disappeared - must regenerate
                 already_updated.append(parent_id)
                 cls.objects.filter(key=f"{item_id}_{parent_id}").delete()
                 cls._update(parent_id, already_updated)
         for child_id in current_relations_as_parent:
-            if (child_id, item_id) not in all_relations and \
-                    child_id not in already_updated:
+            if (
+                child_id,
+                item_id,
+            ) not in all_relations and child_id not in already_updated:
                 # disappeared - must regenerate
                 already_updated.append(child_id)
                 cls.objects.filter(key=f"{child_id}_{item_id}").delete()
diff --git a/archaeological_finds/models.py b/archaeological_finds/models.py
index 9f562c703..c8c526d2f 100644
--- a/archaeological_finds/models.py
+++ b/archaeological_finds/models.py
@@ -21,7 +21,7 @@ from archaeological_finds.models_finds import (
     MaterialTypeQualityType,
     ObjectTypeQualityType,
     FindInsideContainer,
-    FunctionalArea
+    FunctionalArea,
 )
 from archaeological_finds.models_treatments import (
     Treatment,
diff --git a/archaeological_finds/tests.py b/archaeological_finds/tests.py
index 004d7d6c2..1c85c2a9a 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
@@ -2514,45 +2514,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": {
@@ -2566,16 +2608,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(
@@ -2595,6 +2695,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):
diff --git a/archaeological_finds/urls.py b/archaeological_finds/urls.py
index 58125cc06..2e2278d87 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/(?P<pk>[0-9]+)/?$",
+        r"api/ishtar/base-finds/geo/polygons/?pk=(?P<pk>[0-9]+)/?$",
         check_rights(["view_find", "view_own_find"])(
             views.get_geo_items,
         ),
@@ -581,13 +581,45 @@ urlpatterns = [
         kwargs={"get_polygons": True},
     ),
     url(
-        r"api/ishtar/base-finds/geo/point/(?P<pk>[0-9]+)/$",
+        r"api/ishtar/base-finds/geo/point/?pk=(?P<pk>[0-9]+)/$",
         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",
+        kwargs={"get_polygons": False},
+    ),
 ]
 
 urlpatterns += get_urls_for_model(models.Find, views, own=True, autocomplete=True)
diff --git a/archaeological_finds/views.py b/archaeological_finds/views.py
index d0ac01305..06bbfe632 100644
--- a/archaeological_finds/views.py
+++ b/archaeological_finds/views.py
@@ -30,6 +30,8 @@ from django.core.urlresolvers import reverse
 from django.db.models import Q
 from django.http import HttpResponseRedirect, HttpResponse, Http404
 from django.shortcuts import redirect
+
+from archaeological_context_records.models import ContextRecord
 from ishtar_common.utils import ugettext_lazy as _
 from django.views.generic import TemplateView
 from django.views.generic.edit import CreateView, FormView
@@ -37,7 +39,7 @@ from django.views.generic.edit import CreateView, FormView
 from ishtar_common.serializers import PublicSerializer
 
 from ishtar_common.models import IshtarUser, get_current_profile
-from archaeological_operations.models import AdministrativeAct
+from archaeological_operations.models import AdministrativeAct, Operation
 from archaeological_finds import models
 
 from ishtar_common.forms import FinalForm
@@ -1318,10 +1320,28 @@ class PublicFindAPI(APIView):
         return Response(serializer.data)
 
 
-def get_geo_items(request, pk, get_polygons, current_right=None):
-    try:
-        base_find = models.BaseFind.objects.get(pk=pk)
-    except models.BaseFind.DoesNotExist:
-        raise Http404()
-    dic = base_find.get_geo_items(get_polygons=get_polygons)
+def get_geo_items(
+    request,
+    get_polygons,
+    pk=None,
+    context_record_pk=None,
+    operation_pk=None,
+    current_right=None,
+):
+    if operation_pk:
+        try:
+            bf = Operation.objects.get(pk=operation_pk)
+        except Operation.DoesNotExist:
+            raise Http404()
+    elif context_record_pk:
+        try:
+            bf = ContextRecord.objects.get(pk=context_record_pk)
+        except ContextRecord.DoesNotExist:
+            raise Http404()
+    else:
+        try:
+            bf = models.BaseFind.objects.get(pk=pk)
+        except models.BaseFind.DoesNotExist:
+            raise Http404()
+    dic = bf.get_geo_items(get_polygons=get_polygons)
     return HttpResponse(json.dumps(dic).encode("utf-8"))