Swap to loginId instead of game handle

packages/bridge-server/migrations/20240204112812-race-login-id.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  async up (queryInterface, Sequelize) {
+    /**
+     * Add altering commands here.
+     *
+     * Example:
+     * await queryInterface.createTable('users', { id: Sequelize.INTEGER });
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.addColumn(
+        'Racers',
+        'loginId',
+        {
+          type: Sequelize.STRING,
+        },
+        { transaction }
+      );
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  },
+
+  async down (queryInterface, Sequelize) {
+    /**
+     * Add reverting commands here.
+     *
+     * Example:
+     * await queryInterface.dropTable('users');
+     */
+    const transaction = await queryInterface.sequelize.transaction();
+    try {
+      await queryInterface.removeColumn('Racers', 'loginId', { transaction });
+      await transaction.commit();
+    } catch (err) {
+      await transaction.rollback();
+      throw err;
+    }
+  }
+};

packages/bridge-server/models/racer.js

@@ -16,7 +16,8 @@ module.exports = (sequelize, DataTypes) => {
   Racer.init({
     name: DataTypes.STRING,
     gameHandle: DataTypes.STRING,
-    userId: DataTypes.STRING
+    userId: DataTypes.STRING,
+    loginId: DataTypes.STRING,
   }, {
     sequelize,
     modelName: 'Racer',

packages/bridge-server/src/racers/racer.model.ts

@@ -10,6 +10,9 @@ export class Racer extends Model {
     @Column
     gameHandle: string;
 
+    @Column
+    loginId: string;
+
     @HasMany(() => RaceResult)
     results: RaceResult[];
 

packages/bridge-server/src/racers/racers.service.ts

@@ -12,16 +12,16 @@ export class RacersService {
     )
     {}
 
-    async findOne(gameHandle: string) {
+    async findOne(loginId: string) {
-        return this.racerModel.findOne({ where: {gameHandle: gameHandle} });
+        return this.racerModel.findOne({ where: {loginId: loginId} });
     }
 
-    async findOrCreate(gameHandle: string): Promise<Racer> {
+    async findOrCreate(loginId: string): Promise<Racer> {
         try {
             return this.sequelize.transaction( async t => {
                 return this.racerModel.findOrCreate({
                     where: {
-                        gameHandle: gameHandle
+                        loginId: loginId
                     },
                     transaction: t
                   }).then((value) => {
@@ -32,4 +32,19 @@ export class RacersService {
             console.log(error);
         }
     }
+
+    async updateGameHandle(loginId: string, newGameHandle: string) {
+        try {
+            await this.sequelize.transaction( async t => {
+                const transactionHost = { transaction: t };
+                let target_racer = await this.racerModel.findOne(
+                  { where: {loginId: loginId} }
+                );
+                target_racer.gameHandle = newGameHandle;
+                target_racer.save();
+            });
+          } catch (error) {
+      
+          }
+    }
 }

packages/bridge-server/src/upload/upload.service.ts

@@ -39,7 +39,7 @@ export class UploadService {
         let replay = new gbxReplay();
         replay.parse(buff);
 
-        return await this.racersService.findOne(replay.gamerHandle);
+        return await this.racersService.findOne(replay.login);
     }
 
     async replayUploaded(file: Express.Multer.File, body: any) {
@@ -71,7 +71,11 @@ export class UploadService {
         let replay = new gbxReplay();
         replay.parse(buff);
 
-        let currentRacer = await this.racersService.findOrCreate(replay.gamerHandle);
+        let currentRacer = await this.racersService.findOrCreate(replay.login);
+
+        if(currentRacer.gameHandle != replay.gamerHandle) {
+            this.racersService.updateGameHandle(replay.login, replay.gamerHandle);
+        }
 
         let race = await this.racesService.findOneBySeasonAndMapUID(body.seasonId, replay.mapUID)
 
@@ -89,8 +93,6 @@ export class UploadService {
 
         if(body.fileTime < race.startDate.getTime()) {
             throw new NotAcceptableException('EarlyReplay', {cause: new Error(), description: 'Replay generated before the race started.'})
-            console.log("Race Too Soon!")
-            return;
         }
         
         await this.raceResultsService.create(race.id, currentRacer.id, replay.bestTime, file.path, file_hash);