milesight-powermeter-api 2024.9.13-1 → 2024.9.24-0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "milesight-powermeter-api",
-  "version": "2024.9.13-1",
+  "version": "2024.9.24-0",
   "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,7 +22,7 @@
     "build:kube:ci": "scripts/build-app.sh mewe/lorawan-milesight-powermeter-api-service"
   },
   "dependencies": {
-    "@coinspect/therma-action-rule-decoder": "2024.9.12",
+    "@coinspect/therma-action-rule-decoder": "^2025.6.29-0",
     "@nestjs/common": "^10.0.0",
     "@nestjs/core": "^10.0.0",
     "@nestjs/platform-express": "^10.0.0",
@@ -56,22 +56,5 @@
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0",
     "typescript": "^5.1.3"
-  },
-  "jest": {
-    "moduleFileExtensions": [
-      "js",
-      "json",
-      "ts"
-    ],
-    "rootDir": "src",
-    "testRegex": ".*\\.spec\\.ts$",
-    "transform": {
-      "^.+\\.(t|j)s$": "ts-jest"
-    },
-    "collectCoverageFrom": [
-      "**/*.(t|j)s"
-    ],
-    "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
   }
 }

package/src/config/schema.ts

@@ -21,6 +21,7 @@ export interface AppConfig {
         region: string;
     };
     thingType: string;
+    threePhaseThingType: string;
     elasticAPM: {
         enabled: boolean;
         serverURL: string;
@@ -94,6 +95,10 @@ const schema: convict.Schema<AppConfig> = {
         default: 'powermeter-milesight',
         env: 'MILESIGHT_POWERMETER_THING_TYPE',
     },
+    threePhaseThingType: {
+        default: 'three-phase-powermeter-milesight',
+        env: 'MILESIGHT_THREE_PHASE_POWERMETER_THING_TYPE',
+    },
     elasticAPM: {
         enabled: {
             default: false,

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

@@ -8,18 +8,26 @@ import { config } from '../config';
 describe('MilesightController', () => {
     let milesightController: MilesightController;
     let milesightService: MilesightService;
+    let app: TestingModule;
 
     beforeEach(async () => {
-        const app: TestingModule = await Test.createTestingModule({
+        app = await Test.createTestingModule({
             controllers: [MilesightController],
             providers: [DownlinkService, MilesightService],
         }).compile();
         milesightService = app.get<MilesightService>(MilesightService);
         milesightController = app.get<MilesightController>(MilesightController);
     });
+
     afterEach(() => {
         jest.clearAllMocks();
     });
+
+    afterAll(async () => {
+        if (app) {
+            await app.close();
+        }
+    });
     describe('getDeviceList', () => {
         it('should return device list details', async () => {
             const queryParams = { maxResult: 1 };

package/src/controller/three-phase-milesight.controller.spec.ts

@@ -0,0 +1,139 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { HttpException } from '@nestjs/common';
+import { ThreePhaseMilesightController } from './three-phase-milesight.controller';
+import { ThreePhaseMilesightService } from '../service/three-phase-milesight.service';
+import { DownlinkService } from '../service/downlink.service';
+import { config } from '../config';
+
+describe('ThreePhaseMilesightController', () => {
+    let threePhaseMilesightController: ThreePhaseMilesightController;
+    let threePhaseMilesightService: ThreePhaseMilesightService;
+    let app: TestingModule;
+
+    beforeEach(async () => {
+        app = await Test.createTestingModule({
+            controllers: [ThreePhaseMilesightController],
+            providers: [DownlinkService, ThreePhaseMilesightService],
+        }).compile();
+        threePhaseMilesightService = app.get<ThreePhaseMilesightService>(ThreePhaseMilesightService);
+        threePhaseMilesightController = app.get<ThreePhaseMilesightController>(ThreePhaseMilesightController);
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    afterAll(async () => {
+        if (app) {
+            await app.close();
+        }
+    });
+    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 three-phase powermeter device list details',
+                result: expectedResult,
+            };
+            jest.spyOn(threePhaseMilesightService, 'getDeviceList').mockResolvedValue(
+                expectedResult,
+            );
+            const result = await threePhaseMilesightController.getDeviceList(queryParams);
+            expect(result).toEqual(controllerResult);
+        });
+        it('should handle error if device is not retrieved', async () => {
+            const queryParams = { maxResult: 1 };
+            jest.spyOn(threePhaseMilesightService, 'getDeviceList').mockResolvedValue(
+                null,
+            );
+            let errorResult = null;
+            try {
+                await threePhaseMilesightController.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 three-phase device sampleDeviceEui.`,
+                result: true,
+            };
+            jest.spyOn(threePhaseMilesightService, 'rebootDevice').mockResolvedValue(
+                true,
+            );
+            const result = await threePhaseMilesightController.rebootDevice(data);
+            expect(result).toEqual(controllerResult);
+        });
+        it('should handle error properly', async () => {
+            jest.spyOn(threePhaseMilesightService, 'rebootDevice').mockResolvedValue(
+                null,
+            );
+            let errorResult = null;
+            try {
+                await threePhaseMilesightController.rebootDevice(data);
+            } catch (error) {
+                errorResult = error;
+            }
+            expect(errorResult).toBeInstanceOf(HttpException);
+        });
+    });
+    describe('setDeviceInterval', () => {
+        const data = {
+            deviceEui: 'sampleDeviceEui',
+            serialNumber: 'sampleDeviceName',
+            interval: 1440,
+        };
+        it('should return result', async () => {
+            const controllerResult = {
+                message: `Successfully sent set device interval command for three-phase device sampleDeviceEui.`,
+                result: true,
+            };
+            jest.spyOn(threePhaseMilesightService, 'setDeviceInterval').mockResolvedValue(
+                true,
+            );
+            const result = await threePhaseMilesightController.setDeviceInterval(data);
+            expect(result).toEqual(controllerResult);
+        });
+        it('should handle error properly', async () => {
+            jest.spyOn(threePhaseMilesightService, 'setDeviceInterval').mockResolvedValue(
+                null,
+            );
+            let errorResult = null;
+            try {
+                await threePhaseMilesightController.setDeviceInterval(data);
+            } catch (error) {
+                errorResult = error;
+            }
+            expect(errorResult).toBeInstanceOf(HttpException);
+        });
+    });
+});

package/src/controller/three-phase-milesight.controller.ts

@@ -0,0 +1,88 @@
+import {
+    Body,
+    Controller,
+    HttpException,
+    HttpStatus,
+    Get,
+    Query,
+    Post,
+    UsePipes,
+    ValidationPipe,
+} from '@nestjs/common';
+import {
+    DeviceListParamsDto,
+    MilesightBaseDto,
+    MilesightSetIntervalDto,
+} from '../dto/milesight.dto';
+import { ThreePhaseMilesightService } from '../service/three-phase-milesight.service';
+import { AWSListThings } from '@coinspect/therma-action-rule-decoder';
+
+@Controller('powermeter/three-phase/milesight')
+export class ThreePhaseMilesightController {
+    constructor(private readonly threePhaseMilesightService: ThreePhaseMilesightService) {}
+    @Get()
+    async getDeviceList(
+        @Query() queryParams: DeviceListParamsDto,
+    ): Promise<{ message: string; result: AWSListThings }> {
+        const { maxResult, nextToken } = queryParams;
+        const result = await this.threePhaseMilesightService.getDeviceList(
+            maxResult,
+            nextToken,
+        );
+        if (!result) {
+            throw new HttpException(
+                'Error occured',
+                HttpStatus.INTERNAL_SERVER_ERROR,
+            );
+        }
+        return {
+            message: 'Retrieved three-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.threePhaseMilesightService.rebootDevice(
+            deviceEui,
+            serialNumber ? serialNumber : deviceEui,
+        );
+        if (!result) {
+            throw new HttpException(
+                `Error occurred rebooting three-phase device: ${deviceEui}`,
+                HttpStatus.INTERNAL_SERVER_ERROR,
+            );
+        }
+        return {
+            message: `Successfully sent reboot command for three-phase device ${deviceEui}.`,
+            result,
+        };
+    }
+
+    @Post('interval')
+    @UsePipes(new ValidationPipe())
+    async setDeviceInterval(
+        @Body() body: MilesightSetIntervalDto,
+    ): Promise<{ message: string; result: boolean }> {
+        const { deviceEui, serialNumber, interval } = body;
+        const result = await this.threePhaseMilesightService.setDeviceInterval(
+            deviceEui,
+            serialNumber ? serialNumber : deviceEui,
+            interval,
+        );
+        if (!result) {
+            throw new HttpException(
+                `Error occurred setting interval for three-phase device: ${deviceEui}`,
+                HttpStatus.INTERNAL_SERVER_ERROR,
+            );
+        }
+        return {
+            message: `Successfully sent set device interval command for three-phase device ${deviceEui}.`,
+            result,
+        };
+    }
+}

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

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

package/src/service/three-phase-milesight.service.spec.ts

@@ -0,0 +1,228 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { Logger } from '@nestjs/common';
+import { DownlinkService } from './downlink.service';
+import { ThreePhaseMilesightService } from './three-phase-milesight.service';
+ 
+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('ThreePhaseMilesightService', () => {
+    let threePhaseMilesightService: ThreePhaseMilesightService;
+    let downlinkService: DownlinkService;
+    let module: TestingModule;
+    const mockSendDownlink = jest.fn();
+    const mockLogger = {
+        error: jest.fn(),
+        log: jest.fn(),
+        warn: jest.fn(),
+        debug: jest.fn(),
+        verbose: jest.fn(),
+    };
+
+    beforeEach(async () => {
+        module = await Test.createTestingModule({
+            providers: [
+                {
+                    provide: DownlinkService,
+                    useValue: {
+                        sendDownlink: mockSendDownlink,
+                    },
+                },
+                {
+                    provide: Logger,
+                    useValue: mockLogger,
+                },
+                ThreePhaseMilesightService,
+            ],
+        }).compile();
+
+        threePhaseMilesightService = module.get<ThreePhaseMilesightService>(ThreePhaseMilesightService);
+        downlinkService = module.get<DownlinkService>(DownlinkService);
+    });
+
+    afterEach(async () => {
+        jest.clearAllMocks();
+        mockLogger.error.mockClear();
+    });
+
+    afterAll(async () => {
+        if (module) {
+            await module.close();
+        }
+    });
+
+    describe('getDeviceList', () => {
+        it('should return three-phase 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/three-phase-device',
+                        thingName: 'three-phase-device',
+                        thingTypeName: 'three-phase-powermeter-milesight',
+                        version: 1,
+                    },
+                ],
+            };
+            mockGetListDevices.mockResolvedValue(expectedResult);
+
+            const result = await threePhaseMilesightService.getDeviceList(MaxResult);
+
+            expect(mockGetListDevices).toHaveBeenCalledWith(
+                'three-phase-powermeter-milesight',
+                MaxResult,
+                undefined
+            );
+            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 threePhaseMilesightService.getDeviceList(MaxResult);
+            expect(response).toBeNull();
+            mockGetListDevices.mockClear();
+        });
+    });
+
+    describe('rebootDevice', () => {
+        const data = {
+            deviceEui: 'sampleThreePhaseDeviceEui',
+            serialNumber: 'sampleThreePhaseDeviceName',
+        };
+
+        it('should return true when downlink is successful', async () => {
+            const expectedDownlinkCommand = 'ff10ff';
+            const sendDownlinkSpy = jest
+                .spyOn(downlinkService, 'sendDownlink')
+                .mockResolvedValue(true);
+            
+            const result = await threePhaseMilesightService.rebootDevice(
+                data.deviceEui,
+                data.serialNumber,
+            );
+
+            expect(sendDownlinkSpy).toHaveBeenCalledWith(
+                data.deviceEui,
+                data.serialNumber,
+                expectedDownlinkCommand,
+                'threePhaseMilesightRebootDevice',
+                85,
+                true,
+            );
+            expect(result).toBe(true);
+            sendDownlinkSpy.mockClear();
+        });
+
+        it('should return null when downlink fails', async () => {
+            const sendDownlinkSpy = jest
+                .spyOn(downlinkService, 'sendDownlink')
+                .mockRejectedValue(new Error('Downlink error'));
+            
+            const result = await threePhaseMilesightService.rebootDevice(
+                data.deviceEui,
+                data.serialNumber,
+            );
+
+            expect(result).toBeNull();
+            sendDownlinkSpy.mockClear();
+        });
+    });
+
+    describe('setDeviceInterval', () => {
+        const data = {
+            deviceEui: 'sampleThreePhaseDeviceEui',
+            serialNumber: 'sampleThreePhaseDeviceName',
+            interval: 1440,
+        };
+
+        it('should return true when downlink is successful', async () => {
+            const expectedDownlinkCommand = 'ff8e0005a0'; // 1440 minutes in hex
+            const sendDownlinkSpy = jest
+                .spyOn(downlinkService, 'sendDownlink')
+                .mockResolvedValue(true);
+            
+            const result = await threePhaseMilesightService.setDeviceInterval(
+                data.deviceEui,
+                data.serialNumber,
+                data.interval,
+            );
+
+            expect(sendDownlinkSpy).toHaveBeenCalledWith(
+                data.deviceEui,
+                data.serialNumber,
+                expectedDownlinkCommand,
+                'threePhaseMilesightSetDeviceInterval',
+                85,
+                true,
+            );
+            expect(result).toBe(true);
+            sendDownlinkSpy.mockClear();
+        });
+
+        it('should return null when downlink fails', async () => {
+            const sendDownlinkSpy = jest
+                .spyOn(downlinkService, 'sendDownlink')
+                .mockRejectedValue(new Error('Downlink error'));
+            
+            const result = await threePhaseMilesightService.setDeviceInterval(
+                data.deviceEui,
+                data.serialNumber,
+                data.interval,
+            );
+
+            expect(result).toBeNull();
+            sendDownlinkSpy.mockClear();
+        });
+
+        it('should correctly convert different intervals to hex', async () => {
+            const sendDownlinkSpy = jest
+                .spyOn(downlinkService, 'sendDownlink')
+                .mockResolvedValue(true);
+
+            // Test interval of 60 minutes (0x003c in hex)
+            await threePhaseMilesightService.setDeviceInterval(
+                data.deviceEui,
+                data.serialNumber,
+                60,
+            );
+
+            expect(sendDownlinkSpy).toHaveBeenCalledWith(
+                data.deviceEui,
+                data.serialNumber,
+                'ff8e00003c',
+                'threePhaseMilesightSetDeviceInterval',
+                85,
+                true,
+            );
+
+            sendDownlinkSpy.mockClear();
+        });
+    });
+});

package/src/service/three-phase-milesight.service.ts

@@ -0,0 +1,97 @@
+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 ThreePhaseMilesightService {
+    private readonly logger: Logger;
+    private readonly awsIotAPI: AWSIotAPI;
+
+    constructor(
+        @Inject(DownlinkService)
+        private readonly downlinkService: DownlinkService,
+    ) {
+        this.logger = new Logger(ThreePhaseMilesightService.name);
+        this.awsIotAPI = new AWSIotAPI(config.get('aws'));
+    }
+
+    async getDeviceList(
+        maxResult: number,
+        nextToken?: string,
+    ): Promise<AWSListThings | null> {
+        try {
+            this.logger.log('Retrieving three-phase devices list');
+            const result = await this.awsIotAPI.getListThingsByType(
+                config.get('threePhaseThingType'),
+                maxResult,
+                nextToken,
+            );
+            return result;
+        } catch (error) {
+            this.logger.error(
+                `Error retrieving three-phase devices list details: ${error}`,
+            );
+            return null;
+        }
+    }
+
+    async rebootDevice(
+        deviceEui: string,
+        serialNumber: string,
+    ): Promise<boolean | null> {
+        try {
+            this.logger.log(`Rebooting three-phase device: ${deviceEui}`);
+            const rebootDownlinkCommand = 'ff10ff';
+            const response = await this.downlinkService.sendDownlink(
+                deviceEui,
+                serialNumber,
+                rebootDownlinkCommand,
+                'threePhaseMilesightRebootDevice',
+                fPort,
+                true,
+            );
+            this.logger.log(`Successfully rebooted three-phase device ${deviceEui}`);
+            return response;
+        } catch (error) {
+            this.logger.error(`Error rebooting three-phase device ${deviceEui}: ${error}`);
+            return null;
+        }
+    }
+
+    async setDeviceInterval(
+        deviceEui: string,
+        serialNumber: string,
+        interval: number,
+    ): Promise<boolean | null> {
+        try {
+            this.logger.log(
+                `Setting ${interval} minutes interval for three-phase device: ${deviceEui}`,
+            );
+            const hexString = interval.toString(16).padStart(4, '0');
+            const downlinkCommand = 'ff8e00' + hexString;
+            const response = await this.downlinkService.sendDownlink(
+                deviceEui,
+                serialNumber,
+                downlinkCommand,
+                'threePhaseMilesightSetDeviceInterval',
+                fPort,
+                true,
+            );
+            this.logger.log(
+                `Successfully set device interval for three-phase device ${deviceEui}`,
+            );
+            return response;
+        } catch (error) {
+            this.logger.error(
+                `Error setting device interval for three-phase device ${deviceEui}: ${error}`,
+            );
+            return null;
+        }
+    }
+}

package/timestamp.sh

@@ -1 +1 @@
-export DT=20240923034156
+export DT=20250702031942