scripts/mapping_geojson_to_osm_tags/mappings/engine.ts

import custom_utils from './utils'

const {debugLog} = custom_utils

let listOfBooleanKeys = Object.keys({
    prise_type_ef: 'socket:typee',
    prise_type_2: 'socket:type2',
    prise_type_combo_ccs: 'socket:type2_combo',
    prise_type_chademo: 'socket:chademo',
    gratuit: 'fee',
    paiement_acte: 'authentication:none',
    paiement_cb: 'payment:credit_cards',
    cable_t2_attache: 'socket:type2_cable',
})

export default class {
    mapping_config = {}

    constructor(mappingConfig) {
        this.setConfig(mappingConfig)
    }

    setConfig(mappingConfig) {
        this.mapping_config = mappingConfig
    }

    mapFeaturePoint(featurePointGeoJson) {

        let geoJSONConvertedPoint = {}
        geoJSONConvertedPoint.properties = {...this.mapping_config.default_properties_of_point}
        geoJSONConvertedPoint.type = featurePointGeoJson.type
        geoJSONConvertedPoint.geometry = featurePointGeoJson.geometry

        let props = featurePointGeoJson.properties

        props.forEach((key, value) => {

        })

        return geoJSONConvertedPoint
    }

    /**
     * TODO convert to mapping config property to transform_truthy
     * @param pointKeyName
     * @returns {boolean}
     */
    isBooleanKey(pointKeyName):boolean {

        return listOfBooleanKeys.indexOf(pointKeyName) !== -1
    }

    truthyValues = ['true', 'True', 'TRUE', '1', 1]
    falsyValues = ['false', 'False', 'FALSE', '0', 0]

    filterFeaturesByOffset(offsetCount:number, listOfFeatures) : Array<any>{
        let filteredList = listOfFeatures
        // TODO
        return filteredList
    }

    filterFeaturesByPropertyRegex(bboxConfig, listOfFeatures) {
        console.log('bboxConfig', bboxConfig)
        let filteredList = listOfFeatures
        // TODO
        return filteredList
    }

    filterFeaturesByPropertyRegex(propertyName, criteriaRegex, listOfFeatures) {
        let filteredList = listOfFeatures.filter(feature => {
            return criteriaRegex.test(feature?.properties[propertyName])
        })
        return filteredList
    }

    /**
     * retuns the converted element from mapping config if present, null otherwise
     */
    mapElementFromConf(featurePoint) {
        if (!this.mapping_config) {
            throw new Error('no config was loaded in the mapping engine. use setConfig(my_mapping_config) on this instance of mapping engine before using this.')

        }

        console.log('mapping_config tags', this.mapping_config.tags)
        debugLog('config_name', this.mapping_config.config_name)
        let mappingKeys = Object.keys(this.mapping_config.tags)
        // let mappingKeys = (this.mapping_config.tags)
        let featurePointPropertiesKeys = Object.keys(featurePoint.properties)

        debugLog('============= keys mappingKeys:', this.mapping_config.tags.length, mappingKeys.length)
        debugLog('============= keys featurePointPropertiesKeys :', featurePoint.properties.length, featurePointPropertiesKeys.length)

        let newProperties = Object.create(this.mapping_config.default_properties_of_point)

        return;
        // reinit properties of current point
        let basePoint = Object.create(featurePoint)
        basePoint.type = featurePoint.type
        basePoint.geometry = featurePoint.geometry

        // apply new properties if found in mapping config
        featurePointPropertiesKeys.forEach(pointKeyName => {

            this.convertProperty(pointKeyName, mappingKeys, featurePoint, newProperties)

        })

        basePoint.properties = newProperties

        debugLog('basePoint', basePoint)
        return basePoint
    }

    convertProperty(pointKeyName, mappingKeys, featurePoint, newProperties) {
        console.log('pointKeyName', pointKeyName)
        if (!mappingKeys.indexOf(pointKeyName) !== -1) {
            debugLog('found element', pointKeyName, '=>', this.mapping_config[pointKeyName], 'value : ', featurePoint.properties[pointKeyName])
            let convertedValue = ''

            let valueConvertedFromMapping = featurePoint.properties[pointKeyName]
            let typeofValue = typeof valueConvertedFromMapping
            let isStringValue = typeofValue === 'string'
            debugLog('- pointKeyName', pointKeyName)
            debugLog('- valueConvertedFromMapping', valueConvertedFromMapping)
            // debugLog('typeof featurePoint.properties[pointKeyName] === \'string\'', typeofValue)

            let isConfigMappingObject = typeofValue === 'string'

            if (isStringValue) {
                debugLog('-- string value')
                if (this.isBooleanKey(pointKeyName)) {
                    let lowerValue = (valueConvertedFromMapping + '').toLowerCase()
                    debugLog('isBooleanKey: lowerValue', lowerValue)
                    convertedValue = this.truthyValues.indexOf(lowerValue) ? 'yes' : 'no'

                } else {
                    convertedValue = valueConvertedFromMapping
                }
                debugLog('-- convertedValue', convertedValue)
                if (convertedValue) {
                    newProperties[this.mapping_config[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
                // }
            }
        }
    }

}