support for multiple versions in otps

Author: Alfagun74

src/modules/games/game-versions.controller.spec.ts

@@ -68,7 +68,12 @@ describe("GameVersionsController", () => {
         "bytes=0-999",
       );
 
-      expect(otpService.create).toHaveBeenCalledWith("testuser", 42, 1024);
+      expect(otpService.create).toHaveBeenCalledWith(
+        "testuser",
+        42,
+        7,
+        1024,
+      );
       expect(mockResponse.setHeader).toHaveBeenCalledWith("X-Otp", "mock-otp");
       expect(filesService.download).toHaveBeenCalledWith(
         mockResponse,

src/modules/games/game-versions.controller.ts

@@ -93,7 +93,12 @@ export class GameVersionsController {
   ): Promise<StreamableFile> {
     response.setHeader(
       "X-Otp",
-      this.otpService.create(request.user.username, gameId, Number(speedlimit)),
+      this.otpService.create(
+        request.user.username,
+        gameId,
+        versionId,
+        Number(speedlimit),
+      ),
     );
 
     return this.filesService.download(

src/modules/games/games.controller.spec.ts

@@ -155,7 +155,12 @@ describe("GamesController", () => {
         "bytes=0-999",
       );
 
-      expect(otpService.create).toHaveBeenCalledWith("testuser", 42, 1024);
+      expect(otpService.create).toHaveBeenCalledWith(
+        "testuser",
+        42,
+        undefined,
+        1024,
+      );
       expect(mockResponse.setHeader).toHaveBeenCalledWith("X-Otp", "mock-otp");
       expect(filesService.download).toHaveBeenCalledWith(
         mockResponse,

src/modules/games/games.controller.ts

@@ -392,6 +392,7 @@ export class GamesController {
       this.otpService.create(
         request.user.username,
         Number(params.game_id),
+        undefined,
         Number(speedlimit),
       ),
     );

src/modules/otp/models/otp.model.spec.ts

@@ -2,10 +2,11 @@ import Otp from "./otp.model";
 
 describe("Otp Model", () => {
   it("should create an OTP with all properties", () => {
-    const otp = new Otp("abc123", "testuser", 42, 1024);
+    const otp = new Otp("abc123", "testuser", 42, 7, 1024);
     expect(otp.otp).toBe("abc123");
     expect(otp.username).toBe("testuser");
     expect(otp.gameId).toBe(42);
+    expect(otp.versionId).toBe(7);
     expect(otp.xDownloadSpeedLimit).toBe(1024);
     expect(otp.createdAt).toBeInstanceOf(Date);
     expect(otp.expiresAt).toBeInstanceOf(Date);
@@ -28,16 +29,18 @@ describe("Otp Model", () => {
   it("should create an OTP without optional parameters", () => {
     const otp = new Otp("abc123", "testuser");
     expect(otp.gameId).toBeUndefined();
+    expect(otp.versionId).toBeUndefined();
     expect(otp.xDownloadSpeedLimit).toBeUndefined();
   });
 
   describe("getLoggableData", () => {
     it("should redact the OTP value", () => {
-      const otp = new Otp("secret-value", "testuser", 42, 1024);
+      const otp = new Otp("secret-value", "testuser", 42, 7, 1024);
       const loggable = otp.getLoggableData();
       expect(loggable.otp).toBe("**REDACTED**");
       expect(loggable.username).toBe("testuser");
       expect(loggable.gameId).toBe(42);
+      expect(loggable.versionId).toBe(7);
       expect(loggable.xDownloadSpeedLimit).toBe(1024);
       expect(loggable.createdAt).toBeInstanceOf(Date);
       expect(loggable.expiresAt).toBeInstanceOf(Date);

src/modules/otp/models/otp.model.ts

@@ -4,17 +4,20 @@ export default class Otp {
   createdAt: Date = new Date();
   expiresAt: Date = new Date(Date.now() + 5 * 60 * 1000); // 5 Minutes
   gameId?: number;
+  versionId?: number;
   xDownloadSpeedLimit?: number;
 
   constructor(
     otp: string,
     username: string,
     gameId?: number,
+    versionId?: number,
     xDownloadSpeedLimit?: number,
   ) {
     this.otp = otp;
     this.username = username;
     this.gameId = gameId;
+    this.versionId = versionId;
     this.xDownloadSpeedLimit = xDownloadSpeedLimit;
   }
 
@@ -25,6 +28,7 @@ export default class Otp {
       createdAt: this.createdAt,
       expiresAt: this.expiresAt,
       gameId: this.gameId,
+      versionId: this.versionId,
       xDownloadSpeedLimit: this.xDownloadSpeedLimit,
     };
   }

src/modules/otp/otp.service.spec.ts

@@ -16,7 +16,7 @@ describe("OtpService", () => {
 
   describe("create", () => {
     it("should create an OTP and return the token string", () => {
-      const result = service.create("testuser", 42, 1024);
+      const result = service.create("testuser", 42, 7, 1024);
       expect(result).toBeDefined();
       expect(typeof result).toBe("string");
       expect(result.length).toBeGreaterThan(0);
@@ -38,14 +38,17 @@ describe("OtpService", () => {
   describe("get", () => {
     it("should validate and consume a valid OTP", async () => {
       const mockResponse = { setHeader: jest.fn() } as any;
-      const otp = service.create("testuser", 42, 1024);
+      const otp = service.create("testuser", 42, 7, 1024);
       filesService.download.mockResolvedValue({} as any);
 
       await service.get(otp, mockResponse);
       expect(filesService.download).toHaveBeenCalledWith(
         mockResponse,
         42,
+        7,
         1024,
+        undefined,
+        undefined,
       );
     });
 
@@ -86,14 +89,34 @@ describe("OtpService", () => {
 
     it("should pass download speed limit to filesService", async () => {
       const mockResponse = { setHeader: jest.fn() } as any;
-      const otp = service.create("testuser", 99, 2048);
+      const otp = service.create("testuser", 99, undefined, 2048);
       filesService.download.mockResolvedValue({} as any);
 
       await service.get(otp, mockResponse);
       expect(filesService.download).toHaveBeenCalledWith(
         mockResponse,
         99,
+        undefined,
         2048,
+        undefined,
+        undefined,
+      );
+    });
+
+    it("should bind OTP download to the requested version id", async () => {
+      const mockResponse = { setHeader: jest.fn() } as any;
+      const otp = service.create("testuser", 101, 33, 4096);
+      filesService.download.mockResolvedValue({} as any);
+
+      await service.get(otp, mockResponse);
+
+      expect(filesService.download).toHaveBeenCalledWith(
+        mockResponse,
+        101,
+        33,
+        4096,
+        undefined,
+        undefined,
       );
     });
   });

src/modules/otp/otp.service.ts

@@ -30,10 +30,17 @@ export class OtpService {
   public create(
     username: string,
     gameId?: number,
+    versionId?: number,
     xDownloadSpeedLimit?: number,
   ): string {
     const randomOtp = randomBytes(64).toString("hex");
-    const otp = new Otp(randomOtp, username, gameId, xDownloadSpeedLimit);
+    const otp = new Otp(
+      randomOtp,
+      username,
+      gameId,
+      versionId,
+      xDownloadSpeedLimit,
+    );
     this.otps.set(randomOtp, otp);
     this.logger.log("OTP Created.", otp.getLoggableData());
     return randomOtp;
@@ -52,7 +59,10 @@ export class OtpService {
     return this.filesService.download(
       response,
       existingOtp.gameId,
+      existingOtp.versionId,
       existingOtp.xDownloadSpeedLimit,
+      undefined,
+      undefined,
     );
   }
 }