Merge pull request #544 from SprocketBot/personal/gankoji/tmIntake

Add multi-game support for user intake

core/src/franchise/player/player.resolver.ts

@@ -65,6 +65,9 @@ export class IntakePlayerAccount {
 
 @Resolver(() => Player)
 export class PlayerResolver {
+
+    private readonly logger = new Logger(PlayerResolver.name);
+
     constructor(
         private readonly popService: PopulateService,
         private readonly playerService: PlayerService,
@@ -77,8 +80,6 @@ export class PlayerResolver {
         @Inject(forwardRef(() => OrganizationService)) private readonly organizationService: OrganizationService,
     ) {}
 
-    private readonly logger = new Logger(PlayerResolver.name);
-
     @ResolveField()
     async skillGroup(@Root() player: Player): Promise<GameSkillGroup> {
         return this.popService.populateOneOrFail(Player, player, "skillGroup");

core/src/franchise/player/player.service.ts

@@ -34,16 +34,14 @@ import {
     UserAuthenticationAccountType,
     UserProfile,
 } from "../../database";
-import type {
-    League,
-    ModePreference,
-    Timezone,
-} from "../../database/mledb";
 import {
+    League,
     LeagueOrdinals,
     MLE_Player,
     MLE_PlayerAccount,
+    ModePreference,
     Role,
+    Timezone,
 } from "../../database/mledb";
 import {PlayerToPlayer} from "../../database/mledb-bridge/player_to_player.model";
 import {PlayerToUser} from "../../database/mledb-bridge/player_to_user.model";
@@ -162,6 +160,7 @@ export class PlayerService {
         });
 
         await this.playerRepository.save(player);
+
         return player;
     }
 
@@ -294,17 +293,15 @@ export class PlayerService {
                 await runner.manager.save(member.profile);
                 await runner.manager.save(player);
                 await this.mle_createPlayer(
-                    user.id,
                     player.id,
-                    mleid,
                     discordId,
                     name,
-                    LeagueOrdinals[skillGroup.ordinal - 1],
                     salary,
+                    platforms,
+                    LeagueOrdinals[skillGroup.ordinal - 1],
                     platform,
                     timezone,
                     modePreference,
-                    platforms,
                     runner,
                 );
 
@@ -394,23 +391,20 @@ export class PlayerService {
     }
 
     async mle_createPlayer(
-        sprocketUserId: number,
         sprocketPlayerId: number,
-        mleid: number,
         discordId: string,
         name: string,
-        league: League,
         salary: number,
-        platform: string,
-        timezone: Timezone,
-        preference: ModePreference,
-        accounts: IntakePlayerAccount[],
+        accounts: IntakePlayerAccount[] = [],
+        league: League = League.FOUNDATION,
+        platform: string = "PC",
+        timezone: Timezone = Timezone.US_EAST,
+        preference: ModePreference = ModePreference.BOTH,
         runner?: QueryRunner,
     ): Promise<MLE_Player> {
         let player: MLE_Player = {
             createdBy: "Sprocket FA Intake",
             updatedBy: "Sprocket FA Intake",
-            mleid: mleid,
             name: name,
             salary: salary,
             league: league,
@@ -440,21 +434,14 @@ export class PlayerService {
             await this.mle_playerAccountRepository.save(playerAccounts);
         }
 
-        const ptuBridge = this.ptuRepo.create({
-            userId: sprocketUserId,
-            playerId: player.id,
-        });
-
         const ptpBridge = this.ptpRepo.create({
             sprocketPlayerId: sprocketPlayerId,
             mledPlayerId: player.id,
         });
 
         if (runner) {
-            await runner.manager.save(ptuBridge);
             await runner.manager.save(ptpBridge);
         } else {
-            await this.ptuRepo.save(ptuBridge);
             await this.ptpRepo.save(ptpBridge);
         }
 

core/src/franchise/player/player.types.ts

@@ -1,14 +1,26 @@
+import {
+    Field, Float, InputType,
+    Int,
+} from "@nestjs/graphql";
 import {z} from "zod";
 
 import {
     League, ModePreference, Timezone,
 } from "../../database/mledb";
-
 export interface GameAndOrganization {
     gameId: number;
     organizationId: number;
 }
 
+@InputType()
+export class CreatePlayerTuple {
+    @Field(() => Int)
+    gameSkillGroupId: number;
+
+    @Field(() => Float)
+    salary: number;
+}
+
 export const IntakeSchema = z.array(z.tuple([
     z.string(),
     z.string(),

core/src/identity/user/user.resolver.ts

@@ -5,12 +5,18 @@ import {
 import {JwtService} from "@nestjs/jwt";
 import {config} from "@sprocketbot/common";
 
-import type {UserAuthenticationAccount, UserProfile} from "../../database";
+import type {
+    UserAuthenticationAccount, UserProfile,
+} from "../../database";
 import {
     Member, User, UserAuthenticationAccountType,
 } from "../../database";
 import {MLE_OrganizationTeam} from "../../database/mledb";
+import {PlayerService} from "../../franchise";
+import {IntakePlayerAccount} from "../../franchise/player/player.resolver";
+import {CreatePlayerTuple} from "../../franchise/player/player.types";
 import {MLEOrganizationTeamGuard} from "../../mledb/mledb-player/mle-organization-team.guard";
+import {MemberService} from "../../organization";
 import {PopulateService} from "../../util/populate/populate.service";
 import type {AuthPayload} from "../auth";
 import {UserPayload} from "../auth";
@@ -19,13 +25,17 @@ import {GqlJwtGuard} from "../auth/gql-auth-guard";
 import {IdentityService} from "../identity.service";
 import {UserService} from "./user.service";
 
+const MLE_ORGANIZATION_ID = 2;
+
 @Resolver(() => User)
 export class UserResolver {
     private readonly logger = new Logger(UserResolver.name);
 
     constructor(
         private readonly identityService: IdentityService,
         private readonly userService: UserService,
+        private readonly memberService: MemberService,
+        private readonly playerService: PlayerService,
         private readonly popService: PopulateService,
         private readonly jwtService: JwtService,
     ) {}
@@ -103,4 +113,47 @@ export class UserResolver {
 
         return this.jwtService.sign(payload, {expiresIn: "5m"});
     }
+
+    @Mutation(() => [User])
+    @UseGuards(GqlJwtGuard, MLEOrganizationTeamGuard([MLE_OrganizationTeam.MLEDB_ADMIN, MLE_OrganizationTeam.LEAGUE_OPERATIONS]))
+    async intakeUser(
+        @Args("name", {type: () => String}) name: string,
+        @Args("discord_id", {type: () => String}) d_id: string,
+        @Args("playersToLink", {type: () => [CreatePlayerTuple]}) ptl: CreatePlayerTuple[],
+        @Args("platformAccounts", {type: () => [IntakePlayerAccount] }) platformAccounts: IntakePlayerAccount[] = [],
+    ): Promise<User> {
+        // This looks a little backwards, but the identity service actually
+        // creates the user object *and* the associated auth account for login
+        // at the same time.
+        const user = await this.identityService.registerUser(UserAuthenticationAccountType.DISCORD, d_id);
+
+        // Once we have the user, we can create the member as part of MLE
+        const member = await this.memberService.createMember(
+            {name: name},
+            MLE_ORGANIZATION_ID,
+            user.id,
+        );
+
+        // For each game this user is going to participate in, create
+        // the corresponding player
+        let pid: number = 0;
+        let sal: number = 0;
+        for (const pt of ptl) {
+            const player = await this.playerService.createPlayer(member.id, pt.gameSkillGroupId, pt.salary);
+            pid = player.id;
+            sal = pt.salary;
+        }
+
+        // Finally, create the corresponding MLE Player object
+        await this.playerService.mle_createPlayer(
+            pid,
+            d_id,
+            name,
+            sal,
+            platformAccounts,
+        );
+
+        // Send the newly created user back to the caller
+        return user;
+    }
 }

core/src/organization/member/member.service.ts

@@ -159,8 +159,8 @@ export class MemberService {
         return this.memberRepository.findOneOrFail({
             where: {
                 organizationId: organizationId,
-                userId: userId
-            }
-        })
+                userId: userId,
+            },
+        });
     }
 }