first

mongo.js

@@ -0,0 +1,194 @@
+/* Interface for MongoDB
+*/
+import { MongoClient } from 'mongodb'
+import { logit, logerror } from './logit.js'
+import { statistics } from './readdata.js'
+import { DateTime } from 'luxon'
+
+// const nodemailer = require('nodemailer');
+
+let MONGOHOST = process.env.MONGOHOST || 'localhost'
+let MONGOPORT = process.env.MONGOPORT || 27017
+let MONGOAUTH = process.env.MONGOAUTH || 'false'
+let MONGOUSRP = process.env.MONGOUSRP || ''
+let MONGOBASE = process.env.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 property_coll = 'pptest'
+
+const addandshowstatistics = (client, text, field, start) => {
+    statistics[field] = DateTime.now().diff(start, ['seconds']).toObject().seconds
+    logit(`Write ${text} to mongoDB: Time: ${statistics[field]} sec.`)
+}
+
+export const connectMongo = async () => {
+    try {
+        logit(`Try to connect to ${MONGO_URL}`)
+        let client = await MongoClient.connect(MONGO_URL, { useNewUrlParser: true, useUnifiedTopology: true })
+        logit(`Mongodbase connected to ${MONGO_URL}`)
+        return client
+    }
+    catch (error) {
+        throw (error)
+    }
+}
+
+export const closeMongo = async (client) => {
+    client.close()
+}
+
+
+export const getallProperties = async (client) => {
+    return await client.db(MONGOBASE).collection(property_coll)
+        .find().sort({ _id: 1 }).toArray()
+
+}
+
+export const checkOneproperty = async (client, sid) => {
+    return await client.db(MONGOBASE).collection("properties")
+        .findOne({ _id: sid })
+}
+
+export const writeOneproperty = async (client, prop) => {
+    try {
+        let result = await client.db(MONGOBASE).collection("properties")
+            .insertOne(prop)
+    } catch (e) {
+        if (e.code == 11000) {
+            return false
+        } else {
+            throw (e)
+        }
+    }
+    return true
+}
+
+export const writeProperties = async (client, props) => {
+    let result
+    let startAll = DateTime.now();
+    let start
+    let coll = client.db(MONGOBASE).collection("properties")
+    if (props.new.length !== 0) {
+        start = DateTime.now();
+        try {
+            result = await coll.insertMany(props.new)
+        } catch (e) {
+            logerror(`Write properties new   ${e}`)
+        }
+        logit(`Write ${props.new.length} properties NEW to mongoDB: Result: ${result.acknowledged}, Time: ${start.diffNow('seconds').toObject().seconds * -1} sec.`)
+    }
+    if (props.loc.length !== 0) {
+        start = DateTime.now()
+        try {
+            for (let item of props.loc) {
+                result = await coll.updateOne({ _id: item._id }, {
+                    $set: { location_id: item.location_id },
+                    $push: { location: { $each: [item.location[0]], $position: 0 } }
+                })
+            }
+        } catch (e) {
+            logerror(`Write properties location   ${e}`)
+        }
+        logit(`Write ${props.loc.length} properties LOC to mongoDB: Result: ${result.acknowledged}, Time: ${start.diffNow('seconds').toObject().seconds * -1} sec.`)
+    }
+    if (props.sname.length !== 0) {
+        start = DateTime.now()
+        try {
+            for (let item of props.sname) {
+                result = await coll.updateOne({ _id: item._id }, {
+                    $push: { name: { $each: [item.name[0]], $position: 0 } }
+                })
+            }
+        } catch (e) {
+            logerror(`Write properties samename   ${e}`)
+        }
+        logit(`Write ${props.sname.length} properties NAME to mongoDB: Result: ${result.acknowledged}, Time: ${start.diffNow('seconds').toObject().seconds * -1} sec.`)
+    }
+    addandshowstatistics(client, 'properties', 'writePropsTime', startAll)
+}
+
+export const writeDataArray = async (client, coll, data) => {
+    let result
+    let start = DateTime.now();
+    try {
+        result = await client.db(MONGOBASE).collection(coll)
+            .insertMany(data, { ordered: false })
+    } catch (e) {
+        if (e.code !== 11000) {
+            console.error(e)
+        }
+    }
+    let statname = `writeMongoData[${coll}]Time`
+    addandshowstatistics(client, `${data.length} entries for ${coll}`, `writeMongoData[${coll}]Time`, start)
+
+//    statistics[statname] = DateTime.now().diff(start, ['seconds']).toObject().seconds
+//    logit(`Write Data for ${coll} to mongoDB: Time: ${statistics[statname]} sec.`)
+}
+
+export const writeStatistic = async (client, stat) => {
+    let result
+    let start = DateTime.now();
+    let entry = { timestamp: new Date(), ...stat }
+    try {
+        result = await client.db(MONGOBASE).collection("statistics")
+            .insertOne(entry)
+    } catch (e) {
+        console.error(e)
+    }
+    addandshowstatistics(client, `statistics`, `writeStatisticTime`, start)
+}
+
+export const dropColl = async (client, coll) => {
+    let start = DateTime.now()
+    let result
+    try {
+        result = await client.db(MONGOBASE).collection(coll).drop()
+    } catch (e) {
+        console.error(e)
+    }
+    logit(`Drop collection ${coll}: Result: ${result}, Time: ${start.diffNow('second').toObject().seconds * -1} sec.`)
+}
+
+
+export const createIndex = async (client, coll) => {
+    let result
+    let start = DateTime.now()
+    try {
+        result = await client.db(MONGOBASE).collection(coll).createIndex({ "location.loc": "2dsphere" })
+    } catch (e) {
+        console.error(e)
+    }
+    logit(`Create-Index: Result: ${result}, Time: ${start.diffNow('second').toObject().seconds * -1} sec.`)
+}
+
+export const bulkUpdateMapdata = async (client, data) => {
+    let start = DateTime.now()
+    let result
+    try {
+        result = await client.db(MONGOBASE).collection("mapdata")
+            .bulkWrite(data, { ordered: false })
+    } catch (e) {
+        console.error(e)
+    }
+    logit(`Write MapData: Result: ${result}, Time: ${start.diffNow('second').toObject().seconds * -1} sec.`)
+    return result
+}
+
+
+export const bulkWrite = async (client, coll, data) => {
+    let start = DateTime.now()
+    let result
+    try {
+        result = await client.db(MONGOBASE).collection(coll)
+            .bulkWrite(data, { ordered: false })
+    } catch (e) {
+        console.error(e)
+    }
+    addandshowstatistics(client, `Data for ${coll}`, `writeMongoProperties[${coll}]Time`, start)
+    return result
+}