milesight-powermeter-api 0.0.2-0 → 2024.9.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "milesight-powermeter-api",
-  "version": "0.0.2-0",
+  "version": "2024.9.12",
   "description": "Milesight Powermeter API is an internal tool accessible on backend. The API allows detail retrieval and command sending to its powermeters.",
   "author": "Lester Vitor",
   "license": "UNLICENSED",
@@ -22,9 +22,14 @@
     "build:kube:ci": "scripts/build-app.sh mewe/lorawan-milesight-powermeter-api-service"
   },
   "dependencies": {
+    "@coinspect/therma-action-rule-decoder": "^2024.9.12",
     "@nestjs/common": "^10.0.0",
     "@nestjs/core": "^10.0.0",
     "@nestjs/platform-express": "^10.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "convict": "^6.2.4",
+    "elastic-apm-node": "^4.7.0",
     "reflect-metadata": "^0.2.0",
     "rxjs": "^7.8.1"
   },
@@ -32,6 +37,7 @@
     "@nestjs/cli": "^10.0.0",
     "@nestjs/schematics": "^10.0.0",
     "@nestjs/testing": "^10.0.0",
+    "@types/convict": "^6.1.6",
     "@types/express": "^4.17.17",
     "@types/jest": "^29.5.2",
     "@types/node": "^20.3.1",

package/src/config/index.ts

@@ -0,0 +1,15 @@
+import * as convict from 'convict';
+import * as fs from 'fs';
+import path from 'path';
+
+import { AppConfig, schema } from './schema';
+
+const config: convict.Config<AppConfig> = convict(schema);
+
+const configPath = `${__dirname}/configurations/${config.get('stage')}.json`;
+if (fs.existsSync(configPath)) {
+    config.loadFile(path.resolve(configPath));
+}
+config.validate({ allowed: 'strict' });
+
+export { config };

package/src/config/schema.ts

@@ -0,0 +1,117 @@
+import convict from 'convict';
+
+export interface AppConfig {
+    env: string;
+    stage: string;
+    port: number;
+    fport: number;
+    amqp: {
+        hardware: {
+            host: string;
+            vhost: string;
+            username: string;
+            password: string;
+            downlinkExchange: string;
+            port: number;
+            prefetch: number;
+            server: string;
+        };
+    };
+    aws: {
+        region: string;
+    };
+    thingType: string;
+    elasticAPM: {
+        enabled: boolean;
+        serverURL: string;
+        transactionSampleRate: string;
+        secretToken: string;
+    };
+}
+
+const schema: convict.Schema<AppConfig> = {
+    env: {
+        default: 'development',
+        env: 'NODE_ENV',
+        format: ['production', 'development', 'test'],
+    },
+    stage: {
+        default: 'development',
+        env: 'STAGE',
+        format: ['production', 'development', 'staging'],
+    },
+    port: {
+        default: 9060,
+        env: 'MILESIGHT_POWERMETER_API_PORT',
+    },
+    fport: {
+        default: 85,
+        env: 'MILESIGHT_POWERMETER_DOWNLINK_FPORT',
+    },
+    amqp: {
+        hardware: {
+            host: {
+                default: 'localhost',
+                env: 'AMQP_HOST',
+            },
+            prefetch: {
+                default: 200,
+                env: 'AMQP_PREFETCH',
+            },
+            vhost: {
+                default: '/',
+                env: 'AMQP_VHOST',
+            },
+            username: {
+                default: 'guest',
+                env: 'AMQP_USERNAME',
+            },
+            password: {
+                default: 'guest',
+                env: 'AMQP_PASSWORD',
+            },
+            port: {
+                default: 5672,
+                env: 'AMQP_PORT',
+            },
+            downlinkExchange: {
+                default: 'hardware.downlinkexchange',
+                env: 'AMQP_DOWNLINK_EXCHANGE',
+            },
+            server: {
+                default: '',
+                env: 'AMQP_HARDWARE_SERVER',
+            },
+        },
+    },
+    aws: {
+        region: {
+            default: 'us-east-1',
+            env: 'AWS_REGION',
+        },
+    },
+    thingType: {
+        default: 'powermeter-milesight',
+        env: 'MILESIGHT_POWERMETER_THING_TYPE',
+    },
+    elasticAPM: {
+        enabled: {
+            default: false,
+            env: 'ELASTIC_APM_ENABLED',
+        },
+        serverURL: {
+            default: 'http://localhost:8200',
+            env: 'ELASTIC_APM_SERVER_URL',
+        },
+        transactionSampleRate: {
+            default: '1.0',
+            env: 'TRANSACTION_SAMPLE_RATE',
+        },
+        secretToken: {
+            default: '',
+            env: 'ELASTIC_APM_SECRET_TOKEN',
+        },
+    },
+};
+
+export { schema };

package/src/controller/milesight.controller.spec.ts

@@ -0,0 +1,101 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { HttpException } from '@nestjs/common';
+import { MilesightController } from './milesight.controller';
+import { MilesightService } from '../service/milesight.service';
+import { DownlinkService } from '../service/downlink.service';
+import { config } from '../config';
+
+describe('MilesightController', () => {
+    let milesightController: MilesightController;
+    let milesightService: MilesightService;
+
+    beforeEach(async () => {
+        const app: TestingModule = await Test.createTestingModule({
+            controllers: [MilesightController],
+            providers: [DownlinkService, MilesightService],
+        }).compile();
+        milesightService = app.get<MilesightService>(MilesightService);
+        milesightController = app.get<MilesightController>(MilesightController);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('getDeviceList', () => {
+        it('should return device list details', async () => {
+            const queryParams = { maxResult: 1 };
+            const expectedResult = {
+                $metadata: {
+                    httpStatusCode: 200,
+                    requestId: 'b5f4ba6b-de9c-4c17-9879-b6e2e02d14f5',
+                    extendedRequestId: undefined,
+                    cfId: undefined,
+                    attempts: 1,
+                    totalRetryDelay: 0,
+                },
+                nextToken: 'sampleToken',
+                things: [
+                    {
+                        attributes: {},
+                        thingArn:
+                            'arn:aws:iot:us-east-1:224361144749:thing/aaaaaaaaa',
+                        thingName: 'aaaaaaaaa',
+                        thingTypeName: config.get('thingType'),
+                        version: 1,
+                    },
+                ],
+            };
+            const controllerResult = {
+                message:
+                    'Retrieved single phase powermeter device list details',
+                result: expectedResult,
+            };
+            jest.spyOn(milesightService, 'getDeviceList').mockResolvedValue(
+                expectedResult,
+            );
+            const result = await milesightController.getDeviceList(queryParams);
+            expect(result).toEqual(controllerResult);
+        });
+        it('should handle error if device is not retrieved', async () => {
+            const queryParams = { maxResult: 1 };
+            jest.spyOn(milesightService, 'getDeviceList').mockResolvedValue(
+                null,
+            );
+            let errorResult = null;
+            try {
+                await milesightController.getDeviceList(queryParams);
+            } catch (error) {
+                errorResult = error;
+            }
+            expect(errorResult).toBeInstanceOf(HttpException);
+        });
+    });
+    describe('rebootDevice', () => {
+        const data = {
+            deviceEui: 'sampleDeviceEui',
+            serialNumber: 'sampleDeviceName',
+        };
+        it('should return result', async () => {
+            const controllerResult = {
+                message: `Successfully sent reboot command for sampleDeviceEui.`,
+                result: true,
+            };
+            jest.spyOn(milesightService, 'rebootDevice').mockResolvedValue(
+                true,
+            );
+            const result = await milesightController.rebootDevice(data);
+            expect(result).toEqual(controllerResult);
+        });
+        it('should handle error properly', async () => {
+            jest.spyOn(milesightService, 'rebootDevice').mockResolvedValue(
+                null,
+            );
+            let errorResult = null;
+            try {
+                await milesightController.rebootDevice(data);
+            } catch (error) {
+                errorResult = error;
+            }
+            expect(errorResult).toBeInstanceOf(HttpException);
+        });
+    });
+});

package/src/controller/milesight.controller.ts

@@ -0,0 +1,61 @@
+import {
+    Body,
+    Controller,
+    HttpException,
+    HttpStatus,
+    Get,
+    Query,
+    Post,
+    UsePipes,
+    ValidationPipe,
+} from '@nestjs/common';
+import { DeviceListParamsDto, MilesightBaseDto } from '../dto/milesight.dto';
+import { MilesightService } from '../service/milesight.service';
+import { AWSListThings } from '@coinspect/therma-action-rule-decoder';
+
+@Controller('powermeter/milesight')
+export class MilesightController {
+    constructor(private readonly milesightService: MilesightService) {}
+    @Get()
+    async getDeviceList(
+        @Query() queryParams: DeviceListParamsDto,
+    ): Promise<{ message: string; result: AWSListThings }> {
+        const { maxResult, nextToken } = queryParams;
+        const result = await this.milesightService.getDeviceList(
+            maxResult,
+            nextToken,
+        );
+        if (!result) {
+            throw new HttpException(
+                'Error occured',
+                HttpStatus.INTERNAL_SERVER_ERROR,
+            );
+        }
+        return {
+            message: 'Retrieved single phase powermeter device list details',
+            result,
+        };
+    }
+
+    @Post('reboot')
+    @UsePipes(new ValidationPipe())
+    async rebootDevice(
+        @Body() body: MilesightBaseDto,
+    ): Promise<{ message: string; result: boolean }> {
+        const { deviceEui, serialNumber } = body;
+        const result = await this.milesightService.rebootDevice(
+            deviceEui,
+            serialNumber ? serialNumber : deviceEui,
+        );
+        if (!result) {
+            throw new HttpException(
+                `Error occured rebooting device: ${deviceEui}`,
+                HttpStatus.INTERNAL_SERVER_ERROR,
+            );
+        }
+        return {
+            message: `Successfully sent reboot command for ${deviceEui}.`,
+            result,
+        };
+    }
+}

package/src/dto/index.ts

@@ -0,0 +1 @@
+export * from './milesight.dto';

package/src/dto/milesight.dto.ts

@@ -0,0 +1,31 @@
+import {
+    IsNotEmpty,
+    IsOptional,
+    IsString,
+    Min,
+    Max,
+    IsInt,
+} from 'class-validator';
+import { Type } from 'class-transformer';
+
+export class MilesightBaseDto {
+    @IsNotEmpty()
+    @IsString()
+    deviceEui: string;
+
+    @IsOptional()
+    @IsString()
+    serialNumber: string;
+}
+
+export class DeviceListParamsDto {
+    @Min(1)
+    @Max(250)
+    @IsInt()
+    @Type(() => Number)
+    maxResult: number;
+
+    @IsOptional()
+    @IsString()
+    nextToken?: string;
+}

package/src/helper/initapm.ts

@@ -0,0 +1,11 @@
+import * as apm from 'elastic-apm-node';
+import { config } from '../config';
+apm.start({
+    active: Boolean(config.get('elasticAPM.enabled') || false),
+    serviceName: `lorawan-milesight-powermeter-api-${config.get('stage')}`,
+    serverUrl: config.get('elasticAPM.serverURL'),
+    transactionSampleRate: parseFloat(
+        config.get('elasticAPM.transactionSampleRate'),
+    ),
+    secretToken: config.get('elasticAPM.secretToken'),
+});

package/src/main.ts

@@ -1,8 +1,11 @@
+import './helper/initapm';
 import { NestFactory } from '@nestjs/core';
-import { AppModule } from './app.module';
+import { config } from './config';
+
+import { MilesightPowermeterModule } from './modules/milesight-powermeter.module';
 
 async function bootstrap() {
-  const app = await NestFactory.create(AppModule);
-  await app.listen(3000);
+    const app = await NestFactory.create(MilesightPowermeterModule);
+    await app.listen(config.get('port'));
 }
 bootstrap();

package/src/modules/downlink.module.ts

@@ -0,0 +1,8 @@
+import { Module } from '@nestjs/common';
+import { DownlinkService } from 'src/service/downlink.service';
+
+@Module({
+    providers: [DownlinkService],
+    exports: [DownlinkService],
+})
+export class DownlinkModule {}

package/src/modules/milesight-powermeter.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { MilesightController } from '../controller/milesight.controller';
+import { MilesightService } from '../service/milesight.service';
+import { DownlinkModule } from './downlink.module';
+
+@Module({
+    imports: [DownlinkModule],
+    controllers: [MilesightController],
+    providers: [MilesightService],
+})
+export class MilesightPowermeterModule {}

package/src/service/downlink.service.ts

@@ -0,0 +1,66 @@
+import {
+    AmqpService,
+    AWSDownlinkService,
+} from '@coinspect/therma-action-rule-decoder';
+import { Injectable } from '@nestjs/common';
+
+import { config } from '../config';
+
+@Injectable()
+export class DownlinkService {
+    private amqpService: AmqpService;
+    private downlinkExchange: string;
+    constructor() {
+        const {
+            host: hostname,
+            port,
+            username,
+            password,
+            vhost,
+            prefetch,
+            downlinkExchange,
+            server,
+        } = config.get('amqp.hardware');
+        const amqpConfig = server
+            ? server
+            : {
+                  hostname,
+                  port,
+                  username,
+                  password,
+                  vhost,
+              };
+        this.downlinkExchange = downlinkExchange;
+        this.amqpService = new AmqpService(
+            amqpConfig,
+            'milesight-powermeter-api',
+            prefetch,
+            'AmqpService',
+            true,
+        );
+    }
+    async sendDownlink(
+        deviceEui: string,
+        deviceName: string,
+        payload: string,
+        type: string,
+        fport: number,
+        confirmed: boolean,
+    ) {
+        const channel = await this.amqpService.createChannel();
+        const downlinkService = new AWSDownlinkService(
+            channel,
+            this.downlinkExchange,
+        );
+        const response = await downlinkService.sendDownlink(
+            deviceEui,
+            deviceName,
+            payload,
+            type,
+            fport,
+            confirmed,
+        );
+        await channel.channel.close();
+        return response;
+    }
+}

package/src/service/milesight.service.spec.ts

@@ -0,0 +1,113 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { DownlinkService } from './downlink.service';
+import { MilesightService } from './milesight.service';
+import { config } from '../config';
+
+const mockGetListDevices = jest.fn();
+const mockGetDeviceWithTags = jest.fn();
+jest.mock('@coinspect/therma-action-rule-decoder', () => {
+    const actualPackage = jest.requireActual(
+        '@coinspect/therma-action-rule-decoder',
+    );
+    return {
+        ...actualPackage,
+        AWSIotAPI: jest.fn().mockImplementation(() => ({
+            getListThingsByType: mockGetListDevices,
+        })),
+        AWSWirelessIotAPI: jest.fn().mockImplementation(() => ({
+            getDeviceWithTags: mockGetDeviceWithTags,
+        })),
+    };
+});
+describe('MilesightService', () => {
+    let milesightService: MilesightService;
+    let downlinkService: DownlinkService;
+    const mockSendDownlink = jest.fn();
+    beforeEach(async () => {
+        const module: TestingModule = await Test.createTestingModule({
+            providers: [
+                {
+                    provide: DownlinkService,
+                    useValue: {
+                        sendDownlink: mockSendDownlink,
+                    },
+                },
+                MilesightService,
+            ],
+        }).compile();
+
+        milesightService = module.get<MilesightService>(MilesightService);
+        downlinkService = module.get<DownlinkService>(DownlinkService);
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('getDeviceList', () => {
+        it('should return device list details', async () => {
+            const MaxResult = 1;
+            const expectedResult = {
+                $metadata: {
+                    httpStatusCode: 200,
+                    requestId: 'b5f4ba6b-de9c-4c17-9879-b6e2e02d14f5',
+                    extendedRequestId: undefined,
+                    cfId: undefined,
+                    attempts: 1,
+                    totalRetryDelay: 0,
+                },
+                nextToken: 'sampleToken',
+                things: [
+                    {
+                        attributes: {},
+                        thingArn:
+                            'arn:aws:iot:us-east-1:224361144749:thing/aaaaaaaaa',
+                        thingName: 'aaaaaaaaa',
+                        thingTypeName: config.get('thingType'),
+                        version: 1,
+                    },
+                ],
+            };
+            mockGetListDevices.mockResolvedValue(expectedResult);
+
+            const result = await milesightService.getDeviceList(MaxResult);
+
+            expect(mockGetListDevices).toBeCalled();
+            expect(result).toEqual(expectedResult);
+        });
+
+        it('should return null when getting error on device list', async () => {
+            const MaxResult = 1;
+            mockGetListDevices.mockRejectedValue(new Error('Test error'));
+
+            const response = await milesightService.getDeviceList(MaxResult);
+            expect(response).toBeNull();
+            mockGetListDevices.mockClear();
+        });
+    });
+
+    describe('rebootDevice', () => {
+        const data = {
+            deviceEui: 'sampleDeviceEui',
+            serialNumber: 'sampleDeviceName',
+        };
+
+        it('should return true when downlink is successful', async () => {
+            const expectedDownlinkCommand = 'ff10ff';
+            const sendDownlinkSpy = jest
+                .spyOn(downlinkService, 'sendDownlink')
+                .mockResolvedValue(true);
+            await milesightService.rebootDevice(
+                data.deviceEui,
+                data.serialNumber,
+            );
+            expect(sendDownlinkSpy).toHaveBeenCalledWith(
+                data.deviceEui,
+                data.serialNumber,
+                expectedDownlinkCommand,
+                'milesightPowermeterRebootDevice',
+                85,
+                true,
+            );
+            sendDownlinkSpy.mockClear();
+        });
+    });
+});

package/src/service/milesight.service.ts

@@ -0,0 +1,64 @@
+import {
+    AWSIotAPI,
+    AWSListThings,
+} from '@coinspect/therma-action-rule-decoder';
+import { Inject, Injectable, Logger } from '@nestjs/common';
+import { DownlinkService } from './downlink.service';
+import { config } from '../config';
+
+const fPort = config.get('fport');
+@Injectable()
+export class MilesightService {
+    private readonly logger: Logger;
+    private readonly awsIotAPI: AWSIotAPI;
+    constructor(
+        @Inject(DownlinkService)
+        private readonly downlinkService: DownlinkService,
+    ) {
+        this.logger = new Logger(MilesightService.name);
+        this.awsIotAPI = new AWSIotAPI(config.get('aws'));
+    }
+
+    async getDeviceList(
+        maxResult: number,
+        nextToken?: string,
+    ): Promise<AWSListThings | null> {
+        try {
+            this.logger.log('Retrieving devices list');
+            const result = await this.awsIotAPI.getListThingsByType(
+                config.get('thingType'),
+                maxResult,
+                nextToken,
+            );
+            return result;
+        } catch (error) {
+            this.logger.error(
+                `Error retrieving devices list details: ${error}`,
+            );
+            return null;
+        }
+    }
+
+    async rebootDevice(
+        deviceEui: string,
+        serialNumber: string,
+    ): Promise<boolean | null> {
+        try {
+            this.logger.log(`Rebooting device: ${deviceEui}`);
+            const rebootDownlinkCommand = 'ff10ff';
+            const response = await this.downlinkService.sendDownlink(
+                deviceEui,
+                serialNumber,
+                rebootDownlinkCommand,
+                'milesightPowermeterRebootDevice',
+                fPort,
+                true,
+            );
+            this.logger.log(`Successfully rebooted ${deviceEui}`);
+            return response;
+        } catch (error) {
+            this.logger.error(`Error rebooting ${deviceEui}: ${error}`);
+            return null;
+        }
+    }
+}

package/timestamp.sh

@@ -1 +1 @@
-export DT=20240904045917
+export DT=20240918072210