umap-project 2.5.1__py3-none-any.whl → 2.6.0b0__py3-none-any.whl

umap/static/umap/js/modules/formatter.js

@@ -22,7 +22,7 @@ export const EXPORT_FORMATS = {
       const table = []
       map.eachFeature((feature) => {
         const row = feature.toGeoJSON().properties
-        const center = feature.getCenter()
+        const center = feature.center
         delete row._umap_options
         row.Latitude = center.lat
         row.Longitude = center.lng
@@ -38,7 +38,16 @@ export const EXPORT_FORMATS = {
 export class Formatter {
   async fromGPX(str) {
     const togeojson = await import('../../vendors/togeojson/togeojson.es.js')
-    return togeojson.gpx(this.toDom(str))
+    const data = togeojson.gpx(this.toDom(str))
+    for (const feature of data.features || []) {
+      feature.properties.description = feature.properties.desc
+      for (const key in feature.properties) {
+        if (key.startsWith('_') || typeof feature.properties[key] === 'object') {
+          delete feature.properties[key]
+        }
+      }
+    }
+    return data
   }
 
   async fromKML(str) {
@@ -106,7 +115,7 @@ export class Formatter {
   }
 
   async fromGeoRSS(str) {
-    return GeoRSSToGeoJSON(this.toDom(c))
+    return GeoRSSToGeoJSON(this.toDom(str))
   }
 
   toDom(x) {

umap/static/umap/js/modules/global.js

@@ -1,9 +1,12 @@
 import {
   uMapAlert as Alert,
-  uMapAlertConflict as AlertConflict,
   uMapAlertCreation as AlertCreation,
 } from '../components/alerts/alert.js'
-import { AjaxAutocomplete, AjaxAutocompleteMultiple, AutocompleteDatalist } from './autocomplete.js'
+import {
+  AjaxAutocomplete,
+  AjaxAutocompleteMultiple,
+  AutocompleteDatalist,
+} from './autocomplete.js'
 import Browser from './browser.js'
 import Caption from './caption.js'
 import Facets from './facets.js'
@@ -19,10 +22,14 @@ import Slideshow from './slideshow.js'
 import { SyncEngine } from './sync/engine.js'
 import Dialog from './ui/dialog.js'
 import { EditPanel, FullPanel, Panel } from './ui/panel.js'
-import TableEditor from './tableeditor.js'
 import Tooltip from './ui/tooltip.js'
 import URLs from './urls.js'
 import * as Utils from './utils.js'
+import * as Icon from './rendering/icon.js'
+import { DataLayer, LAYER_TYPES } from './data/layer.js'
+import { DataLayerPermissions, MapPermissions } from './permissions.js'
+import { Point, LineString, Polygon } from './data/features.js'
+import { LeafletMarker, LeafletPolyline, LeafletPolygon } from './rendering/ui.js'
 
 // Import modules and export them to the global scope.
 // For the not yet module-compatible JS out there.
@@ -31,12 +38,13 @@ import * as Utils from './utils.js'
 window.U = {
   Alert,
   AlertCreation,
-  AlertConflict,
   AjaxAutocomplete,
   AjaxAutocompleteMultiple,
   AutocompleteDatalist,
   Browser,
   Caption,
+  DataLayer,
+  DataLayerPermissions,
   Dialog,
   EditPanel,
   Facets,
@@ -44,10 +52,19 @@ window.U = {
   FullPanel,
   Help,
   HTTPError,
+  Icon,
   Importer,
+  LAYER_TYPES,
+  LeafletMarker,
+  LeafletPolygon,
+  LeafletPolyline,
+  LineString,
+  MapPermissions,
   NOKError,
   Orderable,
   Panel,
+  Point,
+  Polygon,
   Request,
   RequestError,
   Rules,
@@ -56,7 +73,6 @@ window.U = {
   Share,
   Slideshow,
   SyncEngine,
-  TableEditor,
   Tooltip,
   URLs,
   Utils,

umap/static/umap/js/modules/permissions.js

@@ -0,0 +1,280 @@
+import { DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
+import { translate } from './i18n.js'
+import { uMapAlert as Alert } from '../components/alerts/alert.js'
+import * as Utils from './utils.js'
+
+// Dedicated object so we can deal with a separate dirty status, and thus
+// call the endpoint only when needed, saving one call at each save.
+export class MapPermissions {
+  constructor(map) {
+    this.setOptions(map.options.permissions)
+    this.map = map
+    this._isDirty = false
+  }
+
+  set isDirty(status) {
+    this._isDirty = status
+    if (status) this.map.isDirty = status
+  }
+
+  get isDirty() {
+    return this._isDirty
+  }
+
+  setOptions(options) {
+    this.options = Object.assign(
+      {
+        owner: null,
+        team: null,
+        editors: [],
+        share_status: null,
+        edit_status: null,
+      },
+      options
+    )
+  }
+
+  isOwner() {
+    return Boolean(this.map.options.user?.is_owner)
+  }
+
+  isAnonymousMap() {
+    return !this.map.options.permissions.owner
+  }
+
+  getMap() {
+    return this.map
+  }
+
+  edit() {
+    if (this.map.options.editMode !== 'advanced') return
+    if (!this.map.options.umap_id) {
+      return Alert.info(translate('Please save the map first'))
+    }
+    const container = DomUtil.create('div', 'permissions-panel')
+    const fields = []
+    DomUtil.createTitle(container, translate('Update permissions'), 'icon-key')
+    if (this.isAnonymousMap()) {
+      if (this.options.anonymous_edit_url) {
+        const helpText = `${translate('Secret edit link:')}<br>${
+          this.options.anonymous_edit_url
+        }`
+        DomUtil.element({
+          tagName: 'p',
+          className: 'help-text',
+          innerHTML: helpText,
+          parent: container,
+        })
+        fields.push([
+          'options.edit_status',
+          {
+            handler: 'IntSelect',
+            label: translate('Who can edit'),
+            selectOptions: this.map.options.edit_statuses,
+            helpText: helpText,
+          },
+        ])
+      }
+    } else {
+      if (this.isOwner()) {
+        fields.push([
+          'options.edit_status',
+          {
+            handler: 'IntSelect',
+            label: translate('Who can edit'),
+            selectOptions: this.map.options.edit_statuses,
+          },
+        ])
+        fields.push([
+          'options.share_status',
+          {
+            handler: 'IntSelect',
+            label: translate('Who can view'),
+            selectOptions: this.map.options.share_statuses,
+          },
+        ])
+        fields.push([
+          'options.owner',
+          { handler: 'ManageOwner', label: translate("Map's owner") },
+        ])
+        if (this.map.options.user?.teams?.length) {
+          fields.push([
+            'options.team',
+            {
+              handler: 'ManageTeam',
+              label: translate('Attach map to a team'),
+              teams: this.map.options.user.teams,
+            },
+          ])
+        }
+      }
+      fields.push([
+        'options.editors',
+        { handler: 'ManageEditors', label: translate("Map's editors") },
+      ])
+    }
+
+    const builder = new U.FormBuilder(this, fields)
+    const form = builder.build()
+    container.appendChild(form)
+    if (this.isAnonymousMap() && this.map.options.user) {
+      // We have a user, and this user has come through here, so they can edit the map, so let's allow to own the map.
+      // Note: real check is made on the back office anyway.
+      const advancedActions = DomUtil.createFieldset(
+        container,
+        translate('Advanced actions')
+      )
+      const advancedButtons = DomUtil.create('div', 'button-bar', advancedActions)
+      DomUtil.createButton(
+        'button',
+        advancedButtons,
+        translate('Attach the map to my account'),
+        this.attach,
+        this
+      )
+    }
+    DomUtil.add('h4', '', container, translate('Datalayers'))
+    this.map.eachDataLayer((datalayer) => {
+      datalayer.permissions.edit(container)
+    })
+    this.map.editPanel.open({ content: container, className: 'dark' })
+  }
+
+  async attach() {
+    const [data, response, error] = await this.map.server.post(this.getAttachUrl())
+    if (!error) {
+      this.options.owner = this.map.options.user
+      Alert.success(translate('Map has been attached to your account'))
+      this.map.editPanel.close()
+    }
+  }
+
+  async save() {
+    if (!this.isDirty) return this.map.continueSaving()
+    const formData = new FormData()
+    if (!this.isAnonymousMap() && this.options.editors) {
+      const editors = this.options.editors.map((u) => u.id)
+      for (let i = 0; i < this.options.editors.length; i++)
+        formData.append('editors', this.options.editors[i].id)
+    }
+    if (this.isOwner() || this.isAnonymousMap())
+      formData.append('edit_status', this.options.edit_status)
+    if (this.isOwner()) {
+      formData.append('owner', this.options.owner?.id)
+      formData.append('team', this.options.team?.id || '')
+      formData.append('share_status', this.options.share_status)
+    }
+    const [data, response, error] = await this.map.server.post(
+      this.getUrl(),
+      {},
+      formData
+    )
+    if (!error) {
+      this.commit()
+      this.isDirty = false
+      this.map.continueSaving()
+      this.map.fire('postsync')
+    }
+  }
+
+  getUrl() {
+    return Utils.template(this.map.options.urls.map_update_permissions, {
+      map_id: this.map.options.umap_id,
+    })
+  }
+
+  getAttachUrl() {
+    return Utils.template(this.map.options.urls.map_attach_owner, {
+      map_id: this.map.options.umap_id,
+    })
+  }
+
+  commit() {
+    this.map.options.permissions = Object.assign(
+      this.map.options.permissions,
+      this.options
+    )
+  }
+
+  getShareStatusDisplay() {
+    return Object.fromEntries(this.map.options.share_statuses)[
+      this.options.share_status
+    ]
+  }
+}
+
+export class DataLayerPermissions {
+  constructor(datalayer) {
+    this.options = Object.assign(
+      {
+        edit_status: null,
+      },
+      datalayer.options.permissions
+    )
+
+    this.datalayer = datalayer
+    this._isDirty = false
+  }
+
+  set isDirty(status) {
+    this._isDirty = status
+    if (status) this.datalayer.isDirty = status
+  }
+
+  get isDirty() {
+    return this._isDirty
+  }
+
+  getMap() {
+    return this.datalayer.map
+  }
+
+  edit(container) {
+    const fields = [
+      [
+        'options.edit_status',
+        {
+          handler: 'IntSelect',
+          label: translate('Who can edit "{layer}"', {
+            layer: this.datalayer.getName(),
+          }),
+          selectOptions: this.datalayer.map.options.datalayer_edit_statuses,
+        },
+      ],
+    ]
+    const builder = new U.FormBuilder(this, fields, {
+      className: 'umap-form datalayer-permissions',
+    })
+    const form = builder.build()
+    container.appendChild(form)
+  }
+
+  getUrl() {
+    return Utils.template(this.datalayer.map.options.urls.datalayer_permissions, {
+      map_id: this.datalayer.map.options.umap_id,
+      pk: this.datalayer.umap_id,
+    })
+  }
+  async save() {
+    if (!this.isDirty) return this.datalayer.map.continueSaving()
+    const formData = new FormData()
+    formData.append('edit_status', this.options.edit_status)
+    const [data, response, error] = await this.datalayer.map.server.post(
+      this.getUrl(),
+      {},
+      formData
+    )
+    if (!error) {
+      this.commit()
+      this.isDirty = false
+      this.datalayer.map.continueSaving()
+    }
+  }
+
+  commit() {
+    this.datalayer.options.permissions = Object.assign(
+      this.datalayer.options.permissions,
+      this.options
+    )
+  }
+}

umap/static/umap/js/{umap.icon.js → modules/rendering/icon.js}

@@ -1,16 +1,36 @@
-U.Icon = L.DivIcon.extend({
-  statics: {
-    RECENT: [],
-  },
-  initialize: function (map, options) {
-    this.map = map
+import {
+  DomEvent,
+  DomUtil,
+  DivIcon,
+  Icon,
+} from '../../../vendors/leaflet/leaflet-src.esm.js'
+import * as Utils from '../utils.js'
+import { SCHEMA } from '../schema.js'
+
+export function getClass(name) {
+  switch (name) {
+    case 'Circle':
+      return Circle
+    case 'Ball':
+      return Ball
+    case 'Drop':
+      return Drop
+    default:
+      return DefaultIcon
+  }
+}
+
+export const RECENT = []
+
+const BaseIcon = L.DivIcon.extend({
+  initialize: function (options) {
     const default_options = {
       iconSize: null, // Made in css
-      iconUrl: this.map.getDefaultOption('iconUrl'),
+      iconUrl: SCHEMA.iconUrl.default,
       feature: null,
     }
     options = L.Util.extend({}, default_options, options)
-    L.Icon.prototype.initialize.call(this, options)
+    Icon.prototype.initialize.call(this, options)
     this.feature = this.options.feature
     if (this.feature?.isReadOnly()) {
       this.options.className += ' readonly'
@@ -18,10 +38,10 @@ U.Icon = L.DivIcon.extend({
   },
 
   _setRecent: (url) => {
-    if (U.Utils.hasVar(url)) return
-    if (url === U.SCHEMA.iconUrl.default) return
-    if (U.Icon.RECENT.indexOf(url) === -1) {
-      U.Icon.RECENT.push(url)
+    if (Utils.hasVar(url)) return
+    if (url === SCHEMA.iconUrl.default) return
+    if (RECENT.indexOf(url) === -1) {
+      RECENT.push(url)
     }
   },
 
@@ -33,29 +53,26 @@ U.Icon = L.DivIcon.extend({
     } else {
       url = this.options[`${name}Url`]
     }
-    return this.formatUrl(url, this.feature)
+    return formatUrl(url, this.feature)
   },
 
   _getColor: function () {
     let color
     if (this.feature) color = this.feature.getDynamicOption('color')
     else if (this.options.color) color = this.options.color
-    else color = this.map.getDefaultOption('color')
+    else color = SCHEMA.color.default
     return color
   },
 
   _getOpacity: function () {
     if (this.feature) return this.feature.getOption('iconOpacity')
-    return this.map.getDefaultOption('iconOpacity')
+    return SCHEMA.iconOpacity.default
   },
 
-  formatUrl: (url, feature) =>
-    U.Utils.greedyTemplate(url || '', feature ? feature.extendedProperties() : {}),
-
   onAdd: () => {},
 })
 
-U.Icon.Default = U.Icon.extend({
+const DefaultIcon = BaseIcon.extend({
   default_options: {
     iconAnchor: new L.Point(16, 40),
     popupAnchor: new L.Point(0, -40),
@@ -63,13 +80,13 @@ U.Icon.Default = U.Icon.extend({
     className: 'umap-div-icon',
   },
 
-  initialize: function (map, options) {
+  initialize: function (options) {
     options = L.Util.extend({}, this.default_options, options)
-    U.Icon.prototype.initialize.call(this, map, options)
+    BaseIcon.prototype.initialize.call(this, options)
   },
 
   _setIconStyles: function (img, name) {
-    U.Icon.prototype._setIconStyles.call(this, img, name)
+    BaseIcon.prototype._setIconStyles.call(this, img, name)
     const color = this._getColor()
     const opacity = this._getOpacity()
     this.elements.container.style.backgroundColor = color
@@ -81,54 +98,56 @@ U.Icon.Default = U.Icon.extend({
   onAdd: function () {
     const src = this._getIconUrl('icon')
     const bgcolor = this._getColor()
-    U.Icon.setIconContrast(this.elements.icon, this.elements.container, src, bgcolor)
+    setContrast(this.elements.icon, this.elements.container, src, bgcolor)
   },
 
   createIcon: function () {
     this.elements = {}
-    this.elements.main = L.DomUtil.create('div')
-    this.elements.container = L.DomUtil.create(
+    this.elements.main = DomUtil.create('div')
+    this.elements.container = DomUtil.create(
       'div',
       'icon_container',
       this.elements.main
     )
-    this.elements.arrow = L.DomUtil.create('div', 'icon_arrow', this.elements.main)
+    this.elements.main.dataset.feature = this.feature?.id
+    this.elements.arrow = DomUtil.create('div', 'icon_arrow', this.elements.main)
     const src = this._getIconUrl('icon')
     if (src) {
-      this.elements.icon = U.Icon.makeIconElement(src, this.elements.container)
+      this.elements.icon = makeElement(src, this.elements.container)
     }
     this._setIconStyles(this.elements.main, 'icon')
     return this.elements.main
   },
 })
 
-U.Icon.Circle = U.Icon.extend({
-  initialize: function (map, options) {
+const Circle = BaseIcon.extend({
+  initialize: function (options) {
     const default_options = {
       popupAnchor: new L.Point(0, -6),
       tooltipAnchor: new L.Point(6, 0),
       className: 'umap-circle-icon',
     }
     options = L.Util.extend({}, default_options, options)
-    U.Icon.prototype.initialize.call(this, map, options)
+    BaseIcon.prototype.initialize.call(this, options)
   },
 
   _setIconStyles: function (img, name) {
-    U.Icon.prototype._setIconStyles.call(this, img, name)
+    BaseIcon.prototype._setIconStyles.call(this, img, name)
     this.elements.main.style.backgroundColor = this._getColor()
     this.elements.main.style.opacity = this._getOpacity()
   },
 
   createIcon: function () {
     this.elements = {}
-    this.elements.main = L.DomUtil.create('div')
+    this.elements.main = DomUtil.create('div')
     this.elements.main.innerHTML = ' '
     this._setIconStyles(this.elements.main, 'icon')
+    this.elements.main.dataset.feature = this.feature?.id
     return this.elements.main
   },
 })
 
-U.Icon.Drop = U.Icon.Default.extend({
+const Drop = DefaultIcon.extend({
   default_options: {
     iconAnchor: new L.Point(16, 42),
     popupAnchor: new L.Point(0, -42),
@@ -137,7 +156,7 @@ U.Icon.Drop = U.Icon.Default.extend({
   },
 })
 
-U.Icon.Ball = U.Icon.Default.extend({
+const Ball = DefaultIcon.extend({
   default_options: {
     iconAnchor: new L.Point(8, 30),
     popupAnchor: new L.Point(0, -28),
@@ -147,19 +166,20 @@ U.Icon.Ball = U.Icon.Default.extend({
 
   createIcon: function () {
     this.elements = {}
-    this.elements.main = L.DomUtil.create('div')
-    this.elements.container = L.DomUtil.create(
+    this.elements.main = DomUtil.create('div')
+    this.elements.container = DomUtil.create(
       'div',
       'icon_container',
       this.elements.main
     )
-    this.elements.arrow = L.DomUtil.create('div', 'icon_arrow', this.elements.main)
+    this.elements.main.dataset.feature = this.feature?.id
+    this.elements.arrow = DomUtil.create('div', 'icon_arrow', this.elements.main)
     this._setIconStyles(this.elements.main, 'icon')
     return this.elements.main
   },
 
   _setIconStyles: function (img, name) {
-    U.Icon.prototype._setIconStyles.call(this, img, name)
+    BaseIcon.prototype._setIconStyles.call(this, img, name)
     const color = this._getColor('color')
     let background
     if (L.Browser.ielt9) {
@@ -174,7 +194,7 @@ U.Icon.Ball = U.Icon.Default.extend({
   },
 })
 
-U.Icon.Cluster = L.DivIcon.extend({
+export const Cluster = DivIcon.extend({
   options: {
     iconSize: [40, 40],
   },
@@ -185,9 +205,9 @@ U.Icon.Cluster = L.DivIcon.extend({
   },
 
   createIcon: function () {
-    const container = L.DomUtil.create('div', 'leaflet-marker-icon marker-cluster')
-    const div = L.DomUtil.create('div', '', container)
-    const span = L.DomUtil.create('span', '', div)
+    const container = DomUtil.create('div', 'leaflet-marker-icon marker-cluster')
+    const div = DomUtil.create('div', '', container)
+    const span = DomUtil.create('span', '', div)
     const backgroundColor = this.datalayer.getColor()
     span.textContent = this.cluster.getChildCount()
     div.style.backgroundColor = backgroundColor
@@ -200,27 +220,28 @@ U.Icon.Cluster = L.DivIcon.extend({
     if (this.datalayer.options.cluster?.textColor) {
       color = this.datalayer.options.cluster.textColor
     }
-    return color || L.DomUtil.TextColorFromBackgroundColor(el, backgroundColor)
+    return color || DomUtil.TextColorFromBackgroundColor(el, backgroundColor)
   },
 })
 
-U.Icon.isImg = (src) =>
-  U.Utils.isPath(src) || U.Utils.isRemoteUrl(src) || U.Utils.isDataImage(src)
+export function isImg(src) {
+  return Utils.isPath(src) || Utils.isRemoteUrl(src) || Utils.isDataImage(src)
+}
 
-U.Icon.makeIconElement = (src, parent) => {
+export function makeElement(src, parent) {
   let icon
-  if (U.Icon.isImg(src)) {
-    icon = L.DomUtil.create('img')
+  if (isImg(src)) {
+    icon = DomUtil.create('img')
     icon.src = src
   } else {
-    icon = L.DomUtil.create('span')
+    icon = DomUtil.create('span')
     icon.textContent = src
   }
   parent.appendChild(icon)
   return icon
 }
 
-U.Icon.setIconContrast = (icon, parent, src, bgcolor) => {
+export function setContrast(icon, parent, src, bgcolor) {
   /*
    * icon: the element we'll adapt the style, it can be an image or text
    * parent: the element we'll consider to decide whether to adapt the style,
@@ -231,14 +252,10 @@ U.Icon.setIconContrast = (icon, parent, src, bgcolor) => {
    */
   if (!icon) return
 
-  if (L.DomUtil.contrastedColor(parent, bgcolor)) {
+  if (DomUtil.contrastedColor(parent, bgcolor)) {
     // Decide whether to switch svg to white or not, but do it
     // only for internal SVG, as invert could do weird things
-    if (
-      U.Utils.isPath(src) &&
-      src.endsWith('.svg') &&
-      src !== U.SCHEMA.iconUrl.default
-    ) {
+    if (Utils.isPath(src) && src.endsWith('.svg') && src !== SCHEMA.iconUrl.default) {
       // Must be called after icon container is added to the DOM
       // An image
       icon.style.filter = 'invert(1)'
@@ -248,3 +265,7 @@ U.Icon.setIconContrast = (icon, parent, src, bgcolor) => {
     }
   }
 }
+
+export function formatUrl(url, feature) {
+  return Utils.greedyTemplate(url || '', feature ? feature.extendedProperties() : {})
+}