scripts/mapping_geojson_to_osm_tags/convert_to_osm_tags.mjs

/**
 * convertisseur de données de bornes de recharge électrique à partir de données Chargemap et open data Etalab
 */
import fs from 'node-fs'
import minimist from 'minimist'
import mappingConfigIRVE from './mappings/converters/configIRVE.mjs'
import mappingConfigIRVE_simple from './mappings/converters/mappingConfigIRVE_simple.mjs'
import mapping_engine from './mappings/engine.mjs'
import custom_utils from './mappings/utils.mjs'

const { debugLog } = custom_utils
const { isBooleanKey } = custom_utils
const { writeFile } = custom_utils

let use_mappping_engine = false
// use_mappping_engine = true

let Mapping_engine = new mapping_engine(mappingConfigIRVE)

let mini_arguments = minimist(process.argv.slice(2))

// let sourceFileChargemapJson = './chargemap_data/hurepoix.json'
let sourceFilePathGeoJson = './etalab_data/latest.json'

// wip filter
let filterOnBoundingBox = true
filterOnBoundingBox = false

let boundingBoxCoordinates = {
	xMin: 1.91,
	xMax: 2.38,
	yMin: 48.7,
	yMax: 48.4,
}

let filterCoordinates = true
let enable_filter_on_department = true
enable_filter_on_department = false

let filterDepartment = 91
if (mini_arguments['department']) {
	filterDepartment = mini_arguments['department']
	enable_filter_on_department = true
}
if (mini_arguments['source']) {
	sourceFilePathGeoJson = mini_arguments['source']
}
if (mini_arguments['engine']) {
	use_mappping_engine = mini_arguments['engine']
}

let filterZipCode = new RegExp(`^${filterDepartment}`)
let filterZipCodeAdresse = new RegExp(` ${filterDepartment}`)
let filteredName = ''

if (enable_filter_on_department) {
	filteredName = '_filtered_zipcode_' + filterDepartment
} else if (filterOnBoundingBox) {
	filteredName = '_filtered_bbox_' + boundingBoxCoordinates.xMin + '-' + boundingBoxCoordinates.xMax + '_' + boundingBoxCoordinates.yMin + '-' + boundingBoxCoordinates.yMax
}
let pointCounterMax = 1000000

let limitConversionToFirstPoint = false
// limitConversionToFirstPoint = true
if (limitConversionToFirstPoint) {
	pointCounterMax = 1
}
let defaultPropertiesOfPoint = {
	'amenity': 'charging_station'
}

let converted_geo_json = {
	type: 'FeatureCollection',
	features: []
}

/**
 *
 * @param sourceFilePath
 * @param mapping
 * @param pointCounterMax
 * @param boundingBoxCoordinates
 */
function convertDataForIRVE (sourceFilePath, mapping, pointCounterMax, boundingBoxCoordinates) {
	debugLog('convertDataFromChargemap from ', sourceFilePath)

	fs.readFile(sourceFilePath, 'utf8', function (err, data) {
		let point_counter = 0
		if (err) {
			return debugLog(err)
		}
		let data_transformed = JSON.parse(data)
		// debug('data keys ', Object.keys(dataTransformed))

		debugLog('debug: properties of point 0', data_transformed.features[0])
		if (data_transformed.features) {

			debugLog('data found, features:', data_transformed.features.length)

			// find interesting list of points to use
			let list_of_points = data_transformed.features
			// for each point from the data source, convert with the mapping

			console.log('listOfPoints.length', list_of_points.length)
			list_of_points.forEach(feature_point => {

				let regex_filter_test_result = true

				if (enable_filter_on_department) {
					debugLog('filtre sur les départements activé')
					regex_filter_test_result = (
						filterZipCode.test(feature_point.properties.consolidated_code_postal)
						||
						filterZipCodeAdresse.test(feature_point.properties.adresse_station)
					)
				} else if (filterOnBoundingBox) {
					debugLog('filtre sur les coordonnées activé')

					let x = feature_point.properties.coordonneesXY[0]
					let xMin = boundingBoxCoordinates.xMin
					let xMax = boundingBoxCoordinates.xMax
					let yMin = boundingBoxCoordinates.yMin
					let yMax = boundingBoxCoordinates.yMax

					let y = feature_point.properties.coordonneesXY[1]
					regex_filter_test_result = (
						(x >= xMin && x <= xMax)
						&&
						(y >= yMin && y <= yMax)
					)

				}

				// filter points depending on zipcode
				if (filterCoordinates && regex_filter_test_result) {

					debugLog('featurePoint.properties.consolidated_code_postal', feature_point.properties.consolidated_code_postal)

					// limit results number of points
					// if (pointcounter < pointCounterMax) {

					debugLog('add point')

					debugLog('featurePoint', feature_point)

					let mapped_point = {}

					if (use_mappping_engine) {
						mapped_point = Mapping_engine.mapElementFromConf(feature_point)
					} else {
						mapped_point = mapElementFromConfSimple(feature_point, mapping)
					}
					debugLog('map one point', feature_point, mapped_point)
					if (mapped_point) {
						converted_geo_json.features.push(mapped_point)
					}
				}
				// }
				point_counter++

			})
			// output new geojson
			console.log('convertedGeoJson.features.length', converted_geo_json.features.length)
			// write file on disk
			let fileNameToWrite = 'my_converted_data_set' + filteredName + '.json'
			console.log('write file ', fileNameToWrite)
			writeFile(fileNameToWrite, JSON.stringify(converted_geo_json, null, 2))

			debugLog('mapped output:', converted_geo_json.features)

			return converted_geo_json
		}
	})
}

/**
 * retuns the converted element from mapping config if present, null otherwise
 */
function mapElementFromConfSimple (featurePoint, mappingConfig) {
	let mappingKeys = Object.keys(mappingConfig)
	let featurePointPropertiesKeys = Object.keys(featurePoint.properties)

	debugLog('keys', mappingKeys, featurePointPropertiesKeys)

	let newProperties = defaultPropertiesOfPoint

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

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

		if (mappingKeys.indexOf(pointKeyName) !== -1) {
			debugLog('found element', pointKeyName, '=>', mappingConfig[pointKeyName], 'value : ', featurePoint.properties[pointKeyName])
			let convertedValue = ''
			if (isBooleanKey(pointKeyName)) {

				let copyOfValue = '' + featurePoint.properties[pointKeyName]
				if (typeof copyOfValue === typeof Object && copyOfValue.key_converted) {
					copyOfValue = copyOfValue.key_converted
				}
				convertedValue = copyOfValue.toLowerCase() == 'true' ? 'yes' : 'no'
			} else {
				convertedValue = featurePoint.properties[pointKeyName]
			}

			if (convertedValue) {
				newProperties[mappingConfig[pointKeyName]] = convertedValue
			}
		}
	})

	debugLog('basePoint', basePoint)
	return basePoint
}

if (use_mappping_engine) {
	console.log(' - using mapping engine')
	console.log(' - pointCounterMax', pointCounterMax)
	Mapping_engine.setConfig(mappingConfigIRVE)
	convertDataForIRVE(sourceFilePathGeoJson, mappingConfigIRVE, pointCounterMax, boundingBoxCoordinates)

} else {

	convertDataForIRVE(sourceFilePathGeoJson, mappingConfigIRVE_simple, pointCounterMax, boundingBoxCoordinates)
}