umap-project 2.7.3__py3-none-any.whl → 2.8.0a0__py3-none-any.whl

umap/tests/test_datalayer.py

@@ -22,10 +22,11 @@ def test_datalayers_should_be_ordered_by_rank(map, datalayer):
     assert list(map.datalayer_set.all()) == [c1, c2, c3, c4, datalayer]
 
 
-def test_upload_to(map, datalayer):
+def test_upload_to(map):
     map.pk = 302
-    datalayer.pk = 17
-    assert datalayer.upload_to().startswith("datalayer/2/0/302/17_")
+    map.save()
+    datalayer = DataLayerFactory(map=map)
+    assert datalayer.geojson.name.startswith(f"datalayer/2/0/302/{datalayer.pk}_")
 
 
 def test_save_should_use_pk_as_name(map, datalayer):
@@ -65,7 +66,7 @@ def test_clone_should_clone_geojson_too(datalayer):
 def test_should_remove_old_versions_on_save(map, settings):
     datalayer = DataLayerFactory(uuid="0f1161c0-c07f-4ba4-86c5-8d8981d8a813", old_id=17)
     settings.UMAP_KEEP_VERSIONS = 3
-    root = Path(datalayer.storage_root())
+    root = Path(datalayer.geojson.storage._base_path(datalayer))
     before = len(datalayer.geojson.storage.listdir(root)[1])
     newer = f"{datalayer.pk}_1440924889.geojson"
     medium = f"{datalayer.pk}_1440923687.geojson"
@@ -273,9 +274,8 @@ def test_anonymous_can_edit_in_inherit_mode_and_map_in_public_mode(
 
 
 def test_should_remove_all_versions_on_delete(map, settings):
-    settings.UMAP_PURGATORY_ROOT = tempfile.mkdtemp()
     datalayer = DataLayerFactory(uuid="0f1161c0-c07f-4ba4-86c5-8d8981d8a813", old_id=17)
-    root = Path(datalayer.storage_root())
+    root = Path(datalayer.geojson.storage._base_path(datalayer))
     before = len(datalayer.geojson.storage.listdir(root)[1])
     other = "123456_1440918637.geojson"
     files = [
@@ -292,4 +292,3 @@ def test_should_remove_all_versions_on_delete(map, settings):
     datalayer.delete()
     found = datalayer.geojson.storage.listdir(root)[1]
     assert found == [other, f"{other}.gz"]
-    assert len(list(Path(settings.UMAP_PURGATORY_ROOT).iterdir())) == 4 + before

umap/tests/test_datalayer_s3.py

@@ -0,0 +1,135 @@
+import json
+import os
+
+import boto3
+import pytest
+from botocore.errorfactory import ClientError
+from django.core.files.base import ContentFile
+from django.core.files.storage import storages
+from moto import mock_aws
+
+from umap.models import DataLayer
+
+from .base import DataLayerFactory
+
+pytestmark = pytest.mark.django_db
+
+
+@pytest.fixture(scope="module", autouse=True)
+def patch_storage():
+    """Mocked AWS Credentials for moto."""
+    os.environ["AWS_ACCESS_KEY_ID"] = "testing"
+    os.environ["AWS_SECRET_ACCESS_KEY"] = "testing"
+    os.environ["AWS_SECURITY_TOKEN"] = "testing"
+    os.environ["AWS_SESSION_TOKEN"] = "testing"
+    os.environ["AWS_DEFAULT_REGION"] = "us-east-1"
+    before = DataLayer.geojson.field.storage
+
+    DataLayer.geojson.field.storage = storages.create_storage(
+        {
+            "BACKEND": "umap.storage.UmapS3",
+            "OPTIONS": {
+                "access_key": "testing",
+                "secret_key": "testing",
+                "bucket_name": "umap",
+                "region_name": "us-east-1",
+            },
+        }
+    )
+    yield
+    DataLayer.geojson.field.storage = before
+
+
+@pytest.fixture(scope="module", autouse=True)
+def mocked_aws():
+    """
+    Mock all AWS interactions
+    Requires you to create your own boto3 clients
+    """
+    with mock_aws():
+        client = boto3.client("s3", region_name="us-east-1")
+        client.create_bucket(Bucket="umap")
+        client.put_bucket_versioning(
+            Bucket="umap", VersioningConfiguration={"Status": "Enabled"}
+        )
+        yield
+
+
+def test_can_create_datalayer(map, datalayer):
+    other = DataLayerFactory(map=map)
+    assert datalayer.geojson.name == f"{datalayer.pk}.geojson"
+    assert other.geojson.name == f"{other.pk}.geojson"
+
+
+def test_clone_should_return_new_instance(map, datalayer):
+    clone = datalayer.clone()
+    assert datalayer.pk != clone.pk
+    assert datalayer.name == clone.name
+    assert datalayer.map == clone.map
+    assert datalayer.geojson != clone.geojson
+    assert datalayer.geojson.name != clone.geojson.name
+    assert clone.geojson.name == f"{clone.pk}.geojson"
+
+
+def test_update_should_add_version(map, datalayer):
+    assert len(datalayer.versions) == 1
+    datalayer.geojson = ContentFile("{}", "foo.json")
+    datalayer.save()
+    assert len(datalayer.versions) == 2
+
+
+def test_get_version(map, datalayer):
+    assert len(datalayer.versions) == 1
+    datalayer.geojson = ContentFile(b'{"foo": "bar"}', "foo.json")
+    datalayer.save()
+    assert len(datalayer.versions) == 2
+    latest = datalayer.versions[0]["ref"]
+    version = datalayer.get_version(latest)
+    assert json.loads(version) == {"foo": "bar"}
+    older = datalayer.versions[1]["ref"]
+    version = datalayer.get_version(older)
+    assert json.loads(version) == {
+        "_umap_options": {
+            "browsable": True,
+            "displayOnLoad": True,
+            "name": "test datalayer",
+        },
+        "features": [
+            {
+                "geometry": {
+                    "coordinates": [
+                        14.68896484375,
+                        48.55297816440071,
+                    ],
+                    "type": "Point",
+                },
+                "properties": {
+                    "_umap_options": {
+                        "color": "DarkCyan",
+                        "iconClass": "Ball",
+                    },
+                    "description": "Da place anonymous again 755",
+                    "name": "Here",
+                },
+                "type": "Feature",
+            },
+        ],
+        "type": "FeatureCollection",
+    }
+
+    latest = datalayer.reference_version
+    version = datalayer.get_version(latest)
+    assert json.loads(version) == {"foo": "bar"}
+
+
+def test_delete_datalayer_should_delete_all_versions(datalayer):
+    # create a new version
+    datalayer.geojson = ContentFile('{"foo": "bar"}', "foo.json")
+    datalayer.save()
+    s3_key = datalayer.geojson.name
+    datalayer.delete()
+    with pytest.raises(ClientError):
+        datalayer.geojson.storage.connection.meta.client.get_object(
+            Bucket="umap",
+            Key=s3_key,
+        )

umap/tests/test_datalayer_views.py

@@ -1,6 +1,7 @@
 import json
 from copy import deepcopy
 from pathlib import Path
+from uuid import uuid4
 
 import pytest
 from django.core.files.base import ContentFile
@@ -105,6 +106,21 @@ def test_gzip_should_be_created_if_accepted(client, datalayer, map, post_data):
     assert Path(flat).stat().st_mtime_ns == Path(gzipped).stat().st_mtime_ns
 
 
+def test_create_datalayer(client, map, post_data):
+    uuid = str(uuid4())
+    url = reverse("datalayer_create", args=(map.pk, uuid))
+    client.login(username=map.owner.username, password="123123")
+    response = client.post(url, post_data, follow=True)
+    assert response.status_code == 200
+    new_datalayer = DataLayer.objects.get(pk=uuid)
+    assert new_datalayer.name == "name"
+    assert new_datalayer.rank == 0
+    # Test response is a json
+    data = json.loads(response.content.decode())
+    assert "id" in data
+    assert data["id"] == uuid
+
+
 def test_update(client, datalayer, map, post_data):
     url = reverse("datalayer_update", args=(map.pk, datalayer.pk))
     client.login(username=map.owner.username, password="123123")
@@ -215,7 +231,7 @@ def test_optimistic_concurrency_control_with_empty_version(
 def test_versions_should_return_versions(client, datalayer, map, settings):
     map.share_status = Map.PUBLIC
     map.save()
-    root = datalayer.storage_root()
+    root = datalayer.geojson.storage._base_path(datalayer)
     datalayer.geojson.storage.save(
         "%s/%s_1440924889.geojson" % (root, datalayer.pk), ContentFile("{}")
     )
@@ -232,6 +248,7 @@ def test_versions_should_return_versions(client, datalayer, map, settings):
         "name": "%s_1440918637.geojson" % datalayer.pk,
         "size": 2,
         "at": "1440918637",
+        "ref": "1440918637",
     }
     assert version in versions["versions"]
 
@@ -239,7 +256,7 @@ def test_versions_should_return_versions(client, datalayer, map, settings):
 def test_versions_can_return_old_format(client, datalayer, map, settings):
     map.share_status = Map.PUBLIC
     map.save()
-    root = datalayer.storage_root()
+    root = datalayer.geojson.storage._base_path(datalayer)
     datalayer.old_id = 123  # old datalayer id (now replaced by uuid)
     datalayer.save()
 
@@ -263,31 +280,32 @@ def test_versions_can_return_old_format(client, datalayer, map, settings):
         "name": old_format_version,
         "size": 2,
         "at": "1440918637",
+        "ref": "1440918637",
     }
     assert version in versions["versions"]
 
-    client.get(
-        reverse("datalayer_version", args=(map.pk, datalayer.pk, old_format_version))
-    )
+    client.get(reverse("datalayer_version", args=(map.pk, datalayer.pk, "1440918637")))
 
 
 def test_version_should_return_one_version_geojson(client, datalayer, map):
     map.share_status = Map.PUBLIC
     map.save()
-    root = datalayer.storage_root()
+    root = datalayer.geojson.storage._base_path(datalayer)
     name = "%s_1440924889.geojson" % datalayer.pk
     datalayer.geojson.storage.save("%s/%s" % (root, name), ContentFile("{}"))
-    url = reverse("datalayer_version", args=(map.pk, datalayer.pk, name))
-    assert client.get(url).content.decode() == "{}"
+    url = reverse("datalayer_version", args=(map.pk, datalayer.pk, "1440924889"))
+    resp = client.get(url)
+    assert resp.status_code == 200
+    assert resp.content.decode() == "{}"
 
 
 def test_version_should_return_403_if_not_allowed(client, datalayer, map):
     map.share_status = Map.PRIVATE
     map.save()
-    root = datalayer.storage_root()
+    root = datalayer.geojson.storage._base_path(datalayer)
     name = "%s_1440924889.geojson" % datalayer.pk
     datalayer.geojson.storage.save("%s/%s" % (root, name), ContentFile("{}"))
-    url = reverse("datalayer_version", args=(map.pk, datalayer.pk, name))
+    url = reverse("datalayer_version", args=(map.pk, datalayer.pk, "1440924889"))
     assert client.get(url).status_code == 403
 
 

umap/tests/test_empty_trash.py

@@ -0,0 +1,34 @@
+from datetime import datetime, timedelta
+from unittest import mock
+
+import pytest
+from django.core.management import call_command
+
+from umap.models import Map
+
+from .base import MapFactory
+
+pytestmark = pytest.mark.django_db
+
+
+def test_empty_trash(user):
+    recent = MapFactory(owner=user)
+    recent_deleted = MapFactory(owner=user)
+    recent_deleted.move_to_trash()
+    recent_deleted.save()
+    with mock.patch("django.utils.timezone.now") as mocked:
+        mocked.return_value = datetime.utcnow() - timedelta(days=8)
+        old_deleted = MapFactory(owner=user)
+        old_deleted.move_to_trash()
+        old_deleted.save()
+        old = MapFactory(owner=user)
+    assert Map.objects.count() == 4
+    call_command("empty_trash", "--days=7", "--dry-run")
+    assert Map.objects.count() == 4
+    call_command("empty_trash", "--days=9")
+    assert Map.objects.count() == 4
+    call_command("empty_trash", "--days=7")
+    assert not Map.objects.filter(pk=old_deleted.pk)
+    assert Map.objects.filter(pk=old.pk)
+    assert Map.objects.filter(pk=recent.pk)
+    assert Map.objects.filter(pk=recent_deleted.pk)

umap/tests/test_map.py

@@ -2,6 +2,7 @@ import pytest
 from django.contrib.auth.models import AnonymousUser
 from django.urls import reverse
 
+from umap.forms import DEFAULT_CENTER
 from umap.models import Map
 
 from .base import MapFactory
@@ -160,8 +161,16 @@ def test_can_change_default_edit_status(user, settings):
 
 
 def test_can_change_default_share_status(user, settings):
+    map = Map.objects.create(owner=user, center=DEFAULT_CENTER)
+    assert map.share_status == Map.DRAFT
+    settings.UMAP_DEFAULT_SHARE_STATUS = Map.PUBLIC
+    map = Map.objects.create(owner=user, center=DEFAULT_CENTER)
     map = MapFactory(owner=user)
     assert map.share_status == Map.PUBLIC
-    settings.UMAP_DEFAULT_SHARE_STATUS = Map.PRIVATE
-    map = MapFactory(owner=user)
-    assert map.share_status == Map.PRIVATE
+
+
+def test_move_to_trash(user, map):
+    map.move_to_trash()
+    map.save()
+    reloaded = Map.objects.get(pk=map.pk)
+    assert reloaded.share_status == Map.DELETED

umap/tests/test_map_views.py

@@ -42,7 +42,7 @@ def test_create(client, user, post_data):
     assert created_map.center.y == 48.94415123418794
     assert j["permissions"] == {
         "edit_status": 3,
-        "share_status": 1,
+        "share_status": 0,
         "owner": {"id": user.pk, "name": "Joe", "url": "/en/user/Joe/"},
         "editors": [],
     }
@@ -114,8 +114,10 @@ def test_delete(client, map, datalayer):
         url, headers={"X-Requested-With": "XMLHttpRequest"}, follow=True
     )
     assert response.status_code == 200
-    assert not Map.objects.filter(pk=map.pk).exists()
-    assert not DataLayer.objects.filter(pk=datalayer.pk).exists()
+    assert Map.objects.filter(pk=map.pk).exists()
+    assert DataLayer.objects.filter(pk=datalayer.pk).exists()
+    reloaded = Map.objects.get(pk=map.pk)
+    assert reloaded.share_status == Map.DELETED
     # Check that user has not been impacted
     assert User.objects.filter(pk=map.owner.pk).exists()
     # Test response is a json
@@ -241,42 +243,46 @@ def test_map_creation_should_allow_unicode_names(client, map, post_data):
     assert created_map.slug == "map"
 
 
-def test_anonymous_can_access_map_with_share_status_public(client, map):
-    url = reverse("map", args=(map.slug, map.pk))
-    map.share_status = map.PUBLIC
-    map.save()
-    response = client.get(url)
-    assert response.status_code == 200
-
-
-def test_anonymous_can_access_map_with_share_status_open(client, map):
+@pytest.mark.parametrize("share_status", [Map.PUBLIC, Map.OPEN])
+def test_anonymous_can_access_map_with_share_status_accessible(
+    client, map, share_status
+):
     url = reverse("map", args=(map.slug, map.pk))
-    map.share_status = map.OPEN
+    map.share_status = share_status
     map.save()
     response = client.get(url)
     assert response.status_code == 200
 
 
-def test_anonymous_cannot_access_map_with_share_status_private(client, map):
+@pytest.mark.parametrize(
+    "share_status", [Map.PRIVATE, Map.DRAFT, Map.BLOCKED, Map.DELETED]
+)
+def test_anonymous_cannot_access_map_with_share_status_restricted(
+    client, map, share_status
+):
     url = reverse("map", args=(map.slug, map.pk))
-    map.share_status = map.PRIVATE
+    map.share_status = share_status
     map.save()
     response = client.get(url)
     assert response.status_code == 403
 
 
-def test_owner_can_access_map_with_share_status_private(client, map):
+@pytest.mark.parametrize("share_status", [Map.PRIVATE, Map.DRAFT])
+def test_owner_can_access_map_with_share_status_restricted(client, map, share_status):
     url = reverse("map", args=(map.slug, map.pk))
-    map.share_status = map.PRIVATE
+    map.share_status = share_status
     map.save()
     client.login(username=map.owner.username, password="123123")
     response = client.get(url)
     assert response.status_code == 200
 
 
-def test_editors_can_access_map_with_share_status_private(client, map, user):
+@pytest.mark.parametrize("share_status", [Map.PRIVATE, Map.DRAFT])
+def test_editors_can_access_map_with_share_status_resricted(
+    client, map, user, share_status
+):
     url = reverse("map", args=(map.slug, map.pk))
-    map.share_status = map.PRIVATE
+    map.share_status = share_status
     map.editors.add(user)
     map.save()
     client.login(username=user.username, password="123123")
@@ -284,10 +290,11 @@ def test_editors_can_access_map_with_share_status_private(client, map, user):
     assert response.status_code == 200
 
 
-def test_anonymous_cannot_access_map_with_share_status_blocked(client, map):
+def test_owner_cannot_access_map_with_share_status_deleted(client, map):
     url = reverse("map", args=(map.slug, map.pk))
-    map.share_status = map.BLOCKED
+    map.share_status = map.DELETED
     map.save()
+    client.login(username=map.owner.username, password="123123")
     response = client.get(url)
     assert response.status_code == 403
 
@@ -401,14 +408,16 @@ def test_anonymous_delete(cookieclient, anonymap):
         url, headers={"X-Requested-With": "XMLHttpRequest"}, follow=True
     )
     assert response.status_code == 200
-    assert not Map.objects.filter(pk=anonymap.pk).count()
+    assert Map.objects.filter(pk=anonymap.pk).exists()
+    reloaded = Map.objects.get(pk=anonymap.pk)
+    assert reloaded.share_status == Map.DELETED
     # Test response is a json
     j = json.loads(response.content.decode())
     assert "redirect" in j
 
 
 @pytest.mark.usefixtures("allow_anonymous")
-def test_no_cookie_cant_delete(client, anonymap):
+def test_no_cookie_cannot_delete(client, anonymap):
     url = reverse("map_delete", args=(anonymap.pk,))
     response = client.post(
         url, headers={"X-Requested-With": "XMLHttpRequest"}, follow=True
@@ -416,6 +425,24 @@ def test_no_cookie_cant_delete(client, anonymap):
     assert response.status_code == 403
 
 
+@pytest.mark.usefixtures("allow_anonymous")
+def test_no_cookie_cannot_view_anonymous_owned_map_in_draft(client, anonymap):
+    anonymap.share_status = Map.DRAFT
+    anonymap.save()
+    url = reverse("map", kwargs={"map_id": anonymap.pk, "slug": anonymap.slug})
+    response = client.get(url)
+    assert response.status_code == 403
+
+
+@pytest.mark.usefixtures("allow_anonymous")
+def test_owner_can_view_anonymous_owned_map_in_draft(cookieclient, anonymap):
+    anonymap.share_status = Map.DRAFT
+    anonymap.save()
+    url = reverse("map", kwargs={"map_id": anonymap.pk, "slug": anonymap.slug})
+    response = cookieclient.get(url)
+    assert response.status_code == 200
+
+
 @pytest.mark.usefixtures("allow_anonymous")
 def test_anonymous_edit_url(cookieclient, anonymap):
     url = anonymap.get_anonymous_edit_url()
@@ -557,16 +584,6 @@ def test_create_readonly(client, user, post_data, settings):
     assert response.content == b"Site is readonly for maintenance"
 
 
-def test_search(client, map):
-    # Very basic search, that do not deal with accent nor case.
-    # See install.md for how to have a smarter dict + index.
-    map.name = "Blé dur"
-    map.save()
-    url = reverse("search")
-    response = client.get(url + "?q=Blé")
-    assert "Blé dur" in response.content.decode()
-
-
 def test_authenticated_user_can_star_map(client, map, user):
     url = reverse("map_star", args=(map.pk,))
     client.login(username=user.username, password="123123")
@@ -748,7 +765,9 @@ def test_download_multiple_maps_editor(client, map, datalayer):
         assert f.infolist()[1].filename == f"umap_backup_test-map_{map.id}.umap"
 
 
-@pytest.mark.parametrize("share_status", [Map.PRIVATE, Map.BLOCKED])
+@pytest.mark.parametrize(
+    "share_status", [Map.PRIVATE, Map.BLOCKED, Map.DRAFT, Map.DELETED]
+)
 def test_download_shared_status_map(client, map, datalayer, share_status):
     map.share_status = share_status
     map.save()
@@ -757,8 +776,9 @@ def test_download_shared_status_map(client, map, datalayer, share_status):
     assert response.status_code == 403
 
 
-def test_download_my_map(client, map, datalayer):
-    map.share_status = Map.PRIVATE
+@pytest.mark.parametrize("share_status", [Map.PRIVATE, Map.DRAFT])
+def test_download_my_map(client, map, datalayer, share_status):
+    map.share_status = share_status
     map.save()
     client.login(username=map.owner.username, password="123123")
     url = reverse("map_download", args=(map.pk,))
@@ -769,7 +789,19 @@ def test_download_my_map(client, map, datalayer):
     assert j["type"] == "umap"
 
 
-@pytest.mark.parametrize("share_status", [Map.PRIVATE, Map.BLOCKED, Map.OPEN])
+@pytest.mark.parametrize("share_status", [Map.BLOCKED, Map.DELETED])
+def test_download_my_map_blocked_or_deleted(client, map, datalayer, share_status):
+    map.share_status = share_status
+    map.save()
+    client.login(username=map.owner.username, password="123123")
+    url = reverse("map_download", args=(map.pk,))
+    response = client.get(url)
+    assert response.status_code == 403
+
+
+@pytest.mark.parametrize(
+    "share_status", [Map.PRIVATE, Map.BLOCKED, Map.OPEN, Map.DRAFT]
+)
 def test_oembed_shared_status_map(client, map, datalayer, share_status):
     map.share_status = share_status
     map.save()

umap/tests/test_views.py

@@ -288,6 +288,28 @@ def test_user_dashboard_display_user_maps(client, map):
     assert "Owner only" in body
 
 
+@pytest.mark.django_db
+def test_user_dashboard_do_not_display_blocked_user_maps(client, map):
+    map.share_status = Map.BLOCKED
+    map.save()
+    client.login(username=map.owner.username, password="123123")
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 200
+    body = response.content.decode()
+    assert map.name not in body
+
+
+@pytest.mark.django_db
+def test_user_dashboard_do_not_display_deleted_user_maps(client, map):
+    map.share_status = Map.DELETED
+    map.save()
+    client.login(username=map.owner.username, password="123123")
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 200
+    body = response.content.decode()
+    assert map.name not in body
+
+
 @pytest.mark.django_db
 def test_user_dashboard_display_user_team_maps(client, map, team, user):
     user.teams.add(team)
@@ -497,3 +519,34 @@ def test_websocket_token_is_generated_for_editors(client, user, user2, map):
     resp = client.get(token_url)
     token = resp.json().get("token")
     assert TimestampSigner().unsign_object(token, max_age=30)
+
+
+@pytest.mark.django_db
+def test_search(client, map):
+    # Very basic search, that do not deal with accent nor case.
+    # See install.md for how to have a smarter dict + index.
+    map.name = "Blé dur"
+    map.save()
+    url = reverse("search")
+    response = client.get(url + "?q=Blé")
+    assert "Blé dur" in response.content.decode()
+
+
+@pytest.mark.django_db
+def test_cannot_search_blocked_map(client, map):
+    map.name = "Blé dur"
+    map.share_status = Map.BLOCKED
+    map.save()
+    url = reverse("search")
+    response = client.get(url + "?q=Blé")
+    assert "Blé dur" not in response.content.decode()
+
+
+@pytest.mark.django_db
+def test_cannot_search_deleted_map(client, map):
+    map.name = "Blé dur"
+    map.share_status = Map.DELETED
+    map.save()
+    url = reverse("search")
+    response = client.get(url + "?q=Blé")
+    assert "Blé dur" not in response.content.decode()

umap/urls.py

@@ -87,7 +87,7 @@ i18n_urls += decorated_patterns(
         name="datalayer_versions",
     ),
     path(
-        "datalayer/<int:map_id>/<uuid:pk>/<str:name>",
+        "datalayer/<int:map_id>/<uuid:pk>/<str:ref>",
         views.DataLayerVersion.as_view(),
         name="datalayer_version",
     ),
@@ -155,8 +155,8 @@ map_urls = [
         views.MapClone.as_view(),
         name="map_clone",
     ),
-    re_path(
-        r"^map/(?P<map_id>[\d]+)/datalayer/create/$",
+    path(
+        "map/<int:map_id>/datalayer/create/<uuid:pk>/",
         views.DataLayerCreate.as_view(),
         name="datalayer_create",
     ),