@catchpower/device-config-interaction 0.0.13

package/esm2022/lib/dataset-processing.service.mjs

@@ -0,0 +1,524 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DatasetProcessingService {
+    //constructor() {}
+    /*
+     * For use with DataView
+     *
+     */
+    getValuefromBuffer(obj, buffer) {
+        let value = 0;
+        if (obj.signed) {
+            switch (obj.length) {
+                case 8:
+                    value = buffer.getInt8(obj.position);
+                    break;
+                case 16:
+                    value = buffer.getInt16(obj.position, obj.little);
+                    break;
+                case 32:
+                    value = buffer.getInt32(obj.position, obj.little);
+                    break;
+            }
+        }
+        else {
+            switch (obj.length) {
+                case 8:
+                    value = buffer.getUint8(obj.position);
+                    break;
+                case 16:
+                    value = buffer.getUint16(obj.position, obj.little);
+                    break;
+                case 32:
+                    value = buffer.getUint32(obj.position, obj.little);
+                    break;
+            }
+        }
+        return value;
+    }
+    /*
+     * For use with DataView
+     *
+     *
+     */
+    writeValueToBuffer(obj, value, buffer) {
+        if (obj.signed) {
+            switch (obj.length) {
+                case 8:
+                    buffer.setInt8(obj.position, value);
+                    break;
+                case 16:
+                    buffer.setInt16(obj.position, value, obj.little);
+                    break;
+                case 32:
+                    buffer.setInt32(obj.position, value, obj.little);
+                    break;
+            }
+        }
+        else {
+            switch (obj.length) {
+                case 8:
+                    buffer.setUint8(obj.position, value);
+                    break;
+                case 16:
+                    buffer.setUint16(obj.position, value, obj.little);
+                    break;
+                case 32:
+                    buffer.setUint32(obj.position, value, obj.little);
+                    break;
+            }
+        }
+    }
+    runProcess(process, rawData, otherData) {
+        const values = this.getChunkValues(process.data, rawData, otherData);
+        //console.log('process values ', values);
+        let pVal = 0;
+        switch (process.type) {
+            case 'ass':
+                pVal = this.assembleProcess(values);
+                process.value = pVal;
+                return;
+            case 'com':
+                pVal = this.compareProcess(values, process);
+                process.value = pVal;
+                return;
+            case 'cal':
+                pVal = this.calculateProcess(values);
+                process.value = pVal;
+                return;
+            case 'tfm':
+                pVal = this.tfmProcess(values);
+                process.value = pVal;
+                return;
+            case 'cdt':
+                pVal = this.cdtProcess(values);
+                process.value = pVal;
+                return;
+            case 'itd':
+                pVal = this.itdProcess(values);
+                process.value = pVal;
+                return;
+            case 'its':
+                pVal = this.itsProcess(values);
+                process.value = pVal;
+                return;
+            case 'bsv':
+                pVal = this.bsvProcess(values);
+                process.value = pVal;
+                return;
+            case 'vfa':
+                pVal = this.vfaProcess(values, process);
+                process.value = pVal;
+                return;
+            case 'cts':
+                pVal = this.ctsProcess(values);
+                process.value = pVal;
+                return;
+        }
+    }
+    assembleProcess(values) {
+        let result = '';
+        values.forEach((v) => {
+            result += v;
+        });
+        return result;
+    }
+    disassembleProcess(string, values) {
+        const result = {};
+        let i = 0;
+        let length = 0;
+        values.forEach((val) => {
+            if (Object.prototype.hasOwnProperty.call(val, 'strLength')) {
+                length = val.strLength;
+            }
+            else {
+                const str = val.value;
+                length = str.length;
+            }
+            if (val.fromData == 'raw') {
+                result[val.value] = Number(string.substring(i, i + length));
+            }
+            i = i + length;
+        });
+        //console.log('Disassemble Result ', JSON.stringify(result));
+        return result;
+    }
+    compareProcess(values, process) {
+        const result = this.compareValues(values[0], values[1], values[2]);
+        let text = 'N/A';
+        if ('comTxt' in process) {
+            if (process.comTxt !== undefined) {
+                if (result) {
+                    text = process.comTxt[0];
+                }
+                else {
+                    return process.comTxt[1];
+                }
+            }
+        }
+        return text;
+    }
+    compareValues(v1, op, v2) {
+        switch (op) {
+            case '<':
+                return v1 < v2;
+            case '<=':
+                return v1 <= v2;
+            case '==':
+                return v1 == v2;
+            case '>=':
+                return v1 >= v2;
+            case '>':
+                return v1 > v2;
+            default:
+                return false;
+        }
+    }
+    calculateProcess(values) {
+        return this.calculateValues(values[0], values[1], values[2]);
+    }
+    calculateValues(v1, op, v2) {
+        switch (op) {
+            case '+':
+                return v1 + v2;
+            case '-':
+                return v1 - v2;
+            case '/':
+                return v1 / v2;
+            case '*':
+                return v1 * v2;
+            default:
+                return 0;
+        }
+    }
+    tfmProcess(values) {
+        const hours = Math.floor((values[0] * 60) / 3600);
+        const mins = Math.floor((values[0] * 60 - hours * 3600) / 60);
+        return this.displayTime(hours, mins);
+    }
+    cdtProcess(values) {
+        const hours = parseInt(values[0].substring(11, 13));
+        const mins = parseInt(values[0].substring(14, 16));
+        return this.displayTime(hours, mins);
+    }
+    //New process to pick value from array based on interger value
+    vfaProcess(values, process) {
+        const value = values[0];
+        if (process.valuesList !== undefined) {
+            if (value < process.valuesList.length) {
+                return process.valuesList[value];
+            }
+            else {
+                return 'nip';
+            }
+        }
+        else {
+            return 'n/a';
+        }
+    }
+    itdProcess(values) {
+        let hours = Math.floor((values[0] * 60) / 3600);
+        //console.log("hours ", hours);
+        const mins = Math.floor((values[0] * 60 - hours * 3600) / 60);
+        //console.log("mins ", mins);
+        let h;
+        let m;
+        if (hours > 23) {
+            hours = hours - 24;
+        }
+        if (hours < 10) {
+            h = '0' + hours;
+        }
+        else {
+            h = hours;
+        }
+        if (mins < 10) {
+            m = '0' + mins;
+        }
+        else {
+            m = mins;
+        }
+        const string = '0000-00-00T' + h + ':' + m;
+        //console.log("$%^&&^%%$$%^&&&^%%%%^^^&&&^^%^%%%^^^& dt string ", string);
+        return string;
+    }
+    dtiProcess(string, values) {
+        //console.log("dtiProcess inputs string: ", string, " Values: ", values);
+        const result = {};
+        let h;
+        let m;
+        values.forEach((val) => {
+            // h = Number(string.substr(11, 2));
+            // m = Number(string.substr(14, 2));
+            h = Number(string.substring(11, 13));
+            m = Number(string.substring(14, 16));
+            result[val.value] = h * 60 + m;
+        });
+        //console.log("date to integer Result ", JSON.stringify(result));
+        return result;
+    }
+    itsProcess(values) {
+        //console.log('itsProcess values', JSON.stringify(values));
+        const str = values[0].toString();
+        return str;
+    }
+    stiProcess(string, values) {
+        const result = {};
+        values.forEach((val) => {
+            result[val.value] = Number(string);
+        });
+        //console.log("string to integer Result ", JSON.stringify(result));
+        return result;
+    }
+    bsvProcess(values) {
+        const startValue = values[0];
+        const pos1 = values[1];
+        const pos2 = pos1 + 1;
+        const binaryStr = parseInt(startValue, 10)
+            .toString(2)
+            .padStart(4, '0');
+        return binaryStr.substring(pos1, pos2);
+    }
+    bsvRevert(string, values, bssObj) {
+        if (Object.prototype.hasOwnProperty.call(bssObj, values[0].value)) {
+            bssObj[values[0].value] = this.replaceCharAt(bssObj[values[0].value], values[1].value, string);
+        }
+        else {
+            bssObj[values[0].value] = '0000';
+            bssObj[values[0].value] = this.replaceCharAt(bssObj[values[0].value], values[1].value, string);
+        }
+        return bssObj;
+    }
+    stcProcess(value) {
+        const initArray = value.split('');
+        const resultArray = [];
+        initArray.forEach((v) => {
+            resultArray.push(v.charCodeAt(0));
+        });
+        return resultArray;
+    }
+    ctsProcess(values) {
+        // let result: string = "";
+        const ary = [];
+        values.forEach((v) => {
+            if (v >= 0) {
+                ary.push(v);
+            }
+            else {
+                ary.push(0);
+            }
+        });
+        //console.log("CTS PROCESS INPUT VALUES ", values);
+        let str = String.fromCharCode(...ary);
+        // eslint-disable-next-line no-control-regex
+        str = str.replace(/[\u0000]/g, '');
+        //str = str.replace(/[^\x20-\x7E]/g, "");
+        return str;
+    }
+    ctsRevert(otherObj, results) {
+        const valAry = this.stcProcess(otherObj.value);
+        //console.log("VAL ARRAY", valAry);
+        //console.log("PROCESS DATA", JSON.stringify(otherObj.processData));
+        let progress = 0;
+        otherObj.processData[0].data.forEach((process) => {
+            const res = {};
+            if (valAry.length >= progress) {
+                res[process.value] = valAry[progress];
+            }
+            else {
+                res[process.value] = 0;
+            }
+            results = Object.assign(results, res);
+            ++progress;
+        });
+        return results;
+    }
+    binaryStrToDecimal(str) {
+        return parseInt(str, 2);
+    }
+    replaceCharAt(string, index, char) {
+        return (string.substring(0, index) + char + string.substring(index + char.length));
+        //return string.substr(0, index) + char + string.substr(index + char.length);
+    }
+    writeFormValuesToRawObj(formValues, rawObj) {
+        // rawObj.forEach((raw) => {
+        //   if (formValues.hasOwnProperty(raw.name)) {
+        //     raw.value = Math.round(formValues[raw.name] / raw.multi);
+        //   }
+        // });
+        for (let i = 0; i < rawObj.length; i++) {
+            if (Object.prototype.hasOwnProperty.call(formValues, rawObj[i].name)) {
+                rawObj[i].value = Math.round(formValues[rawObj[i].name] / rawObj[i].multi);
+            }
+        }
+        return rawObj;
+    }
+    getPwd(rawValues) {
+        const pwdArray = [];
+        let i;
+        let name;
+        for (i = 0; i < 16; i++) {
+            if (i < 10) {
+                name = 'pass_0' + i;
+            }
+            else {
+                name = 'pass_' + i;
+            }
+            rawValues.forEach((v) => {
+                if (v.name == name) {
+                    pwdArray.push(v.value);
+                }
+            });
+        }
+        return pwdArray;
+    }
+    strToPwd(string) {
+        const pwdArray = [];
+        let i;
+        if (string == null) {
+            string = '';
+        }
+        for (i = 0; i < 16; i++) {
+            if (i < string.length) {
+                pwdArray.push(string.charCodeAt(i));
+            }
+            else {
+                pwdArray.push(0);
+            }
+        }
+        return pwdArray;
+    }
+    chkPwd(arr1, arr2) {
+        if (!Array.isArray(arr1) ||
+            !Array.isArray(arr2) ||
+            arr1.length !== arr2.length)
+            return false;
+        for (let i = 0; i < arr1.length; i++) {
+            if (arr1[i] !== arr2[i])
+                return false;
+        }
+        return true;
+    }
+    writePwdToConfig(passArray, rawObj) {
+        let i;
+        let name;
+        //console.log("Before write password ", JSON.stringify(rawObj));
+        for (i = 0; i < 16; i++) {
+            if (i < 10) {
+                name = 'pass_0' + i;
+            }
+            else {
+                name = 'pass_' + i;
+            }
+            rawObj.forEach((v) => {
+                if (v.name == name) {
+                    v.value = passArray[i];
+                }
+            });
+        }
+        //console.log("After write password ", JSON.stringify(rawObj));
+        return rawObj;
+    }
+    displayTime(hours, mins) {
+        //console.log("hours = ", hours, " mins = ", mins);
+        let m = mins;
+        let p = 'am';
+        if (mins < 10) {
+            m = '0' + mins;
+        }
+        if (hours > 11) {
+            p = 'pm';
+        }
+        if (hours == 0) {
+            hours = 12;
+        }
+        if (hours > 12) {
+            hours -= 12;
+        }
+        return hours + ':' + m + ' ' + p;
+    }
+    getChunkValues(processData, rawData, otherData) {
+        // console.log(
+        //   'GET CHUNK VALUES ',
+        //   JSON.stringify(rawData),
+        //   ' ',
+        //   JSON.stringify(otherData)
+        // );
+        let v;
+        const values = [];
+        processData.forEach((chunk) => {
+            //console.log('Process Raw chunk ', JSON.stringify(chunk));
+            switch (chunk.fromData) {
+                case 'raw':
+                    rawData.forEach((rd) => {
+                        if (rd.name == chunk.value) {
+                            //console.log('RAW chunk name: ', rd.name);
+                            v = rd.value;
+                        }
+                    });
+                    break;
+                case 'other':
+                    otherData.forEach((od) => {
+                        if (od.name == chunk.value) {
+                            v = od.value;
+                        }
+                    });
+                    break;
+                case 'no':
+                    v = chunk.value;
+                    break;
+            }
+            if (typeof chunk.strLength === 'undefined') {
+                values.push(v);
+            }
+            else {
+                const pad = v.toString().padStart(chunk.strLength, '0');
+                values.push(pad);
+            }
+        });
+        return values;
+    }
+    uint8ArrayToArray(uint8) {
+        return Array.from(uint8);
+    }
+    arrayToUint8Array(array) {
+        return Uint8Array.from(array);
+    }
+    isUint8Array(v) {
+        const isStr = Object.prototype.toString;
+        return isStr.call(v) === '[object Uint8Array]';
+    }
+    processRaw(input, configObj) {
+        let buffer;
+        if (this.isUint8Array(input)) {
+            buffer = input;
+        }
+        else {
+            buffer = this.arrayToUint8Array(input);
+        }
+        const rawDataBuffer = new DataView(buffer.buffer, 0, 254);
+        //console.log('PROCESS RAW CONFIG ', rawDataBuffer);
+        configObj.rawData.forEach((datapoint) => {
+            datapoint.value =
+                this.getValuefromBuffer(datapoint.buffer, rawDataBuffer) *
+                    datapoint.multi;
+        });
+    }
+    processOther(configObj) {
+        configObj.otherData.forEach((dataPoint) => {
+            dataPoint.processData.forEach((process) => {
+                this.runProcess(process, configObj.rawData, configObj.otherData);
+                dataPoint.value = process.value;
+            });
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DatasetProcessingService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DatasetProcessingService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: DatasetProcessingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dataset-processing.service.js","sourceRoot":"","sources":["../../../../projects/device-config-interaction/src/lib/dataset-processing.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport {\n  IBufferObj,\n  IProcessDataObj,\n  IProcessDataStep,\n  IRawDataObj,\n  IOtherDataObj,\n  IConfig,\n  IDisplay,\n} from '../lib/interfaces/devices-list';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DatasetProcessingService {\n  //constructor() {}\n  /*\n   * For use with DataView\n   *\n   */\n  getValuefromBuffer(obj: IBufferObj, buffer: DataView) {\n    let value = 0;\n    if (obj.signed) {\n      switch (obj.length) {\n        case 8:\n          value = buffer.getInt8(obj.position);\n          break;\n        case 16:\n          value = buffer.getInt16(obj.position, obj.little);\n          break;\n        case 32:\n          value = buffer.getInt32(obj.position, obj.little);\n          break;\n      }\n    } else {\n      switch (obj.length) {\n        case 8:\n          value = buffer.getUint8(obj.position);\n          break;\n        case 16:\n          value = buffer.getUint16(obj.position, obj.little);\n          break;\n        case 32:\n          value = buffer.getUint32(obj.position, obj.little);\n          break;\n      }\n    }\n    return value;\n  }\n\n  /*\n   * For use with DataView\n   *\n   *\n   */\n  writeValueToBuffer(obj: IBufferObj, value: number, buffer: DataView) {\n    if (obj.signed) {\n      switch (obj.length) {\n        case 8:\n          buffer.setInt8(obj.position, value);\n          break;\n        case 16:\n          buffer.setInt16(obj.position, value, obj.little);\n          break;\n        case 32:\n          buffer.setInt32(obj.position, value, obj.little);\n          break;\n      }\n    } else {\n      switch (obj.length) {\n        case 8:\n          buffer.setUint8(obj.position, value);\n          break;\n        case 16:\n          buffer.setUint16(obj.position, value, obj.little);\n          break;\n        case 32:\n          buffer.setUint32(obj.position, value, obj.little);\n          break;\n      }\n    }\n  }\n\n  runProcess(\n    process: IProcessDataObj,\n    rawData: IRawDataObj[],\n    otherData: IOtherDataObj[]\n  ) {\n    const values: (string | number)[] = this.getChunkValues(\n      process.data,\n      rawData,\n      otherData\n    );\n    //console.log('process values ', values);\n    let pVal: string | number | boolean = 0;\n    switch (process.type) {\n      case 'ass':\n        pVal = this.assembleProcess(values);\n        process.value = pVal;\n        return;\n      case 'com':\n        pVal = this.compareProcess(\n          values as [number, '<' | '<=' | '==' | '>=' | '>', number],\n          process\n        );\n        process.value = pVal;\n        return;\n      case 'cal':\n        pVal = this.calculateProcess(\n          values as [number, '+' | '-' | '/' | '*', number]\n        );\n        process.value = pVal;\n        return;\n      case 'tfm':\n        pVal = this.tfmProcess(values as number[]);\n        process.value = pVal;\n        return;\n      case 'cdt':\n        pVal = this.cdtProcess(values as string[]);\n        process.value = pVal;\n        return;\n      case 'itd':\n        pVal = this.itdProcess(values as number[]);\n        process.value = pVal;\n        return;\n      case 'its':\n        pVal = this.itsProcess(values as number[]);\n        process.value = pVal;\n        return;\n      case 'bsv':\n        pVal = this.bsvProcess(values);\n        process.value = pVal;\n        return;\n      case 'vfa':\n        pVal = this.vfaProcess(values as number[], process);\n        process.value = pVal;\n        return;\n      case 'cts':\n        pVal = this.ctsProcess(values as number[]);\n        process.value = pVal;\n        return;\n    }\n  }\n\n  assembleProcess(values: (string | number)[]) {\n    let result = '';\n    values.forEach((v) => {\n      result += v;\n    });\n    return result;\n  }\n\n  disassembleProcess(string: string, values: IProcessDataStep[]) {\n    const result: { [key: string]: number } = {};\n    let i = 0;\n    let length = 0;\n    values.forEach((val) => {\n      if (Object.prototype.hasOwnProperty.call(val, 'strLength')) {\n        length = val.strLength as number;\n      } else {\n        const str = val.value as string;\n        length = str.length;\n      }\n      if (val.fromData == 'raw') {\n        result[val.value] = Number(string.substring(i, i + length));\n      }\n      i = i + length;\n    });\n    //console.log('Disassemble Result ', JSON.stringify(result));\n    return result;\n  }\n\n  compareProcess(\n    values: [number, '<' | '<=' | '==' | '>=' | '>', number],\n    process: IProcessDataObj\n  ) {\n    const result: boolean = this.compareValues(values[0], values[1], values[2]);\n    let text = 'N/A';\n    if ('comTxt' in process) {\n      if (process.comTxt !== undefined) {\n        if (result) {\n          text = process.comTxt[0];\n        } else {\n          return process.comTxt[1];\n        }\n      }\n    }\n    return text;\n  }\n\n  compareValues(v1: number, op: '<' | '<=' | '==' | '>=' | '>', v2: number) {\n    switch (op) {\n      case '<':\n        return v1 < v2;\n      case '<=':\n        return v1 <= v2;\n      case '==':\n        return v1 == v2;\n      case '>=':\n        return v1 >= v2;\n      case '>':\n        return v1 > v2;\n      default:\n        return false;\n    }\n  }\n\n  calculateProcess(values: [number, '+' | '-' | '/' | '*', number]) {\n    return this.calculateValues(values[0], values[1], values[2]);\n  }\n\n  calculateValues(v1: number, op: '+' | '-' | '/' | '*', v2: number) {\n    switch (op) {\n      case '+':\n        return v1 + v2;\n      case '-':\n        return v1 - v2;\n      case '/':\n        return v1 / v2;\n      case '*':\n        return v1 * v2;\n      default:\n        return 0;\n    }\n  }\n\n  tfmProcess(values: number[]) {\n    const hours: number = Math.floor((values[0] * 60) / 3600);\n    const mins: number = Math.floor((values[0] * 60 - hours * 3600) / 60);\n    return this.displayTime(hours, mins);\n  }\n\n  cdtProcess(values: string[]) {\n    const hours: number = parseInt(values[0].substring(11, 13));\n    const mins: number = parseInt(values[0].substring(14, 16));\n    return this.displayTime(hours, mins);\n  }\n\n  //New process to pick value from array based on interger value\n  vfaProcess(values: number[], process: IProcessDataObj) {\n    const value = values[0];\n    if (process.valuesList !== undefined) {\n      if (value < process.valuesList.length) {\n        return process.valuesList[value];\n      } else {\n        return 'nip';\n      }\n    } else {\n      return 'n/a';\n    }\n  }\n\n  itdProcess(values: number[]) {\n    let hours: number = Math.floor((values[0] * 60) / 3600);\n    //console.log(\"hours \", hours);\n    const mins: number = Math.floor((values[0] * 60 - hours * 3600) / 60);\n    //console.log(\"mins \", mins);\n    let h: number | string;\n    let m: number | string;\n    if (hours > 23) {\n      hours = hours - 24;\n    }\n    if (hours < 10) {\n      h = '0' + hours;\n    } else {\n      h = hours;\n    }\n    if (mins < 10) {\n      m = '0' + mins;\n    } else {\n      m = mins;\n    }\n    const string: string = '0000-00-00T' + h + ':' + m;\n    //console.log(\"$%^&&^%%$$%^&&&^%%%%^^^&&&^^%^%%%^^^& dt string \", string);\n    return string;\n  }\n\n  dtiProcess(string: string, values: IProcessDataStep[]) {\n    //console.log(\"dtiProcess inputs string: \", string, \" Values: \", values);\n    const result: { [key: string | number]: number } = {};\n    let h: number;\n    let m: number;\n    values.forEach((val) => {\n      // h = Number(string.substr(11, 2));\n      // m = Number(string.substr(14, 2));\n      h = Number(string.substring(11, 13));\n      m = Number(string.substring(14, 16));\n      result[val.value] = h * 60 + m;\n    });\n    //console.log(\"date to integer Result \", JSON.stringify(result));\n    return result;\n  }\n\n  itsProcess(values: number[]) {\n    //console.log('itsProcess values', JSON.stringify(values));\n    const str: string = values[0].toString();\n    return str;\n  }\n\n  stiProcess(string: string, values: IProcessDataStep[]) {\n    const result: { [key: string | number]: number } = {};\n    values.forEach((val) => {\n      result[val.value] = Number(string);\n    });\n    //console.log(\"string to integer Result \", JSON.stringify(result));\n    return result;\n  }\n\n  bsvProcess(values: (number | string)[]) {\n    const startValue: string = values[0] as string;\n    const pos1: number = values[1] as number;\n    const pos2: number = pos1 + 1;\n    const binaryStr: string = parseInt(startValue, 10)\n      .toString(2)\n      .padStart(4, '0');\n    return binaryStr.substring(pos1, pos2);\n  }\n\n  bsvRevert(\n    string: string,\n    values: IProcessDataStep[],\n    bssObj: { [key: string]: string | number }\n  ) {\n    if (Object.prototype.hasOwnProperty.call(bssObj, values[0].value)) {\n      bssObj[values[0].value] = this.replaceCharAt(\n        bssObj[values[0].value] as string,\n        values[1].value as number,\n        string\n      );\n    } else {\n      bssObj[values[0].value] = '0000';\n      bssObj[values[0].value] = this.replaceCharAt(\n        bssObj[values[0].value] as string,\n        values[1].value as number,\n        string\n      );\n    }\n    return bssObj;\n  }\n\n  stcProcess(value: string) {\n    const initArray = value.split('');\n    const resultArray: number[] = [];\n    initArray.forEach((v) => {\n      resultArray.push(v.charCodeAt(0));\n    });\n    return resultArray;\n  }\n\n  ctsProcess(values: number[]) {\n    // let result: string = \"\";\n    const ary: number[] = [];\n    values.forEach((v) => {\n      if (v >= 0) {\n        ary.push(v);\n      } else {\n        ary.push(0);\n      }\n    });\n    //console.log(\"CTS PROCESS INPUT VALUES \", values);\n    let str = String.fromCharCode(...ary);\n    // eslint-disable-next-line no-control-regex\n    str = str.replace(/[\\u0000]/g, '');\n    //str = str.replace(/[^\\x20-\\x7E]/g, \"\");\n    return str;\n  }\n\n  ctsRevert(\n    otherObj: IOtherDataObj,\n    results: { [key: string | number]: string | number }\n  ) {\n    const valAry = this.stcProcess(<string>otherObj.value);\n    //console.log(\"VAL ARRAY\", valAry);\n    //console.log(\"PROCESS DATA\", JSON.stringify(otherObj.processData));\n    let progress = 0;\n    otherObj.processData[0].data.forEach((process) => {\n      const res: { [key: string | number]: string | number } = {};\n\n      if (valAry.length >= progress) {\n        res[process.value] = valAry[progress];\n      } else {\n        res[process.value] = 0;\n      }\n      results = Object.assign(results, res);\n      ++progress;\n    });\n    return results;\n  }\n\n  binaryStrToDecimal(str: string) {\n    return parseInt(str, 2);\n  }\n\n  replaceCharAt(string: string, index: number, char: string) {\n    return (\n      string.substring(0, index) + char + string.substring(index + char.length)\n    );\n    //return string.substr(0, index) + char + string.substr(index + char.length);\n  }\n\n  writeFormValuesToRawObj(\n    formValues: { [key: string]: string | number },\n    rawObj: IRawDataObj[]\n  ) {\n    // rawObj.forEach((raw) => {\n    //   if (formValues.hasOwnProperty(raw.name)) {\n    //     raw.value = Math.round(formValues[raw.name] / raw.multi);\n    //   }\n    // });\n    for (let i = 0; i < rawObj.length; i++) {\n      if (Object.prototype.hasOwnProperty.call(formValues, rawObj[i].name)) {\n        rawObj[i].value = Math.round(\n          (formValues[rawObj[i].name] as number) / rawObj[i].multi\n        );\n      }\n    }\n    return rawObj;\n  }\n\n  getPwd(rawValues: IRawDataObj[]) {\n    const pwdArray: number[] = [];\n    let i: number;\n    let name: string;\n\n    for (i = 0; i < 16; i++) {\n      if (i < 10) {\n        name = 'pass_0' + i;\n      } else {\n        name = 'pass_' + i;\n      }\n      rawValues.forEach((v) => {\n        if (v.name == name) {\n          pwdArray.push(v.value);\n        }\n      });\n    }\n\n    return pwdArray;\n  }\n\n  strToPwd(string: string) {\n    const pwdArray: number[] = [];\n    let i: number;\n\n    if (string == null) {\n      string = '';\n    }\n\n    for (i = 0; i < 16; i++) {\n      if (i < string.length) {\n        pwdArray.push(string.charCodeAt(i));\n      } else {\n        pwdArray.push(0);\n      }\n    }\n\n    return pwdArray;\n  }\n\n  chkPwd(arr1: number[], arr2: number[]) {\n    if (\n      !Array.isArray(arr1) ||\n      !Array.isArray(arr2) ||\n      arr1.length !== arr2.length\n    )\n      return false;\n\n    for (let i = 0; i < arr1.length; i++) {\n      if (arr1[i] !== arr2[i]) return false;\n    }\n\n    return true;\n  }\n\n  writePwdToConfig(passArray: number[], rawObj: IRawDataObj[]) {\n    let i: number;\n    let name: string;\n\n    //console.log(\"Before write password \", JSON.stringify(rawObj));\n\n    for (i = 0; i < 16; i++) {\n      if (i < 10) {\n        name = 'pass_0' + i;\n      } else {\n        name = 'pass_' + i;\n      }\n      rawObj.forEach((v) => {\n        if (v.name == name) {\n          v.value = passArray[i];\n        }\n      });\n    }\n\n    //console.log(\"After write password \", JSON.stringify(rawObj));\n\n    return rawObj;\n  }\n\n  displayTime(hours: number, mins: number) {\n    //console.log(\"hours = \", hours, \" mins = \", mins);\n    let m: number | string = mins;\n    let p = 'am';\n    if (mins < 10) {\n      m = '0' + mins;\n    }\n    if (hours > 11) {\n      p = 'pm';\n    }\n    if (hours == 0) {\n      hours = 12;\n    }\n    if (hours > 12) {\n      hours -= 12;\n    }\n    return hours + ':' + m + ' ' + p;\n  }\n\n  getChunkValues(\n    processData: IProcessDataStep[],\n    rawData: IRawDataObj[],\n    otherData: IOtherDataObj[]\n  ) {\n    // console.log(\n    //   'GET CHUNK VALUES ',\n    //   JSON.stringify(rawData),\n    //   ' ',\n    //   JSON.stringify(otherData)\n    // );\n    let v: string | number;\n    const values: (string | number)[] = [];\n    processData.forEach((chunk) => {\n      //console.log('Process Raw chunk ', JSON.stringify(chunk));\n      switch (chunk.fromData) {\n        case 'raw':\n          rawData.forEach((rd) => {\n            if (rd.name == chunk.value) {\n              //console.log('RAW chunk name: ', rd.name);\n              v = rd.value;\n            }\n          });\n          break;\n        case 'other':\n          otherData.forEach((od) => {\n            if (od.name == chunk.value) {\n              v = od.value;\n            }\n          });\n          break;\n        case 'no':\n          v = chunk.value;\n          break;\n      }\n\n      if (typeof chunk.strLength === 'undefined') {\n        values.push(v);\n      } else {\n        const pad = v.toString().padStart(chunk.strLength, '0');\n        values.push(pad);\n      }\n    });\n    return values;\n  }\n\n  uint8ArrayToArray(uint8: Uint8Array): number[] {\n    return Array.from(uint8);\n  }\n\n  arrayToUint8Array(array: number[]): Uint8Array {\n    return Uint8Array.from(array);\n  }\n\n  isUint8Array(v: number[] | Uint8Array) {\n    const isStr = Object.prototype.toString;\n    return isStr.call(v) === '[object Uint8Array]';\n  }\n\n  processRaw(input: number[] | Uint8Array, configObj: IConfig | IDisplay) {\n    let buffer: Uint8Array;\n    if (this.isUint8Array(input)) {\n      buffer = input as Uint8Array;\n    } else {\n      buffer = this.arrayToUint8Array(input as number[]);\n    }\n    const rawDataBuffer = new DataView(buffer.buffer, 0, 254);\n    //console.log('PROCESS RAW CONFIG ', rawDataBuffer);\n    configObj.rawData.forEach((datapoint) => {\n      datapoint.value =\n        this.getValuefromBuffer(datapoint.buffer, rawDataBuffer) *\n        datapoint.multi;\n    });\n  }\n\n  processOther(configObj: IConfig | IDisplay) {\n    configObj.otherData.forEach((dataPoint) => {\n      dataPoint.processData.forEach((process) => {\n        this.runProcess(process, configObj.rawData, configObj.otherData);\n        dataPoint.value = process.value;\n      });\n    });\n  }\n}\n"]}