lsp/db/dbcontroller.js

const MongoClient = require('mongodb').MongoClient;
const models = require('../models')

const mongodb_hostname = process.env.MONGODB_HOST || '0.0.0.0';
const mongodb_port = process.env.MONGODB_PORT || 27017;
const mongodb_database = process.env.MONGODB_DATABASE || 'lsp';
const mongodb_url = 'mongodb://' + mongodb_hostname + ':' + mongodb_port;

const client = new MongoClient(mongodb_url, { useUnifiedTopology: true });

const bucketMaxSize = 4096;

var _db;
var _data;
var _ipx_data;
var _events;
var _alerts;

var days = function(date) {
  return new Date((date - date%86400) * 1000);
}

var init = async function () {
  await client.connect(function (err) {
    if (err) {
      console.log('MongoDB Client error');
      console.log(err);
      return { error: "Error connecting to DB: " + err }

    } else {
      _db       = client.db(mongodb_database);
      _devices  = _db.collection('devices');
      _data     = _db.collection('data');
      _ipx_data = _db.collection('ipx-data');
      _events   = _db.collection('events');
      _alerts   = _db.collection('alerts');

      console.log('MongoDB Client connected');
      ////////////////////////////
      // FLUSH DB BY UNCOMMENTING 
      // _devices.deleteMany(function(err, objects){});
      // _data.deleteMany(function(err, objects){});
      // _ipx_data.deleteMany(function(err, objects){});
      // _events.deleteMany(function(err, objects){});
      // _alerts.deleteMany(function(err, objects){});

      return null;
    }
  });
}

var addData = async function (relay, device, element) {
  try {
    const model = await models.data.validateAsync(element);

    await _data.updateOne(
      {
        device: device,
        date: days(element.date),
        bucketSize: { $lt: bucketMaxSize },
      },
      {
        $addToSet: {
          data: model
        },
        $min: { min: model.value },
        $max: { max: model.value },
        $inc: { bucketSize: 1 },
      },
      {
        upsert: true
      })
      .then(err => {
        return err;
      })
  } catch (err) {
    return err;
  }
}

var addEvent = async function (relay, device, element) {
  try {
    const model = await models.event.validateAsync(element);

    await _events.updateOne(
      {
        device: device,
        date: days(element.date),
        bucketSize: { $lt: bucketMaxSize },
      },
      {
        $addToSet: {
          events: model
        },
        $min: { first: model.date },
        $max: { last: model.date },
        $inc: { bucketSize: 1 },
      },
      {
        upsert: true
      })
      .then(err => {
        return err;
      })
  } catch (err) {
    return err;
  }
}

var addAlert = async function (relay, device, element) {
  try {
    const model = await models.alert.validateAsync(element);

    await _alerts.updateOne(
      {
        device: device,
        relay: relay,
        bucketSize: { $lt: bucketMaxSize },
      },
      {
        $addToSet: {
          alerts: model
        },
        $min: { first: model.date },
        $max: { last: model.date },
        $inc: { bucketSize: 1 },
      },
      {
        upsert: true
      })
      .then(err => {
        return err;
      })
  } catch (err) {
    console.log(err)
    return err;
  }
}

var addIPXData = async function (relay, device, child, element) {
  try {
    const model = await models.ipxdata.validateAsync(element);

    await _ipx_data.updateOne(
      {
        device: device,
        child: child,
        date: days(element.date),
        bucketSize: { $lt: bucketMaxSize },
      },
      {
        $addToSet: {
          data: model
        },
        $min: { first: model.date },
        $max: { last: model.date },
        $inc: { bucketSize: 1 },
      },
      {
        upsert: true
      })
      .then(err => {
        return err;
      })
  } catch (err) {
    return err;
  }
}

var addDevice = async function (element) {
  try {
    const model = await models.device.validateAsync(element);

    await _devices.updateOne(
      {
        msn: model.msn
      },
      {
        $set: model
      },
      {
        upsert: true
      })
      .then(err => {
        return err;
      })
  } catch (err) {
    return err;
  }
}

var updateDevice = async function (model) {
  try {
    await _devices.updateOne(
      {
        msn: model.msn
      },
      {
        $set: model
      },
      {
        upsert: true
      })
      .then(err => {
        return err;
      })
  } catch (err) {
    return err;
  }
}

var getDevice = async function (msn) {
  try {
    if (!msn) { throw ("msn_not_provided")}

    return await _devices.findOne(
      {
        $or : [{relayMsn: msn}, {msn: msn}]
      })
      .then(element => {
        return element;
      })
  } catch (err) {
    throw err
  }
}

var getDeviceChildren = async function (msn) {
  try {
    if (!msn) { throw ("msn_not_provided")}
    
    return await _devices.findOne(
      {
        relayMsn: msn
      })
      .then(element => {
        return element.inventory;
      })
  } catch (err) {
    throw err
  }
}

var getDeviceParents = async function (msn) {
  try {
    if (!msn) { throw ("msn_not_provided")}
    
    return await _devices.find(
      {
        inventory: { $in: {msn: msn} }
      })
      .then(elements => {
        return elements;
      })
  } catch (err) {
    throw err
  }
}

exports.init = init

exports.addData = addData
exports.addEvent = addEvent
exports.addAlert = addAlert
exports.addIPXData = addIPXData
exports.addDevice = addDevice
exports.updateDevice = updateDevice
exports.getDevice = getDevice
exports.getDeviceChildren = getDeviceChildren
exports.getDeviceParents = getDeviceParents