src/menu/menu.interface.ts

@@ -6,9 +6,4 @@ export interface MenuItem {
     filters?: Record<string, string>;
     isDynamic?: boolean;
     templateId?: string;
-  ranges?: Array<{
-    min: number;
-    max: number;
-    status: number;
-  }>;
   }

src/menu/menu.module.ts

@@ -1,13 +1,11 @@
 import { Module } from '@nestjs/common';
 import { MenuController } from './menu.controller';
-import { HttpModule } from '@nestjs/axios';
 import { MenuService } from './menu.service';
-import { PrometheusModule } from '../prometheus.module';
+import { PrometheusModule } from '../prometheus.module'; // Импортируем PrometheusModule
-import { RangeService } from './range.service';
 
 @Module({
-  imports: [PrometheusModule, HttpModule],
+  imports: [PrometheusModule], // Добавляем в imports
   controllers: [MenuController],
-  providers: [MenuService, RangeService]
+  providers: [MenuService]
 })
 export class MenuModule {}

src/menu/menu.service.ts

@@ -3,14 +3,10 @@ import { PrometheusService } from '../prometheus.service';
 import { MenuItem } from './menu.interface';
 import * as fs from 'fs/promises';
 import * as path from 'path';
-import { RangeService } from './range.service';
 
 @Injectable()
 export class MenuService {
-  constructor(
+  constructor(private readonly prometheusService: PrometheusService) { }
-    private readonly prometheusService: PrometheusService,
-    private readonly rangeService: RangeService
-  ) { }
 
   private readonly menuOverridesPath = path.join(process.cwd(), 'data', 'menu.json');
 
@@ -21,8 +17,8 @@ export class MenuService {
   }
 
   async getFullMenu(): Promise<MenuItem> {
-    const dynamicItemsPromise = this.generateDynamicItems();
+    const dynamicItems = await this.generateDynamicItems();
-    const baseMenu = await this.injectDynamicItems(this.getStaticStructure(), dynamicItemsPromise);
+    const baseMenu = this.injectDynamicItems(this.getStaticStructure(), dynamicItems);
     const overrides = await this.loadOverrides();
     return this.applyOverrides(baseMenu, overrides);
   }
@@ -50,7 +46,7 @@ export class MenuService {
       const parsed = JSON.parse(content);
       return parsed.overrides || [];
     } catch (e) {
-      return [];
+      return []; // если файл не существует
     }
   }
 
@@ -77,6 +73,7 @@ export class MenuService {
   private async generateDynamicItems(): Promise<MenuItem[]> {
     const metricNames = await this.prometheusService.fetchAllMetrics();
 
+    // Получаем все серии для каждой метрики
     const allSeries = (
       await Promise.all(
         metricNames.map(async name => {
@@ -89,7 +86,9 @@ export class MenuService {
       )
     ).flat();
 
-    const metadataMap = new Map<string, string>();
+    // Загружаем мета-информацию по каждой метрике
+    const metadataMap = new Map<string, string>(); // metric -> help
+
     await Promise.all(
       metricNames.map(async metric => {
         try {
@@ -127,30 +126,18 @@ export class MenuService {
     const filteredSeries = allSeries.filter(({ labels }) => {
       const device = labels.device;
       const instance = labels.instance;
+
       return (!device || !isGarbageDevice(device)) &&
         (!instance || !isGarbageInstance(instance));
     });
-
     const devices = this.extractUniqueEntities(filteredSeries, 'device');
-    const deviceItems = await Promise.all(
-      devices.map(device => this.createDeviceItem(device, allSeries, metadataMap))
-    );
 
-    return deviceItems;
+    return devices.map(device => ({
-  }
-
-  private async createDeviceItem(
-    device: string,
-    seriesData: { metric: string; labels: Record<string, string> }[],
-    metadataMap: Map<string, string>
-  ): Promise<MenuItem> {
-    const moduleItems = await this.generateModuleItems(device, seriesData, metadataMap);
-    return {
       id: `device_${device}`,
       title: `Graviton S2082I (${device})`,
-      items: moduleItems,
+      items: this.generateModuleItems(device, allSeries, metadataMap),
       isDynamic: true
-    };
+    }));
   }
 
   private extractUniqueEntities(metrics: any[], field: string): string[] {
@@ -165,16 +152,16 @@ export class MenuService {
   
   private normalizeIdPart(part: string): string {
     return part
-      .replace(/\$/g, '_')
+      .replace(/\$/g, '_')  // Заменяем $ на _
-      .replace(/[^a-zA-Z0-9-_]/g, '');
+      .replace(/[^a-zA-Z0-9-_]/g, '');  // Удаляем другие спецсимволы
   }
 
-  private async generateModuleItems(
+  private generateModuleItems(
     device: string,
     seriesData: { metric: string; labels: Record<string, string> }[],
     metadataMap: Map<string, string>
-  ): Promise<MenuItem[]> {
+  ): MenuItem[] {
-    const modules = new Map<string, string>();
+    const modules = new Map<string, string>(); // source_id -> display name
 
     seriesData.forEach(({ labels }) => {
       if (labels.device === device && labels.source_id) {
@@ -191,48 +178,55 @@ export class MenuService {
       }
     });
 
-    const modulePromises = Array.from(modules.entries()).map(
+    return Array.from(modules.entries()).map(([sourceId, displayName]) => ({
-      async ([sourceId, displayName]) => ({
       id: `module_${device}_${sourceId}`,
       title: displayName,
-        items: await this.generateMetricItems(device, sourceId, seriesData, metadataMap),
+      items: this.generateMetricItems(device, sourceId, seriesData, metadataMap),
       isDynamic: true
-      })
+    }));
-    );
-
-    return Promise.all(modulePromises);
   }
 
-  private async generateMetricItems(
+  private generateMetricItems(
     device: string,
     module: string,
     seriesData: { metric: string; labels: Record<string, string> }[],
     metadataMap: Map<string, string>
-  ): Promise<MenuItem[]> {
+  ): MenuItem[] {
-    const ranges = await this.rangeService.getRanges();
+    // Фильтруем метрики для текущего устройства и модуля
     const filtered = seriesData.filter(
       ({ labels }) => labels.device === device && labels.source_id === module
     );
   
+    // Получаем уникальные имена метрик
     const uniqueMetrics = new Set(filtered.map(entry => entry.metric));
-    const safeDevice = this.normalizeIdPart(device);
-    const safeModule = this.normalizeIdPart(module);
   
+    // Нормализуем идентификаторы
+    const normalizeIdPart = (part: string): string => {
+      return part
+        .replace(/\$/g, '_')       // Заменяем $ на _
+        .replace(/[^a-zA-Z0-9-_]/g, '')  // Удаляем другие спецсимволы
+        .replace(/_+/g, '_')       // Заменяем множественные _ на один
+        .replace(/^_|_$/g, '');    // Удаляем _ в начале и конце
+    };
+  
+    const safeDevice = normalizeIdPart(device);
+    const safeModule = normalizeIdPart(module);
+  
+    // Формируем пункты меню
     return Array.from(uniqueMetrics).map(metric => {
       const description = metadataMap.get(metric) || metric;
-      const safeMetric = this.normalizeIdPart(metric);
+      const safeMetric = normalizeIdPart(metric);
-      const metricRanges = ranges[description] || [];
   
       return {
-        id: `metric_${safeDevice}_${safeModule}_${safeMetric}`,
+        id: `metric_${safeDevice}_${safeModule}_${safeMetric}`, // Безопасный ID
         title: description,
         metric,
         filters: {
-          device,
+          device,          // Оригинальное значение device
-          source_id: module
+          source_id: module // Оригинальное значение source_id
         },
-        ranges: metricRanges,
         isDynamic: true,
+        // Сохраняем оригинальные значения для отладки
         meta: {
           originalDevice: device,
           originalModule: module
@@ -241,24 +235,15 @@ export class MenuService {
     });
   }
 
-  private async injectDynamicItems(
+  private injectDynamicItems(menu: MenuItem, dynamicItems: MenuItem[]): MenuItem {
-    menu: MenuItem,
-    dynamicItemsPromise: Promise<MenuItem[]>
-  ): Promise<MenuItem> {
-    const dynamicItems = await dynamicItemsPromise;
-
     if (menu.id === 'media_servers') {
       return { ...menu, items: dynamicItems };
     }
 
-    if (menu.items) {
+    return {
-      const updatedItems = await Promise.all(
+      ...menu,
-        menu.items.map(item => this.injectDynamicItems(item, dynamicItemsPromise))
+      items: menu.items?.map(item => this.injectDynamicItems(item, dynamicItems)) || []
-      );
+    };
-      return { ...menu, items: updatedItems };
-    }
-
-    return menu;
   }
 
   async updateMenuItem(id: string, update: Partial<MenuItem>): Promise<MenuItem> {

src/menu/range.service.ts

@@ -1,54 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { HttpService } from '@nestjs/axios';
-import { firstValueFrom } from 'rxjs';
-
-@Injectable()
-export class RangeService {
-    constructor(private readonly httpService: HttpService) { }
-
-    async getRanges(): Promise<Record<string, Array<{ min: number; max: number; status: number }>>> {
-        try {
-            const response = await firstValueFrom(
-                this.httpService.request({
-                    method: 'OPTIONS',
-                    url: 'http://192.168.2.39:9999/api/ranges/9999',
-                    headers: {
-                        'Accept': 'application/json'
-                    }
-                })
-            );
-
-            // Проверяем, что ответ содержит данные в ожидаемом формате
-            if (!response.data || !Array.isArray(response.data)) {
-                console.error('Invalid response format from ranges API', response.data);
-                return {};
-            }
-
-            const rangesMap: Record<string, Array<{ min: number; max: number; status: number }>> = {};
-
-            response.data.forEach(item => {
-                if (item.name && Array.isArray(item.ranges)) {
-                    rangesMap[item.name] = item.ranges;
-                }
-            });
-
-            return rangesMap;
-        } catch (error) {
-            console.error('Failed to fetch ranges:', error);
-
-            // Детальное логирование ошибки
-            if (error.response) {
-                console.error('Server responded with:', {
-                    status: error.response.status,
-                    data: error.response.data
-                });
-            } else if (error.request) {
-                console.error('No response received:', error.request);
-            } else {
-                console.error('Request setup error:', error.message);
-            }
-
-            return {};
-        }
-    }
-}

src/prometheus.service.ts

@@ -174,6 +174,7 @@ export class PrometheusService {
     return this.fetchMetricsWithFilters(menuItem.metric, menuItem.filters);
   }
 
+  // ✅ Новый метод: получает базовое описание метрики (help, type)
   async fetchMetricMetadata(metric: string): Promise<{
     name: string;
     help?: string;
@@ -201,6 +202,7 @@ export class PrometheusService {
     }
   }
 
+  // ✅ Новый метод: получает ВСЕ серии метрики (все комбинации label-ов)
   async fetchMetricSeries(metric: string): Promise<Record<string, string>[]> {
     try {
       const response = await lastValueFrom(