scripts/mapping_geojson_to_osm_tags/mappings/engine.ts

import custom_utils from './utils'
import MappingConfigType from "./mapping-config.type";

const {debugLog} = custom_utils

let listOfBooleanKeys = [
    "prise_type_ef",
    "prise_type_2",
    "prise_type_combo_ccs",
    "prise_type_chademo",
    "gratuit",
    "paiement_acte",
    "paiement_cb",
    "cable_t2_attache"
]

export default class {
    mapping_config: any = {}

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

    setConfig(mappingConfig: MappingConfigType) {
        this.mapping_config = mappingConfig
    }

    mapFeaturePoint(featurePointGeoJson: any) {

        let geoJSONConvertedPoint: any = {}
        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: string): boolean {

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

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

    /**
     * reduce number of features
     * @param offsetCount
     * @param listOfFeatures
     */
    filterFeaturesByOffset(offsetCount: number, listOfFeatures: any): Array<any> {
        let filteredList = listOfFeatures
        // TODO
        return filteredList
    }

    // filterFeaturesByPropertyRegex(bboxConfig:any, listOfFeatures:any) {
    //     debugLog('bboxConfig', bboxConfig)
    //     let filteredList = listOfFeatures
    //     // TODO
    //     return filteredList
    // }

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

    /**
     * retuns the converted element from mapping config if present, null otherwise
     */
    mapElementFromConf(featurePoint: any): any {
        // debugLog('mapElementFromConf: 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.')
        }

        debugLog('mapElementFromConf: config_name', this.mapping_config.config_name)
        let mappingKeys = Object.keys(this.mapping_config.tags)
        let featurePointPropertiesKeys = Object.keys(featurePoint.properties)

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

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


        // 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 => {

            debugLog('mapElementFromConf: convert', pointKeyName)
            this.convertProperty(pointKeyName, mappingKeys, featurePoint, newProperties)

        })

        basePoint.properties = newProperties

        // debugLog('mapElementFromConf: basePoint', basePoint)
        return basePoint
    }

    /**
     * convertit une propriété en une autre selon la config de mapping
     * @param pointKeyName
     * @param mappingKeys
     * @param featurePoint
     * @param newProperties
     */
    convertProperty(pointKeyName: string, mappingKeys: any, featurePoint: any, newProperties: any) {
        let originalValue = featurePoint.properties[pointKeyName]
        let mappingValueObject: any = '';

        if (mappingKeys.indexOf(pointKeyName) > 0) {
            mappingValueObject = this.mapping_config.tags[pointKeyName]
            debugLog('convertProperty: mappingValueObject ', mappingValueObject)
        }

        debugLog(' ------ convertProperty: pointKeyName', pointKeyName)
        // debugLog('convertProperty: mappingKeys', mappingKeys)
        /**
         * only use existing keys
         */
        if (mappingKeys.indexOf(pointKeyName) > 0) {
            let valueConvertedFromMapping = featurePoint.properties[pointKeyName]
            let keyConvertedFromMapping = mappingKeys[mappingKeys.indexOf(pointKeyName)]
            let mappingConfigOfTag = this.mapping_config.tags[pointKeyName]

            console.log('========== mappingConfigOfTag', mappingConfigOfTag)
            debugLog('convertProperty: found element', pointKeyName, '=>', keyConvertedFromMapping, 'value : ', valueConvertedFromMapping)
            let convertedValue = ''

            let typeOfConfigForKey = typeof mappingConfigOfTag
            let isStringValue = typeOfConfigForKey === 'string'
            let isConfigMappingObject = typeOfConfigForKey === 'object'

            debugLog('convertProperty: - typeofValue', typeOfConfigForKey)
            debugLog('convertProperty: - pointKeyName', pointKeyName)
            debugLog('convertProperty: - valueConvertedFromMapping', valueConvertedFromMapping)
            debugLog('typeof valueConvertedFromMapping === \'string\'', typeOfConfigForKey)


            debugLog('convertProperty: isStringValue?', valueConvertedFromMapping, isStringValue)
            console.log('convertProperty: isStringValue?', valueConvertedFromMapping, isStringValue)

            console.log('mappingConfigOfTag', mappingConfigOfTag)
            console.log('typeOfConfigForKey', typeOfConfigForKey)


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

                } else {
                    console.log('convertProperty: -- simple conversion : ', pointKeyName, '_', originalValue, '=>', valueConvertedFromMapping)
                    convertedValue = valueConvertedFromMapping
                }
                debugLog('convertProperty: -- convertedValue', convertedValue)
                if (convertedValue) {
                    newProperties[keyConvertedFromMapping] = convertedValue
                }
            } else {
                debugLog('convertProperty: no string value')
            }

            if (isConfigMappingObject) {
                let configObject = mappingConfigOfTag

                debugLog('convertProperty: is config object', configObject)
                let newKey: any = '' + pointKeyName
                let remove_original_key = false;

                if (configObject.key_converted) {
                    newKey = configObject.key_converted
                }
                // else {
                //     newKey = pointKeyName
                // }

                /**
                 * conversion booléenne
                 */
                if (mappingValueObject.boolean_value_conversion) {
                    debugLog('convertProperty: is boolean_value_conversion')
                    debugLog('convertProperty: ==========> original value', originalValue)
                    if (this.truthyValues.indexOf(originalValue) !== -1) {
                        convertedValue = 'yes'
                    }
                    if (this.falsyValues.indexOf(originalValue) !== -1) {
                        convertedValue = 'no'
                    }
                } else {
                    debugLog('convertProperty: is NOT having boolean_value_conversion', mappingValueObject)
                }

                /**
                 * gestion des valeurs conditionnelles
                 * nous pouvons renseigner une string ou un objet décrivant les transformations à réaliser
                 */
                if (configObject.conditional_values) {
                    console.log('convertProperty: conditional_values__________',
                        configObject.conditional_values)

                    let keysConditionnalValues: any = Object.keys(configObject.conditional_values)

                    let isFoundValue = keysConditionnalValues.indexOf(originalValue)
                    console.log('isFoundValue', isFoundValue)
                    console.log('keysConditionnalValues', keysConditionnalValues)
                    if (isFoundValue !== -1) {
                        let conditionnalConfig: any = configObject.conditional_values[keysConditionnalValues[isFoundValue]]

                        if (conditionnalConfig.tags_to_add) {
                            // on peut définir un ensemble de tags à rajouter
                            let tagKeys = Object.keys(conditionnalConfig.tags_to_add)
                            console.log('conditionnalConfig.tags_to_add', conditionnalConfig.tags_to_add)
                            conditionnalConfig.tags_to_add.forEach((object: any, pair: any) => {
                                console.log('object', object)
                                console.log('pair', pair)
                                let key: any = Object.keys(object)
                                key = key[0]
                                let value = object[key]

                                console.log('key', key)
                                console.log('value', value)
                                newProperties[key] = value
                            })
                        }
                        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 (configObject.remove_original_key) {
                        remove_original_key = true
                    }
                }

                debugLog('convertProperty: convertedValue ==========> {', newKey, ':', convertedValue, '}')
                console.log(' =============== remove_original_key', remove_original_key)
                if (!remove_original_key && newKey && !configObject.ignore_this_data) {

                    debugLog('convertProperty: added')
                    newProperties[newKey] = convertedValue
                }
            }
        }
    }

}