230 lines
6.3 KiB
JavaScript
230 lines
6.3 KiB
JavaScript
/**
|
|
* 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/configIRVE'
|
|
|
|
let mini_arguments = minimist(process.argv.slice(2))
|
|
|
|
let show_debug = 0
|
|
|
|
// 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 enableFilterOnDepartment = true
|
|
let filterDepartment = 91
|
|
if (mini_arguments['department']) {
|
|
filterDepartment = mini_arguments['department']
|
|
}
|
|
|
|
let filterZipCode = new RegExp(`^${filterDepartment}`)
|
|
let filterZipCodeAdresse = new RegExp(` ${filterDepartment}`)
|
|
let filteredName = ''
|
|
|
|
if (enableFilterOnDepartment) {
|
|
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 sourceFileChargemapJson = './chargemap_data/hurepoix.json'
|
|
let sourceFileIRVEGeoJson = './etalab_data/latest.json'
|
|
let defaultPropertiesOfPoint = {
|
|
'amenity': 'charging_station'
|
|
}
|
|
|
|
|
|
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',
|
|
})
|
|
|
|
function debugLog (message) {
|
|
if (!show_debug) {
|
|
return
|
|
}
|
|
console.log('debug: ', ...message)
|
|
}
|
|
|
|
function convertDataForIRVE (sourceFilePath, mapping, pointCounterMax, boundingBoxCoordinates) {
|
|
debugLog('convertDataFromChargemap from ', sourceFilePath)
|
|
|
|
let convertedGeoJson = {
|
|
type: 'FeatureCollection',
|
|
features: []
|
|
}
|
|
|
|
fs.readFile(sourceFilePath, 'utf8', function (err, data) {
|
|
let pointcounter = 0
|
|
if (err) {
|
|
return debugLog(err)
|
|
}
|
|
let dataTransformed = JSON.parse(data)
|
|
// debug('data keys ', Object.keys(dataTransformed))
|
|
|
|
debugLog('debug: properties of point 0', dataTransformed.features[0])
|
|
if (dataTransformed.features) {
|
|
|
|
debugLog('data found, features:', dataTransformed.features.length)
|
|
|
|
// find interesting list of points to use
|
|
let listOfPoints = dataTransformed.features
|
|
// for each point from the data source, convert with the mapping
|
|
|
|
console.log('listOfPoints.length', listOfPoints.length)
|
|
listOfPoints.forEach(featurePoint => {
|
|
|
|
let regextestresult = true
|
|
|
|
if (enableFilterOnDepartment) {
|
|
console.log('filtre sur les départements activé')
|
|
regextestresult = (
|
|
filterZipCode.test(featurePoint.properties.consolidated_code_postal)
|
|
||
|
|
filterZipCodeAdresse.test(featurePoint.properties.adresse_station)
|
|
)
|
|
} else if (filterOnBoundingBox) {
|
|
console.log('filtre sur les coordonnées activé')
|
|
|
|
let x = featurePoint.properties.coordonneesXY[0]
|
|
let xMin = boundingBoxCoordinates.xMin
|
|
let xMax = boundingBoxCoordinates.xMax
|
|
let yMin = boundingBoxCoordinates.yMin
|
|
let yMax = boundingBoxCoordinates.yMax
|
|
|
|
let y = featurePoint.properties.coordonneesXY[1]
|
|
regextestresult = (
|
|
(x >= xMin && x <= xMax)
|
|
&&
|
|
(y >= yMin && y <= yMax)
|
|
)
|
|
|
|
}
|
|
|
|
// filter points depending on zipcode
|
|
if (filterCoordinates && regextestresult) {
|
|
|
|
debugLog('featurePoint.properties.consolidated_code_postal', featurePoint.properties.consolidated_code_postal)
|
|
|
|
// limit results number of points
|
|
// if (pointcounter < pointCounterMax) {
|
|
|
|
debugLog('add point')
|
|
|
|
debugLog('featurePoint', featurePoint)
|
|
|
|
let mappedPoint = mapElementFromConf(featurePoint, mapping)
|
|
debugLog('map one point', featurePoint, mappedPoint)
|
|
if (mappedPoint) {
|
|
convertedGeoJson.features.push(mappedPoint)
|
|
}
|
|
}
|
|
// }
|
|
pointcounter++
|
|
|
|
})
|
|
// output new geojson
|
|
console.log('convertedGeoJson.features.length', convertedGeoJson.features.length)
|
|
// write file on disk
|
|
let fileNameToWrite = 'my_converted_data_set' + filteredName + '.json'
|
|
console.log('write file ', fileNameToWrite)
|
|
writeJsonFile(fileNameToWrite, JSON.stringify(convertedGeoJson, null, 2))
|
|
|
|
debugLog('mapped output:', convertedGeoJson.features)
|
|
|
|
return convertedGeoJson
|
|
}
|
|
})
|
|
}
|
|
|
|
function isBooleanKey (pointKeyName) {
|
|
|
|
return listOfBooleanKeys.indexOf(pointKeyName) !== -1
|
|
}
|
|
|
|
/**
|
|
* retuns the converted element from mapping config if present, null otherwise
|
|
*/
|
|
|
|
function mapElementFromConf (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)) {
|
|
|
|
convertedValue = featurePoint.properties[pointKeyName].toLowerCase() == 'true' ? 'yes' : 'no'
|
|
} else {
|
|
convertedValue = featurePoint.properties[pointKeyName]
|
|
}
|
|
|
|
if (convertedValue) {
|
|
newProperties[mappingConfig[pointKeyName]] = convertedValue
|
|
}
|
|
}
|
|
})
|
|
|
|
debugLog('basePoint', basePoint)
|
|
return basePoint
|
|
}
|
|
|
|
function writeJsonFile (fileName, fileContent) {
|
|
debugLog('write file ', fileName)
|
|
|
|
return fs.writeFile(
|
|
`./output/${fileName}`,
|
|
fileContent,
|
|
'utf8',
|
|
(err) => {
|
|
if (err) {
|
|
debugLog(`Error writing file: ${err}`)
|
|
} else {
|
|
debugLog(`File ${fileName} is written successfully!`)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
console.log('pointCounterMax', pointCounterMax)
|
|
convertDataForIRVE(sourceFileIRVEGeoJson, mappingConfigIRVE, pointCounterMax, boundingBoxCoordinates)
|
|
|
|
// convertDataFromChargemap(sourceFileChargemapJson, mappingConfigIRVE)
|