Start using mongo timeseries

mooving all database relevant function to influx.js resp. mongo.js

aktual data now also readable from mongo

databases/influx.js

@@ -5,6 +5,7 @@ import { DateTime } from 'luxon'
 // import csvParse from 'csv-parser'
 import { logit, logerror } from '../utilities/logit.js'
 import {returnOnError} from "../utilities/reporterror.js";
+import {csv2Json} from "../utilities/csv2json.js";
 
 let INFLUXHOST = process.env.INFLUXHOST || "localhost"
 let INFLUXPORT = process.env.INFLUXPORT || 8086
@@ -17,7 +18,7 @@ let INFLUXORG = process.env.INFLUXORG || "citysensor"
 const INFLUXURL_READ = `http://${INFLUXHOST}:${INFLUXPORT}/api/v2/query?org=${INFLUXORG}`
 const INFLUXURL_WRITE = `http://${INFLUXHOST}:${INFLUXPORT}/api/v2/write?org=${INFLUXORG}&bucket=${INFLUXDATABUCKET}`
 
-export const influxRead = async (query) => {
+const influxRead = async (query) => {
     let start = DateTime.now()
     logit(`ReadInflux from ${INFLUXURL_READ}`)
     let erg = { values: [], err: null}
@@ -45,7 +46,7 @@ export const influxRead = async (query) => {
 }
 
 
-export const influxWrite = async (data) => {
+const influxWrite = async (data) => {
     let start = DateTime.now()
     let ret
     try {
@@ -69,3 +70,97 @@ export const influxWrite = async (data) => {
     logit(`Influx-Write-Time: ${start.diffNow('seconds').toObject().seconds * -1} sec`)
     return ret
 }
+
+const fetchFromInflux = async (ret, query) => {
+    let { values, err}  = await influxRead(query)
+    if(err) {
+        if(err.toString().includes('400')) {
+            return returnOnError(ret, 'SYNTAXURL', fetchFromInflux.name)
+        } else {
+            return returnOnError(ret, err, fetchFromInflux.name)
+        }
+    }
+    if (values.length <= 2) {
+        return returnOnError(ret, 'NODATA', fetchFromInflux.name)
+    }
+    ret.values = csv2Json(values)
+    return ret
+}
+
+export const fetchActData = async (opts) => {
+    let ret = {err: null, values: []}
+    let sorting = ''
+    if(opts.sort) {
+        if (opts.sort === 1) {
+            sorting = '|> sort(columns: ["_time"], desc: false)'
+        } else if (opts.sort === -1) {
+            sorting = '|> sort(columns: ["_time"], desc: true)'
+        }
+    }
+    // build the flux query
+    let query = `
+    from(bucket: "sensor_data")     
+|> range(${opts.start}, ${opts.stop})  
+|> filter(fn: (r) => r.sid == "${opts.sensorid}")  
+${sorting}
+|> keep(columns: ["_time","_field","_value"]) 
+|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
+`
+    return await fetchFromInflux(ret, query)
+}
+
+export const fetchNoiseAVGData = async (opts) => {
+    let ret = {err: null, values: []}
+    let small =  '|> keep(columns: ["_time", "peakcount", "n_AVG"])'
+    if (opts.long) {
+        small = ''
+    }
+    let queryAVG = `
+import "math"
+threshold = ${opts.peak}
+
+data = from(bucket: "sensor_data")
+  |> range(${opts.start}, ${opts.stop})  
+  |> filter(fn: (r) => r["sid"] == "${opts.sensorid}")
+e10 = data 
+  |> filter(fn: (r) => r._field == "E10tel_eq") 
+  |> aggregateWindow(every: 1h, fn: mean, createEmpty: false)
+  |> map(fn:  (r) => ({r with _value: (10.0 * math.log10(x: r._value))}))
+  |> keep(columns: ["_time","_field","_value"]) 
+  |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
+  |> rename(columns: {"E10tel_eq" : "n_AVG"})
+ecnt = data
+  |> filter(fn: (r) => r._field == "E10tel_eq") 
+  |> aggregateWindow(every: 1h, fn: count, createEmpty: false)
+  |> keep(columns: ["_time","_field","_value"]) 
+  |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
+  |> rename(columns: {"E10tel_eq" : "count"})
+esum = data
+  |> filter(fn: (r) => r._field == "E10tel_eq") 
+  |> aggregateWindow(every: 1h, fn: sum, createEmpty: false)
+  |> keep(columns: ["_time","_field","_value"]) 
+  |> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
+  |> rename(columns: {"E10tel_eq" : "n_sum"})
+peak = data
+  |> filter(fn: (r) => r._field == "noise_LA_max") 
+  |> aggregateWindow(
+        every: 1h,
+        fn: (column, tables=<-) => tables
+            |> reduce(
+                identity: {peakcount: 0.0},
+                fn: (r, accumulator) => ({
+                    peakcount: if r._value >= threshold then
+                        accumulator.peakcount + 1.0
+                    else
+                        accumulator.peakcount + 0.0,
+                }),
+            ),
+      )
+  |> keep(columns: ["_time","peakcount"]) 
+  part1 = join( tables: {e10: e10, ecnt: ecnt}, on: ["_time"])
+  part2 = join( tables: {esum: esum, peak: peak}, on: ["_time"])
+  join( tables: {P1: part1, P2: part2}, on: ["_time"])
+  ${small}
+`
+    return await fetchFromInflux(ret, queryAVG)
+}

databases/mongo.js

@@ -30,7 +30,7 @@ export const connectMongo = async () => {
 //        logit(`Try to connect to ${MONGO_URL}`)
 //        let client = await MongoClient.connect(MONGO_URL, { useNewUrlParser: true , useUnifiedTopology: true })
         let client = await MongoClient.connect(MONGO_URL)
-//        logit(`Mongodbase connected to ${MONGO_URL}`)
+        logit(`Mongodbase connected to ${MONGO_URL}`)
         return client
     }
     catch(error){
@@ -143,3 +143,57 @@ export const readAKWs = async (options) => {
     }
     return ret
 }
+
+export const fetchActData = async (opts) => {
+    let ret = {err: null, values: []}
+    let start = opts.start.slice(7)
+    let end = opts.stop.slice(6)
+    start = DateTime.fromISO(start).toJSDate()
+    end = DateTime.fromISO(end).toJSDate()
+    let query = {sensorid: opts.sensorid, datetime: {$gte: start, $lt: end}}
+    let client = await connectMongo()
+    try {
+        ret.values = await client.db(MONGOBASE).collection('sensors')
+            .find(query).toArray()
+    }
+    catch(e) {
+        ret.err = e
+    }
+    finally {
+        client.close()
+    }
+    return ret
+}
+/*
+    let docs = await collection.find(
+        { datetime:
+            { $gte: start.toDate(),  $lt: end.toDate() }
+        },
+        { projection:
+            {_id:0, E_eq:0, E_mx:0, E_mi:0, E10tel_mx:0, E10tel_mi:0}, sort: {datetime: sort}
+        },
+    ).toArray();
+*/
+
+
+export const fetchActDataxx = async (opts) => {
+    let ret = {err: null, values: []}
+    let sorting = ''
+    if(opts.sort) {
+        if (opts.sort === 1) {
+            sorting = '|> sort(columns: ["_time"], desc: false)'
+        } else if (opts.sort === -1) {
+            sorting = '|> sort(columns: ["_time"], desc: true)'
+        }
+    }
+    // build the flux query
+    let query = `
+    from(bucket: "sensor_data")     
+|> range(${opts.start}, ${opts.stop})  
+|> filter(fn: (r) => r.sid == "${opts.sensorid}")  
+${sorting}
+|> keep(columns: ["_time","_field","_value"]) 
+|> pivot(rowKey:["_time"], columnKey: ["_field"], valueColumn: "_value")
+`
+    return await fetchFromInflux(ret, query)
+}