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

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

@@ -1,28 +1,21 @@
 import { DomUtil } from '../../vendors/leaflet/leaflet-src.esm.js'
 import { translate } from './i18n.js'
 import { uMapAlert as Alert } from '../components/alerts/alert.js'
+import { ServerStored } from './saving.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
+export class MapPermissions extends ServerStored {
+  constructor(umap) {
+    super()
+    this.setProperties(umap.properties.permissions)
+    this._umap = umap
     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(
+  setProperties(properties) {
+    this.properties = Object.assign(
       {
         owner: null,
         team: null,
@@ -30,42 +23,54 @@ export class MapPermissions {
         share_status: null,
         edit_status: null,
       },
-      options
+      properties
     )
   }
 
+  render() {
+    this._umap.render(['properties.permissions'])
+  }
+
   isOwner() {
-    return Boolean(this.map.options.user?.is_owner)
+    return Boolean(this._umap.properties.user?.is_owner)
   }
 
   isAnonymousMap() {
-    return !this.map.options.permissions.owner
+    return !this._umap.properties.permissions.owner
   }
 
   _editAnonymous(container) {
     const fields = []
     if (this.isOwner()) {
       fields.push([
-        'options.edit_status',
+        'properties.edit_status',
         {
           handler: 'IntSelect',
           label: translate('Who can edit'),
-          selectOptions: this.map.options.edit_statuses,
+          selectOptions: this._umap.properties.edit_statuses,
+        },
+      ])
+      fields.push([
+        'properties.share_status',
+        {
+          handler: 'IntSelect',
+          label: translate('Who can view'),
+          selectOptions: this._umap.properties.share_statuses,
         },
       ])
       const builder = new U.FormBuilder(this, fields)
       const form = builder.build()
       container.appendChild(form)
 
-      if (this.options.anonymous_edit_url) {
+      if (this.properties.anonymous_edit_url) {
         DomUtil.createCopiableInput(
           container,
           translate('Secret edit link:'),
-          this.options.anonymous_edit_url
+          this.properties.anonymous_edit_url
         )
       }
 
-      if (this.map.options.user?.id) {
+      if (this._umap.properties.user?.id) {
         // 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(
@@ -93,38 +98,38 @@ export class MapPermissions {
     container.appendChild(fieldset)
     if (this.isOwner()) {
       topFields.push([
-        'options.edit_status',
+        'properties.edit_status',
         {
           handler: 'IntSelect',
           label: translate('Who can edit'),
-          selectOptions: this.map.options.edit_statuses,
+          selectOptions: this._umap.properties.edit_statuses,
         },
       ])
       topFields.push([
-        'options.share_status',
+        'properties.share_status',
         {
           handler: 'IntSelect',
           label: translate('Who can view'),
-          selectOptions: this.map.options.share_statuses,
+          selectOptions: this._umap.properties.share_statuses,
         },
       ])
       collaboratorsFields.push([
-        'options.owner',
+        'properties.owner',
         { handler: 'ManageOwner', label: translate("Map's owner") },
       ])
-      if (this.map.options.user?.teams?.length) {
+      if (this._umap.properties.user?.teams?.length) {
         collaboratorsFields.push([
-          'options.team',
+          'properties.team',
           {
             handler: 'ManageTeam',
             label: translate('Attach map to a team'),
-            teams: this.map.options.user.teams,
+            teams: this._umap.properties.user.teams,
           },
         ])
       }
     }
     collaboratorsFields.push([
-      'options.editors',
+      'properties.editors',
       { handler: 'ManageEditors', label: translate("Map's editors") },
     ])
 
@@ -143,20 +148,20 @@ export class MapPermissions {
   }
 
   _editDatalayers(container) {
-    if (this.map.hasLayers()) {
+    if (this._umap.hasLayers()) {
       const fieldset = Utils.loadTemplate(
         `<fieldset class="separator"><legend>${translate('Datalayers')}</legend></fieldset>`
       )
       container.appendChild(fieldset)
-      this.map.eachDataLayer((datalayer) => {
+      this._umap.eachDataLayer((datalayer) => {
         datalayer.permissions.edit(fieldset)
       })
     }
   }
 
   edit() {
-    if (this.map.options.editMode !== 'advanced') return
-    if (!this.map.options.umap_id) {
+    if (this._umap.properties.editMode !== 'advanced') return
+    if (!this._umap.id) {
       Alert.info(translate('Please save the map first'))
       return
     }
@@ -165,77 +170,83 @@ export class MapPermissions {
     if (this.isAnonymousMap()) this._editAnonymous(container)
     else this._editWithOwner(container)
     this._editDatalayers(container)
-    this.map.editPanel.open({ content: container, className: 'dark' })
+    this._umap.editPanel.open({ content: container, className: 'dark' })
   }
 
   async attach() {
-    const [data, response, error] = await this.map.server.post(this.getAttachUrl())
+    const [data, response, error] = await this._umap.server.post(this.getAttachUrl())
     if (!error) {
-      this.options.owner = this.map.options.user
+      this.properties.owner = this._umap.properties.user
       Alert.success(translate('Map has been attached to your account'))
-      this.map.editPanel.close()
+      this._umap.editPanel.close()
     }
   }
 
   async save() {
     if (!this.isDirty) return
     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.isAnonymousMap() && this.properties.editors) {
+      const editors = this.properties.editors.map((u) => u.id)
+      for (let i = 0; i < this.properties.editors.length; i++)
+        formData.append('editors', this.properties.editors[i].id)
     }
     if (this.isOwner() || this.isAnonymousMap()) {
-      formData.append('edit_status', this.options.edit_status)
+      formData.append('edit_status', this.properties.edit_status)
+      formData.append('share_status', this.properties.share_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)
+      formData.append('owner', this.properties.owner?.id)
+      formData.append('team', this.properties.team?.id || '')
     }
-    const [data, response, error] = await this.map.server.post(
+    const [data, response, error] = await this._umap.server.post(
       this.getUrl(),
       {},
       formData
     )
     if (!error) {
       this.commit()
-      this.isDirty = false
-      this.map.fire('postsync')
+      return true
     }
   }
 
   getUrl() {
-    return Utils.template(this.map.options.urls.map_update_permissions, {
-      map_id: this.map.options.umap_id,
+    return this._umap.urls.get('map_update_permissions', {
+      map_id: this._umap.id,
     })
   }
 
   getAttachUrl() {
-    return Utils.template(this.map.options.urls.map_attach_owner, {
-      map_id: this.map.options.umap_id,
+    return this._umap.urls.get('map_attach_owner', {
+      map_id: this._umap.id,
     })
   }
 
   commit() {
-    this.map.options.permissions = Object.assign(
-      this.map.options.permissions,
-      this.options
+    this._umap.properties.permissions = Object.assign(
+      {},
+      this._umap.properties.permissions,
+      this.properties
     )
   }
 
   getShareStatusDisplay() {
-    if (this.map.options.share_statuses) {
-      return Object.fromEntries(this.map.options.share_statuses)[
-        this.options.share_status
+    if (this._umap.properties.share_statuses) {
+      return Object.fromEntries(this._umap.properties.share_statuses)[
+        this.properties.share_status
       ]
     }
   }
+
+  isDraft() {
+    return this.properties.share_status === 0
+  }
 }
 
-export class DataLayerPermissions {
-  constructor(datalayer) {
-    this.options = Object.assign(
+export class DataLayerPermissions extends ServerStored {
+  constructor(umap, datalayer) {
+    super()
+    this._umap = umap
+    this.properties = Object.assign(
       {
         edit_status: null,
       },
@@ -243,32 +254,18 @@ export class DataLayerPermissions {
     )
 
     this.datalayer = datalayer
-    this._isDirty = false
-  }
-
-  set isDirty(status) {
-    this._isDirty = status
-    if (status) this.datalayer.isDirty = status
-  }
-
-  get isDirty() {
-    return this._isDirty
-  }
-
-  get map() {
-    return this.datalayer.map
   }
 
   edit(container) {
     const fields = [
       [
-        'options.edit_status',
+        'properties.edit_status',
         {
           handler: 'IntSelect',
           label: translate('Who can edit "{layer}"', {
             layer: this.datalayer.getName(),
           }),
-          selectOptions: this.map.options.datalayer_edit_statuses,
+          selectOptions: this._umap.properties.datalayer_edit_statuses,
         },
       ],
     ]
@@ -280,31 +277,32 @@ export class DataLayerPermissions {
   }
 
   getUrl() {
-    return this.map.urls.get('datalayer_permissions', {
-      map_id: this.map.options.umap_id,
-      pk: this.datalayer.umap_id,
+    return this._umap.urls.get('datalayer_permissions', {
+      map_id: this._umap.id,
+      pk: this.datalayer.id,
     })
   }
 
   async save() {
     if (!this.isDirty) return
     const formData = new FormData()
-    formData.append('edit_status', this.options.edit_status)
-    const [data, response, error] = await this.map.server.post(
+    formData.append('edit_status', this.properties.edit_status)
+    const [data, response, error] = await this._umap.server.post(
       this.getUrl(),
       {},
       formData
     )
     if (!error) {
       this.commit()
-      this.isDirty = false
+      return true
     }
   }
 
   commit() {
     this.datalayer.options.permissions = Object.assign(
+      {},
       this.datalayer.options.permissions,
-      this.options
+      this.properties
     )
   }
 }

umap/static/umap/js/modules/rendering/layers/base.js

@@ -5,20 +5,20 @@ import * as Utils from '../../utils.js'
 export const LayerMixin = {
   browsable: true,
 
-  onInit: function (map) {
-    if (this.datalayer.autoLoaded()) map.on('zoomend', this.onZoomEnd, this)
+  onInit: function (leafletMap) {
+    if (this.datalayer.autoLoaded()) leafletMap.on('zoomend', this.onZoomEnd, this)
   },
 
-  onDelete: function (map) {
-    map.off('zoomend', this.onZoomEnd, this)
+  onDelete: function (leafletMap) {
+    leafletMap.off('zoomend', this.onZoomEnd, this)
   },
 
-  onAdd: function (map) {
-    map.on('moveend', this.onMoveEnd, this)
+  onAdd: function (leafletMap) {
+    leafletMap.on('moveend', this.onMoveEnd, this)
   },
 
-  onRemove: function (map) {
-    map.off('moveend', this.onMoveEnd, this)
+  onRemove: function (leafletMap) {
+    leafletMap.off('moveend', this.onMoveEnd, this)
   },
 
   getType: function () {
@@ -73,17 +73,17 @@ export const Default = FeatureGroup.extend({
   initialize: function (datalayer) {
     this.datalayer = datalayer
     FeatureGroup.prototype.initialize.call(this)
-    LayerMixin.onInit.call(this, this.datalayer.map)
+    LayerMixin.onInit.call(this, this.datalayer._leafletMap)
   },
 
-  onAdd: function (map) {
-    LayerMixin.onAdd.call(this, map)
-    return FeatureGroup.prototype.onAdd.call(this, map)
+  onAdd: function (leafletMap) {
+    LayerMixin.onAdd.call(this, leafletMap)
+    return FeatureGroup.prototype.onAdd.call(this, leafletMap)
   },
 
-  onRemove: function (map) {
-    LayerMixin.onRemove.call(this, map)
-    return FeatureGroup.prototype.onRemove.call(this, map)
+  onRemove: function (leafletMap) {
+    LayerMixin.onRemove.call(this, leafletMap)
+    return FeatureGroup.prototype.onRemove.call(this, leafletMap)
   },
 })
 

umap/static/umap/js/modules/rendering/layers/classified.js

@@ -20,7 +20,7 @@ const ClassifiedMixin = {
     }
     this.ensureOptions(this.datalayer.options[key])
     FeatureGroup.prototype.initialize.call(this, [], this.datalayer.options[key])
-    LayerMixin.onInit.call(this, this.datalayer.map)
+    LayerMixin.onInit.call(this, this.datalayer._leafletMap)
   },
 
   ensureOptions: () => {},

umap/static/umap/js/modules/rendering/layers/cluster.js

@@ -40,7 +40,7 @@ export const Cluster = L.MarkerClusterGroup.extend({
       options.maxClusterRadius = this.datalayer.options.cluster.radius
     }
     L.MarkerClusterGroup.prototype.initialize.call(this, options)
-    LayerMixin.onInit.call(this, this.datalayer.map)
+    LayerMixin.onInit.call(this, this.datalayer._leafletMap)
     this._markerCluster = MarkerCluster
     this._layers = []
   },

umap/static/umap/js/modules/rendering/layers/heat.js

@@ -21,7 +21,7 @@ export const Heat = L.HeatLayer.extend({
   initialize: function (datalayer) {
     this.datalayer = datalayer
     L.HeatLayer.prototype.initialize.call(this, [], this.datalayer.options.heat)
-    LayerMixin.onInit.call(this, this.datalayer.map)
+    LayerMixin.onInit.call(this, this.datalayer._leafletMap)
     if (!Utils.isObject(this.datalayer.options.heat)) {
       this.datalayer.options.heat = {}
     }