feat: libre hardware monitor beta support (#13)

* feat: screenshots updated

* feat: libre hardware monitor beta support

* fix: sensor name correction

Author: gajjartejas

app/models/api/deviceInfo.ts

@@ -1,6 +1,6 @@
 export enum IAPISensorType {
   Voltage = 'Voltage',
-  Clock = 'Vlock',
+  Clock = 'Clock',
   Load = 'Load',
   Temperature = 'Temperature',
   Fan = 'Fan',
@@ -9,19 +9,23 @@ export enum IAPISensorType {
   Level = 'Level',
   Power = 'Power',
   Throughput = 'Throughput',
+  Current = 'Current',
+  Capacity = 'Capacity',
 }
 
 export enum IAPIHardwareType {
   CPU = 'CPU',
   GpuNvidia = 'GpuNvidia',
   GpuAti = 'GpuAti',
+  GpuIntel = 'GpuIntel',
   HDD = 'HDD',
   Heatmaster = 'Heatmaster',
   Mainboard = 'Mainboard',
   Chipset = 'Chipset',
   TBalancer = 'TBalancer',
   RAM = 'RAM',
   NIC = 'NIC',
+  Battery = 'Battery',
 }
 
 export enum IAPISystemType {

app/models/mapper/cardValueViewModel.ts

@@ -9,6 +9,9 @@ import {
   IDeviceSensorData,
   IDeviceChipset,
   IDeviceNIC,
+  IDeviceGpuintel,
+  IDeviceBattery,
+  IDeviceGpunvidia,
 } from 'app/models/models/deviceInfo';
 import { IAPIHardwareType, IAPISensorType, IAPISystemType } from 'app/models/api/deviceInfo';
 
@@ -36,25 +39,25 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
       let voltages = getObjectFromType(chipsetInfo.chipset, IAPISensorType.Voltage) as IDeviceChipset[];
       let voltagesVMs = voltages.map(voltageInfo => {
         let voltagesVM = convertArrayToVM(voltageInfo.voltage!);
-        return { id: voltageInfo.id, values: voltagesVM, title: IAPISensorType.Voltage, sections: null };
+        return { id: voltageInfo.id, values: voltagesVM, title: voltageInfo.text, sections: null };
       });
       //Temperatures
       let temperatures = getObjectFromType(chipsetInfo.chipset, IAPISensorType.Temperature) as IDeviceChipset[];
       let temperaturesVMs = temperatures.map(temperatureInfo => {
         let temperaturesVM = convertArrayToVM(temperatureInfo.temperature!);
-        return { id: temperatureInfo.id, values: temperaturesVM, title: IAPISensorType.Temperature, sections: null };
+        return { id: temperatureInfo.id, values: temperaturesVM, title: temperatureInfo.text, sections: null };
       });
       //Fans
       let fans = getObjectFromType(chipsetInfo.chipset, IAPISensorType.Fan) as IDeviceChipset[];
       let fansVMs = fans.map(fanInfo => {
         let fansVM = convertArrayToVM(fanInfo.fan!);
-        return { id: fanInfo.id, values: fansVM, title: IAPISensorType.Fan, sections: null };
+        return { id: fanInfo.id, values: fansVM, title: fanInfo.text, sections: null };
       });
       //Controls
       let controls = getObjectFromType(chipsetInfo.chipset, IAPISensorType.Control) as IDeviceChipset[];
       let controlsVMs = controls.map(controlInfo => {
         let controlsVM = convertArrayToVM(controlInfo.control!);
-        return { id: controlInfo.id, values: controlsVM, title: IAPISensorType.Control, sections: null };
+        return { id: controlInfo.id, values: controlsVM, title: controlInfo.text, sections: null };
       });
       return {
         id: chipsetInfo.id,
@@ -78,34 +81,40 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
     if (!cpuInfo.cpu) {
       return null;
     }
-    //VLocks
-    let vlocks = getObjectFromType(cpuInfo.cpu, IAPISensorType.Clock) as IDeviceCPU[];
-    let vlocksVMs = vlocks.map(vlockInfo => {
-      let vlocksVM = convertArrayToVM(vlockInfo.vlock!);
-      return { id: vlockInfo.id, values: vlocksVM, title: IAPISensorType.Clock, sections: null };
+    //Voltages
+    let voltages = getObjectFromType(cpuInfo.cpu, IAPISensorType.Voltage) as IDeviceChipset[];
+    let voltagesVMs = voltages.map(voltageInfo => {
+      let voltagesVM = convertArrayToVM(voltageInfo.voltage!);
+      return { id: voltageInfo.id, values: voltagesVM, title: voltageInfo.text, sections: null };
+    });
+    //Cocks
+    let clocks = getObjectFromType(cpuInfo.cpu, IAPISensorType.Clock) as IDeviceCPU[];
+    let clocksVMs = clocks.map(clockInfo => {
+      let clocksVM = convertArrayToVM(clockInfo.clock!);
+      return { id: clockInfo.id, values: clocksVM, title: clockInfo.text, sections: null };
     });
     //Temperatures
     let temperatures = getObjectFromType(cpuInfo.cpu, IAPISensorType.Temperature) as IDeviceCPU[];
     let temperaturesVMs = temperatures.map(temperatureInfo => {
       let controlsVMs = convertArrayToVM(temperatureInfo.temperature!);
-      return { id: temperatureInfo.id, values: controlsVMs, title: IAPISensorType.Temperature, sections: null };
+      return { id: temperatureInfo.id, values: controlsVMs, title: temperatureInfo.text, sections: null };
     });
     //Loads
     let loads = getObjectFromType(cpuInfo.cpu, IAPISensorType.Load) as IDeviceCPU[];
     let loadsVMs = loads.map(loadInfo => {
       let controlsVMs = convertArrayToVM(loadInfo.load!);
-      return { id: loadInfo.id, values: controlsVMs, title: IAPISensorType.Load, sections: null };
+      return { id: loadInfo.id, values: controlsVMs, title: loadInfo.text, sections: null };
     });
     //Powers
     let powers = getObjectFromType(cpuInfo.cpu, IAPISensorType.Power) as IDeviceCPU[];
     let powersVMs = powers.map(power => {
       let powerVMs = convertArrayToVM(power.power!);
-      return { id: power.id, values: powerVMs, title: IAPISensorType.Power, sections: null };
+      return { id: power.id, values: powerVMs, title: power.text, sections: null };
     });
     return {
       id: cpuInfo.id,
       title: `${IAPIHardwareType.CPU} - ${cpuInfo.text}`,
-      sections: [...vlocksVMs, ...powersVMs, ...temperaturesVMs, ...loadsVMs],
+      sections: [...voltagesVMs, ...clocksVMs, ...powersVMs, ...temperaturesVMs, ...loadsVMs],
       values: null,
     } as ICardViewModel;
   });
@@ -121,13 +130,13 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
     let loads = getObjectFromType(ramInfo.ram, IAPISensorType.Load) as IDeviceRAM[];
     let loadsVMs = loads.map(load => {
       let loadVMs = convertArrayToVM(load.load!);
-      return { id: load.id, values: loadVMs, title: IAPISensorType.Load, sections: null };
+      return { id: load.id, values: loadVMs, title: load.text, sections: null };
     });
     //Data
     let powers = getObjectFromType(ramInfo.ram, IAPISensorType.Power) as IDeviceRAM[];
     let powersVMs = powers.map(power => {
       let powerVMs = convertArrayToVM(power.power!);
-      return { id: power.id, values: powerVMs, title: IAPISensorType.Power, sections: null };
+      return { id: power.id, values: powerVMs, title: power.text, sections: null };
     });
     return {
       id: ramInfo.id,
@@ -148,43 +157,43 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
     let voltages = getObjectFromType(gpuAtiInfo.gpuati, IAPISensorType.Voltage) as IDeviceGpuati[];
     let voltagesVMs = voltages.map(voltage => {
       let controlsVM = convertArrayToVM(voltage.voltage!);
-      return { id: voltage.id, values: controlsVM, title: IAPISensorType.Voltage, sections: null };
+      return { id: voltage.id, values: controlsVM, title: voltage.text, sections: null };
     });
     //Clocks
     let clocks = getObjectFromType(gpuAtiInfo.gpuati, IAPISensorType.Clock) as IDeviceGpuati[];
     let clocksVMs = clocks.map(clock => {
-      let controlsVM = convertArrayToVM(clock.vlock!);
-      return { id: clock.id, values: controlsVM, title: IAPISensorType.Clock, sections: null };
+      let controlsVM = convertArrayToVM(clock.clock!);
+      return { id: clock.id, values: controlsVM, title: clock.text, sections: null };
     });
     //Temperatures
     let temperatures = getObjectFromType(gpuAtiInfo.gpuati, IAPISensorType.Temperature) as IDeviceGpuati[];
     let temperaturesVMs = temperatures.map(temperature => {
       let temperaturesVM = convertArrayToVM(temperature.temperature!);
-      return { id: temperature.id, values: temperaturesVM, title: IAPISensorType.Temperature, sections: null };
+      return { id: temperature.id, values: temperaturesVM, title: temperature.text, sections: null };
     });
     //Load
     let loads = getObjectFromType(gpuAtiInfo.gpuati, IAPISensorType.Load) as IDeviceGpuati[];
     let loadsVMs = loads.map(load => {
       let loadsVM = convertArrayToVM(load.load!);
-      return { id: load.id, values: loadsVM, title: IAPISensorType.Load, sections: null };
+      return { id: load.id, values: loadsVM, title: load.text, sections: null };
     });
     //Fan
     let fans = getObjectFromType(gpuAtiInfo.gpuati, IAPISensorType.Fan) as IDeviceGpuati[];
     let fansVMs = fans.map(fan => {
       let fansVM = convertArrayToVM(fan.fan!);
-      return { id: fan.id, values: fansVM, title: IAPISensorType.Fan, sections: null };
+      return { id: fan.id, values: fansVM, title: fan.text, sections: null };
     });
     //Controls
     let controls = getObjectFromType(gpuAtiInfo.gpuati, IAPISensorType.Control) as IDeviceGpuati[];
     let controlsVMs = controls.map(control => {
       let controlsVM = convertArrayToVM(control.control!);
-      return { id: control.id, values: controlsVM, title: IAPISensorType.Control, sections: null };
+      return { id: control.id, values: controlsVM, title: control.text, sections: null };
     });
     //Power
     let powers = getObjectFromType(gpuAtiInfo.gpuati, IAPISensorType.Power) as IDeviceGpuati[];
     let powersVMs = powers.map(power => {
       let powersVM = convertArrayToVM(power.power!);
-      return { id: power.id, values: powersVM, title: IAPISensorType.Power, sections: null };
+      return { id: power.id, values: powersVM, title: power.text, sections: null };
     });
     return {
       id: gpuAtiInfo.id,
@@ -210,46 +219,46 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
       return null;
     }
     //Voltages
-    let voltages = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Voltage) as IDeviceGpuati[];
+    let voltages = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Voltage) as IDeviceGpunvidia[];
     let voltagesVMs = voltages.map(voltage => {
       let controlsVM = convertArrayToVM(voltage.voltage!);
-      return { id: voltage.id, values: controlsVM, title: IAPISensorType.Voltage, sections: null };
+      return { id: voltage.id, values: controlsVM, title: voltage.text, sections: null };
     });
     //Clocks
-    let clocks = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Clock) as IDeviceGpuati[];
+    let clocks = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Clock) as IDeviceGpunvidia[];
     let clocksVMs = clocks.map(clock => {
-      let controlsVM = convertArrayToVM(clock.vlock!);
-      return { id: clock.id, values: controlsVM, title: IAPISensorType.Clock, sections: null };
+      let controlsVM = convertArrayToVM(clock.clock!);
+      return { id: clock.id, values: controlsVM, title: clock.text, sections: null };
     });
     //Temperatures
-    let temperatures = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Temperature) as IDeviceGpuati[];
+    let temperatures = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Temperature) as IDeviceGpunvidia[];
     let temperaturesVMs = temperatures.map(temperature => {
       let temperaturesVM = convertArrayToVM(temperature.temperature!);
-      return { id: temperature.id, values: temperaturesVM, title: IAPISensorType.Temperature, sections: null };
+      return { id: temperature.id, values: temperaturesVM, title: temperature.text, sections: null };
     });
     //Load
-    let loads = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Load) as IDeviceGpuati[];
+    let loads = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Load) as IDeviceGpunvidia[];
     let loadsVMs = loads.map(load => {
       let loadsVM = convertArrayToVM(load.load!);
-      return { id: load.id, values: loadsVM, title: IAPISensorType.Load, sections: null };
+      return { id: load.id, values: loadsVM, title: load.text, sections: null };
     });
     //Fan
-    let fans = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Fan) as IDeviceGpuati[];
+    let fans = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Fan) as IDeviceGpunvidia[];
     let fansVMs = fans.map(fan => {
       let fansVM = convertArrayToVM(fan.fan!);
-      return { id: fan.id, values: fansVM, title: IAPISensorType.Fan, sections: null };
+      return { id: fan.id, values: fansVM, title: fan.text, sections: null };
     });
     //Controls
-    let controls = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Control) as IDeviceGpuati[];
+    let controls = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Control) as IDeviceGpunvidia[];
     let controlsVMs = controls.map(control => {
       let controlsVM = convertArrayToVM(control.control!);
-      return { id: control.id, values: controlsVM, title: IAPISensorType.Control, sections: null };
+      return { id: control.id, values: controlsVM, title: control.text, sections: null };
     });
     //Power
-    let powers = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Power) as IDeviceGpuati[];
+    let powers = getObjectFromType(gpuNvidiaInfo.gpunvidia, IAPISensorType.Power) as IDeviceGpunvidia[];
     let powersVMs = powers.map(power => {
       let powersVM = convertArrayToVM(power.power!);
-      return { id: power.id, values: powersVM, title: IAPISensorType.Power, sections: null };
+      return { id: power.id, values: powersVM, title: power.text, sections: null };
     });
     return {
       id: gpuNvidiaInfo.id,
@@ -268,6 +277,34 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
   });
   let gpuNvidiaSectionViewModelsMapped = gpuNvidiaSectionViewModels.filter(v => v).map(v => v!);
 
+  //CARD
+  let computerGpusIntel = getObjectFromType(computers, IAPIHardwareType.GpuIntel) as IDeviceComputer[];
+
+  let gpuIntelSectionViewModels = computerGpusIntel.map(gpuIntelInfo => {
+    if (!gpuIntelInfo.gpuintel) {
+      return null;
+    }
+    //Power
+    let powers = getObjectFromType(gpuIntelInfo.gpuintel, IAPISensorType.Power) as IDeviceGpuintel[];
+    let powersVMs = powers.map(power => {
+      let powersVM = convertArrayToVM(power.power!);
+      return { id: power.id, values: powersVM, title: power.text, sections: null };
+    });
+    //Load
+    let loads = getObjectFromType(gpuIntelInfo.gpuintel, IAPISensorType.Load) as IDeviceGpuintel[];
+    let loadsVMs = loads.map(load => {
+      let loadsVM = convertArrayToVM(load.load!);
+      return { id: load.id, values: loadsVM, title: load.text, sections: null };
+    });
+    return {
+      id: gpuIntelInfo.id,
+      title: `${IAPIHardwareType.GpuIntel} - ${gpuIntelInfo.text}`,
+      sections: [...loadsVMs, ...powersVMs],
+      values: null,
+    } as ICardViewModel;
+  });
+  let gpuIntelSectionViewModelsMapped = gpuIntelSectionViewModels.filter(v => v).map(v => v!);
+
   //HDD
   let computerHdds = getObjectFromType(computers, IAPIHardwareType.HDD) as IDeviceComputer[];
   let computerHddViewModels = computerHdds.map(hddInfo => {
@@ -295,13 +332,13 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
     let powers = getObjectFromType(hddInfo.hdd, IAPISensorType.Power) as IDeviceHDD[];
     let powersVMs = powers.map(power => {
       let powersVM = convertArrayToVM(power.power!);
-      return { id: power.id, values: powersVM, title: IAPISensorType.Power, sections: null };
+      return { id: power.id, values: powersVM, title: power.text, sections: null };
     });
     //Throughput
     let throughputs = getObjectFromType(hddInfo.hdd, IAPISensorType.Throughput) as IDeviceHDD[];
     let throughputsVMs = throughputs.map(throughput => {
       let throughputsVM = convertArrayToVM(throughput.throughput!);
-      return { id: throughput.id, values: throughputsVM, title: IAPISensorType.Throughput, sections: null };
+      return { id: throughput.id, values: throughputsVM, title: throughput.text, sections: null };
     });
     return {
       id: hddInfo.id,
@@ -322,19 +359,19 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
     let loads = getObjectFromType(nicInfo.nic, IAPISensorType.Load) as IDeviceNIC[];
     let loadsVMs = loads.map(load => {
       let loadsVM = convertArrayToVM(load.load!);
-      return { id: load.id, values: loadsVM, title: IAPISensorType.Load, sections: null };
+      return { id: load.id, values: loadsVM, title: load.text, sections: null };
     });
     //Data
     let powers = getObjectFromType(nicInfo.nic, IAPISensorType.Power) as IDeviceNIC[];
     let powersVMs = powers.map(power => {
       let powerVMs = convertArrayToVM(power.power!);
-      return { id: power.id, values: powerVMs, title: IAPISensorType.Power, sections: null };
+      return { id: power.id, values: powerVMs, title: power.text, sections: null };
     });
     //Throughput
     let throughputs = getObjectFromType(nicInfo.nic, IAPISensorType.Throughput) as IDeviceNIC[];
     let throughputsVMs = throughputs.map(throughput => {
       let throughputsVM = convertArrayToVM(throughput.throughput!);
-      return { id: throughput.id, values: throughputsVM, title: IAPISensorType.Throughput, sections: null };
+      return { id: throughput.id, values: throughputsVM, title: throughput.text, sections: null };
     });
     return {
       id: nicInfo.id,
@@ -345,14 +382,61 @@ export const convertToViewModel = (device: IDevice | null): ICardViewModel[] =>
   });
   let computerNicViewModelsMapped = computerNicViewModels.filter(v => v).map(v => v!);
 
+  //BATTERY
+  let computerBatteries = getObjectFromType(computers, IAPIHardwareType.Battery) as IDeviceComputer[];
+  let batterySectionViewModels = computerBatteries.map(batteryInfo => {
+    if (!batteryInfo.battery) {
+      return null;
+    }
+    //Voltages
+    let voltages = getObjectFromType(batteryInfo.battery, IAPISensorType.Voltage) as IDeviceBattery[];
+    let voltagesVMs = voltages.map(voltage => {
+      let controlsVM = convertArrayToVM(voltage.voltage!);
+      return { id: voltage.id, values: controlsVM, title: voltage.text, sections: null };
+    });
+    //Currents
+    let currents = getObjectFromType(batteryInfo.battery, IAPISensorType.Clock) as IDeviceBattery[];
+    let currentsVMs = currents.map(current => {
+      let controlsVM = convertArrayToVM(current.current!);
+      return { id: current.id, values: controlsVM, title: current.text, sections: null };
+    });
+    //Power
+    let powers = getObjectFromType(batteryInfo.battery, IAPISensorType.Power) as IDeviceBattery[];
+    let powersVMs = powers.map(power => {
+      let powersVM = convertArrayToVM(power.power!);
+      return { id: power.id, values: powersVM, title: power.text, sections: null };
+    });
+    //Level
+    let levels = getObjectFromType(batteryInfo.battery, IAPISensorType.Level) as IDeviceBattery[];
+    let levelsVMs = levels.map(level => {
+      let levelsVM = convertArrayToVM(level.level!);
+      return { id: level.id, values: levelsVM, title: level.text, sections: null };
+    });
+    //Capacities
+    let capacities = getObjectFromType(batteryInfo.battery, IAPISensorType.Capacity) as IDeviceBattery[];
+    let capacitiesVMs = capacities.map(capacity => {
+      let capacitiesVM = convertArrayToVM(capacity.capacity!);
+      return { id: capacity.id, values: capacitiesVM, title: capacity.text, sections: null };
+    });
+    return {
+      id: batteryInfo.id,
+      title: `${IAPIHardwareType.Battery} - ${batteryInfo.text}`,
+      sections: [...voltagesVMs, ...currentsVMs, ...powersVMs, ...levelsVMs, ...capacitiesVMs],
+      values: null,
+    } as ICardViewModel;
+  });
+  let batterySectionViewModelsMapped = batterySectionViewModels.filter(v => v).map(v => v!);
+
   return [
     ...mainboardSectionViewModelsMapped,
     ...computerCpusViewModelsMapped,
     ...ramSectionViewModelsMapped,
+    ...gpuIntelSectionViewModelsMapped,
     ...gpuAtiSectionViewModelsMapped,
     ...gpuNvidiaSectionViewModelsMapped,
     ...computerHddViewModelsMapped,
     ...computerNicViewModelsMapped,
+    ...batterySectionViewModelsMapped,
   ];
 };