319 lines
10 KiB
TypeScript
319 lines
10 KiB
TypeScript
import { Body, Injectable } from '@nestjs/common';
|
|
import axios, { Axios, AxiosResponse } from 'axios';
|
|
import { readFile, writeFile } from 'node:fs/promises';
|
|
import { response } from 'express';
|
|
import { json } from 'node:stream/consumers';
|
|
import math, { create, all, evaluate, number, random, complex, string, SQRT1_2 } from 'mathjs';
|
|
import { ClickhouseService } from 'src/database/clickhouse/clickhouse.service';
|
|
import { classToPlain } from 'class-transformer';
|
|
|
|
|
|
|
|
@Injectable()
|
|
export class MetricK2 {
|
|
id: string;
|
|
name: string;
|
|
type: string;
|
|
addr: string;
|
|
value: number;
|
|
description: string;
|
|
status: number;
|
|
device: number;
|
|
source: string;
|
|
};
|
|
|
|
@Injectable()
|
|
export class K2Metrics {
|
|
service_name: string;
|
|
// device: number;
|
|
// source: string;
|
|
//endpoint_name: string;
|
|
metrics: MetricK2[];
|
|
};
|
|
|
|
@Injectable()
|
|
export class RangeValues {
|
|
min: number;
|
|
max: number;
|
|
status: number;
|
|
};
|
|
|
|
@Injectable()
|
|
export class MetricsRanges {
|
|
name: string;
|
|
ranges: RangeValues[];
|
|
};
|
|
|
|
@Injectable()
|
|
export class ComplexMetricsCalculation {
|
|
id: string;
|
|
name: string;
|
|
values: string;
|
|
formula: string;
|
|
};
|
|
|
|
var prev: K2Metrics; //Prevous K2
|
|
|
|
|
|
@Injectable()
|
|
export class ZvksmetricsService {
|
|
async useStatusModel(inputData: any): Promise<any> {
|
|
let inp: K2Metrics = new K2Metrics();
|
|
inp = inputData;
|
|
|
|
let complex: K2Metrics = new K2Metrics();
|
|
complex.service_name = inputData.service_name;
|
|
complex.metrics = [];
|
|
|
|
let model: ComplexMetricsCalculation[] = [];
|
|
model = await this.setComplexMetrics();
|
|
|
|
let scope: MetricsRanges[] = [];
|
|
scope = await this.setMetricsRanges();
|
|
|
|
if (!prev) {
|
|
prev = inp;
|
|
}
|
|
// console.log(prev);
|
|
|
|
let intermediate = await this.getComplexMetricsValues(inp, prev, complex, model, scope);
|
|
|
|
console.log(intermediate);
|
|
let ctp: any = classToPlain(intermediate);
|
|
let copmplexParameterBody: string = JSON.stringify(ctp);
|
|
let rtp: any = classToPlain(inputData);
|
|
let rawParameterBody: string = JSON.stringify(rtp);
|
|
// console.log(parameterBody);
|
|
let abc = new ClickhouseService();
|
|
await abc.ClickHouseAddRecords('raw', rawParameterBody);
|
|
await abc.ClickHouseAddRecords('complex', copmplexParameterBody);
|
|
|
|
|
|
// const val = JSON.parse(JSON.stringify(model[0].values));
|
|
|
|
// let editedMetrics : K2Metrics = await this.getMetrics (inp, comlexCalc, scope);
|
|
let responseFromExporter: any = await this.sendMetrics(intermediate);
|
|
let responseFromExporter1: any = await this.sendMetrics(inp);
|
|
|
|
prev = inp;
|
|
|
|
return responseFromExporter;
|
|
|
|
}
|
|
|
|
async getMetrics(inputData: K2Metrics, scope: MetricsRanges[]): Promise<K2Metrics> {
|
|
let arr: MetricK2[] = inputData.metrics;
|
|
let length: number = arr.length;
|
|
|
|
for (let i = 0; i < length; i++) {
|
|
arr[i].status = await this.setMetricsStatus(arr[i], scope);
|
|
}
|
|
inputData.metrics = arr;
|
|
|
|
return inputData;
|
|
}
|
|
|
|
// async getComplexMetrics(complexData: K2Metrics, scope: MetricsRanges[]): Promise<K2Metrics> {
|
|
// let arr: MetricK2[] = complexData.metrics;
|
|
// let length: number = arr.length;
|
|
|
|
// for (let i = 0; i < length; i++) {
|
|
// arr[i].status = await this.setMetricsStatus(arr[i], scope);
|
|
// }
|
|
// complexData.metrics = arr;
|
|
|
|
// return complexData;
|
|
// }
|
|
|
|
async getComplexMetricsValues(inputData: K2Metrics, prevousData: K2Metrics, complexData: K2Metrics, complexCalc: ComplexMetricsCalculation[], scope: MetricsRanges[]): Promise<K2Metrics> {
|
|
let length: number = complexCalc.length;
|
|
let metrics: MetricK2[] = complexData.metrics;
|
|
|
|
let devices: number[] = [18, 19];
|
|
let device_len: number = devices.length;
|
|
|
|
// const jsonData = require('../conf/devices.json');
|
|
// console.log(jsonData);
|
|
for (let d = 0; d < device_len; d++) {
|
|
for (let i = 0; i < length; i++) {
|
|
let metr = { "source": "" };
|
|
let val = await this.setComplexMetricValue(complexCalc[i].values, complexCalc[i].formula, inputData.metrics, prevousData.metrics, devices[d], metr);
|
|
if (val != null || val != undefined) {
|
|
let complexMetric = new MetricK2();
|
|
complexMetric.id = complexCalc[i].id;
|
|
complexMetric.name = complexCalc[i].name;
|
|
complexMetric.type = inputData.metrics[0].type;
|
|
complexMetric.addr = inputData.metrics[0].addr;
|
|
complexMetric.value = val;
|
|
complexMetric.description = complexCalc[i].name;
|
|
complexMetric.status = await this.showStatus(scope, complexMetric.name, val);
|
|
complexMetric.device = devices[d];
|
|
complexMetric.source = metr.source;
|
|
metrics.push(complexMetric);
|
|
}
|
|
}
|
|
}
|
|
|
|
// console.log(complexData.metrics);
|
|
|
|
return complexData;
|
|
}
|
|
|
|
async setComplexMetricValue(value: string, formula: string, currMetrics: MetricK2[], prevMetrics: MetricK2[], device: number, obj: any): Promise<any> {
|
|
const val = JSON.parse(JSON.stringify(value));
|
|
let arr = val.arr;
|
|
// let dev = currMetrics.find(element => element.id == "measure_1217")?.id;
|
|
// console.log(dev);
|
|
let arr_len: number = arr.length;
|
|
obj.source = currMetrics.find(element => element.name == arr[0] && element.device == device)?.source;
|
|
// console.log(obj.source);
|
|
|
|
for (let i = 0; i < arr_len; i++) {
|
|
let temp = arr[i];
|
|
arr[i] = currMetrics.find(element => element.name == arr[i] && element.device == device)?.value;
|
|
|
|
// if(!arr[i]){
|
|
// console.log(arr[i], temp, device);
|
|
// arr[i]=0;
|
|
// }
|
|
}
|
|
let prevarr = val.prevarr;
|
|
if (prevarr) {
|
|
let prevarr_len: number = prevarr.length;
|
|
for (let i = 0; i < prevarr_len; i++) {
|
|
let temp1 = prevarr[i];
|
|
prevarr[i] = prevMetrics.find(element => element.name == prevarr[i] && element.device == device)?.value;
|
|
// console.log(prevarr[i], temp1, device);
|
|
}
|
|
}
|
|
|
|
// console.log(obj.soure);
|
|
try {
|
|
let result: number = evaluate(formula, val);
|
|
// console.log(result);
|
|
return result;
|
|
// console.log(result);
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async setMetricsStatus(metric: MetricK2, scope: MetricsRanges[]): Promise<number> {
|
|
if (metric && scope) {
|
|
return await this.showStatus(scope, metric.name, metric.value);
|
|
}
|
|
else {
|
|
return 5;
|
|
}
|
|
}
|
|
|
|
async sendMetrics(inputData: K2Metrics): Promise<string> {
|
|
let resp: any;
|
|
let path: string = 'http://192.168.2.34:9050/update';
|
|
let body: any = JSON.stringify(inputData);
|
|
let options: any = {
|
|
headers: { 'Content-Type': 'application/json' }
|
|
};
|
|
|
|
await axios.post(path, body, options).then((response) => {
|
|
resp = response.status + ' ' + response.data;
|
|
// console.log(resp);
|
|
}).catch((error) => {
|
|
resp = error;
|
|
});
|
|
|
|
return resp;
|
|
}
|
|
|
|
async showStatus(scope: MetricsRanges[], metricName: string, metricValue: number): Promise<number> {
|
|
let status: number = 0;
|
|
let test: any = scope.find(element => element.name == metricName);
|
|
if (test) {
|
|
let range: MetricsRanges = test;
|
|
let transit: any = range.ranges.find(element => element.min <= metricValue && metricValue <= element.max)?.status;
|
|
if (transit) {
|
|
status = transit;
|
|
return status;
|
|
}
|
|
else {
|
|
return 0;
|
|
}
|
|
}
|
|
return status;
|
|
}
|
|
|
|
async setMetricsRanges(@Body() rangesData: any = null): Promise<MetricsRanges[]> {
|
|
let url: string = 'http://192.168.2.39:9999/api/ranges/9999';
|
|
let options: any = {
|
|
headers: { 'Content-Type': 'application/json' }
|
|
};
|
|
|
|
await axios.options(url, options).then((response) => {
|
|
rangesData = response.data;
|
|
}).catch((error) => {
|
|
rangesData = error;
|
|
});
|
|
// console.log(rangesData);
|
|
return rangesData;
|
|
}
|
|
|
|
async saveRanges(inputRanges: string): Promise<any> {
|
|
let ret: any;
|
|
let filePath = './src/zvksmetrics/conf/ranges.json';
|
|
console.log(inputRanges);
|
|
let inp: string = JSON.stringify(inputRanges);
|
|
try {
|
|
await writeFile(filePath, inp);
|
|
ret = "200 OK";
|
|
}
|
|
catch {
|
|
ret = "Error write file";
|
|
console.log(ret);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
async setComplexMetrics(@Body() complexData: any = null): Promise<ComplexMetricsCalculation[]> {
|
|
let url: string = 'http://192.168.2.39:9999/api/complex/5555';
|
|
let options: any = {
|
|
headers: { 'Content-Type': 'application/json' }
|
|
};
|
|
|
|
await axios.options(url, options).then((response) => {
|
|
complexData = response.data;
|
|
}).catch((error) => {
|
|
complexData = error;
|
|
});
|
|
// console.log(rangesData);
|
|
return complexData;
|
|
}
|
|
|
|
async showRangesOptions(filePath: string): Promise<JSON> {
|
|
let content: JSON = JSON.parse('{"name":"name"}');
|
|
filePath = './src/zvksmetrics/conf/ranges.json';
|
|
try {
|
|
content = JSON.parse(await readFile(filePath, { encoding: 'utf8' }));
|
|
}
|
|
catch {
|
|
console.log('Error read file');
|
|
}
|
|
|
|
return content;
|
|
}
|
|
|
|
async showComplexMetricsConfig(filePath: string): Promise<JSON> {
|
|
let content: JSON = JSON.parse('{"name":"name"}');
|
|
filePath = './src/zvksmetrics/conf/complex.json';
|
|
try {
|
|
content = JSON.parse(await readFile(filePath, { encoding: 'utf8' }));
|
|
}
|
|
catch {
|
|
console.log('Error read file');
|
|
}
|
|
|
|
return content;
|
|
}
|
|
|
|
|
|
};
|