umap-project 2.5.0__py3-none-any.whl → 2.6.0__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/importers/overpass.js

@@ -25,10 +25,20 @@ class Autocomplete extends SingleMixin(BaseAjax) {
   }
 
   createResult(item) {
+    const labels = [item.properties.name]
+    if (item.properties.county) {
+      labels.push(item.properties.county)
+    }
+    if (item.properties.state) {
+      labels.push(item.properties.state)
+    }
+    if (item.properties.country) {
+      labels.push(item.properties.country)
+    }
     return super.createResult({
       // Overpass convention to get their id from an osm one.
       value: item.properties.osm_id + 3600000000,
-      label: `${item.properties.name}`,
+      label: labels.join(', '),
     })
   }
 }
@@ -42,11 +52,10 @@ export class Importer {
       options?.searchUrl ||
       'https://photon.komoot.io/api?q={q}&layer=county&layer=city&layer=state'
     this.id = 'overpass'
+    this.boundaryChoice = null
   }
 
   async open(importer) {
-    let boundary = null
-    let boundaryName = null
     const container = DomUtil.create('div')
     container.innerHTML = TEMPLATE
     this.autocomplete = new Autocomplete(container.querySelector('#area'), {
@@ -55,10 +64,15 @@ export class Importer {
         'Type area name, or let empty to load data in current map view'
       ),
       on_select: (choice) => {
-        boundary = choice.item.value
-        boundaryName = choice.item.label
+        this.boundaryChoice = choice
+      },
+      on_unselect: (choice) => {
+        this.boundaryChoice = null
       },
     })
+    if (this.boundaryChoice) {
+      this.autocomplete.displaySelected(this.boundaryChoice)
+    }
     this.map.help.parse(container)
 
     const confirm = (form) => {
@@ -69,10 +83,10 @@ export class Importer {
       let tags = form.tags
       if (!tags.startsWith('[')) tags = `[${tags}]`
       let area = '{south},{west},{north},{east}'
-      if (boundary) area = `area:${boundary}`
+      if (this.boundaryChoice) area = `area:${this.boundaryChoice.item.value}`
       const query = `[out:json];nwr${tags}(${area});out ${form.out};`
       importer.url = `${this.baseUrl}?data=${query}`
-      if (boundary) importer.layerName = boundaryName
+      if (this.boundaryChoice) importer.layerName = this.boundaryChoice.item.label
       importer.format = 'osm'
     }
 
@@ -81,7 +95,7 @@ export class Importer {
         template: container,
         className: `${this.id} importer dark`,
         accept: translate('Choose this data'),
-        cancel: false
+        cancel: false,
       })
       .then(confirm)
   }

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
+    )
+  }
+}