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

umap/storage.py

@@ -0,0 +1,216 @@
+import operator
+import os
+import shutil
+import time
+from gzip import GzipFile
+from pathlib import Path
+
+from botocore.exceptions import ClientError
+from django.conf import settings
+from django.contrib.staticfiles.storage import ManifestStaticFilesStorage
+from django.core.files.storage import FileSystemStorage
+from rcssmin import cssmin
+from rjsmin import jsmin
+from storages.backends.s3 import S3Storage
+
+
+class UmapManifestStaticFilesStorage(ManifestStaticFilesStorage):
+    support_js_module_import_aggregation = True
+    max_post_process_passes = 15
+
+    # We remove `;` at the end of all regexps to match our biome config.
+    _js_module_import_aggregation_patterns = (
+        "*.js",
+        (
+            (
+                (
+                    r"""(?P<matched>import(?s:(?P<import>[\s\{].*?))"""
+                    r"""\s*from\s*['"](?P<url>[\.\/].*?)["']\s*)"""
+                ),
+                'import%(import)s from "%(url)s"\n',
+            ),
+            (
+                (
+                    r"""(?P<matched>export(?s:(?P<exports>[\s\{].*?))"""
+                    r"""\s*from\s*["'](?P<url>[\.\/].*?)["']\s*)"""
+                ),
+                'export%(exports)s from "%(url)s"\n',
+            ),
+            (
+                r"""(?P<matched>import\s*['"](?P<url>[\.\/].*?)["']\s*)""",
+                'import"%(url)s"\n',
+            ),
+            (
+                r"""(?P<matched>import\(["'](?P<url>.*?)["']\)\.then)""",
+                """import("%(url)s").then""",
+            ),
+            (
+                r"""(?P<matched>await import\(["'](?P<url>.*?)["']\))""",
+                """await import("%(url)s")""",
+            ),
+        ),
+    )
+
+    def post_process(self, paths, **options):
+        collected = super().post_process(paths, **options)
+        for original_path, processed_path, processed in collected:
+            if isinstance(processed, Exception):
+                print("Error with file", original_path)
+                raise processed
+            if processed_path.endswith(".js"):
+                path = Path(settings.STATIC_ROOT) / processed_path
+                initial = path.read_text()
+                if "sourceMappingURL" not in initial:  # Already minified.
+                    minified = jsmin(initial)
+                    path.write_text(minified)
+            if processed_path.endswith(".css"):
+                path = Path(settings.STATIC_ROOT) / processed_path
+                initial = path.read_text()
+                if "sourceMappingURL" not in initial:  # Already minified.
+                    minified = cssmin(initial)
+                    path.write_text(minified)
+            yield original_path, processed_path, True
+
+
+class UmapS3(S3Storage):
+    gzip = True
+
+    def get_reference_version(self, instance):
+        metadata = self.connection.meta.client.head_object(
+            Bucket=self.bucket_name, Key=instance.geojson.name
+        )
+        # Do not fail if bucket does not handle versioning
+        return metadata.get("VersionId", metadata["ETag"])
+
+    def make_filename(self, instance):
+        return f"{str(instance.pk)}.geojson"
+
+    def list_versions(self, instance):
+        response = self.connection.meta.client.list_object_versions(
+            Bucket=self.bucket_name, Prefix=instance.geojson.name
+        )
+        return [
+            {
+                "ref": version["VersionId"],
+                "at": version["LastModified"].timestamp() * 1000,
+                "size": version["Size"],
+            }
+            for version in response["Versions"]
+        ]
+
+    def get_version(self, ref, instance):
+        try:
+            data = self.connection.meta.client.get_object(
+                Bucket=self.bucket_name,
+                Key=instance.geojson.name,
+                VersionId=ref,
+            )
+        except ClientError:
+            raise ValueError(f"Invalid version reference: {ref}")
+        return GzipFile(mode="r", fileobj=data["Body"]).read()
+
+    def get_version_path(self, ref, instance):
+        return self.url(instance.geojson.name, parameters={"VersionId": ref})
+
+    def onDatalayerSave(self, instance):
+        pass
+
+    def onDatalayerDelete(self, instance):
+        return self.connection.meta.client.delete_object(
+            Bucket=self.bucket_name,
+            Key=instance.geojson.name,
+        )
+
+
+class UmapFileSystem(FileSystemStorage):
+    def get_reference_version(self, instance):
+        return self._extract_version_ref(instance.geojson.name)
+
+    def make_filename(self, instance):
+        root = self._base_path(instance)
+        name = "%s_%s.geojson" % (instance.pk, int(time.time() * 1000))
+        return root / name
+
+    def list_versions(self, instance):
+        root = self._base_path(instance)
+        names = self.listdir(root)[1]
+        names = [name for name in names if self._is_valid_version(name, instance)]
+        versions = [self._version_metadata(name, instance) for name in names]
+        versions.sort(reverse=True, key=operator.itemgetter("at"))
+        return versions
+
+    def get_version(self, ref, instance):
+        with self.open(self.get_version_path(ref, instance), "r") as f:
+            return f.read()
+
+    def get_version_path(self, ref, instance):
+        base_path = Path(settings.MEDIA_ROOT) / self._base_path(instance)
+        fullpath = base_path / f"{instance.pk}_{ref}.geojson"
+        if instance.old_id and not fullpath.exists():
+            fullpath = base_path / f"{instance.old_id}_{ref}.geojson"
+        if not fullpath.exists():
+            raise ValueError(f"Invalid version reference: {ref}")
+        return fullpath
+
+    def onDatalayerSave(self, instance):
+        self._purge_gzip(instance)
+        self._purge_old_versions(instance, keep=settings.UMAP_KEEP_VERSIONS)
+
+    def onDatalayerDelete(self, instance):
+        self._purge_gzip(instance)
+        self._purge_old_versions(instance, keep=None)
+
+    def _extract_version_ref(self, path):
+        version = path.split(".")[0]
+        if "_" in version:
+            return version.split("_")[-1]
+        return version
+
+    def _base_path(self, instance):
+        path = ["datalayer", str(instance.map.pk)[-1]]
+        if len(str(instance.map.pk)) > 1:
+            path.append(str(instance.map.pk)[-2])
+        path.append(str(instance.map.pk))
+        return Path(os.path.join(*path))
+
+    def _is_valid_version(self, name, instance):
+        valid_prefixes = [name.startswith("%s_" % instance.pk)]
+        if instance.old_id:
+            valid_prefixes.append(name.startswith("%s_" % instance.old_id))
+        return any(valid_prefixes) and name.endswith(".geojson")
+
+    def _version_metadata(self, name, instance):
+        ref = self._extract_version_ref(name)
+        return {
+            "name": name,
+            "ref": ref,
+            "at": ref,
+            "size": self.size(self._base_path(instance) / name),
+        }
+
+    def _purge_old_versions(self, instance, keep=None):
+        root = self._base_path(instance)
+        versions = self.list_versions(instance)
+        if keep is not None:
+            versions = versions[keep:]
+        for version in versions:
+            name = version["name"]
+            # Should not be in the list, but ensure to not delete the file
+            # currently used in database
+            if keep is not None and instance.geojson.name.endswith(name):
+                continue
+            try:
+                self.delete(root / name)
+            except FileNotFoundError:
+                pass
+
+    def _purge_gzip(self, instance):
+        root = self._base_path(instance)
+        names = self.listdir(root)[1]
+        prefixes = [f"{instance.pk}_"]
+        if instance.old_id:
+            prefixes.append(f"{instance.old_id}_")
+        prefixes = tuple(prefixes)
+        for name in names:
+            if name.startswith(prefixes) and name.endswith(".gz"):
+                self.delete(root / name)

umap/templates/base.html

@@ -18,7 +18,6 @@
     <meta name="viewport"
           content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no" />
     {# See https://evilmartians.com/chronicles/how-to-favicon-in-2021-six-files-that-fit-most-needs #}
-    {% autoescape off %}
     <link rel="icon"
           href="{% static 'umap/favicons/favicon.ico' %}"
           sizes="32x32">
@@ -29,7 +28,6 @@
           href="{% static 'umap/favicons/apple-touch-icon.png' %}">
     <!-- 180×180 -->
     <link rel="manifest" href="/manifest.webmanifest">
-    {% endautoescape %}
   </head>
   <body class="{% block body_class %}{% endblock body_class %}">
     {% block header %}

umap/templates/umap/components/alerts/alert.html

@@ -1,10 +1,8 @@
 {% load i18n static %}
 
-{% autoescape off %}
 <style type="text/css">
     @import "{% static 'umap/js/components/alerts/alert.css' %}";
 </style>
-{% endautoescape %}
 <template id="umap-alert-template">
   <div role="dialog" class="dark window umap-alert">
     <div>
@@ -99,7 +97,6 @@
   </div>
 </template>
 <umap-alert-conflict></umap-alert-conflict>
-{% autoescape off %}
 <script type="module">
   import { register } from '{% static 'umap/js/components/base.js' %}'
   import {
@@ -111,4 +108,3 @@
   register(uMapAlertCreation, 'umap-alert-creation')
   register(uMapAlertConflict, 'umap-alert-conflict')
 </script>
-{% endautoescape %}

umap/templates/umap/css.html

@@ -1,7 +1,5 @@
 {% load static %}
 
-{% autoescape off %}
-
 <link rel="stylesheet"
       href="{% static 'umap/vendors/leaflet/leaflet.css' %}" />
 <link rel="stylesheet"
@@ -41,4 +39,3 @@
 <link rel="stylesheet" href="{% static 'umap/css/tableeditor.css' %}" />
 <link rel="stylesheet" href="{% static 'umap/css/bar.css' %}" />
 <link rel="stylesheet" href="{% static 'umap/theme.css' %}" />
-{% endautoescape %}

umap/templates/umap/js.html

@@ -1,6 +1,5 @@
 {% load static %}
 
-{% autoescape off %}
 <script type="module"
         src="{% static 'umap/vendors/leaflet/leaflet-src.esm.js' %}"
         defer></script>
@@ -43,4 +42,3 @@
 <script src="{% static 'umap/js/umap.forms.js' %}" defer></script>
 <script src="{% static 'umap/js/umap.controls.js' %}" defer></script>
 <script type="module" src="{% static 'umap/js/components/fragment.js' %}" defer></script>
-{% endautoescape %}

umap/templates/umap/map_init.html

@@ -5,9 +5,7 @@
 </div>
 <!-- djlint:off -->
 <script defer type="module">
-    {% autoescape off %}
     import Umap from '{% static "umap/js/modules/umap.js" %}'
-    {% endautoescape %}
     U.MAP = new Umap("map", {{ map_settings|notag|safe }})
 </script>
 <!-- djlint:on -->

umap/templates/umap/user_dashboard.html

@@ -46,9 +46,7 @@
 {% block bottom_js %}
   {{ block.super }}
   <script type="module">
-    {% autoescape off %}
     import Umap from '{% static "umap/js/modules/umap.js" %}'
-    {% endautoescape %}
     const CACHE = {}
     for (const mapOpener of document.querySelectorAll("button.map-opener")) {
       mapOpener.addEventListener('click', (event) => {

umap/tests/integration/test_edit_datalayer.py

@@ -221,14 +221,3 @@ def test_deleting_datalayer_should_remove_from_caption(
     page.locator(".panel.right").get_by_title("Delete layer").click()
     page.get_by_role("button", name="OK").click()
     expect(panel.get_by_text("test datalayer")).to_be_hidden()
-
-
-def test_can_edit_datalayer_name_in_list(live_server, openmap, datalayer, page):
-    page.goto(f"{live_server.url}{openmap.get_absolute_url()}?edit")
-    page.get_by_role("link", name="Manage layers").click()
-    page.get_by_text("test datalayer").click()
-    page.get_by_text("test datalayer").fill("test datalayer foobar")
-    page.get_by_role("button", name="Open browser").click()
-    expect(
-        page.locator(".panel.left").get_by_text("test datalayer foobar")
-    ).to_be_visible()

umap/tests/integration/test_import.py

@@ -9,6 +9,7 @@ from playwright.sync_api import expect
 
 from umap.models import DataLayer
 
+from ..base import mock_tiles
 from .helpers import save_and_get_json
 
 pytestmark = pytest.mark.django_db
@@ -764,23 +765,3 @@ def test_import_georss_from_textarea(tilelayer, live_server, page):
     # A layer has been created
     expect(layers).to_have_count(1)
     expect(markers).to_have_count(1)
-
-
-def test_import_from_multiple_files(live_server, page, tilelayer):
-    page.goto(f"{live_server.url}/map/new/")
-    page.get_by_title("Import data").click()
-    file_input = page.locator("input[type='file']")
-    with page.expect_file_chooser() as fc_info:
-        file_input.click()
-    file_chooser = fc_info.value
-    FIXTURES = Path(__file__).parent.parent / "fixtures"
-    paths = [
-        FIXTURES / "test_upload_data.json",
-        FIXTURES / "test_upload_simple_marker.json",
-    ]
-    file_chooser.set_files(paths)
-    markers = page.locator(".leaflet-marker-icon")
-    expect(markers).to_have_count(0)
-    page.get_by_role("button", name="Import data", exact=True).click()
-    # Two in one file, one in the other
-    expect(markers).to_have_count(3)

umap/tests/test_datalayer_s3.py

@@ -27,7 +27,7 @@ def patch_storage():
 
     DataLayer.geojson.field.storage = storages.create_storage(
         {
-            "BACKEND": "umap.storage.s3.S3DataStorage",
+            "BACKEND": "umap.storage.UmapS3",
             "OPTIONS": {
                 "access_key": "testing",
                 "secret_key": "testing",

umap/tests/test_statics.py

@@ -15,7 +15,7 @@ def staticfiles(settings):
     # Make sure settings are properly reset after the test
     settings.STORAGES = deepcopy(settings.STORAGES)
     settings.STORAGES["staticfiles"]["BACKEND"] = (
-        "umap.storage.staticfiles.UmapManifestStaticFilesStorage"
+        "umap.storage.UmapManifestStaticFilesStorage"
     )
     try:
         call_command("collectstatic", "--noinput")

umap/tests/test_team_views.py

@@ -1,7 +1,7 @@
 import pytest
 from django.urls import reverse
 
-from umap.models import Map, Team
+from umap.models import Team
 
 pytestmark = pytest.mark.django_db
 
@@ -15,40 +15,6 @@ def test_can_see_team_maps(client, map, team):
     assert map.name in response.content.decode()
 
 
-@pytest.mark.parametrize("share_status", [Map.PRIVATE, Map.DRAFT])
-def test_others_cannot_see_team_private_maps_in_team_page(
-    client, map, team, user, share_status
-):
-    map.team = team
-    map.share_status = share_status
-    map.save()
-    url = reverse("team_maps", args=(team.pk,))
-    response = client.get(url)
-    assert response.status_code == 200
-    assert map.name not in response.content.decode()
-    # User is not in team
-    client.login(username=user.username, password="123123")
-    response = client.get(url)
-    assert response.status_code == 200
-    assert map.name not in response.content.decode()
-
-
-@pytest.mark.parametrize("share_status", [Map.PRIVATE, Map.DRAFT])
-def test_members_can_see_private_maps_in_team_page(
-    client, map, team, user, share_status
-):
-    map.team = team
-    map.share_status = share_status
-    map.save()
-    user.teams.add(team)
-    user.save()
-    url = reverse("team_maps", args=(team.pk,))
-    client.login(username=user.username, password="123123")
-    response = client.get(url)
-    assert response.status_code == 200
-    assert map.name in response.content.decode()
-
-
 def test_user_can_see_their_teams(client, team, user):
     user.teams.add(team)
     user.save()

umap/tests/test_views.py

@@ -267,6 +267,80 @@ def test_change_user_slug(client, user, settings):
     assert f"/en/user/{user.pk}/" in response.content.decode()
 
 
+@pytest.mark.django_db
+def test_user_dashboard_is_restricted_to_logged_in(client):
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 302
+    assert response["Location"] == "/en/login/?next=/en/me"
+
+
+@pytest.mark.django_db
+def test_user_dashboard_display_user_maps(client, map):
+    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 in body
+    assert f"{map.get_absolute_url()}?edit" in body
+    assert f"{map.get_absolute_url()}?share" in body
+    assert f"/map/{map.pk}/download" in body
+    assert "Everyone (public)" in body
+    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)
+    user.save()
+    map.team = team
+    map.save()
+    client.login(username=user.username, password="123123")
+    response = client.get(reverse("user_dashboard"))
+    assert response.status_code == 200
+    body = response.content.decode()
+    assert map.name in body
+    assert map.get_absolute_url() in body
+
+
+@pytest.mark.django_db
+def test_user_dashboard_display_user_maps_distinct(client, map):
+    # cf https://github.com/umap-project/umap/issues/1325
+    anonymap = MapFactory(name="Map witout owner should not appear")
+    user1 = UserFactory(username="user1")
+    user2 = UserFactory(username="user2")
+    map.editors.add(user1)
+    map.editors.add(user2)
+    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 body.count(f'<a href="/en/map/test-map_{map.pk}">test map</a>') == 1
+    assert body.count(anonymap.name) == 0
+
+
 @pytest.mark.django_db
 def test_logout_should_return_redirect(client, user, settings):
     client.login(username=user.username, password="123123")

umap/views.py

@@ -317,11 +317,7 @@ class TeamMaps(PaginatorMixin, DetailView):
     context_object_name = "current_team"
 
     def get_maps(self):
-        qs = Map.public
-        user = self.request.user
-        if user.is_authenticated and user in self.object.users.all():
-            qs = Map.objects
-        return qs.filter(team=self.object).order_by("-modified_at")
+        return Map.public.filter(team=self.object).order_by("-modified_at")
 
     def get_context_data(self, **kwargs):
         kwargs.update(
@@ -456,27 +452,27 @@ showcase = MapsShowCase.as_view()
 
 
 def validate_url(request):
-    assert request.method == "GET", "Wrong HTTP method"
+    assert request.method == "GET"
     url = request.GET.get("url")
-    assert url, "Missing URL"
+    assert url
     try:
         URLValidator(url)
-    except ValidationError as err:
-        raise AssertionError(err)
-    assert "HTTP_REFERER" in request.META, "Missing HTTP_REFERER"
+    except ValidationError:
+        raise AssertionError()
+    assert "HTTP_REFERER" in request.META
     referer = urlparse(request.META.get("HTTP_REFERER"))
     toproxy = urlparse(url)
     local = urlparse(settings.SITE_URL)
-    assert toproxy.hostname, "No hostname"
-    assert referer.hostname == local.hostname, f"{referer.hostname} != {local.hostname}"
-    assert toproxy.hostname != "localhost", "Invalid localhost target"
-    assert toproxy.netloc != local.netloc, "Invalid netloc"
+    assert toproxy.hostname
+    assert referer.hostname == local.hostname
+    assert toproxy.hostname != "localhost"
+    assert toproxy.netloc != local.netloc
     try:
         # clean this when in python 3.4
         ipaddress = socket.gethostbyname(toproxy.hostname)
-    except Exception as err:
-        raise AssertionError(err)
-    assert not PRIVATE_IP.match(ipaddress), "Private IP"
+    except:
+        raise AssertionError()
+    assert not PRIVATE_IP.match(ipaddress)
     return url
 
 
@@ -484,8 +480,7 @@ class AjaxProxy(View):
     def get(self, *args, **kwargs):
         try:
             url = validate_url(self.request)
-        except AssertionError as err:
-            print(f"AjaxProxy: {err}")
+        except AssertionError:
             return HttpResponseBadRequest()
         try:
             ttl = int(self.request.GET.get("ttl"))
@@ -1173,7 +1168,7 @@ class DataLayerView(BaseDetailView):
             # (no gzip/cache-control/If-Modified-Since/If-None-Match)
             data = self.filedata
             response = HttpResponse(data, content_type="application/geo+json")
-        response["X-Datalayer-Version"] = self.fileversion
+            response["X-Datalayer-Version"] = self.fileversion
         return response
 
 

{umap_project-2.8.0.dist-info → umap_project-2.8.0a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: umap-project
-Version: 2.8.0
+Version: 2.8.0a0
 Summary: Create maps with OpenStreetMap layers in a minute and embed them in your site.
 Author-email: Yohan Boniface <yb@enix.org>
 Maintainer-email: David Larlet <david@larlet.fr>