feat: avm module

src/app.module.ts

@@ -1,18 +1,17 @@
 import { Module } from '@nestjs/common';
 import { ServeStaticModule } from '@nestjs/serve-static';
 import { join } from 'path';
-import { MeasurementModule } from './measurement/measurement.module';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { TypeOrmModule, TypeOrmModuleOptions } from '@nestjs/typeorm';
-import { MeasurementEntity } from './measurement/measurement.entity';
+import { MeasurementEntity } from './avm/measurement.entity';
 import { APP_INTERCEPTOR } from '@nestjs/core';
 import { HTTPLoggingInterceptor } from './logging-interceptor';
 import { DeviceModule } from './devices/device.modules';
 import { AvmModule } from './avm/avm.modules';
+import { DeviceEntity } from './devices/device.entity';
 
 @Module({
   imports: [
-    MeasurementModule,
     DeviceModule,
     AvmModule,
     ServeStaticModule.forRoot({
@@ -28,7 +27,7 @@ import { AvmModule } from './avm/avm.modules';
           port: 5432,
           password: configService.getOrThrow('DB_PW'),
           username: configService.getOrThrow('DB_USER'),
-          entities: [MeasurementEntity],
+          entities: [MeasurementEntity, DeviceEntity],
           database: configService.getOrThrow('DB_NAME'),
           synchronize: true,
           logging: false,

src/avm/avm.controller.ts

@@ -1,6 +1,7 @@
 import { Controller, Get, Param } from '@nestjs/common';
 import { AvmService } from './avm.service';
 import { LoginService } from './login.service';
+import { MeasurementEntity } from './measurement.entity';
 
 @Controller('avm/:ain')
 export class AvmController {
@@ -9,9 +10,8 @@ export class AvmController {
     private readonly loginService: LoginService,
   ) {}
 
-  @Get('energy')
-  async getEnergy(@Param('ain') ain: string): Promise<string> {
-    const sid = await this.loginService.getSid();
-    return this.avmService.getEnergy(ain, sid);
+  @Get('measurement')
+  async getEnergy(@Param('ain') ain: string): Promise<MeasurementEntity> {
+    return this.avmService.getMeasurement(ain);
   }
 }

src/avm/avm.modules.ts

@@ -3,9 +3,11 @@ import { AvmController } from './avm.controller';
 import { AvmService } from './avm.service';
 import { HttpModule } from '@nestjs/axios';
 import { LoginService } from './login.service';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { MeasurementEntity } from './measurement.entity';
 
 @Module({
-  imports: [HttpModule],
+  imports: [HttpModule, TypeOrmModule.forFeature([MeasurementEntity])],
   controllers: [AvmController],
   providers: [AvmService, LoginService],
   exports: [],

src/avm/avm.service.ts

@@ -1,7 +1,12 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { HttpService } from '@nestjs/axios';
-import { firstValueFrom, map, Observable } from 'rxjs';
+import { firstValueFrom, map } from 'rxjs';
 import { ConfigService } from '@nestjs/config';
+import { MeasurementEntity } from './measurement.entity';
+import { LoginService } from './login.service';
+import { XMLParser } from 'fast-xml-parser';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
 
 @Injectable()
 export class AvmService {
@@ -11,12 +16,30 @@ export class AvmService {
 
   constructor(
     private readonly httpService: HttpService,
+    private readonly loginService: LoginService,
     readonly configService: ConfigService,
+    @InjectRepository(MeasurementEntity)
+    private measurementRepository: Repository<MeasurementEntity>,
   ) {
     this.fb = configService.getOrThrow<string>('FB');
   }
 
-  public async getEnergy(ain: string, sid: string): Promise<string> {
+  public async getMeasurement(ain: string): Promise<MeasurementEntity> {
+    const sid = await this.loginService.getSid();
+    const energy = await this.getEnergy(ain, sid);
+    const power = await this.getPower(ain, sid);
+    const temperature = await this.getTemperature(ain, sid);
+    const voltage = await this.getVoltage(ain, sid);
+    const parser = new XMLParser();
+    const entity = new MeasurementEntity();
+    entity.energy = energy;
+    entity.power = power;
+    entity.temperature = temperature;
+
+    return entity;
+  }
+
+  private async getEnergy(ain: string, sid: string): Promise<number> {
     const request = this.httpService
       .get<string>(`${this.fb}/${this.endpoint}`, {
         params: {
@@ -25,6 +48,45 @@ export class AvmService {
           switchcmd: 'getswitchenergy',
         },
       })
+      .pipe(map((res) => parseInt(res.data)));
+    return firstValueFrom(request);
+  }
+
+  private async getTemperature(ain: string, sid: string): Promise<number> {
+    const request = this.httpService
+      .get<string>(`${this.fb}/${this.endpoint}`, {
+        params: {
+          sid,
+          ain,
+          switchcmd: 'gettemperature',
+        },
+      })
+      .pipe(map((res) => parseInt(res.data)));
+    return firstValueFrom(request);
+  }
+
+  private async getPower(ain: string, sid: string): Promise<number> {
+    const request = this.httpService
+      .get<string>(`${this.fb}/${this.endpoint}`, {
+        params: {
+          sid,
+          ain,
+          switchcmd: 'getswitchpower',
+        },
+      })
+      .pipe(map((res) => parseInt(res.data)));
+    return firstValueFrom(request);
+  }
+
+  private async getVoltage(ain: string, sid: string): Promise<string> {
+    const request = this.httpService
+      .get<string>(`${this.fb}/${this.endpoint}`, {
+        params: {
+          sid,
+          ain,
+          switchcmd: 'getdevicelistinfos',
+        },
+      })
       .pipe(map((res) => res.data));
     return firstValueFrom(request);
   }

src/devices/create-device.dto.ts

@@ -0,0 +1,9 @@
+import { Type } from 'class-transformer';
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class CreateDeviceDto {
+  @Type(() => String)
+  @IsString()
+  @IsNotEmpty()
+  readonly ain: string;
+}

src/devices/device.controller.ts

@@ -1,13 +1,13 @@
 import { Controller, Get } from '@nestjs/common';
-import { DeviceDto } from './device.dto';
 import { DeviceService } from './device.service';
+import { DeviceEntity } from './device.entity';
 
 @Controller('devices')
 export class DeviceController {
   constructor(private readonly deviceService: DeviceService) {}
 
   @Get()
-  devices(): Promise<DeviceDto[]> {
+  devices(): Promise<DeviceEntity[]> {
     return this.deviceService.getDevices();
   }
 }

src/devices/device.entity.ts

@@ -0,0 +1,4 @@
+import { Entity } from 'typeorm';
+
+@Entity({ name: 'devices' })
+export class DeviceEntity {}

src/devices/device.modules.ts

@@ -1,11 +1,11 @@
 import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
-import { MeasurementEntity } from '../measurement/measurement.entity';
 import { DeviceController } from './device.controller';
 import { DeviceService } from './device.service';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { DeviceEntity } from './device.entity';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([MeasurementEntity])],
+  imports: [TypeOrmModule.forFeature([DeviceEntity])],
   controllers: [DeviceController],
   providers: [DeviceService],
   exports: [],

src/devices/device.service.ts

@@ -1,23 +1,16 @@
 import { Injectable } from '@nestjs/common';
-import { DeviceDto } from './device.dto';
 import { InjectRepository } from '@nestjs/typeorm';
-import { MeasurementEntity } from '../measurement/measurement.entity';
 import { Repository } from 'typeorm';
+import { DeviceEntity } from './device.entity';
 
 @Injectable()
 export class DeviceService {
   constructor(
-    @InjectRepository(MeasurementEntity)
-    private measurementRepository: Repository<MeasurementEntity>,
+    @InjectRepository(DeviceEntity)
+    private deviceRepository: Repository<DeviceEntity>,
   ) {}
 
-  async getDevices(): Promise<DeviceDto[]> {
-    const x = await this.measurementRepository
-      .createQueryBuilder('measurement')
-      .select('DISTINCT(device) ain')
-      .getRawMany();
-    console.log(x);
-
+  async getDevices(): Promise<DeviceEntity[]> {
     return Promise.resolve([]);
   }
 }