seee prev. commit

.vscode/launch.json

@@ -7,7 +7,7 @@
         {
             "type": "node",
             "request": "launch",
-            "name": "Launch Program",
+            "name": "Launch esprimo",
             "skipFiles": [
                 "<node_internals>/**"
             ],
@@ -18,6 +18,19 @@
                 "MONGOHOST": "esprimo",
                 "MONGOPORT": "27098"
             }
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "name": "Launch strato",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/bin/www.js",
+            "env": {
+                "MONGOHOST": "h3006374.stratoserver.net",
+                "MONGOPORT": "27097"
+            }
         }
     ]
 }

actions/getsensorData.js

@@ -8,12 +8,12 @@ import {csv2Json} from "../utilities/csv2json.js"
 import checkParams from "../utilities/checkparams.js"
 import {getOneProperty} from "./getproperties.js"
 import {getNoiseData} from "../sensorspecials/noise.js"
-import {getRadioData} from "../sensorspecials/radioact.js"
+import {getgeigerData} from "../sensorspecials/geigeract.js"
 
 // Possible params for the different sensor types
 const noiseParams = [
     {name:'data', type: 'string', default: 'live'},
-    {name: 'span', type: 'int', default: ''},
+    {name: 'span', type: 'int', default: 1},
     {name: 'daystart', type: 'bool', default: null},
     {name: 'peak', type: 'int', default: 70},
     {name: 'since', type: 'date', default: '1900-01-01T00:00:00Z'},
@@ -27,11 +27,11 @@ const noiseParams = [
 ]
 const thpParams = []
 const pmParams = []
-const radioParams = [
+const geigerParams = [
     {name: 'what', type: 'string', default: 'day'},
-    {name: 'span', type: 'int', default: ''},
+    {name: 'span', type: 'int', default: 1},
     {name: 'daystart', type: 'bool', default: null},
-    {name: 'avg', type: 'int', default: 10},
+    {name: 'avg', type: 'int', default: 1},
     {name: 'since', type: 'date', default: '1900-01-01T00:00:00Z'},
     {name: 'box', type: 'array', default: null},
     {name: 'out', type: 'string', default: ''},
@@ -39,7 +39,8 @@ const radioParams = [
     {name: 'long', type: 'bool', default: false},
     {name: 'sort', type: 'int', default: 1},
     {name: 'last_seen', type: 'date', default: '1900-01-01T00:00:00Z'},
-    {name: 'datetime', type: 'date', default: null}
+    {name: 'datetime', type: 'date', default: null},
+    {name: 'mooving', type: 'bool', default: false},
 ]
 
 // >>>>>>>>>>>>>>>>>>>>> DUMMIES
@@ -56,7 +57,7 @@ const sensorTypeTable = [
     { typ: 'thp', possibleParams: thpParams, func: getThpData},
     { typ: 'noise', possibleParams: noiseParams, func: getNoiseData},
     { typ: 'pm', possibleParams: pmParams, func: getPmData},
-    { typ: 'radioactivity', possiblePramas: radioParams, func: getRadioData}
+    { typ: 'radioactivity', possibleParams: geigerParams, func: getgeigerData}
 ]
 
 /* Units:
@@ -149,8 +150,8 @@ export async function getSensorData(params) {
 
 //    export const getActData = async (opts) => {
 export async function getActData(opts) {
-    let retI = await influx.fetchActData(opts)
+//    let retI = await influx.fetchActData(opts)
-    retI.mongo = false
+//    retI.mongo = false
     let retM = await mongo.fetchActData(opts)
     retM.mongo = true
     return retM

databases/mongo.js

@@ -176,6 +176,82 @@ export const fetchActData = async (opts) => {
     ).toArray();
 */
 
+export const fetchgeigerAVGData = async (opts) => {
+    let docs = []
+    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 datRange = {sensorid: opts.sensorid, datetime: {$gte: start, $lt: end}}
+    let sorting = {datetime: opts.sort};
+    let client = await connectMongo()
+    try {
+        if(opts.mooving) {
+            docs = await client.db(MONGOBASE).collection('sensors').aggregate([
+                {
+                    $sort: sorting
+                },                               // sort by date
+                {
+                    $match: {sensorid: opts.sensorid}
+                },            // select only values for given sensor
+                {
+                    $match: datRange
+                },                             // select only values in give data range
+                {
+                    $setWindowFields: {
+                        sortBy: {datetime: 1},
+                        output: {
+                            cpm_avg: {
+                                $avg: "$values.counts_per_minute",
+                                window: {
+                                    range: [-60, 0],
+                                    unit: "minute"
+                                }
+                            }
+                        }
+                    }
+                },
+                {
+                    $project: {_id:0, cpm_avg: 1, datetime:1, uSvph_avg: { $multiply: ["$cpm_avg", opts.factor]}
+                }        
+            ]).toArray();  
+        } else {
+            docs = await client.db(MONGOBASE).collection('sensors').aggregate([
+                {
+                    $sort: sorting
+                },                               // sort by date
+                {
+                    $match: {sensorid: opts.sensorid}
+                },            // select only values for given sensor
+                {
+                    $match: datRange
+                },                             // select only values in give data range
+                {   $group: {
+                        _id: {$dateTrunc: {
+                            date: "$datetime",
+                            unit: "minute",
+                            binSize: 60
+                            }},
+                        cpm_avg: {$avg: "$values.counts_per_minute"},        // calculate the average
+                    }
+                },
+                { $addFields: { datetime: "$_id"}},             // change '_id' to 'datetime
+                {
+                    $project: {_id:0, uSvph_avg: { $multiply: ["$cpm_avg", opts.factor]}, datetime: 1, cpm_avg: 1}
+                }        
+            ]).toArray();  
+        }
+    } catch(e) {                                            // if there was an error
+        ret.err = e                                         // log it to console
+    }
+    finally {
+        client.close()
+    }
+    ret.values = docs
+    return ret
+}
+
 export const fetchNoiseAVGData = async (opts) => {
     let docs = []
     let ret = {err: null, values: []}
@@ -216,6 +292,8 @@ export const fetchNoiseAVGData = async (opts) => {
     return ret
 }
 
+export const fetchAVGData = async (opts) => {
+}
 /*
 // *********************************************
 // getAverageData

sensorspecials/noise.js

@@ -8,16 +8,7 @@ import {DateTime} from 'luxon'
 import { translate as trans } from '../routes/api.js'
 import * as influx from "../databases/influx.js"
 import * as mongo from "../databases/mongo.js"
-
+import { setoptionfromtable } from "../utilities/chartoptions.js"
-
-const setoptionfromtable = (opt,tabval) => {
-    let ret = opt
-    if ((opt === null) || (opt === '') || (opt < tabval)){
-         ret = tabval
-    }
-    return ret
-}
-
 
 export const getNoiseData = async (params, possibles, props) => {
     let ret = {err: null}

sensorspecials/radioact.js

@@ -1,128 +0,0 @@
-// Data preparation for fetching radioactivity data
-// rxf 2022-06-24
-
-import {returnOnError} from "../utilities/reporterror.js";
-import { getActData, getAvgData, getLongAvg } from "../actions/getsensorData.js"
-import checkParams from "../utilities/checkparams.js";
-
-
-const radioactFilter = (data, opts, actual) => {
-    let erg = {}
-    erg.sid = opts.sensorid
-    erg.sname = opts.sname
-    erg.values = []
-    for (let x of data.values) {
-        let entry = {}
-        entry.datetime = x.datetime
-        if(actual) {
-            entry.cpm = x.counts_per_minute,
-            entry.uSvh = x.counts_per_minute / 60 * opts.factor
-        } else {
-            entry.cpmAvg = x.counts_per_minute,
-            entry.uSvhAvg = x.counts_per_minute / 60 * opts.factor
-        }
-        erg.values.push(entry)
-    }
-    return erg
-}
-
-
-export const getRadioData = async (params, possibles, props) => {
-    let ret = {err: null}
-
-    let {opts, erro} = checkParams(params, {
-        mandatory:[
-            {name:'sensorid', type: 'int'},
-        ],
-        optional: possibles
-    })
-    // To be compatible with old API:
-    if (opts.out === 'csv') {
-        opts.csv = true
-    }
-    if (erro) {
-        return returnOnError(ret, erro, getNoiseData.name)
-    }
-
-    // execute function depending on given 'what'
-    for(let x of whatTable) {
-        if (x.what === opts.what) {
-            opts.span = setoptionfromtable(opts.span, x.span)
-            opts.daystart = setoptionfromtable(opts.daystart, x.daystart)
-            let {start, stop} = calcRange(opts)             // calc time range
-            opts.start = start
-            opts.stop = stop
-            let erg = await x.func(opts)                    // get the data
-            ret = {
-                err: erg.err,
-                options: {
-                    sid: opts.sensorid,
-                    indoor: props.location[0].indoor,
-                    span: opts.span,
-                    start: DateTime.fromISO(opts.start.slice(7)),
-                    data: opts.data,
-                    count: erg.values.length,
-                },
-                values: erg.values,
-            }
-            if(ret.values.length === 0) {
-                ret.err = trans('NODATA')
-            }
-            return ret
-        }
-    }
-    return returnOnError(ret, 'CMNDUNKNOWN', getNoiseData.name)
-}
-
-/*
-
-
-    let erg = { err: null, data: {}}
-
-    let params = {
-        sensorid: opts.sensorid,
-        avg: opts.avg,
-        datetime: opts.start
-    }
-    if (opts.what === 'oneday') {
-        params.span = 1
-    } else if (opts.what === 'oneweek') {
-        params.span = 7
-    } else {
-        params.span = 31
-        params.moving = false
-        params.avg = 1440
-    }
-    let { data, err } = await getAvgData(params)
-    if (err != null) {
-        return returnOnError(erg, err, getRadioData.name)
-    }
-    erg.data.radiomovavg = radioactFilter(data, opts, false)
-    if (opts.what === 'oneday') {
-        const { data, err} = await getActData(params)
-        if (err != null) {
-            return returnOnError(erg, err, getRadioData.name)
-        }
-        erg.data.radioactual = radioactFilter(data, opts, true)
-    }
-    if(opts.climatesid && ((opts.what === 'oneday') || (opts.what === 'oneweek'))) {
-        params.sensorid = opts.climatesid
-        params.avg = 10
-        const { data, err} = await getAvgData(params)
-        if (err != null) {
-            return returnOnError(erg, err, getRadioData.name)
-        }
-        data.sid = opts.climatesid
-        data.sname = opts.climatesname
-        erg.data.climate = data
-    }
-    return erg
-}
-*/
-
-
-const whatTable = [
-    {'what':'day', 'span': 1, 'daystart': false, 'func': getDayData},
-    {'what':'week', 'span': 7, 'daystart': false, 'func': getWeekgData},
-    {'what':'month', 'span': 30, 'daystart': true, 'func': getMonthData},
-];

test/test.js

@@ -9,7 +9,7 @@ describe("get data for map - test", function() {
         "west": 8.99760833740236
     }
 
-    it("radioactivity should return at least 4 elements", async function() {
+    it("geigeractivity should return at least 4 elements", async function() {
         const erg = await getData4map(
             {
                 "type": "radioactivity",

utilities/chartoptions.js

@@ -137,3 +137,12 @@ export function calcDays(data, isyear) {
     return days;
 };
 
+export const setoptionfromtable = (opt,tabval) => {
+    let ret = opt
+    if ((opt === null) || (opt === '') || (opt === undefined) || (opt < tabval)){
+         ret = tabval
+    }
+    return ret
+}
+
+