common.js

/*
  MIT License Copyright 2021, 2024 - Bitpool Pty Ltd
*/

const { createLogger, format, transports } = require("winston");
const { randomUUID } = require("crypto");
const os = require("os");
const { exec } = require("child_process");
const baEnum = require("./resources/node-bacstack-ts/dist/index.js").enum;
const fs = require("fs");

class BacnetConfig {
  constructor(
    device,
    objects,
    bacnet_polling_schedule,
    apduTimeout,
    localIpAdrress,
    roundDecimal,
    local_device_port,
    apduSize,
    maxSegments,
    broadCastAddr
  ) {
    this.device = {
      deviceId: device.deviceId,
      address: device.address,
    };
    this.polling = {
      schedule: bacnet_polling_schedule,
    };
    this.objects = [
      {
        objectId: {
          type: objects.object_type,
          instance: objects.instance,
          properties: objects.object_props,
        },
      },
    ];
    this.apduTimeout = apduTimeout;
    this.localIpAdrress = localIpAdrress;
    this.roundDecimal = roundDecimal;
    this.port = local_device_port;
    this.apduSize = apduSize;
    this.maxSegments = maxSegments;
    this.broadCastAddr = broadCastAddr;
  }
}

class BacnetClientConfig {
  constructor(
    apduTimeout,
    localIpAdrress,
    local_device_port,
    apduSize,
    maxSegments,
    broadCastAddr,
    discover_polling_schedule,
    toRestartNodeRed,
    deviceId,
    manual_instance_range_enabled,
    manual_instance_range_start,
    manual_instance_range_end,
    device_read_schedule,
    retries,
    cacheFileEnabled,
    sanitise_device_schedule,
    portRangeMatrix
  ) {
    this.apduTimeout = apduTimeout;
    this.localIpAdrress = localIpAdrress;
    this.port = local_device_port;
    this.apduSize = apduSize;
    this.maxSegments = maxSegments;
    this.broadCastAddr = broadCastAddr;
    this.discover_polling_schedule = discover_polling_schedule;
    this.toRestartNodeRed = toRestartNodeRed;
    this.deviceId = deviceId;
    this.manual_instance_range_enabled = manual_instance_range_enabled;
    this.manual_instance_range_start = manual_instance_range_start;
    this.manual_instance_range_end = manual_instance_range_end;
    this.device_read_schedule = device_read_schedule;
    this.retries = retries;
    this.cacheFileEnabled = cacheFileEnabled;
    this.sanitise_device_schedule = sanitise_device_schedule;
    this.portRangeMatrix = this.generatePortRangeArray(portRangeMatrix);
  }

  generatePortRangeArray(rangeMatrix) {
    let portArray = [];
    for (let x = 0; x < rangeMatrix.length; x++) {
      let rangeEntry = rangeMatrix[x];
      let start = parseInt(rangeEntry.start);
      let end = parseInt(rangeEntry.end);
      for (let i = start; i <= end; i++) {
        portArray.push(i);
      }
    }

    return portArray;
  }
}



class ReadCommandConfig {
  constructor(pointsToRead, objectProperties, decimalPrecision) {
    this.pointsToRead = pointsToRead;
    this.objectProperties = objectProperties;
    this.precision = decimalPrecision;
  }
}

class WriteCommandConfig {
  constructor(device, objects) {
    this.device = {
      deviceId: device.deviceId,
      address: device.address,
    };
    this.objects = [
      {
        objectId: {
          type: objects.object_type,
          instance: objects.instance,
          properties: objects.object_props,
        },
      },
    ];
  }
}

const getUnit = function (id) {
  for (var key in baEnum.EngineeringUnits) {
    if (baEnum.EngineeringUnits[key] == id) {
      if (baEnum.EngineeringUnits.hasOwnProperty(key)) {
        let unitsArr = key.split("_");
        let unit;
        unitsArr.forEach((ele, index) => {
          if (index == 0) {
            unit = ele.toLowerCase();
          } else {
            unit += "-" + ele.toLowerCase();
          }
        });
        return unit;
      }
    }
  }
  return "no-units";
};

const generateId = function () {
  return randomUUID();
};

const getIpAddress = function () {
  return new Promise(function (resolve, reject) {
    const nets = os.networkInterfaces();
    const results = Object.create(null); // Or just '{}', an empty object
    for (const name of Object.keys(nets)) {
      for (const net of nets[name]) {
        // Skip over non-IPv4 and internal (i.e. 127.0.0.1) addresses
        let family = parseInt(net.family.toString().match(/[0-9]/));
        if (family === 4 && !net.internal) {
          if (!results[name]) {
            results[name] = [];
          }
          results[name].push(net.address);
        }
      }
    }

    if (os.version().includes("Ubuntu") || os.version().includes("SMP")) {
      let allInterfaceName = "All interfaces";
      if (!results[allInterfaceName]) {
        results[allInterfaceName] = [];
      }
      results[allInterfaceName].push("0.0.0.0");
    } else if (os.version().includes("Windows")) {
      //do nothing
    }

    resolve(results);
  });
};

const roundDecimalPlaces = function (value, decimals) {
  if (decimals) return Number(Math.round(value + "e" + decimals) + "e-" + decimals);
  return value;
};

const doNodeRedRestart = function () {
  return new Promise(function (resolve, reject) {
    try {
      exec("restart", (error, stdout, stderr) => {
        if (error) {
          console.log(`Node-Red restart error: ${error.message}`);
          reject(error.message);
        }
        if (stderr) {
          console.log(`Node-Red restart stderr: ${stderr}`);
          reject(stderr);
        }
        resolve(stdout);
      });
    } catch (e) {
      console.log(`Node-Red restart error: ${e}`);
      reject(e);
    }
  });
};

// STORE CONFIG FUNCTION ==========================================================
//
// ================================================================================
async function Store_Config(data) {
  try {
    await fs.writeFile("edge-bacnet-datastore.cfg", data, { encoding: "utf8", flag: "w" }, (err) => {
      if (err) {
        console.log("Store_Config writeFile error: ", err);
      }
    });
  } catch (e) {
    //do nothing
  }
}

// READ CONFIG SYNC FUNCTION ======================================================
//
// ================================================================================
function Read_Config_Sync() {
  var data = "{}";
  try {
    data = fs.readFileSync("edge-bacnet-datastore.cfg", { encoding: "utf8", flag: "r" });
  } catch (err) {
    data = "{}";
    Store_Config(data);
  }
  return data;
}

// STORE CONFIG FUNCTION - BACNET SERVER ==========================================
//
// ================================================================================
async function Store_Config_Server(data) {
  try {
    await fs.writeFile("edge-bacnet-server-datastore.cfg", data, (err) => {
      if (err) {
        //console.log("Store_Config_Server writeFile error: ", err);
      }
    });
  } catch (err) { }
}

// READ CONFIG SYNC FUNCTION - BACNET SERVER ======================================
//
// ================================================================================
function Read_Config_Sync_Server() {
  var data = "{}";
  try {
    data = fs.readFileSync("edge-bacnet-server-datastore.cfg", { encoding: "utf8", flag: "r" });
  } catch (err) {
    if (err.errno == -4058) {
      data = "{}";
      Store_Config_Server(data);
    }
  }
  return data;
}

function isNumber(value) {
  return value != null && typeof value === "number" && !isNaN(value);
}

function decodeBitArray(size, bits) {
  let array = [];
  for (let i = 0; i < bits.length; i++) {
    let bit = bits[i];
    let bitString = bit.toString(2);
    if (bitString.length < size) {
      const remainingLength = size - bitString.length;
      const backFillString = "0".repeat(remainingLength);
      array.push(backFillString + bitString);
    } else if (bitString.length == size) {
      array.push(bitString);
    }
    if (i == bits.length - 1) {
      return array;
    }
  };
}

function getBacnetErrorString(classInt, codeInt) {
  const classString = Object.keys(baEnum.ErrorClass).find(key => baEnum.ErrorClass[key] === classInt);
  const codeString = Object.keys(baEnum.ErrorCode).find(key => baEnum.ErrorCode[key] === codeInt);
  return `BacnetError - Class:${classString} - Code:${codeString}`;
}

function parseBacnetError(error) {
  let err = error.message;
  if (err.includes("Class") && err.includes("Code")) {
    const match = err.match(/Class:(\d+) - Code:(\d+)/);
    if (match) {
      err = getBacnetErrorString(parseInt(match[1], 10), parseInt(match[2], 10));
    }
  } else if (err.includes("ERR_TIMEOUT")) {
    err = "Request TIMEOUT";
  }

  return err;
};

module.exports = {
  BacnetConfig,
  BacnetClientConfig,
  ReadCommandConfig,
  WriteCommandConfig,
  getUnit,
  generateId,
  getIpAddress,
  roundDecimalPlaces,
  doNodeRedRestart,
  Store_Config,
  Read_Config_Sync,
  Store_Config_Server,
  Read_Config_Sync_Server,
  isNumber,
  decodeBitArray,
  parseBacnetError,
  getBacnetErrorString,
};