umap-project 2.0.4__py3-none-any.whl → 2.1.0__py3-none-any.whl

umap/tests/test_datalayer_views.py

@@ -35,7 +35,7 @@ def test_get_with_public_mode(client, settings, datalayer, map):
     url = reverse("datalayer_view", args=(map.pk, datalayer.pk))
     response = client.get(url)
     assert response.status_code == 200
-    assert response["Last-Modified"] is not None
+    assert response["X-Datalayer-Version"] is not None
     assert response["Cache-Control"] is not None
     assert "Content-Encoding" not in response
     j = json.loads(response.content.decode())
@@ -111,7 +111,7 @@ def test_update(client, datalayer, map, post_data):
     # Test response is a json
     j = json.loads(response.content.decode())
     assert "id" in j
-    assert datalayer.pk == j["id"]
+    assert str(datalayer.pk) == j["id"]
     assert j["browsable"] is True
     assert Path(modified_datalayer.geojson.path).exists()
 
@@ -154,48 +154,50 @@ def test_should_not_be_possible_to_delete_with_wrong_map_id_in_url(
     assert DataLayer.objects.filter(pk=datalayer.pk).exists()
 
 
-def test_optimistic_concurrency_control_with_good_last_modified(
+def test_optimistic_concurrency_control_with_good_version(
     client, datalayer, map, post_data
 ):
     map.share_status = Map.PUBLIC
     map.save()
-    # Get Last-Modified
+    # Get reference version
     url = reverse("datalayer_view", args=(map.pk, datalayer.pk))
     response = client.get(url)
-    last_modified = response["Last-Modified"]
+    reference_version = response["X-Datalayer-Version"]
     url = reverse("datalayer_update", args=(map.pk, datalayer.pk))
     client.login(username=map.owner.username, password="123123")
     name = "new name"
     post_data["name"] = "new name"
     response = client.post(
-        url, post_data, follow=True, HTTP_IF_UNMODIFIED_SINCE=last_modified
+        url, post_data, follow=True, HTTP_X_DATALAYER_REFERENCE=reference_version
     )
     assert response.status_code == 200
     modified_datalayer = DataLayer.objects.get(pk=datalayer.pk)
     assert modified_datalayer.name == name
 
 
-def test_optimistic_concurrency_control_with_bad_last_modified(
+def test_optimistic_concurrency_control_with_bad_version(
     client, datalayer, map, post_data
 ):
     url = reverse("datalayer_update", args=(map.pk, datalayer.pk))
     client.login(username=map.owner.username, password="123123")
     name = "new name"
     post_data["name"] = name
-    response = client.post(url, post_data, follow=True, HTTP_IF_UNMODIFIED_SINCE="xxx")
+    response = client.post(
+        url, post_data, follow=True, HTTP_X_DATALAYER_REFERENCE="xxx"
+    )
     assert response.status_code == 412
     modified_datalayer = DataLayer.objects.get(pk=datalayer.pk)
     assert modified_datalayer.name != name
 
 
-def test_optimistic_concurrency_control_with_empty_last_modified(
+def test_optimistic_concurrency_control_with_empty_version(
     client, datalayer, map, post_data
 ):
     url = reverse("datalayer_update", args=(map.pk, datalayer.pk))
     client.login(username=map.owner.username, password="123123")
     name = "new name"
     post_data["name"] = name
-    response = client.post(url, post_data, follow=True, HTTP_IF_UNMODIFIED_SINCE=None)
+    response = client.post(url, post_data, follow=True, X_DATALAYER_REFERENCE=None)
     assert response.status_code == 200
     modified_datalayer = DataLayer.objects.get(pk=datalayer.pk)
     assert modified_datalayer.name == name
@@ -225,6 +227,41 @@ def test_versions_should_return_versions(client, datalayer, map, settings):
     assert version in versions["versions"]
 
 
+def test_versions_can_return_old_format(client, datalayer, map, settings):
+    map.share_status = Map.PUBLIC
+    map.save()
+    root = datalayer.storage_root()
+    datalayer.old_id = 123  # old datalayer id (now replaced by uuid)
+    datalayer.save()
+
+    datalayer.geojson.storage.save(
+        "%s/%s_1440924889.geojson" % (root, datalayer.pk), ContentFile("{}")
+    )
+    datalayer.geojson.storage.save(
+        "%s/%s_1440923687.geojson" % (root, datalayer.pk), ContentFile("{}")
+    )
+
+    # store with the id prefix (rather than the uuid)
+    old_format_version = "%s_1440918637.geojson" % datalayer.old_id
+    datalayer.geojson.storage.save(
+        ("%s/" % root) + old_format_version, ContentFile("{}")
+    )
+
+    url = reverse("datalayer_versions", args=(map.pk, datalayer.pk))
+    versions = json.loads(client.get(url).content.decode())
+    assert len(versions["versions"]) == 4
+    version = {
+        "name": old_format_version,
+        "size": 2,
+        "at": "1440918637",
+    }
+    assert version in versions["versions"]
+
+    client.get(
+        reverse("datalayer_version", args=(map.pk, datalayer.pk, old_format_version))
+    )
+
+
 def test_version_should_return_one_version_geojson(client, datalayer, map):
     map.share_status = Map.PUBLIC
     map.save()
@@ -444,7 +481,7 @@ def test_optimistic_merge_both_added(client, datalayer, map, reference_data):
     assert response.status_code == 200
 
     response = client.get(reverse("datalayer_view", args=(map.pk, datalayer.pk)))
-    reference_timestamp = response["Last-Modified"]
+    reference_version = response.headers.get("X-Datalayer-Version")
 
     # Client 1 adds "Point 5, 6" to the existing data
     client1_feature = {
@@ -454,14 +491,16 @@ def test_optimistic_merge_both_added(client, datalayer, map, reference_data):
     }
     client1_data = deepcopy(reference_data)
     client1_data["features"].append(client1_feature)
-    # Sleep to change the current timestamp (used in the If-Unmodified-Since header)
-    time.sleep(1)
+
     post_data["geojson"] = SimpleUploadedFile(
         "foo.json",
         json.dumps(client1_data).encode("utf-8"),
     )
     response = client.post(
-        url, post_data, follow=True, HTTP_IF_UNMODIFIED_SINCE=reference_timestamp
+        url,
+        post_data,
+        follow=True,
+        headers={"X-Datalayer-Reference": reference_version},
     )
     assert response.status_code == 200
 
@@ -479,7 +518,10 @@ def test_optimistic_merge_both_added(client, datalayer, map, reference_data):
         json.dumps(client2_data).encode("utf-8"),
     )
     response = client.post(
-        url, post_data, follow=True, HTTP_IF_UNMODIFIED_SINCE=reference_timestamp
+        url,
+        post_data,
+        follow=True,
+        headers={"X-Datalayer-Reference": reference_version},
     )
     assert response.status_code == 200
     modified_datalayer = DataLayer.objects.get(pk=datalayer.pk)
@@ -513,20 +555,22 @@ def test_optimistic_merge_conflicting_change_raises(
     assert response.status_code == 200
 
     response = client.get(reverse("datalayer_view", args=(map.pk, datalayer.pk)))
-    reference_timestamp = response["Last-Modified"]
+
+    reference_version = response.headers.get("X-Datalayer-Version")
 
     # First client changes the first feature.
     client1_data = deepcopy(reference_data)
     client1_data["features"][0]["geometry"] = {"type": "Point", "coordinates": [5, 6]}
 
-    # Sleep to change the current timestamp (used in the If-Unmodified-Since header)
-    time.sleep(1)
     post_data["geojson"] = SimpleUploadedFile(
         "foo.json",
         json.dumps(client1_data).encode("utf-8"),
     )
     response = client.post(
-        url, post_data, follow=True, HTTP_IF_UNMODIFIED_SINCE=reference_timestamp
+        url,
+        post_data,
+        follow=True,
+        headers={"X-Datalayer-Reference": reference_version},
     )
     assert response.status_code == 200
 
@@ -539,7 +583,10 @@ def test_optimistic_merge_conflicting_change_raises(
         json.dumps(client2_data).encode("utf-8"),
     )
     response = client.post(
-        url, post_data, follow=True, HTTP_IF_UNMODIFIED_SINCE=reference_timestamp
+        url,
+        post_data,
+        follow=True,
+        headers={"X-Datalayer-Reference": reference_version},
     )
     assert response.status_code == 412
 

umap/tests/test_map_views.py

@@ -7,6 +7,7 @@ from django.contrib.auth import get_user_model
 from django.core import mail
 from django.core.signing import Signer
 from django.urls import reverse
+from django.utils import translation
 
 from umap.models import DataLayer, Map, Star
 
@@ -147,6 +148,13 @@ def test_should_not_consider_the_query_string_for_canonical_check(client, map):
     assert response.status_code == 200
 
 
+def test_map_headers(client, map):
+    url = reverse("map", kwargs={"map_id": map.pk, "slug": map.slug})
+    response = client.get(url)
+    assert response.status_code == 200
+    assert response.headers["Access-Control-Allow-Origin"] == "*"
+
+
 def test_short_url_should_redirect_to_canonical(client, map):
     url = reverse("map_short_url", kwargs={"pk": map.pk})
     canonical = reverse("map", kwargs={"map_id": map.pk, "slug": map.slug})
@@ -803,6 +811,7 @@ def test_oembed_map(client, map, datalayer):
     url = f"{reverse('map_oembed')}?url=http://testserver{map.get_absolute_url()}"
     response = client.get(url)
     assert response.status_code == 200
+    assert response.headers["Access-Control-Allow-Origin"] == "*"
     j = json.loads(response.content.decode())
     assert j["type"] == "rich"
     assert j["version"] == "1.0"
@@ -815,6 +824,17 @@ def test_oembed_map(client, map, datalayer):
     )
 
 
+def test_oembed_map_with_non_default_language(client, map, datalayer):
+    translation.activate("en")
+    path = map.get_absolute_url()
+    assert path.startswith("/en/")
+    path = path.replace("/en/", "/fr/")
+    url = f"{reverse('map_oembed')}?url=http://testserver{path}"
+    response = client.get(url)
+    assert response.status_code == 200
+    translation.activate("en")
+
+
 def test_oembed_link(client, map, datalayer):
     response = client.get(map.get_absolute_url())
     assert response.status_code == 200

umap/tests/test_merge_features.py

@@ -1,6 +1,6 @@
 import pytest
 
-from umap.utils import merge_features
+from umap.utils import ConflictError, merge_features
 
 
 def test_adding_one_element():
@@ -50,18 +50,38 @@ def test_removing_same_element():
 
 
 def test_removing_changed_element():
-    with pytest.raises(ValueError):
+    with pytest.raises(ConflictError):
         merge_features(["A", "B"], ["A", "C"], ["A"])
 
 
 def test_changing_removed_element():
-    with pytest.raises(ValueError):
+    with pytest.raises(ConflictError):
         merge_features(["A", "B"], ["A"], ["A", "C"])
 
 
 def test_changing_same_element():
-    with pytest.raises(ValueError):
+    with pytest.raises(ConflictError):
         merge_features(["A", "B"], ["A", "D"], ["A", "C"])
     # Order does not count
-    with pytest.raises(ValueError):
+    with pytest.raises(ConflictError):
         merge_features(["A", "B", "C"], ["B", "D", "A"], ["A", "E", "B"])
+
+
+def test_merge_with_ids_raises():
+    # If reference doesn't have ids, but latest and incoming has
+    # We need to raise as a conflict
+    reference = [
+        {"properties": {}, "geometry": "A"},
+        {"properties": {}, "geometry": "B"},
+    ]
+    latest = [
+        {"properties": {id: "100"}, "geometry": "A"},
+        {"properties": {id: "101"}, "geometry": "B"},
+    ]
+    incoming = [
+        {"properties": {id: "200"}, "geometry": "A"},
+        {"properties": {id: "201"}, "geometry": "B"},
+    ]
+
+    with pytest.raises(ConflictError):
+        merge_features(reference, latest, incoming)

umap/urls.py

@@ -72,18 +72,18 @@ i18n_urls = [
 ]
 i18n_urls += decorated_patterns(
     [can_view_map, cache_control(must_revalidate=True)],
-    re_path(
-        r"^datalayer/(?P<map_id>\d+)/(?P<pk>[\d]+)/$",
+    path(
+        "datalayer/<int:map_id>/<uuid:pk>/",
         views.DataLayerView.as_view(),
         name="datalayer_view",
     ),
-    re_path(
-        r"^datalayer/(?P<map_id>\d+)/(?P<pk>[\d]+)/versions/$",
+    path(
+        "datalayer/<int:map_id>/<uuid:pk>/versions/",
         views.DataLayerVersions.as_view(),
         name="datalayer_versions",
     ),
-    re_path(
-        r"^datalayer/(?P<map_id>\d+)/(?P<pk>[\d]+)/(?P<name>[_\w]+.geojson)$",
+    path(
+        "datalayer/<int:map_id>/<uuid:pk>/<str:name>",
         views.DataLayerVersion.as_view(),
         name="datalayer_version",
     ),
@@ -145,13 +145,13 @@ map_urls = [
         views.DataLayerCreate.as_view(),
         name="datalayer_create",
     ),
-    re_path(
-        r"^map/(?P<map_id>[\d]+)/datalayer/delete/(?P<pk>\d+)/$",
+    path(
+        "map/<int:map_id>/datalayer/delete/<uuid:pk>/",
         views.DataLayerDelete.as_view(),
         name="datalayer_delete",
     ),
-    re_path(
-        r"^map/(?P<map_id>[\d]+)/datalayer/permissions/(?P<pk>\d+)/$",
+    path(
+        "map/<int:map_id>/datalayer/permissions/<uuid:pk>/",
         views.UpdateDataLayerPermissions.as_view(),
         name="datalayer_permissions",
     ),
@@ -165,8 +165,8 @@ if settings.DEFAULT_FROM_EMAIL:
         )
     )
 datalayer_urls = [
-    re_path(
-        r"^map/(?P<map_id>[\d]+)/datalayer/update/(?P<pk>\d+)/$",
+    path(
+        "map/<int:map_id>/datalayer/update/<uuid:pk>/",
         views.DataLayerUpdate.as_view(),
         name="datalayer_update",
     ),

umap/utils.py

@@ -1,7 +1,9 @@
 import gzip
+import json
 import os
 
 from django.conf import settings
+from django.core.serializers.json import DjangoJSONEncoder
 from django.urls import URLPattern, URLResolver, get_resolver
 
 
@@ -162,3 +164,8 @@ def merge_features(reference: list, latest: list, incoming: list):
         merged.append(item)
 
     return merged
+
+
+def json_dumps(obj, **kwargs):
+    """Utility using the Django JSON Encoder when dumping objects"""
+    return json.dumps(obj, cls=DjangoJSONEncoder, **kwargs)

umap/views.py

@@ -38,11 +38,11 @@ from django.http import (
 from django.middleware.gzip import re_accepts_gzip
 from django.shortcuts import get_object_or_404
 from django.urls import resolve, reverse, reverse_lazy
+from django.utils import translation
 from django.utils.encoding import smart_bytes
 from django.utils.http import http_date
 from django.utils.timezone import make_aware
 from django.utils.translation import gettext as _
-from django.utils.translation import to_locale
 from django.views.decorators.cache import cache_control
 from django.views.decorators.http import require_GET
 from django.views.generic import DetailView, TemplateView, View
@@ -67,7 +67,14 @@ from .forms import (
     UserProfileForm,
 )
 from .models import DataLayer, Licence, Map, Pictogram, Star, TileLayer
-from .utils import ConflictError, _urls_for_js, gzip_file, is_ajax, merge_features
+from .utils import (
+    ConflictError,
+    _urls_for_js,
+    gzip_file,
+    is_ajax,
+    json_dumps,
+    merge_features,
+)
 
 User = get_user_model()
 
@@ -315,14 +322,14 @@ class UserDownload(DetailView, SearchMixin):
         with zipfile.ZipFile(zip_buffer, "a", zipfile.ZIP_DEFLATED, False) as zip_file:
             for map_ in self.get_maps():
                 umapjson = map_.generate_umapjson(self.request)
-                geojson_file = io.StringIO(json.dumps(umapjson))
+                geojson_file = io.StringIO(json_dumps(umapjson))
                 file_name = f"umap_backup_{map_.slug}_{map_.pk}.umap"
                 zip_file.writestr(file_name, geojson_file.getvalue())
 
         response = HttpResponse(zip_buffer.getvalue(), content_type="application/zip")
-        response[
-            "Content-Disposition"
-        ] = 'attachment; filename="umap_backup_complete.zip"'
+        response["Content-Disposition"] = (
+            'attachment; filename="umap_backup_complete.zip"'
+        )
         return response
 
 
@@ -354,7 +361,7 @@ class MapsShowCase(View):
             }
 
         geojson = {"type": "FeatureCollection", "features": [make(m) for m in maps]}
-        return HttpResponse(smart_bytes(json.dumps(geojson)))
+        return HttpResponse(smart_bytes(json_dumps(geojson)))
 
 
 showcase = MapsShowCase.as_view()
@@ -441,7 +448,7 @@ ajax_proxy = AjaxProxy.as_view()
 
 
 def simple_json_response(**kwargs):
-    return HttpResponse(json.dumps(kwargs), content_type="application/json")
+    return HttpResponse(json_dumps(kwargs), content_type="application/json")
 
 
 # ############## #
@@ -488,7 +495,7 @@ class MapDetailMixin:
             "urls": _urls_for_js(),
             "tilelayers": TileLayer.get_list(),
             "editMode": self.edit_mode,
-            "default_iconUrl": "%sumap/img/marker.svg" % settings.STATIC_URL,  # noqa
+            "schema": Map.extra_schema,
             "umap_id": self.get_umap_id(),
             "starred": self.is_starred(),
             "licences": dict((l.name, l.json) for l in Licence.objects.all()),
@@ -529,7 +536,7 @@ class MapDetailMixin:
             if hasattr(self.request, "LANGUAGE_CODE"):
                 lang = self.request.LANGUAGE_CODE
             properties["lang"] = lang
-            locale = to_locale(lang)
+            locale = translation.to_locale(lang)
             properties["locale"] = locale
             context["locale"] = locale
         geojson = self.get_geojson()
@@ -537,7 +544,7 @@ class MapDetailMixin:
             geojson["properties"] = {}
         geojson["properties"].update(properties)
         geojson["properties"]["datalayers"] = self.get_datalayers()
-        context["map_settings"] = json.dumps(geojson, indent=settings.DEBUG)
+        context["map_settings"] = json_dumps(geojson, indent=settings.DEBUG)
         self.set_preconnect(geojson["properties"], context)
         return context
 
@@ -608,7 +615,9 @@ class MapView(MapDetailMixin, PermissionsMixin, DetailView):
             if request.META.get("QUERY_STRING"):
                 canonical = "?".join([canonical, request.META["QUERY_STRING"]])
             return HttpResponsePermanentRedirect(canonical)
-        return super(MapView, self).get(request, *args, **kwargs)
+        response = super(MapView, self).get(request, *args, **kwargs)
+        response["Access-Control-Allow-Origin"] = "*"
+        return response
 
     def get_canonical_url(self):
         return self.object.get_absolute_url()
@@ -666,9 +675,9 @@ class MapDownload(DetailView):
     def render_to_response(self, context, *args, **kwargs):
         umapjson = self.object.generate_umapjson(self.request)
         response = simple_json_response(**umapjson)
-        response[
-            "Content-Disposition"
-        ] = f'attachment; filename="umap_backup_{self.object.slug}.umap"'
+        response["Content-Disposition"] = (
+            f'attachment; filename="umap_backup_{self.object.slug}.umap"'
+        )
         return response
 
 
@@ -692,6 +701,8 @@ class MapOEmbed(View):
             raise Http404("Host not allowed.")
 
         url_path = parsed_url.path
+        lang = translation.get_language_from_path(url_path)
+        translation.activate(lang)
         view, args, kwargs = resolve(url_path)
         if "slug" not in kwargs or "map_id" not in kwargs:
             raise Http404("Invalid URL path.")
@@ -715,7 +726,9 @@ class MapOEmbed(View):
             f'<p><a href="//{netloc}{map_url}">{label}</a></p>'
         )
         data["html"] = html
-        return simple_json_response(**data)
+        response = simple_json_response(**data)
+        response["Access-Control-Allow-Origin"] = "*"
+        return response
 
 
 class MapViewGeoJSON(MapView):
@@ -962,20 +975,20 @@ class GZipMixin(object):
 
     @property
     def path(self):
-        return self.object.geojson.path
+        return Path(self.object.geojson.path)
 
     @property
     def gzip_path(self):
         return Path(f"{self.path}{self.EXT}")
 
-    def compute_last_modified(self, path):
-        stat = os.stat(path)
-        return http_date(stat.st_mtime)
+    def read_version(self, path):
+        # Remove optional .gz, then .geojson, then return the trailing version from path.
+        return str(path.with_suffix("").with_suffix("")).split("_")[-1]
 
     @property
-    def last_modified(self):
+    def version(self):
         # Prior to 1.3.0 we did not set gzip mtime as geojson mtime,
-        # but we switched from If-Match header to IF-Unmodified-Since
+        # but we switched from If-Match header to If-Unmodified-Since
         # and when users accepts gzip their last modified value is the gzip
         # (when umap is served by nginx and X-Accel-Redirect)
         # one, so we need to compare with that value in that case.
@@ -985,7 +998,7 @@ class GZipMixin(object):
             if self.accepts_gzip and self.gzip_path.exists()
             else self.path
         )
-        return self.compute_last_modified(path)
+        return self.read_version(path)
 
     @property
     def accepts_gzip(self):
@@ -1016,7 +1029,7 @@ class DataLayerView(GZipMixin, BaseDetailView):
             with open(path, "rb") as f:
                 # Should not be used in production!
                 response = HttpResponse(f.read(), content_type="application/geo+json")
-            response["Last-Modified"] = self.last_modified
+            response["X-Datalayer-Version"] = self.version
             response["Content-Length"] = statobj.st_size
         return response
 
@@ -1024,9 +1037,8 @@ class DataLayerView(GZipMixin, BaseDetailView):
 class DataLayerVersion(DataLayerView):
     @property
     def path(self):
-        return "{root}/{path}".format(
-            root=settings.MEDIA_ROOT,
-            path=self.object.get_version_path(self.kwargs["name"]),
+        return Path(settings.MEDIA_ROOT) / self.object.get_version_path(
+            self.kwargs["name"]
         )
 
 
@@ -1037,11 +1049,11 @@ class DataLayerCreate(FormLessEditMixin, GZipMixin, CreateView):
     def form_valid(self, form):
         form.instance.map = self.kwargs["map_inst"]
         self.object = form.save()
-        # Simple response with only metadatas (including new id)
+        # Simple response with only metadata (including new id)
         response = simple_json_response(
             **self.object.metadata(self.request.user, self.request)
         )
-        response["Last-Modified"] = self.last_modified
+        response["X-Datalayer-Version"] = self.version
         return response
 
 
@@ -1049,30 +1061,29 @@ class DataLayerUpdate(FormLessEditMixin, GZipMixin, UpdateView):
     model = DataLayer
     form_class = DataLayerForm
 
-    def has_been_modified_since(self, if_unmodified_since):
-        return if_unmodified_since and self.last_modified != if_unmodified_since
+    def has_changes_since(self, incoming_version):
+        return incoming_version and self.version != incoming_version
 
-    def merge(self, if_unmodified_since):
+    def merge(self, reference_version):
         """
-        Attempt to apply the incoming changes to the document the client was using, and
-        then merge it with the last document we have on storage.
+        Attempt to apply the incoming changes to the reference, and then merge it
+        with the last document we have on storage.
 
         Returns either None (if the merge failed) or the merged python GeoJSON object.
         """
 
-        # Use If-Modified-Since to find the correct version in our storage.
+        # Use the provided info to find the correct version in our storage.
         for name in self.object.get_versions():
-            path = os.path.join(settings.MEDIA_ROOT, self.object.get_version_path(name))
-            if if_unmodified_since == self.compute_last_modified(path):
+            path = Path(settings.MEDIA_ROOT) / self.object.get_version_path(name)
+            if reference_version == self.read_version(path):
                 with open(path) as f:
                     reference = json.loads(f.read())
                 break
         else:
             # If the document is not found, we can't merge.
             return None
-
         # New data received in the request.
-        entrant = json.loads(self.request.FILES["geojson"].read())
+        incoming = json.loads(self.request.FILES["geojson"].read())
 
         # Latest known version of the data.
         with open(self.path) as f:
@@ -1082,7 +1093,7 @@ class DataLayerUpdate(FormLessEditMixin, GZipMixin, UpdateView):
             merged_features = merge_features(
                 reference.get("features", []),
                 latest.get("features", []),
-                entrant.get("features", []),
+                incoming.get("features", []),
             )
             latest["features"] = merged_features
             return latest
@@ -1097,16 +1108,15 @@ class DataLayerUpdate(FormLessEditMixin, GZipMixin, UpdateView):
         if not self.object.can_edit(user=self.request.user, request=self.request):
             return HttpResponseForbidden()
 
-        ius_header = self.request.META.get("HTTP_IF_UNMODIFIED_SINCE")
-
-        if self.has_been_modified_since(ius_header):
-            merged = self.merge(ius_header)
+        reference_version = self.request.headers.get("X-Datalayer-Reference")
+        if self.has_changes_since(reference_version):
+            merged = self.merge(reference_version)
             if not merged:
                 return HttpResponse(status=412)
 
             # Replace the uploaded file by the merged version.
             self.request.FILES["geojson"].file = BytesIO(
-                json.dumps(merged).encode("utf-8")
+                json_dumps(merged).encode("utf-8")
             )
 
             # Mark the data to be reloaded by form_valid
@@ -1120,8 +1130,7 @@ class DataLayerUpdate(FormLessEditMixin, GZipMixin, UpdateView):
             data["geojson"] = json.loads(self.object.geojson.read().decode())
             self.request.session["needs_reload"] = False
         response = simple_json_response(**data)
-
-        response["Last-Modified"] = self.last_modified
+        response["X-Datalayer-Version"] = self.version
         return response
 
 

umap/wsgi.py

@@ -13,6 +13,7 @@ middleware here, or combine a Django application with an application of another
 framework.
 
 """
+
 import os
 
 os.environ.setdefault("DJANGO_SETTINGS_MODULE", "umap.settings")