MapComplete/scripts/onwheels/convertData.ts

import { parse } from "csv-parse/sync"
import { readFileSync, writeFileSync } from "fs"
import { Feature, FeatureCollection, GeoJsonProperties } from "geojson"
import Constants from "./constants"

/**
 * Function to determine the tags for a category
 *
 * @param category The category of the item
 * @returns List of tags for the category
 */
function categoryTags(category: string): GeoJsonProperties {
    const tags = {
        tags: Object.keys(Constants.categories[category]).map((tag) => {
            return `${tag}=${Constants.categories[category][tag]}`
        }),
    }
    if (!tags) {
        throw `Unknown category: ${category}`
    }
    return tags
}

/**
 * Rename tags to match the OSM standard
 *
 * @param item The item to convert
 * @returns GeoJsonProperties for the item
 */
function renameTags(item): GeoJsonProperties {
    const properties: GeoJsonProperties = {}
    properties.tags = []
    // Loop through the original item tags
    for (const key in item) {
        // Check if we need it and it's not a null value
        if (Constants.names[key] && item[key]) {
            // Name and id tags need to be in the properties
            if (Constants.names[key] == "name" || Constants.names[key] == "id") {
                properties[Constants.names[key]] = item[key]
            }
            // Other tags need to be in the tags variable
            if (Constants.names[key] !== "id") {
                // Website needs to have at least any = encoded
                if (Constants.names[key] == "website") {
                    let website = item[key]
                    // Encode URL
                    website = website.replace("=", "%3D")
                    item[key] = website
                }
                properties.tags.push(Constants.names[key] + "=" + item[key])
            }
        }
    }
    return properties
}

/**
 * Convert types to match the OSM standard
 *
 * @param properties The properties to convert
 * @returns The converted properties
 */
function convertTypes(properties: GeoJsonProperties): GeoJsonProperties {
    // Split the tags into a list
    let tags = properties.tags.split(";")

    for (const tag in tags) {
        // Split the tag into key and value
        const key = tags[tag].split("=")[0]
        const value = tags[tag].split("=")[1]
        const originalKey = Object.keys(Constants.names).find((tag) => Constants.names[tag] === key)

        if (Constants.types[originalKey]) {
            // We need to convert the value to the correct type
            let newValue
            switch (Constants.types[originalKey]) {
                case "boolean":
                    newValue = value === "1" ? "yes" : "no"
                    break
                default:
                    newValue = value
                    break
            }
            tags[tag] = `${key}=${newValue}`
        }
    }

    // Rejoin the tags
    properties.tags = tags.join(";")

    // Return the properties
    return properties
}

/**
 * Function to add units to the properties if necessary
 *
 * @param properties The properties to add units to
 * @returns The properties with units added
 */
function addUnits(properties: GeoJsonProperties): GeoJsonProperties {
    // Split the tags into a list
    let tags = properties.tags.split(";")

    for (const tag in tags) {
        const key = tags[tag].split("=")[0]
        const value = tags[tag].split("=")[1]
        const originalKey = Object.keys(Constants.names).find((tag) => Constants.names[tag] === key)

        // Check if the property needs units, and doesn't already have them
        if (Constants.units[originalKey] && value.match(/.*([A-z]).*/gi) === null) {
            tags[tag] = `${key}=${value} ${Constants.units[originalKey]}`
        }
    }

    // Rejoin the tags
    properties.tags = tags.join(";")

    // Return the properties
    return properties
}

/**
 * Function that adds Maproulette instructions and blurb to each item
 *
 * @param properties The properties to add Maproulette tags to
 * @param item The original CSV item
 */
function addMaprouletteTags(properties: GeoJsonProperties, item: any): GeoJsonProperties {
    properties["blurb"] = `This is feature out of the ${item["Categorie"]} category.
  It may match another OSM item, if so, you can add any missing tags to it.
  If it doesn't match any other OSM item, you can create a new one.
  Here is a list of tags that can be added:
  ${properties["tags"].split(";").join("\n")}
  You can also easily import this item using MapComplete: https://mapcomplete.osm.be/onwheels.html#${
      properties["id"]
  }`
    return properties
}

/**
 * Main function to convert original CSV into GeoJSON
 *
 * @param args List of arguments [input.csv]
 */
function main(args: string[]): void {
    const csvOptions = {
        columns: true,
        skip_empty_lines: true,
        trim: true,
    }
    const file = args[0]
    const output = args[1]

    // Create an empty list to store the converted features
    var items: Feature[] = []

    // Read CSV file
    const csv: Record<any, string>[] = parse(readFileSync(file), csvOptions)

    // Loop through all the entries
    for (var i = 0; i < csv.length; i++) {
        const item = csv[i]

        // Determine coordinates
        const lat = Number(item["Latitude"])
        const lon = Number(item["Longitude"])

        // Check if coordinates are valid
        if (isNaN(lat) || isNaN(lon)) {
            throw `Not a valid lat or lon for entry ${i}: ${JSON.stringify(item)}`
        }

        // Create a new collection to store the converted properties
        var properties: GeoJsonProperties = {}

        // Add standard tags for category
        const category = item["Categorie"]
        const tagsCategory = categoryTags(category)

        // Add the rest of the needed tags
        properties = { ...properties, ...renameTags(item) }

        // Merge them together
        properties.tags = [...tagsCategory.tags, ...properties.tags]
        properties.tags = properties.tags.join(";")

        // Convert types
        properties = convertTypes(properties)

        // Add units if necessary
        properties = addUnits(properties)

        // Add Maproulette tags
        properties = addMaprouletteTags(properties, item)

        // Create the new feature
        const feature: Feature = {
            type: "Feature",
            id: item["ID"],
            geometry: {
                type: "Point",
                coordinates: [lon, lat],
            },
            properties,
        }

        // Push it to the list we created earlier
        items.push(feature)
    }

    // Make a FeatureCollection out of it
    const featureCollection: FeatureCollection = {
        type: "FeatureCollection",
        features: items,
    }

    // Write the data to a file or output to the console
    if (output) {
        writeFileSync(`${output}.geojson`, JSON.stringify(featureCollection, null, 2))
    } else {
        console.log(JSON.stringify(featureCollection))
    }
}

// Execute the main function, with the stripped arguments
main(process.argv.slice(2))