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_user = process.env.MONGODB_USER;
const mongodb_pass = process.env.MONGODB_PASSWORD;

// Build the MongoDB URI based on whether authentication is provided
let mongodb_url;
if (mongodb_user && mongodb_pass) {
  // Authenticated connection
  mongodb_url = `mongodb://${mongodb_user}:${mongodb_pass}@${mongodb_hostname}:${mongodb_port}`;
} else {
  // No authentication
  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 () {
  try {
    await client.connect();
    _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');

    if (mongodb_user && mongodb_pass) {
      console.log('MongoDB Client connected with authentication');
    } else {
      console.log('MongoDB Client connected without authentication');
    }
  } catch (err) {
    console.error('MongoDB Client error:', err);
    return { error: "Error connecting to DB: " + err };
  }
};

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