[ADD] Lametric without cache

BliTz037 · BliTz037 · commit d4b604135cba · 2024-10-26T14:10:47.000+02:00
diff --git a/src/app.module.ts b/src/app.module.ts
@@ -5,9 +5,10 @@ import { MinecraftModule } from './minecraft/minecraft.module';
 import { SourceModule } from './source/source.module';
 import { FivemModule } from './fivem/fivem.module';
 import { LoggerMiddleware } from 'src/middleware/logger.middleware';
+import { LametricModule } from './lametric/lametric.module';
 
 @Module({
-  imports: [MinecraftModule, SourceModule, FivemModule],
+  imports: [MinecraftModule, SourceModule, FivemModule, LametricModule],
   controllers: [AppController],
   providers: [AppService],
 })
diff --git a/src/fivem/fivem.module.ts b/src/fivem/fivem.module.ts
@@ -6,6 +6,7 @@ import { CacheModule } from '@nestjs/cache-manager';
 @Module({
   imports: [CacheModule.register()],
   controllers: [FivemController],
-  providers: [FivemService]
+  providers: [FivemService],
+  exports: [FivemService]
 })
 export class FivemModule {}
diff --git a/src/lametric/dto/lametricFrameDto.ts b/src/lametric/dto/lametricFrameDto.ts
@@ -0,0 +1,17 @@
+import { ApiProperty, getSchemaPath } from "@nestjs/swagger";
+import FrameGoalDto from "./lametricFrameGoalDto";
+import FrameSparklineDto from "./lametricFrameSparklineDto";
+import FrameTextDto from "./lametricFrameTextDto";
+
+export default class LametricFrameDto {    
+    @ApiProperty({
+        description: "Frames to display on the LaMetric device",
+        type: 'array',
+        items: { oneOf: [
+            { $ref: getSchemaPath(FrameTextDto) },
+            { $ref: getSchemaPath(FrameGoalDto) },
+            { $ref: getSchemaPath(FrameSparklineDto) }
+        ]}
+    })
+    frames: (FrameTextDto | FrameGoalDto | FrameSparklineDto)[];
+}
diff --git a/src/lametric/dto/lametricFrameGoalDto.ts b/src/lametric/dto/lametricFrameGoalDto.ts
@@ -0,0 +1,21 @@
+import { ApiProperty } from "@nestjs/swagger";
+import GoalData from "./lametricGoalData";
+
+export default class LametricFrameGoalDto {
+    constructor(goalData: GoalData, icon: string) {
+        this.goalData = goalData;
+        this.icon = icon;
+    }
+
+    @ApiProperty({
+        description: "Goal data",
+        type: GoalData
+    })
+    goalData: GoalData;
+
+    @ApiProperty({
+        description: "Icon to display",
+        example: "7285"
+    })
+    icon: string;
+}
diff --git a/src/lametric/dto/lametricFrameSparklineDto.ts b/src/lametric/dto/lametricFrameSparklineDto.ts
@@ -0,0 +1,20 @@
+import { ApiProperty } from "@nestjs/swagger";
+
+export default class LametricFrameSparklineDto {
+    constructor(index: number, chartData: number[]) {
+        this.index = index;
+        this.chartData = chartData;
+    }
+
+    @ApiProperty({
+        description: "Chart index",
+        example: 0
+    })
+    index: number;
+    
+    @ApiProperty({
+        description: "Chart data",
+        example: [1, 2, 3, 4, 5]
+    })
+    chartData: number[];
+}
diff --git a/src/lametric/dto/lametricFrameTextDto.ts b/src/lametric/dto/lametricFrameTextDto.ts
@@ -0,0 +1,20 @@
+import { ApiProperty } from "@nestjs/swagger";
+
+export default class LametricFrameTextDto {
+    constructor(text: string, icon: string) {
+        this.text = text;
+        this.icon = icon;
+    }
+
+    @ApiProperty({
+        description: "Text to display",
+        example: "Hypixel"
+    })
+    text: string;
+
+    @ApiProperty({
+        description: "Icon to display",
+        example: "7285"
+    })
+    icon: string;
+}
diff --git a/src/lametric/dto/lametricGoalData.ts b/src/lametric/dto/lametricGoalData.ts
@@ -0,0 +1,34 @@
+import { ApiProperty } from "@nestjs/swagger";
+
+export default class LametricGoalData {
+    constructor(current: number, start: number, end: number, unit: string, duration: number, progress: number, direction: string) {
+         this.current = current;
+         this.start = start;
+         this.end = end;
+         this.unit = unit;
+    }
+
+    @ApiProperty({
+        description: "Current value",
+        example: 100
+    })
+    current: number;
+
+    @ApiProperty({
+        description: "Start value",
+        example: 0
+    })
+    start: number;
+
+    @ApiProperty({
+        description: "End value",
+        example: 100
+    })
+    end: number;
+
+    @ApiProperty({
+        description: "Unit",
+        example: "players"
+    })
+    unit: string;
+}
diff --git a/src/lametric/dto/lametricServerCheckedDto.ts b/src/lametric/dto/lametricServerCheckedDto.ts
@@ -0,0 +1,45 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsEnum, IsNotEmpty, IsOptional, IsString } from 'class-validator';
+import { LametricServerTypeParams } from 'src/utils/enums';
+
+export default class LametricServerCheckedDto {
+  @ApiProperty({
+    description: 'Name of game server',
+    example: 'Hypixel',
+  })
+  @IsNotEmpty()
+  @IsString()
+  name: string;
+
+  @ApiProperty({
+    description: 'Type of game server',
+    example: LametricServerTypeParams.Minecraft,
+    enum: [
+      LametricServerTypeParams.Minecraft,
+      LametricServerTypeParams.MinecraftBedrock,
+      LametricServerTypeParams.Source,
+      LametricServerTypeParams.FiveM,
+      LametricServerTypeParams.FiveMByCfxCode,
+    ],
+  })
+  @IsNotEmpty()
+  @IsString()
+  @IsEnum(LametricServerTypeParams)
+  type: LametricServerTypeParams;
+
+  @ApiProperty({
+    description: "Server's address",
+    example: 'mc.hypixel.net',
+  })
+  @IsNotEmpty()
+  @IsString()
+  address: string;
+
+  @ApiProperty({
+    description: 'Enable sparkline',
+    enum: ['true', 'false'],
+  })
+  @IsOptional()
+  @IsString()
+  sparkline: string = 'false';
+}
diff --git a/src/lametric/filter/lametricRequestIncomplete.filter.ts b/src/lametric/filter/lametricRequestIncomplete.filter.ts
@@ -0,0 +1,16 @@
+import { ArgumentsHost, BadRequestException, Catch, Logger } from "@nestjs/common";
+import LametricFrameTextDto from "../dto/lametricFrameTextDto";
+
+@Catch(BadRequestException)
+export default class LametricRequestIncompleteFilter {
+    catch(exception: BadRequestException, host: ArgumentsHost) {
+        Logger.warn("The request is incomplete, default response is sent.", exception.getResponse(), "RequestIncompleteFilter");
+        const response = host.switchToHttp().getResponse();
+        response.status(200)
+            .json({
+                "frames": [
+                    new LametricFrameTextDto("Please fill all fields in Lametric app.", "555")
+                ]
+            });
+    }
+}
diff --git a/src/lametric/lametric.controller.spec.ts b/src/lametric/lametric.controller.spec.ts
@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { LametricController } from './lametric.controller';
+
+describe('LametricController', () => {
+  let controller: LametricController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [LametricController],
+    }).compile();
+
+    controller = module.get<LametricController>(LametricController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});
diff --git a/src/lametric/lametric.controller.ts b/src/lametric/lametric.controller.ts
@@ -0,0 +1,43 @@
+import { Controller, Get, Query, UseFilters } from '@nestjs/common';
+import { ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { LametricService } from './lametric.service';
+import LametricServerCheckedDto from './dto/lametricServerCheckedDto';
+import LametricFrameDto from './dto/lametricFrameDto';
+import LametricRequestIncompleteFilter from './filter/lametricRequestIncomplete.filter';
+
+@ApiTags('Lametric')
+@Controller('lametric')
+export class LametricController {
+  constructor(private readonly lametricService: LametricService) {}
+
+  @Get()
+  @ApiOperation({
+    summary: 'Get number of player connected',
+    description:
+      'Return a JSON response which should be read by the lametric clock with :\n- The name of your server\n- The icon of game server\n- The number of player connected.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Response if the server is found and online',
+    schema: {
+      example: {
+        frames: [
+          {
+            text: 'Hypixel',
+            icon: '7285',
+          },
+          {
+            text: '47944 / 200000',
+            icon: '7285',
+          },
+        ],
+      },
+    },
+  })
+  @UseFilters(LametricRequestIncompleteFilter)
+  async trackServer(
+    @Query() serverChecked: LametricServerCheckedDto,
+  ): Promise<LametricFrameDto> {
+    return await this.lametricService.trackServer(serverChecked);
+  }
+}
diff --git a/src/lametric/lametric.module.ts b/src/lametric/lametric.module.ts
@@ -0,0 +1,12 @@
+import { Module } from '@nestjs/common';
+import { LametricController } from './lametric.controller';
+import { MinecraftModule } from 'src/minecraft/minecraft.module';
+import { SourceModule } from 'src/source/source.module';
+import { FivemModule } from 'src/fivem/fivem.module';
+import { LametricService } from './lametric.service';
+
+@Module({
+  imports: [MinecraftModule, SourceModule, FivemModule],  
+  controllers: [LametricController], providers: [LametricService]
+})
+export class LametricModule {}
diff --git a/src/lametric/lametric.service.spec.ts b/src/lametric/lametric.service.spec.ts
@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { LametricService } from './lametric.service';
+
+describe('LametricService', () => {
+  let service: LametricService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [LametricService],
+    }).compile();
+
+    service = module.get<LametricService>(LametricService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});
diff --git a/src/lametric/lametric.service.ts b/src/lametric/lametric.service.ts
@@ -0,0 +1,89 @@
+import { Injectable } from '@nestjs/common';
+import { FivemService } from 'src/fivem/fivem.service';
+import { MinecraftService } from 'src/minecraft/minecraft.service';
+import { SourceService } from 'src/source/source.service';
+import LametricFrameDto from './dto/lametricFrameDto';
+import LametricServerCheckedDto from './dto/lametricServerCheckedDto';
+import { LametricIconServer, LametricServerTypeParams } from 'src/utils/enums';
+import LametricFrameTextDto from './dto/lametricFrameTextDto';
+
+@Injectable()
+export class LametricService {
+  constructor(
+    private readonly minecraftService: MinecraftService,
+    private readonly sourceService: SourceService,
+    private readonly fivemService: FivemService,
+  ) {}
+
+  readonly actionDict: {
+    [id in LametricServerTypeParams]: (address: string) => Promise<any>;
+  } = {
+    Minecraft: (address: string) =>
+      this.minecraftService.trackServer({ address: address }),
+    MinecraftBedrock: (address: string) =>
+      this.minecraftService.trackBedrockServer({ address: address }),
+    Source: (address: string) =>
+      this.sourceService.trackServer({ address: address }),
+    FiveM: (address: string) =>
+      this.fivemService.trackServer({ address: address }),
+    FiveMCfxCode: (code: string) =>
+      this.fivemService.trackServerByCfx({ code: code }),
+  };
+
+  readonly serverIconDict: {
+    [serverType in LametricServerTypeParams]: LametricIconServer;
+  } = {
+    Minecraft: LametricIconServer.Minecraft,
+    MinecraftBedrock: LametricIconServer.Minecraft,
+    Source: LametricIconServer.Source,
+    FiveM: LametricIconServer.FiveM,
+    FiveMCfxCode: LametricIconServer.FiveM,
+  };
+
+  async trackServer(
+    serverChecked: LametricServerCheckedDto,
+  ): Promise<LametricFrameDto> {
+    const icon: LametricIconServer = this.serverIconDict[serverChecked.type];
+    const frame: LametricFrameDto = {
+      frames: [new LametricFrameTextDto(serverChecked.name, icon)],
+    };
+
+    let result = await this.actionDict[serverChecked.type](
+      serverChecked.address,
+    );
+    if (!result.online) {
+      frame.frames.push(new LametricFrameTextDto('OFFLINE', icon));
+      return frame;
+    }
+
+    switch (serverChecked.type) {
+      case LametricServerTypeParams.Minecraft:
+      case LametricServerTypeParams.MinecraftBedrock:
+      case LametricServerTypeParams.Source:
+        frame.frames.push(
+          new LametricFrameTextDto(
+            `${result.players.online} / ${result.players.max}`,
+            icon,
+          ),
+        );
+        break;
+      case LametricServerTypeParams.FiveM:
+        frame.frames.push(
+          new LametricFrameTextDto(
+            `${result.clients}/${result.Data.sv_maxclients}`,
+            icon,
+          ),
+        );
+        break;
+      case LametricServerTypeParams.FiveMByCfxCode:
+        frame.frames.push(
+          new LametricFrameTextDto(
+            `${result.Data.clients}/${result.Data.sv_maxclients}`,
+            icon,
+          ),
+        );
+        break;
+    }
+    return frame;
+  }
+}
diff --git a/src/minecraft/minecraft.module.ts b/src/minecraft/minecraft.module.ts
diff --git a/src/source/source.module.ts b/src/source/source.module.ts
diff --git a/src/utils/enums.ts b/src/utils/enums.ts
