umap-project 2.8.0a0__tar.gz → 2.8.0a2__tar.gz

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: umap-project
-Version: 2.8.0a0
+Version: 2.8.0a2
 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>

umap_project-2.8.0a2/umap/__init__.py

@@ -0,0 +1 @@
+VERSION = "2.8.0a2"

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/locale/en/LC_MESSAGES/django.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2024-12-11 17:05+0000\n"
+"POT-Creation-Date: 2024-12-13 08:26+0000\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -617,57 +617,57 @@ msgstr ""
 msgid "View the map"
 msgstr ""
 
-#: views.py:820
+#: views.py:821
 msgid "See full screen"
 msgstr ""
 
-#: views.py:963
+#: views.py:964
 msgid "Map editors updated with success!"
 msgstr ""
 
-#: views.py:999
+#: views.py:1000
 #, python-format
 msgid "The uMap edit link for your map: %(map_name)s"
 msgstr ""
 
-#: views.py:1002
+#: views.py:1003
 #, python-format
 msgid "Here is your secret edit link: %(link)s"
 msgstr ""
 
-#: views.py:1009
+#: views.py:1010
 #, python-format
 msgid "Can't send email to %(email)s"
 msgstr ""
 
-#: views.py:1012
+#: views.py:1013
 #, python-format
 msgid "Email sent to %(email)s"
 msgstr ""
 
-#: views.py:1023
+#: views.py:1024
 msgid "Only its owner can delete the map."
 msgstr ""
 
-#: views.py:1026
+#: views.py:1027
 msgid "Map successfully deleted."
 msgstr ""
 
-#: views.py:1052
+#: views.py:1053
 #, python-format
 msgid ""
 "Your map has been cloned! If you want to edit this map from another "
 "computer, please use this link: %(anonymous_url)s"
 msgstr ""
 
-#: views.py:1057
+#: views.py:1058
 msgid "Congratulations, your map has been cloned!"
 msgstr ""
 
-#: views.py:1308
+#: views.py:1309
 msgid "Layer successfully deleted."
 msgstr ""
 
-#: views.py:1330
+#: views.py:1331
 msgid "Permissions updated with success!"
 msgstr ""

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/management/commands/empty_trash.py

@@ -23,10 +23,13 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         days = options["days"]
-        since = datetime.utcnow() - timedelta(days=days)
+        since = (datetime.utcnow() - timedelta(days=days)).date()
         print(f"Deleting map in trash since {since}")
         maps = Map.objects.filter(share_status=Map.DELETED, modified_at__lt=since)
         for map in maps:
+            map_id = map.id
+            map_name = map.name
+            trashed_at = map.modified_at.date()
             if not options["dry_run"]:
                 map.delete()
-            print(f"Deleted map {map.name} ({map.id}), trashed on {map.modified_at}")
+            print(f"Deleted map {map_name} ({map_id}), trashed at {trashed_at}")

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/management/commands/migrate_to_S3.py

@@ -2,7 +2,7 @@ from django.conf import settings
 from django.core.management.base import BaseCommand
 
 from umap.models import DataLayer
-from umap.storage import UmapFileSystem
+from umap.storage.fs import FSDataStorage
 
 
 class Command(BaseCommand):
@@ -11,9 +11,9 @@ class Command(BaseCommand):
     def handle(self, *args, **options):
         assert settings.UMAP_READONLY, "You must run that script with a read-only uMap."
         assert (
-            settings.STORAGES["data"]["BACKEND"] == "umap.storage.UmapS3"
+            settings.STORAGES["data"]["BACKEND"] == "umap.storage.s3.S3DataStorage"
         ), "You must configure your storages to point to S3"
-        fs_storage = UmapFileSystem()
+        fs_storage = FSDataStorage()
         for datalayer in DataLayer.objects.all():
             geojson_fs_path = str(datalayer.geojson)
             try:

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/settings/base.py

@@ -176,10 +176,10 @@ STORAGES = {
         "BACKEND": "django.core.files.storage.FileSystemStorage",
     },
     "data": {
-        "BACKEND": "umap.storage.UmapFileSystem",
+        "BACKEND": "umap.storage.fs.FSDataStorage",
     },
     "staticfiles": {
-        "BACKEND": "umap.storage.UmapManifestStaticFilesStorage",
+        "BACKEND": "umap.storage.staticfiles.UmapManifestStaticFilesStorage",
     },
 }
 # Add application/json and application/geo+json to default django-storages setting

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/static/umap/js/modules/data/layer.js

@@ -252,10 +252,11 @@ export class DataLayer extends ServerStored {
   }
 
   fromGeoJSON(geojson, sync = true) {
-    this.addData(geojson, sync)
+    const features = this.addData(geojson, sync)
     this._geojson = geojson
     this.onDataLoaded()
     this.dataChanged()
+    return features
   }
 
   onDataLoaded() {
@@ -315,7 +316,7 @@ export class DataLayer extends ServerStored {
     const response = await this._umap.request.get(url)
     if (response?.ok) {
       this.clear()
-      this._umap.formatter
+      return this._umap.formatter
         .parse(await response.text(), this.options.remoteData.format)
         .then((geojson) => this.fromGeoJSON(geojson))
     }
@@ -443,10 +444,11 @@ export class DataLayer extends ServerStored {
     try {
       // Do not fail if remote data is somehow invalid,
       // otherwise the layer becomes uneditable.
-      this.makeFeatures(geojson, sync)
+      return this.makeFeatures(geojson, sync)
     } catch (err) {
       console.log('Error with DataLayer', this.id)
       console.error(err)
+      return []
     }
   }
 
@@ -463,10 +465,13 @@ export class DataLayer extends ServerStored {
       ? geojson
       : geojson.features || geojson.geometries
     if (!collection) return
+    const features = []
     this.sortFeatures(collection)
-    for (const feature of collection) {
-      this.makeFeature(feature, sync)
+    for (const featureJson of collection) {
+      const feature = this.makeFeature(featureJson, sync)
+      if (feature) features.push(feature)
     }
+    return features
   }
 
   makeFeature(geojson = {}, sync = true, id = null) {
@@ -503,31 +508,47 @@ export class DataLayer extends ServerStored {
   }
 
   async importRaw(raw, format) {
-    this._umap.formatter
+    return this._umap.formatter
       .parse(raw, format)
       .then((geojson) => this.addData(geojson))
-      .then(() => this.zoomTo())
-    this.isDirty = true
+      .then((data) => {
+        if (data?.length) this.isDirty = true
+        return data
+      })
   }
 
-  importFromFiles(files, type) {
-    for (const f of files) {
-      this.importFromFile(f, type)
+  readFile(f) {
+    return new Promise((resolve) => {
+      const reader = new FileReader()
+      reader.onloadend = () => resolve(reader.result)
+      reader.readAsText(f)
+    })
+  }
+
+  async importFromFiles(files, type) {
+    let all = []
+    for (const file of files) {
+      const features = await this.importFromFile(file, type)
+      if (features) {
+        all = all.concat(features)
+      }
     }
+    return new Promise((resolve) => {
+      resolve(all)
+    })
   }
 
-  importFromFile(f, type) {
-    const reader = new FileReader()
+  async importFromFile(file, type) {
     type = type || Utils.detectFileType(f)
-    reader.readAsText(f)
-    reader.onload = (e) => this.importRaw(e.target.result, type)
+    const raw = await this.readFile(file)
+    return this.importRaw(raw, type)
   }
 
   async importFromUrl(uri, type) {
     uri = this._umap.renderUrl(uri)
     const response = await this._umap.request.get(uri)
     if (response?.ok) {
-      this.importRaw(await response.text(), type)
+      return this.importRaw(await response.text(), type)
     }
   }
 
@@ -930,9 +951,9 @@ export class DataLayer extends ServerStored {
     else this.hide()
   }
 
-  zoomTo() {
+  zoomTo(bounds) {
     if (!this.isVisible()) return
-    const bounds = this.layer.getBounds()
+    bounds = bounds || this.layer.getBounds()
     if (bounds.isValid()) {
       const options = { maxZoom: this.getOption('zoomTo') }
       this._leafletMap.fitBounds(bounds, options)

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/static/umap/js/modules/importer.js

@@ -1,4 +1,8 @@
-import { DomEvent, DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
+import {
+  DomEvent,
+  DomUtil,
+  LatLngBounds,
+} from '../../vendors/leaflet/leaflet-src.esm.js'
 import { uMapAlert as Alert } from '../components/alerts/alert.js'
 import { translate } from './i18n.js'
 import { SCHEMA } from './schema.js'
@@ -270,16 +274,12 @@ export default class Importer extends Utils.WithTemplate {
   }
 
   submit() {
-    let hasErrors
     if (this.format === 'umap') {
-      hasErrors = !this.full()
+      this.full()
     } else if (!this.url) {
-      hasErrors = !this.copy()
+      this.copy()
     } else if (this.action) {
-      hasErrors = !this[this.action]()
-    }
-    if (hasErrors === false) {
-      Alert.info(translate('Data successfully imported!'))
+      this[this.action]()
     }
   }
 
@@ -294,8 +294,9 @@ export default class Importer extends Utils.WithTemplate {
       } else if (this.url) {
         this._umap.importFromUrl(this.url, this.format)
       }
+      this.onSuccess()
     } catch (e) {
-      Alert.error(translate('Invalid umap data'))
+      this.onError(translate('Invalid umap data'))
       console.error(e)
       return false
     }
@@ -306,7 +307,7 @@ export default class Importer extends Utils.WithTemplate {
       return false
     }
     if (!this.format) {
-      Alert.error(translate('Please choose a format'))
+      this.onError(translate('Please choose a format'))
       return false
     }
     const layer = this.layer
@@ -318,26 +319,65 @@ export default class Importer extends Utils.WithTemplate {
       layer.options.remoteData.proxy = true
       layer.options.remoteData.ttl = SCHEMA.ttl.default
     }
-    layer.fetchRemoteData(true)
+    layer.fetchRemoteData(true).then((features) => {
+      if (features?.length) {
+        layer.zoomTo()
+        this.onSuccess()
+      } else {
+        this.onError()
+      }
+    })
   }
 
-  copy() {
+  async copy() {
     // Format may be guessed from file later.
     // Usefull in case of multiple files with different formats.
     if (!this.format && !this.files.length) {
-      Alert.error(translate('Please choose a format'))
+      this.onError(translate('Please choose a format'))
       return false
     }
+    let promise
     const layer = this.layer
     if (this.clear) layer.empty()
     if (this.files.length) {
-      for (const file of this.files) {
-        this._umap.processFileToImport(file, layer, this.format)
-      }
+      promise = layer.importFromFiles(this.files, this.format)
     } else if (this.raw) {
-      layer.importRaw(this.raw, this.format)
+      promise = layer.importRaw(this.raw, this.format)
     } else if (this.url) {
-      layer.importFromUrl(this.url, this.format)
+      promise = layer.importFromUrl(this.url, this.format)
+    }
+    if (promise) promise.then((data) => this.onCopyFinished(layer, data))
+  }
+
+  onError(message = translate('No data has been found for import')) {
+    Alert.error(message)
+  }
+
+  onSuccess(count) {
+    if (count) {
+      Alert.success(translate('Successfully imported {count} feature(s)'), {
+        count: count,
+      })
+    } else {
+      Alert.success(translate('Data successfully imported!'))
+    }
+  }
+
+  onCopyFinished(layer, features) {
+    // undefined features means error, let original error message pop
+    if (!features) return
+    if (!features.length) {
+      this.onError()
+    } else {
+      const bounds = new LatLngBounds()
+      for (const feature of features) {
+        const featureBounds = feature.ui.getBounds
+          ? feature.ui.getBounds()
+          : feature.ui.getCenter()
+        bounds.extend(featureBounds)
+      }
+      this.onSuccess(features.length)
+      layer.zoomTo(bounds)
     }
   }
 }

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/static/umap/js/modules/umap.js

@@ -316,12 +316,14 @@ export default class Umap extends ServerStored {
         dataUrl = this.renderUrl(dataUrl)
         dataUrl = this.proxyUrl(dataUrl)
         const datalayer = this.createDataLayer()
-        await datalayer.importFromUrl(dataUrl, dataFormat)
+        await datalayer
+          .importFromUrl(dataUrl, dataFormat)
+          .then(() => datalayer.zoomTo())
       }
     } else if (data) {
       data = decodeURIComponent(data)
       const datalayer = this.createDataLayer()
-      await datalayer.importRaw(data, dataFormat)
+      await datalayer.importRaw(data, dataFormat).then(() => datalayer.zoomTo())
     }
   }
 
@@ -1514,7 +1516,7 @@ export default class Umap extends ServerStored {
   processFileToImport(file, layer, type) {
     type = type || Utils.detectFileType(file)
     if (!type) {
-      U.Alert.error(
+      Alert.error(
         translate('Unable to detect format of file {filename}', {
           filename: file.name,
         })

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/static/umap/locale/en.js

@@ -520,7 +520,9 @@ const locale = {
     "Import helpers": "Import helpers",
     "Import helpers will fill the URL field for you.": "Import helpers will fill the URL field for you.",
     "Wikipedia": "Wikipedia",
-    "Save draft": "Save draft"
+    "Save draft": "Save draft",
+    "No data has been found for import": "No data has been found for import",
+    "Successfully imported {count} feature(s)": "Successfully imported {count} feature(s)"
 }
 L.registerLocale("en", locale)
 L.setLocale("en")

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/static/umap/locale/en.json

@@ -520,5 +520,7 @@
     "Import helpers": "Import helpers",
     "Import helpers will fill the URL field for you.": "Import helpers will fill the URL field for you.",
     "Wikipedia": "Wikipedia",
-    "Save draft": "Save draft"
+    "Save draft": "Save draft",
+    "No data has been found for import": "No data has been found for import",
+    "Successfully imported {count} feature(s)": "Successfully imported {count} feature(s)"
 }

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/static/umap/locale/fr.js

@@ -520,7 +520,9 @@ const locale = {
     "Import helpers": "Assistants d'import",
     "Import helpers will fill the URL field for you.": "Les assistants d'import vont renseigner le champ URL pour vous.",
     "Wikipedia": "Wikipedia",
-    "Save draft": "Enregistrer le brouillon"
+    "Save draft": "Enregistrer le brouillon",
+    "No data has been found for import": "Aucunes données à importer",
+    "Successfully imported {count} feature(s)": "{count} élément(s) ajouté(s) à la carte"
 }
 L.registerLocale("fr", locale)
 L.setLocale("fr")

{umap_project-2.8.0a0 → umap_project-2.8.0a2}/umap/static/umap/locale/fr.json

@@ -520,5 +520,7 @@
     "Import helpers": "Assistants d'import",
     "Import helpers will fill the URL field for you.": "Les assistants d'import vont renseigner le champ URL pour vous.",
     "Wikipedia": "Wikipedia",
-    "Save draft": "Enregistrer le brouillon"
+    "Save draft": "Enregistrer le brouillon",
+    "No data has been found for import": "Aucunes données à importer",
+    "Successfully imported {count} feature(s)": "{count} élément(s) ajouté(s) à la carte"
 }

umap_project-2.8.0a2/umap/storage/__init__.py

@@ -0,0 +1,3 @@
+# Retrocompat
+
+from .staticfiles import UmapManifestStaticFilesStorage  # noqa: F401

umap_project-2.8.0a2/umap/storage/fs.py

@@ -0,0 +1,101 @@
+import operator
+import os
+import time
+from pathlib import Path
+
+from django.conf import settings
+from django.core.files.storage import FileSystemStorage
+
+
+class FSDataStorage(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_project-2.8.0a2/umap/storage/s3.py

@@ -0,0 +1,61 @@
+from gzip import GzipFile
+
+from django.core.exceptions import ImproperlyConfigured
+
+try:
+    from botocore.exceptions import ClientError
+    from storages.backends.s3 import S3Storage
+except ImportError:
+    raise ImproperlyConfigured(
+        "You need to install s3 dependencies: pip install umap-project[s3]"
+    )
+
+
+class S3DataStorage(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,
+        )