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

umap/models.py

@@ -1,17 +1,12 @@
 import json
-import operator
-import os
-import shutil
-import time
 import uuid
-from pathlib import Path
 
 from django.conf import settings
 from django.contrib.auth.models import User
 from django.contrib.gis.db import models
 from django.core.files.base import File
+from django.core.files.storage import storages
 from django.core.signing import Signer
-from django.template.defaultfilters import slugify
 from django.urls import reverse
 from django.utils.functional import classproperty
 from django.utils.translation import gettext_lazy as _
@@ -38,13 +33,22 @@ def get_user_stars_url(self):
     return reverse("user_stars", kwargs={"identifier": identifier})
 
 
+def get_user_metadata(self):
+    return {
+        "id": self.pk,
+        "name": str(self),
+        "url": self.get_url(),
+    }
+
+
 User.add_to_class("__str__", display_name)
 User.add_to_class("get_url", get_user_url)
 User.add_to_class("get_stars_url", get_user_stars_url)
+User.add_to_class("get_metadata", get_user_metadata)
 
 
 def get_default_share_status():
-    return settings.UMAP_DEFAULT_SHARE_STATUS or Map.PUBLIC
+    return settings.UMAP_DEFAULT_SHARE_STATUS or Map.DRAFT
 
 
 def get_default_edit_status():
@@ -161,20 +165,30 @@ class Map(NamedModel):
     ANONYMOUS = 1
     COLLABORATORS = 2
     OWNER = 3
+    DRAFT = 0
     PUBLIC = 1
     OPEN = 2
     PRIVATE = 3
     BLOCKED = 9
+    DELETED = 99
+    ANONYMOUS_EDIT_STATUS = (
+        (OWNER, _("Only editable with secret edit link")),
+        (ANONYMOUS, _("Everyone can edit")),
+    )
     EDIT_STATUS = (
         (ANONYMOUS, _("Everyone")),
         (COLLABORATORS, _("Editors and team only")),
         (OWNER, _("Owner only")),
     )
-    SHARE_STATUS = (
+    ANONYMOUS_SHARE_STATUS = (
+        (DRAFT, _("Draft (private)")),
         (PUBLIC, _("Everyone (public)")),
+    )
+    SHARE_STATUS = ANONYMOUS_SHARE_STATUS + (
         (OPEN, _("Anyone with link")),
         (PRIVATE, _("Editors and team only")),
         (BLOCKED, _("Blocked")),
+        (DELETED, _("Deleted")),
     )
     slug = models.SlugField(db_index=True)
     center = models.PointField(geography=True, verbose_name=_("center"))
@@ -250,13 +264,17 @@ class Map(NamedModel):
                 "hash": False,
                 "scrollWheelZoom": False,
                 "noControl": True,
-                "umap_id": self.pk,
+                "id": self.pk,
                 "schema": self.extra_schema,
                 "slideshow": {},
             }
         )
         return map_settings
 
+    def move_to_trash(self):
+        self.share_status = Map.DELETED
+        self.save()
+
     def delete(self, **kwargs):
         # Explicitely call datalayers.delete, so we can deal with removing files
         # (the cascade delete would not call the model delete method)
@@ -270,7 +288,7 @@ class Map(NamedModel):
         umapjson["uri"] = request.build_absolute_uri(self.get_absolute_url())
         datalayers = []
         for datalayer in self.datalayer_set.all():
-            with open(datalayer.geojson.path, "rb") as f:
+            with datalayer.geojson.open("rb") as f:
                 layer = json.loads(f.read())
             if datalayer.settings:
                 layer["_umap_options"] = datalayer.settings
@@ -352,19 +370,20 @@ class Map(NamedModel):
         return can
 
     def can_view(self, request):
-        if self.share_status == self.BLOCKED:
+        if self.share_status in [Map.BLOCKED, Map.DELETED]:
             can = False
-        elif self.owner is None:
-            can = True
-        elif self.share_status in [self.PUBLIC, self.OPEN]:
+        elif self.share_status in [Map.PUBLIC, Map.OPEN]:
             can = True
+        elif self.owner is None:
+            can = settings.UMAP_ALLOW_ANONYMOUS and self.is_anonymous_owner(request)
         elif not request.user.is_authenticated:
             can = False
         elif request.user == self.owner:
             can = True
         else:
+            restricted = self.share_status in [Map.PRIVATE, Map.DRAFT]
             can = not (
-                self.share_status == self.PRIVATE
+                restricted
                 and request.user not in self.editors.all()
                 and self.team not in request.user.teams.all()
             )
@@ -423,10 +442,11 @@ class Pictogram(NamedModel):
 # Must be out of Datalayer for Django migration to run, because of python 2
 # serialize limitations.
 def upload_to(instance, filename):
-    if instance.pk:
-        return instance.upload_to()
-    name = "%s.geojson" % slugify(instance.name)[:50] or "untitled"
-    return os.path.join(instance.storage_root(), name)
+    return instance.geojson.storage.make_filename(instance)
+
+
+def set_storage():
+    return storages["data"]
 
 
 class DataLayer(NamedModel):
@@ -444,13 +464,18 @@ class DataLayer(NamedModel):
         (COLLABORATORS, _("Editors and team only")),
         (OWNER, _("Owner only")),
     )
-    uuid = models.UUIDField(
-        unique=True, primary_key=True, default=uuid.uuid4, editable=False
+    ANONYMOUS_EDIT_STATUS = (
+        (INHERIT, _("Inherit")),
+        (OWNER, _("Only editable with secret edit link")),
+        (ANONYMOUS, _("Everyone can edit")),
     )
+    uuid = models.UUIDField(unique=True, primary_key=True, editable=False)
     old_id = models.IntegerField(null=True, blank=True)
     map = models.ForeignKey(Map, on_delete=models.CASCADE)
     description = models.TextField(blank=True, null=True, verbose_name=_("description"))
-    geojson = models.FileField(upload_to=upload_to, blank=True, null=True)
+    geojson = models.FileField(
+        upload_to=upload_to, blank=True, null=True, storage=set_storage
+    )
     display_on_load = models.BooleanField(
         default=False,
         verbose_name=_("display on load"),
@@ -469,50 +494,16 @@ class DataLayer(NamedModel):
     class Meta:
         ordering = ("rank",)
 
-    def save(self, force_insert=False, force_update=False, **kwargs):
-        is_new = not bool(self.pk)
-        super(DataLayer, self).save(
-            force_insert=force_insert, force_update=force_update, **kwargs
-        )
-
-        if is_new:
-            force_insert, force_update = False, True
-            filename = self.upload_to()
-            old_name = self.geojson.name
-            new_name = self.geojson.storage.save(filename, self.geojson)
-            self.geojson.storage.delete(old_name)
-            self.geojson.name = new_name
-            super(DataLayer, self).save(
-                force_insert=force_insert, force_update=force_update, **kwargs
-            )
-        self.purge_gzip()
-        self.purge_old_versions()
+    def save(self, **kwargs):
+        super(DataLayer, self).save(**kwargs)
+        self.geojson.storage.onDatalayerSave(self)
+        if hasattr(self, "_reference_version"):
+            del self._reference_version
 
     def delete(self, **kwargs):
-        self.purge_gzip()
-        self.to_purgatory()
+        self.geojson.storage.onDatalayerDelete(self)
         return super().delete(**kwargs)
 
-    def to_purgatory(self):
-        dest = Path(settings.UMAP_PURGATORY_ROOT)
-        dest.mkdir(parents=True, exist_ok=True)
-        src = Path(self.geojson.storage.location) / self.storage_root()
-        for version in self.versions:
-            name = version["name"]
-            shutil.move(src / name, dest / f"{self.map.pk}_{name}")
-
-    def upload_to(self):
-        root = self.storage_root()
-        name = "%s_%s.geojson" % (self.pk, int(time.time() * 1000))
-        return os.path.join(root, name)
-
-    def storage_root(self):
-        path = ["datalayer", str(self.map.pk)[-1]]
-        if len(str(self.map.pk)) > 1:
-            path.append(str(self.map.pk)[-2])
-        path.append(str(self.map.pk))
-        return os.path.join(*path)
-
     def metadata(self, request=None):
         # Retrocompat: minimal settings for maps not saved after settings property
         # has been introduced
@@ -525,73 +516,34 @@ class DataLayer(NamedModel):
         obj["id"] = self.pk
         obj["permissions"] = {"edit_status": self.edit_status}
         obj["editMode"] = "advanced" if self.can_edit(request) else "disabled"
+        obj["_referenceVersion"] = self.reference_version
         return obj
 
     def clone(self, map_inst=None):
         new = self.__class__.objects.get(pk=self.pk)
         new._state.adding = True
-        new.pk = None
+        new.pk = uuid.uuid4()
         if map_inst:
             new.map = map_inst
-        new.geojson = File(new.geojson.file.file)
+        new.geojson = File(new.geojson.file.file, name="tmpname")
         new.save()
         return new
 
-    def is_valid_version(self, name):
-        valid_prefixes = [name.startswith("%s_" % self.pk)]
-        if self.old_id:
-            valid_prefixes.append(name.startswith("%s_" % self.old_id))
-        return any(valid_prefixes) and name.endswith(".geojson")
-
-    def version_metadata(self, name):
-        els = name.split(".")[0].split("_")
-        return {
-            "name": name,
-            "at": els[1],
-            "size": self.geojson.storage.size(self.get_version_path(name)),
-        }
+    @property
+    def reference_version(self):
+        if not hasattr(self, "_reference_version"):
+            self._reference_version = self.geojson.storage.get_reference_version(self)
+        return self._reference_version
 
     @property
     def versions(self):
-        root = self.storage_root()
-        names = self.geojson.storage.listdir(root)[1]
-        names = [name for name in names if self.is_valid_version(name)]
-        versions = [self.version_metadata(name) for name in names]
-        versions.sort(reverse=True, key=operator.itemgetter("at"))
-        return versions
-
-    def get_version(self, name):
-        path = self.get_version_path(name)
-        with self.geojson.storage.open(path, "r") as f:
-            return f.read()
-
-    def get_version_path(self, name):
-        return "{root}/{name}".format(root=self.storage_root(), name=name)
-
-    def purge_old_versions(self):
-        root = self.storage_root()
-        versions = self.versions[settings.UMAP_KEEP_VERSIONS :]
-        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 self.geojson.name.endswith(name):
-                continue
-            try:
-                self.geojson.storage.delete(os.path.join(root, name))
-            except FileNotFoundError:
-                pass
-
-    def purge_gzip(self):
-        root = self.storage_root()
-        names = self.geojson.storage.listdir(root)[1]
-        prefixes = [f"{self.pk}_"]
-        if self.old_id:
-            prefixes.append(f"{self.old_id}_")
-        prefixes = tuple(prefixes)
-        for name in names:
-            if name.startswith(prefixes) and name.endswith(".gz"):
-                self.geojson.storage.delete(os.path.join(root, name))
+        return self.geojson.storage.list_versions(self)
+
+    def get_version(self, ref):
+        return self.geojson.storage.get_version(ref, self)
+
+    def get_version_path(self, ref):
+        return self.geojson.storage.get_version_path(ref, self)
 
     def can_edit(self, request=None):
         """

umap/settings/base.py

@@ -175,10 +175,25 @@ STORAGES = {
     "default": {
         "BACKEND": "django.core.files.storage.FileSystemStorage",
     },
+    "data": {
+        "BACKEND": "umap.storage.UmapFileSystem",
+    },
     "staticfiles": {
         "BACKEND": "umap.storage.UmapManifestStaticFilesStorage",
     },
 }
+# Add application/json and application/geo+json to default django-storages setting
+# in order to gzip our datalayers geojson files.
+GZIP_CONTENT_TYPES = [
+    "text/css",
+    "text/javascript",
+    "application/javascript",
+    "application/x-javascript",
+    "image/svg+xml",
+    "application/json",
+    "application/geo+json",
+]
+
 
 # =============================================================================
 # Templates
@@ -260,14 +275,19 @@ UMAP_MAPS_PER_PAGE_OWNER = 10
 UMAP_SEARCH_CONFIGURATION = "simple"
 UMAP_HELP_URL = "https://wiki.openstreetmap.org/wiki/UMap#Feedback_and_help"
 USER_MAPS_URL = "user_maps"
-DATABASES = {"default": env.db(default="postgis://localhost:5432/umap")}
+DATABASES = {
+    "default": env.db(
+        default="postgis://localhost:5432/umap",
+        engine="django.contrib.gis.db.backends.postgis",
+    )
+}
 UMAP_DEFAULT_SHARE_STATUS = None
 UMAP_DEFAULT_EDIT_STATUS = None
 UMAP_DEFAULT_FEATURES_HAVE_OWNERS = False
 UMAP_HOME_FEED = "latest"
 UMAP_IMPORTERS = {}
 UMAP_HOST_INFOS = {}
-UMAP_PURGATORY_ROOT = "/tmp/umappurgatory"
+UMAP_LABEL_KEYS = ["name", "title"]
 
 UMAP_READONLY = env("UMAP_READONLY", default=False)
 UMAP_GZIP = True