handle engine convert fields

mapping_geojson_to_osm_tags/mappings/converters/configIRVE.mjs

@@ -100,7 +100,7 @@ export default {
             key_converted: null,
             conditional_values: {
                 // ajout de trois tags si la valeur est yes
-                yes: {
+                "yes": {
                     tags_to_add: [
                         {bicycle: "yes"},
                         {scooter: "yes"},

mapping_geojson_to_osm_tags/mappings/engine.mjs

@@ -1,75 +1,138 @@
 import debugLog from './utils.mjs'
 
 export default class {
-    config = {}
+	config = {}
-    constructor(mappingConfig){
 
-        this.setConfig(mappingConfig)
+	constructor (mappingConfig) {
-    }
-    setConfig(mappingConfig){
-        this.config = mappingConfig
-    }
 
-    mapFeaturePoint(featurePointGeoJson){
+		this.setConfig(mappingConfig)
+	}
 
-        let geoJSONConvertedPoint = {}
+	setConfig (mappingConfig) {
-        geoJSONConvertedPoint.properties = {... this.config.default_properties_of_point};
+		this.config = mappingConfig
-        geoJSONConvertedPoint.type = featurePointGeoJson.type;
+	}
-        geoJSONConvertedPoint.geometry = featurePointGeoJson.geometry
 
-        let props = featurePointGeoJson.properties
+	mapFeaturePoint (featurePointGeoJson) {
 
-        props.forEach((key,value)=>{
+		let geoJSONConvertedPoint = {}
+		geoJSONConvertedPoint.properties = { ...this.config.default_properties_of_point }
+		geoJSONConvertedPoint.type = featurePointGeoJson.type
+		geoJSONConvertedPoint.geometry = featurePointGeoJson.geometry
 
-        })
+		let props = featurePointGeoJson.properties
 
-        return geoJSONConvertedPoint;
+		props.forEach((key, value) => {
-    }
 
+		})
 
-    isBooleanKey (pointKeyName) {
+		return geoJSONConvertedPoint
+	}
 
-        return listOfBooleanKeys.indexOf(pointKeyName) !== -1
+	isBooleanKey (pointKeyName) {
-    }
 
-    /**
+		return listOfBooleanKeys.indexOf(pointKeyName) !== -1
-     * retuns the converted element from mapping config if present, null otherwise
+	}
-     */
-    mapElementFromConf (featurePoint, mappingConfig) {
-        let mappingKeys = Object.keys(mappingConfig)
-        let featurePointPropertiesKeys = Object.keys(featurePoint.properties)
 
-        debugLog('keys', mappingKeys, featurePointPropertiesKeys)
+	truthyValues = ['true', 'True', 'TRUE', '1', 1]
+	falsyValues = ['false', 'False', 'FALSE', '0', 0]
 
-        let newProperties = defaultPropertiesOfPoint
+	/**
+	 * retuns the converted element from mapping config if present, null otherwise
+	 */
+	mapElementFromConf (featurePoint, mappingConfig) {
+		let mappingKeys = Object.keys(mappingConfig)
+		let featurePointPropertiesKeys = Object.keys(featurePoint.properties)
 
-        // reinit properties of current point
+		debugLog('keys', mappingKeys, featurePointPropertiesKeys)
-        let basePoint = Object.create(featurePoint)
-        basePoint.type = featurePoint.type
-        basePoint.geometry = featurePoint.geometry
-        basePoint.properties = newProperties
 
-        // apply new properties if found in mapping config
+		let newProperties = defaultPropertiesOfPoint
-        featurePointPropertiesKeys.forEach(pointKeyName => {
 
-            if (mappingKeys.indexOf(pointKeyName) !== -1) {
+		// reinit properties of current point
-                debugLog('found element', pointKeyName, '=>', mappingConfig[pointKeyName], 'value : ', featurePoint.properties[pointKeyName])
+		let basePoint = Object.create(featurePoint)
-                let convertedValue = ''
+		basePoint.type = featurePoint.type
-                if (isBooleanKey(pointKeyName)) {
+		basePoint.geometry = featurePoint.geometry
+		basePoint.properties = newProperties
 
-                    convertedValue = featurePoint.properties[pointKeyName].toLowerCase() == 'true' ? 'yes' : 'no'
+		// apply new properties if found in mapping config
-                } else {
+		featurePointPropertiesKeys.forEach(pointKeyName => {
-                    convertedValue = featurePoint.properties[pointKeyName]
-                }
 
-                if (convertedValue) {
+			if (mappingKeys.indexOf(pointKeyName) !== -1) {
-                    newProperties[mappingConfig[pointKeyName]] = convertedValue
+				debugLog('found element', pointKeyName, '=>', mappingConfig[pointKeyName], 'value : ', featurePoint.properties[pointKeyName])
-                }
+				let convertedValue = ''
-            }
-        })
 
-        debugLog('basePoint', basePoint)
+				let valueConvertedFromMapping = featurePoint.properties[pointKeyName]
-        return basePoint
+				let typeofValue = typeof valueConvertedFromMapping
-    }
+				let isStringValue = typeofValue === 'string'
+				console.log('typeof featurePoint.properties[pointKeyName] === \'string\'', typeofValue)
+
+				let isConfigMappingObject = typeofValue === 'string'
+
+				if (isStringValue) {
+					if (isBooleanKey(pointKeyName)) {
+						convertedValue = (valueConvertedFromMapping + '').toLowerCase() == 'true' ? 'yes' : 'no'
+					} else {
+						convertedValue = valueConvertedFromMapping
+					}
+
+					if (convertedValue) {
+						newProperties[mappingConfig[pointKeyName]] = convertedValue
+					}
+				} else if (isConfigMappingObject) {
+					let newKey = ''
+					let configObject = valueConvertedFromMapping
+
+					if (configObject.key_converted) {
+						newKey = configObject.key_converted
+					}
+
+					/**
+					 * gestion des valeurs conditionnelles
+					 * nous pouvons renseigner une string ou un objet décrivant les transformations à réaliser
+					 */
+					if (configObject.conditional_values) {
+						let keysConditionnalValues = Object.keys(configObject.conditional_values)
+						let isFoundValue = keysConditionnalValues.indexOf(valueConvertedFromMapping)
+						if (isFoundValue !== -1) {
+							let conditionnalConfig = keysConditionnalValues[isFoundValue]
+
+							if (conditionnalConfig.tags_to_add) {
+								// on peut définir un ensemble de tags à rajouter
+								newProperties.push(...conditionnalConfig.tags_to_add)
+							}
+							if (conditionnalConfig.truthy_value) {
+								// convertir la valeur, si elle est truthy, la transformer en ce que donne la propriété truthy_value
+								// exemple: le jeu de données dit que la colonne cable_t2_attache vaut "True", mais on veut le convertir en "1".
+								// on met donc truthy_value: '1'
+								if (this.truthyValues.indexOf( valueConvertedFromMapping) !== -1) {
+									convertedValue = conditionnalConfig.truthy_value
+								}
+							}
+							if (conditionnalConfig.falsy_value) {
+								if (this.falsyValues.indexOf( valueConvertedFromMapping) !== -1) {
+									convertedValue = conditionnalConfig.falsy_value
+								}
+							}
+							if (conditionnalConfig.transform_function) {
+								// une transformation de la valeur
+								// apply transformation to value
+								convertedValue = conditionnalConfig.transform_function(valueConvertedFromMapping)
+							}
+							// use the value converted
+							else if (conditionnalConfig.value_converted) {
+								convertedValue = conditionnalConfig.value_converted
+							}
+						}
+					}
+
+					if (newKey && !configObject.ignore_this_data) {
+						newProperties[newKey] = convertedValue
+					}
+				}
+			}
+		})
+
+		debugLog('basePoint', basePoint)
+		return basePoint
+	}
 
 }

mapping_geojson_to_osm_tags/mappings/infer_domain_from_csv.mjs

@@ -0,0 +1,32 @@
+
+
+let show_debug = 0
+
+/**
+ * faire un log
+ * @param message
+ */
+function debugLog (message) {
+    if (!show_debug) {
+        return
+    }
+    console.log('debug: ', ...message)
+}
+
+
+/**
+ *
+ * @param pointKeyName
+ * @returns {boolean}
+ */
+function openCSV(filePath) {
+
+    console.log('open csv filePath')
+    return
+}
+
+export default
+{
+    debugLog,
+    isBooleanKey
+}