bkp7 / schema-js-api

src/fullsignalk.js

/*
 * Copyright 2016, Teppo Kurki
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

var _ = require('lodash')
var signalkSchema = require('./') // TODO should not be needed
var getId
var debug = require('debug')('signalk:fullsignalk')

function FullSignalK (id, type, defaults) {
  // hack, apparently not available initially, so need to set lazily
  getId = signalkSchema.getSourceId

  if (!type || ((type !== 'aton') && (type !== 'aircraft') && (type !== 'sar'))) { type = 'vessels' } // vessels is the default if the passed value is anything invalid

  this.root = {}
  this.root.version = '1.0.2'  // Should we read this from the package.json file?
  this.root.self = ''
  this.root[type] = {}

  if (id) {
    this.root[type][id] = defaults && defaults.vessels && defaults.vessels.self ? defaults.vessels.self : {}
    this.self = this.root[type][id]
    fillIdentity(this.root)
    this.root.self = type + '.' + id
  }

  this.sources = {}
  this.root.sources = this.sources
  this.lastModifieds = {}
}

function fillIdentity (full) {
  // looks at all members of vessels, aton, aircraft and sar, takes their property name and
  // ensures there is one of mmsi, uuid or url within that branch as appropriate
  const groups = ['vessels', 'aton', 'aircraft', 'sar']
  for (var g = 0; g < groups.length; g++) {
    if (full.hasOwnProperty(groups[g])) {
      for (var identity in full[groups[g]]) {

A for in loop automatically includes the property of any prototype object, consider checking the key using hasOwnProperty.

        fillIdentityField(full[groups[g]][identity], identity)
        // fill arbitrarily the last id as self, used in tests
        full.self = identity // TODO this shouldn't be here it would unexpectedly change the self
      }
    }
  }
}

function fillIdentityField (vesselData, identity) {
   // accepts a vessel/aton/sar/aircraft branch and the id of that branch and makes sure there is one of
   // mmsi, uuid or url within it
   // eg. fillIdentityField({}, 'urn:mrn:imo:mmsi:230099999') returns {"mmsi": "230099999"}
  const mmsiPrefix = 'urn:mrn:imo:mmsi:'
  if (identity.indexOf(mmsiPrefix) === 0) {
    vesselData.mmsi = identity.substring(mmsiPrefix.length, identity.length)
  } else if (identity.indexOf('urn:mrn:signalk') === 0) {
    vesselData.uuid = identity
  } else {
    vesselData.url = identity
  }
}

require('util').inherits(FullSignalK, require('events').EventEmitter)

FullSignalK.prototype.retrieve = function () {
  return this.root
}

FullSignalK.prototype.addDelta = function (delta) {
  this.emit('delta', delta)
  var context = findContext(this.root, delta.context)
  this.addUpdates(context, delta.context, delta.updates)
  this.updateLastModified(delta.context)
}

FullSignalK.prototype.updateLastModified = function (contextKey) {
  this.lastModifieds[contextKey] = new Date().getTime()
}

FullSignalK.prototype.pruneContexts = function (seconds) {
  var threshold = new Date().getTime() - seconds * 1000
  for (let contextKey in this.lastModifieds) {
    if (this.lastModifieds[contextKey] < threshold) {
      this.deleteContext(contextKey)
      delete this.lastModifieds[contextKey]
    }
  }
}

FullSignalK.prototype.deleteContext = function (contextKey) {
  debug('Deleting context ' + contextKey)
  var pathParts = contextKey.split('.')
  if (pathParts.length === 2) {
    delete this.root[pathParts[0]][pathParts[1]]
  }
}

function findContext (root, contextPath) {
  var context = _.get(root, contextPath)
  if (!context) {
    context = {}
    _.set(root, contextPath, context)
  }
  var identity = contextPath.split('.')[1]
  if (!identity) {
    return undefined
  }
  fillIdentityField(context, identity)
  return context
}

FullSignalK.prototype.addUpdates = function (context, contextPath, updates) {
  var len = updates.length
  for (var i = 0; i < len; ++i) {
    this.addUpdate(context, contextPath, updates[i])
  }
}

FullSignalK.prototype.addUpdate = function (context, contextPath, update) {
  if (typeof update.source !== 'undefined') {
    this.updateSource(context, update.source, update.timestamp)
  } else if (typeof update['$source'] !== 'undefined') {
    this.updateDollarSource(context, update['$source'], update.timestamp)
  } else {
    console.error('No source in delta update:' + JSON.stringify(update))
  }
  addValues(context, contextPath, update.source || update['$source'], update.timestamp, update.values)
}

FullSignalK.prototype.updateDollarSource = function (context, dollarSource, timestamp) {

The parameter timestamp is not used and could be removed.

  const parts = dollarSource.split('.')
  parts.reduce((cursor, part) => {
    if (typeof cursor[part] === 'undefined') {
      cursor[part] = {}
    }
    return cursor[part]
  }, this.sources)
}

FullSignalK.prototype.updateSource = function (context, source, timestamp) {
  if (!this.sources[source.label]) {
    this.sources[source.label] = {}
    this.sources[source.label].label = source.label
    this.sources[source.label].type = source.type
  }

  if (source.type === 'NMEA2000' || source.src) {
    handleNmea2000Source(this.sources[source.label], source, timestamp)
    return
  }

  if (source.type === 'NMEA0183' || source.sentence) {
    handleNmea0183Source(this.sources[source.label], source, timestamp)
    return
  }

  handleOtherSource(this.sources[source.label], source, timestamp)
}

function handleNmea2000Source (labelSource, source, timestamp) {
  if (!labelSource[source.src]) {
    labelSource[source.src] = {
      n2k: {
        src: source.src,
        pgns: {}
      }
    }
  }
  if (source.instance && !labelSource[source.src][source.instance]) {
    labelSource[source.src][source.instance] = {}
  }
  labelSource[source.src].n2k.pgns[source.pgn] = timestamp
}

function handleNmea0183Source (labelSource, source, timestamp) {
  var talker = source.talker || 'II'
  if (!labelSource[talker]) {
    labelSource[talker] = {
      talker: talker,
      sentences: {}
    }
  }
  labelSource[talker].sentences[source.sentence] = timestamp
}

function handleOtherSource (sourceLeaf, source, timestamp) {
  sourceLeaf.timestamp = timestamp
}

function addValues (context, contextPath, source, timestamp, pathValues) {
  var len = pathValues.length
  for (var i = 0; i < len; ++i) {
    addValue(context, contextPath, source, timestamp, pathValues[i])
  }
}

function addValue (context, contextPath, source, timestamp, pathValue) {
  if (_.isUndefined(pathValue.path) || _.isUndefined(pathValue.value)) {
    console.error('Illegal value in delta:' + JSON.stringify(pathValue))
    return
  }
  var valueLeaf
  if (pathValue.path.length === 0) {
    _.merge(context, pathValue.value)
    return
  } else {
    const splitPath = pathValue.path.split('.')
    valueLeaf = splitPath.reduce(function (previous, pathPart, i) {
      if (!previous[pathPart]) {
        previous[pathPart] = {}
        let meta = signalkSchema.getMetadata(contextPath + '.' + pathValue.path)
        if (meta && i === splitPath.length - 1) {
          // ignore properties from keyswithmetadata.json
          meta = JSON.parse(JSON.stringify(meta))
          delete meta.properties

          previous[pathPart].meta = meta
        }
      }
      return previous[pathPart]
    }, context)
  }

  var sourceId
  if (valueLeaf.values) { // multiple values already
    sourceId = getId(source)
    if (!valueLeaf.values[sourceId]) {
      valueLeaf.values[sourceId] = {}
    }
    assignValueToLeaf(pathValue.value, valueLeaf.values[sourceId])
    valueLeaf.values[sourceId].timestamp = timestamp
    setMessage(valueLeaf.values[sourceId], source)
  } else if (typeof valueLeaf.value !== 'undefined' && valueLeaf['$source'] !== getId(source)) {
    // first multiple value

    sourceId = valueLeaf['$source']
    var tmp = {}
    copyLeafValueToLeaf(valueLeaf, tmp)
    valueLeaf.values = {}
    valueLeaf.values[sourceId] = tmp
    valueLeaf.values[sourceId].timestamp = valueLeaf.timestamp

    sourceId = getId(source)
    valueLeaf.values[sourceId] = {}
    assignValueToLeaf(pathValue.value, valueLeaf.values[sourceId])
    valueLeaf.values[sourceId].timestamp = timestamp
    setMessage(valueLeaf.values[sourceId], source)
  }
  assignValueToLeaf(pathValue.value, valueLeaf)
  if (pathValue.path.length !== 0) {
    valueLeaf['$source'] = getId(source)
    valueLeaf.timestamp = timestamp
    setMessage(valueLeaf, source)
  }
}

function copyLeafValueToLeaf (fromLeaf, toLeaf) {
  _.assign(toLeaf, _.omit(fromLeaf, ['$source', 'timestamp', 'meta']))
}

function assignValueToLeaf (value, leaf) {
  leaf.value = value
}

function setMessage (leaf, source) {
  if (!source) {
    return
  }
  if (source.pgn) {
    leaf.pgn = source.pgn
    delete leaf.sentence
  }
  if (source.sentence) {
    leaf.sentence = source.sentence
    delete leaf.pgn
  }
}

module.exports = FullSignalK