Skip to content

Interactive interface for browsing global, full-resolution satellite imagery

6.1 KB
Raw Blame
const fs = require('fs')
const path = require('path')
const yargs = require('yargs')
const { hideBin } = require('yargs/helpers')
const moment = require('moment')
const { processTemporalLayer } = require('./processTemporalLayer')
const prog = path.basename(__filename)

const options = yargs(hideBin(process.argv))
  .usage('Usage: $0 [optionsFile] [configDir]')
  .option('optionsFile', {
    demandOption: true,
    alias: 'o',
    type: 'string',
    description: 'options file'
  })
  .option('configDir', {
    demandOption: true,
    alias: 'c',
    type: 'string',
    description: 'config directory'
  })
  .option('features', {
    demandOption: true,
    alias: 'f',
    type: 'string',
    description: 'features.json file'
  })
  .option('cacheMode', {
    demandOption: false,
    alias: 'cm',
    type: 'string',
    description: 'Cache mode for fetching data'
  })
  .epilog('Validates and corrects the configuration files.')

const { argv } = options
if (!argv.optionsFile && !argv.configDir && !argv.features) {
  throw new Error('Invalid number of arguments')
}

const optionsFile = argv.optionsFile
const configDir = argv.configDir
const cacheMode = argv.cacheMode
const featuresFile = argv.features

let featuresData = fs.readFileSync(featuresFile)
let features = JSON.parse(featuresData)
if (fs.existsSync(featuresFile)) {
  featuresData = fs.readFileSync(featuresFile)
  features = JSON.parse(featuresData)
} else {
  throw new Error(`Error: ${featuresFile} feature file does not exist`)
}

let errorCount = 0
let warningCount = 0
const removedLayers = []

const mainConfigFile = path.join(configDir, 'wv.json')
const wv = JSON.parse(fs.readFileSync(mainConfigFile, 'utf8'))
const opt = JSON.parse(fs.readFileSync(optionsFile, 'utf8'))

const tolerant = opt.tolerant || false

function fail (message) {
  console.error(`${prog}: ERROR: ${message}`)
  errorCount += 1
}

function error (message) {
  tolerant ? warn(message) : fail(message)
}

function warn (message) {
  console.error(`${prog}: WARN: ${message}`)
  warningCount += 1
}

function removeLayer (wv, layerId) {
  removedLayers.push(layerId)
  delete wv.layers[layerId]
  if (wv.layerOrder.includes(layerId)) {
    wv.layerOrder = wv.layerOrder.filter((id) => id !== layerId)
  }
}

function isDateTimeFormat (input) {
  try {
    moment(input, 'YYYY-MM-DD HH:mm:ss')
    return true
  } catch (e) {
    return false
  }
}

if (tolerant) warn('Validation enforcement disabled')

let startDate = moment.max()

async function main () {
  for (const layerId of Object.keys(wv.layers)) {
    let layer = wv.layers[layerId]
    if (layerId !== layer.id) {
      error(`[${layerId}] layer id does not match id of ${layer.id}`)
    }
    if (!wv.layerOrder.includes(layerId)) {
      if (opt.layerOrderExceptions && opt.layerOrderExceptions.includes(layerId)) {
        removeLayer(wv, layerId)
        continue
      } else if (tolerant || opt.ignoreLayerOrder) {
        wv.layerOrder.push(layerId)
      } else {
        removeLayer(wv, layerId)
        continue
      }
    }
    if (layer.vectorStyle && !layer.vectorStyle.id) {
      error(`[${layerId}] No vectorStyle definition`)
    }
    if (!layer.group && opt.warnOnUnexpectedLayer) {
      error(`[${layerId}] Possible unexpected layer, no group defined`)
      removeLayer(wv, layerId)
      continue
    } else if (!layer.group) {
      removeLayer(wv, layerId)
      continue
    }
    if (!('projections' in layer) || !Object.keys(layer.projections).length) {
      error(`[${layerId}] No projections defined`)
      removeLayer(wv, layerId)
      continue
    }
    if ('temporal' in layer) {
      warn(`[${layerId}] GC Layer temporal values overwritten by Options`)
      layer = await processTemporalLayer(layer, layer.temporal, undefined, cacheMode, features)
    }
    if (layer.futureTime) {
      if ('endDate' in layer) delete layer.endDate
    }

    if (layer.futureTime) {
      // do nothing
    } else {
      if ('endDate' in layer && layer.ongoing) delete layer.endDate
    }
    if ('startDate' in layer) {
      const startTime = layer.startDate.replace('T', ' ').replace('Z', '')
      let d
      if (isDateTimeFormat(startTime)) {
        d = moment(startTime, 'YYYY-MM-DD HH:mm:ss')
      } else {
        d = moment(layer.startDate, 'YYYY-MM-DD')
      }
      startDate = moment.min(startDate, d)
    }
  }

  if (startDate.isValid()) {
    wv.startDate = startDate.format('YYYY-MM-DD') + 'T' + startDate.format('HH:mm:ss') + 'Z'
  }

  for (const layerId of wv.layerOrder) {
    if (!wv.layers[layerId]) {
      error(`[${layerId}] In layer order but no definition`)
    }
  }

  const startingLayers = []
  for (const startingLayer of wv.defaults.startingLayers) {
    if (!wv.layers[startingLayer.id]) {
      error(`Invalid starting layer: ${startingLayer.id}`)
    } else {
      startingLayers.push(startingLayer)
    }
  }
  wv.defaults.startingLayers = startingLayers
  wv.buildDate = Math.round(Date.now() / 1000)

  for (const [projection, projectionValue] of Object.entries(wv.naturalEvents.layers)) {
    for (const [eventType, eventTypeLayerList] of Object.entries(projectionValue)) {
      for (const layerObject of eventTypeLayerList) {
        if (!wv.layers[layerObject[0]]) {
          error(`The ${layerObject[0]} layer in the Natural events ${projection} ${eventType} config does not have a matching ID in the layer config`)
        }
      }
    }
  }

  for (const measurement of Object.values(wv.measurements)) {
    if (!measurement.sources) continue
    for (const source of Object.values(measurement.sources)) {
      if (!source.settings) continue
      for (const setting of source.settings) {
        if (!wv.layers[setting]) {
          error(`In measurement ${measurement.id}, source ${source.id}, layer not found: ${setting}`)
        }
      }
    }
  }

  const removeCount = removedLayers.length
  console.warn(`${prog}: ${errorCount} error(s), ${warningCount} warning(s), ${removeCount} removed`)
  if (removeCount > 0) {
    console.warn(removedLayers)
  }

  fs.writeFileSync(mainConfigFile, JSON.stringify(wv, null, 2))

  if (errorCount > 0) {
    throw new Error(`${prog}: Error: ${errorCount} errors occured`)
  }
}

main().catch((err) => {
  console.error(err.stack)
})