323 lines
10 KiB
JavaScript
323 lines
10 KiB
JavaScript
/* Interface for MongoDB
|
|
*/
|
|
import { MongoClient } from 'mongodb'
|
|
import { logit, logerror } from '../utilities/logit.js'
|
|
import { DateTime } from 'luxon'
|
|
import {returnOnError} from "../utilities/reporterror.js";
|
|
|
|
// const nodemailer = require('nodemailer');
|
|
|
|
let MONGOHOST = process.env.MONGOHOST;
|
|
let MONGOPORT = process.env.MONGOPORT;
|
|
let MONGOAUTH = process.env.MONGOAUTH;
|
|
let MONGOUSRP = process.env.MONGOUSRP;
|
|
let MONGOBASE = process.env.MONGOBASE;
|
|
|
|
if (MONGOHOST === undefined) { MONGOHOST = 'localhost';}
|
|
if (MONGOPORT === undefined) { MONGOPORT = 27097; }
|
|
if (MONGOAUTH === undefined) { MONGOAUTH = 'false'; }
|
|
if (MONGOBASE === undefined) { MONGOBASE = 'allsensors'; }
|
|
|
|
let MONGO_URL = 'mongodb://'+MONGOHOST+':'+MONGOPORT; // URL to mongo database
|
|
if (MONGOAUTH === 'true') {
|
|
MONGO_URL = 'mongodb://'+MONGOUSRP+'@' + MONGOHOST + ':' + MONGOPORT + '/?authSource=' + MONGOBASE; // URL to mongo database
|
|
}
|
|
|
|
export const properties_collection = 'pptest'
|
|
|
|
let statistics = {}
|
|
let client
|
|
|
|
export const connectMongo = async () => {
|
|
try {
|
|
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}`)
|
|
return client
|
|
}
|
|
catch(error){
|
|
throw(error)
|
|
}
|
|
}
|
|
|
|
export const closeMongo = async (client) => {
|
|
client.close()
|
|
}
|
|
|
|
const listDatabases = async (client) => {
|
|
let databasesList = await client.db().admin().listDatabases();
|
|
|
|
console.log("Databases:");
|
|
databasesList.databases.forEach(db => console.log(` - ${db.name}`));
|
|
}
|
|
|
|
/* ***************************************************
|
|
// READ routines
|
|
******************************************************/
|
|
|
|
// Read properties from the database
|
|
export const readProperties = async (query, limit = 0) => {
|
|
let ret = {err: null, properties: null}
|
|
client = await connectMongo()
|
|
try {
|
|
if ("sid" in query) { // if sid is given, read property for sid
|
|
ret.properties = await client.db(MONGOBASE).collection(properties_collection).findOne({_id: query.sid})
|
|
} else { // otherwise read props corresponding to query
|
|
ret.properties = await client.db(MONGOBASE).collection(properties_collection).find(query).limit(limit).toArray()
|
|
}
|
|
} catch (e) {
|
|
ret.err = e
|
|
}
|
|
finally {
|
|
await closeMongo(client)
|
|
client = null
|
|
}
|
|
return ret
|
|
}
|
|
|
|
// read mapdata from database
|
|
export const readMapdata = async (query, limit) => {
|
|
let ret = {err: null, mapdata: []}
|
|
client = await connectMongo()
|
|
try {
|
|
ret.mapdata = await client.db(MONGOBASE).collection("mapdata").find(query).limit(limit).toArray()
|
|
} catch (e) {
|
|
ret.err = e
|
|
}
|
|
finally {
|
|
await closeMongo(client)
|
|
client = null
|
|
}
|
|
return ret
|
|
}
|
|
|
|
|
|
export const getallProperties = async (coll, query) => {
|
|
let ret = {err: null, properties: []}
|
|
client = await connectMongo()
|
|
try {
|
|
ret.properties = await client.db(MONGOBASE).collection(coll)
|
|
.find(query).toArray()
|
|
} catch (e) {
|
|
ret.err = e
|
|
}
|
|
finally {
|
|
await closeMongo(client)
|
|
client = null
|
|
}
|
|
return ret
|
|
}
|
|
|
|
|
|
export const getOneproperty = async (sid) => {
|
|
let ret = {error: false}
|
|
client = await connectMongo()
|
|
try {
|
|
ret.properties = await client.db(MONGOBASE).collection("properties_collection")
|
|
.findOne({_id: sid})
|
|
} catch (e) {
|
|
ret = {error: true, errortext: e}
|
|
}
|
|
finally {
|
|
await closeMongo(client)
|
|
client = null
|
|
}
|
|
return ret
|
|
}
|
|
|
|
|
|
export const doAggregate = async (coll, query, conn, clos) => {
|
|
let ret = {error: false}
|
|
if (conn) {
|
|
client = await connectMongo()
|
|
}
|
|
try {
|
|
ret.values = await client.db(MONGOBASE).collection(coll).aggregate(query).toArray()
|
|
} catch (e) {
|
|
ret = {error: true, errortext: e}
|
|
}
|
|
finally {
|
|
if (clos) {
|
|
await closeMongo(client)
|
|
client = null
|
|
}
|
|
}
|
|
return ret
|
|
}
|
|
|
|
|
|
export const writeOneproperty = async (client, prop) => {
|
|
try {
|
|
let result = await client.db(MONGOBASE).collection("properties_collection")
|
|
.insertOne(prop)
|
|
} catch(e) {
|
|
if (e.code === 11000) {
|
|
return false
|
|
} else {
|
|
throw(e)
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
export const writeProperties = async (client, props) => {
|
|
let start = DateTime.now();
|
|
if (props.new.length !== 0) {
|
|
try {
|
|
let result = await client.db(MONGOBASE).collection("properties_collection")
|
|
.insertMany(props.new)
|
|
} catch (e) {
|
|
console.error(e)
|
|
}
|
|
}
|
|
if (props.loc.length !== 0) {
|
|
try {
|
|
for (let item of props.loc) {
|
|
let result = await client.db(MONGOBASE).collection("properties_collection")
|
|
.updateOne({_id: item._id}, {
|
|
$set: {location_id: item.location_id},
|
|
$push: {location: { $each: [item.location[0]], $position: 0}}
|
|
})
|
|
}
|
|
} catch (e) {
|
|
console.error(e)
|
|
}
|
|
}
|
|
if (props.sname.lenth !== 0) {
|
|
try {
|
|
for (let item of props.sname) {
|
|
let result = await client.db(MONGOBASE).collection("properties_collection")
|
|
.updateOne({_id: item._id}, {
|
|
$set: {name: item.name, since: item.since}
|
|
})
|
|
}
|
|
} catch (e) {
|
|
console.error(e)
|
|
}
|
|
}
|
|
statistics.writePropsTime = DateTime.now().diff(start, ['seconds']).toObject().seconds
|
|
logit(`Write properties to mongoDB: ${statistics.writePropsTime} sec.`)
|
|
}
|
|
|
|
export const writeDataArray = async (data, collection, conn, clos) => {
|
|
let start = DateTime.now();
|
|
let result
|
|
if (conn) {
|
|
client = await connectMongo()
|
|
}
|
|
try {
|
|
result = await client.db(MONGOBASE).collection(collection)
|
|
.insertMany(data)
|
|
} catch (e) {
|
|
console.error(e)
|
|
} finally {
|
|
if(clos) {
|
|
await closeMongo(client)
|
|
client = null
|
|
}
|
|
}
|
|
statistics.writeDataTime = DateTime.now().diff(start, ['seconds']).toObject().seconds
|
|
logit(`Write Data to mongoDB: ${statistics.writeDataTime} sec.`)
|
|
return result
|
|
}
|
|
|
|
export const writeStatistic = async (client, stat) => {
|
|
let start = DateTime.now();
|
|
let entry = { timestamp: new Date(), ...stat }
|
|
try {
|
|
let result = await client.db(MONGOBASE).collection("statistics")
|
|
.insertOne(entry)
|
|
} catch (e) {
|
|
console.error(e)
|
|
}
|
|
statistics.writeStatisticTime = DateTime.now().diff(start, ['seconds']).toObject().seconds
|
|
logit(`Write statistics to mongoDB: ${statistics.writeStatisticTime} sec.`)
|
|
}
|
|
|
|
export const readAKWs = async (options) => {
|
|
let ret = {values: { akws: [], th1_akws: []}, err: null}
|
|
let erg = []
|
|
client = await connectMongo()
|
|
try {
|
|
let docs = await client.db(MONGOBASE).collection("akws")
|
|
.find().toArray()
|
|
if(docs == null) {
|
|
return returnOnError(ret, 'akws - docs == null', readAKWs.name)
|
|
}
|
|
logit(`getawkdata: data fetched from akws, length= ${docs.length}`);
|
|
ret.values.akws = docs
|
|
let docs1 = await client.db(MONGOBASE).collection("th1_akws")
|
|
.find().toArray()
|
|
if(docs1 == null) {
|
|
return returnOnError(ret, 'th1_akws - docs == null', readAKWs.name)
|
|
}
|
|
logit(`getawkdata: data fetched from th1_akws, length= ${docs1.length}`)
|
|
ret.values.th1_akws = docs1
|
|
} catch (e) {
|
|
return returnOnError(ret, e, readAKWs.name)
|
|
}
|
|
finally {
|
|
await closeMongo(client)
|
|
client = null
|
|
}
|
|
return ret
|
|
}
|
|
|
|
/*
|
|
async function getMAPaktData(db,opt) {
|
|
let box = opt.box;
|
|
if ((box == "") || (box == undefined)) {
|
|
return {"avgs": [], "lastDate": null};
|
|
}
|
|
var south = parseFloat(box[0][1]);
|
|
var north = parseFloat(box[1][1]);
|
|
var east = parseFloat(box[1][0]);
|
|
var west = parseFloat(box[0][0]);
|
|
var collection = db.collection('mapdata'); // use the mapdata collection
|
|
var aktData = [];
|
|
var now = moment();
|
|
var lastDate = 0;
|
|
let loc;
|
|
loc = {
|
|
location: {
|
|
$geoWithin: {
|
|
$box: [
|
|
[west, south],
|
|
[east, north]
|
|
]
|
|
}
|
|
},
|
|
name: { $regex : "^Laerm|^DNMS"},
|
|
}
|
|
let docs = await collection.find(loc).toArray();
|
|
// console.log(docs);
|
|
for (var i = 0; i < docs.length; i++) {
|
|
var item = docs[i];
|
|
var oneAktData = {};
|
|
oneAktData['location'] = item.location.coordinates;
|
|
oneAktData['id'] = item._id; // ID des Sensors holen
|
|
oneAktData['lastSeen'] = item.values.datetime;
|
|
oneAktData['indoor'] = item.indoor;
|
|
var dati = item.values.datetime;
|
|
var dt = new Date(dati);
|
|
if ((now - dt) >= 31 * 24 * 3600 * 1000) { // älter als 1 Monat ->
|
|
oneAktData['noise_max'] = -2; // -2 zurückgeben
|
|
} else if ((now - dt) >= 3600 * 1000) { // älter als 1 Stunde ->
|
|
oneAktData['noise_max'] = -1; // -1 zurückgeben
|
|
} else {
|
|
oneAktData['noise_max'] = -5; // bedutet -> nicht anzeigen
|
|
if (item.values.hasOwnProperty('noise_LA_max')) {
|
|
oneAktData['noise_max'] = item.values.noise_LA_max.toFixed(0); // und merken
|
|
}
|
|
if (dati > lastDate) {
|
|
lastDate = dati;
|
|
}
|
|
}
|
|
aktData.push(oneAktData); // dies ganzen Werte nun in das Array
|
|
}
|
|
return {"avgs": aktData, "lastDate": lastDate}; // alles bearbeitet _> Array senden
|
|
};
|
|
|
|
*/
|