readin/mongo.js

/* Interface for MongoDB
*/
import { MongoClient } from 'mongodb'
import { logit, logerror } from './logit.js'
import { statistics } from './readdata.js'
import { DateTime } from 'luxon'

let DEVELOP = process.env.DEVELOP || 'false'

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 || 'sensor_data'


let MONGO_URL = 'mongodb://' + MONGOHOST + ':' + MONGOPORT;  	// URL to mongo database
if (MONGOAUTH == 'true') {
    MONGO_URL = 'mongodb://' + MONGOUSRP + '@' + MONGOHOST + ':' + MONGOPORT + '/?authSource=admin';          // URL to mongo database
}

export const property_coll = 'properties'

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 {
        if(DEVELOP === 'true')  {
            logit(`Try to connect to ${MONGO_URL}`)
        } else {
            logit(`Try to connect to ${'mongodb://' + MONGOHOST + ':' + MONGOPORT}`)
        }
        let client = await MongoClient.connect(MONGO_URL, { useNewUrlParser: true, useUnifiedTopology: true })
        if ( DEVELOP === 'true') {
            logit(`Mongodbase connected to ${MONGO_URL}`)
        } else {
            logit('Mongodbase connected')
        }
        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
}