check

src/backend/Components/GameCoordinator/GameCoordinator.ts

@@ -3,6 +3,7 @@ import { TGameCoordinator, TPGameCoordinator } from "./RPCInterface";
 import { FrontworkComponent } from "../../Types/FrontworkComponent";
 import { IGameCoordinator } from "./Interface";
 import { IUserManager } from "../UserManager/Interface";
+import { User } from "../../Types/Types";
 
 @Injectable(IGameCoordinator)
 export class GameCoordinator
@@ -10,7 +11,14 @@ export class GameCoordinator
     name = "GameCoordinator" as "GameCoordinator"
 
     @Inject(IUserManager)
-    private userManager : IUserManager
+    private userManager: IUserManager
+
+    private queue: {
+        [sessionToken in string]: {
+            user: User,
+            callback: Function
+        }
+    }
 
     RPCs: () => [
     ]
@@ -18,15 +26,24 @@ export class GameCoordinator
     RPCFeatures = () => [
     ]
 
-    getTableDefinitions(){
+    getTableDefinitions() {
         return []
     }
 
-    findMatch = (sessionToken, gameOptions) => {
+    findMatch = async (sessionToken, gameOptions, callback) => {
+        const [username, record] = this.userManager.getUserRecordByToken(sessionToken)
+        if (!username || !record) throw new Error("Bad session")
 
+        const user = await this.userManager.getUser(username)
+        if (!user) throw new Error("Unknown user")
+
+        this.queue[sessionToken] = {
+            callback: callback,
+            user: user
+        }
     }
 
-    joinMatch = (sessionToken, gameToken, deckOptions) => {
-        
+    joinMatch = (sessionToken, gameToken, deckOptions, callback) => {
+
     }
 }

src/backend/Components/UserManager/Interface.ts

@@ -7,7 +7,7 @@ export class IUserManager{
     setPermission: (perm: RPCPermission) => Promise<void>
     getPermissions: () => Promise<RPCPermission[]>
     checkToken: (token: string, rank: Rank) => boolean
-    getUserRecordByToken: (tokenValue: string) => [string, UserRecord] | void
+    getUserRecordByToken: (tokenValue: string) => [string, UserRecord]
     getUser: (username: string) => Promise<User | void>
     adminLogout: (username: string) => Promise<void>
     changeRank: (user:User, rank: Rank) => Promise<User>

src/backend/Components/UserManager/UserManager.ts

@@ -132,14 +132,14 @@ export class UserManager
                     }
                     try {
                         //If no ADMIN user exists next created user will be made ADMIN
-                        if(this.checkForAdmin){
-                            const admin:User = await this.knexModule
-                            .knex('users')
-                            .where(<SomeOf<User>>{
-                                rank: 'ADMIN'
-                            }).first()
-                            
-                            if(!admin){
+                        if (this.checkForAdmin) {
+                            const admin: User = await this.knexModule
+                                .knex('users')
+                                .where(<SomeOf<User>>{
+                                    rank: 'ADMIN'
+                                }).first()
+
+                            if (!admin) {
                                 user.rank = 'ADMIN'
                             }
                             this.checkForAdmin = false
@@ -182,10 +182,11 @@ export class UserManager
 
         await Promise.all(
             [...this.admin.frontworkComponents].flatMap(exp => exp.RPCFeatures().map(async (feature) => {
-                try {
-                    await this.knexModule.knex.insert({ rpcname: feature.name }).into('rpcpermissions')
-                } catch (e) {
-                }
+                    await this.knexModule
+                    .knex('rpcpermissions')
+                    .insert(<SomeOf<RPCPermission>>{ 
+                        rpcname: feature.name 
+                    })
             })))
 
         this.privilegedServer = await this.startRankServer()
@@ -212,6 +213,7 @@ export class UserManager
 
         let user: User, token: Token
         try {
+            //@ts-ignore
             [user, token] = await Promise.race([socket.call('getUserData'), new Promise((res, rej) => { setTimeout(rej, 250); })])
         } catch (e) {
             getLogger('UserManager#checkConnection').debug('Client didn\'t respond', e)
@@ -244,9 +246,12 @@ export class UserManager
 
     adminChangePassword = async (username: string, pwHash: string): Promise<User> => {
         const salted = await saltedHash(pwHash, salt)
-        await this.knexModule.knex('users')
-            .update({ pwhash: salted })
-            .where({
+        await this.knexModule
+            .knex('users')
+            .update(<SomeOf<User>>{
+                pwhash: salted
+            })
+            .where(<SomeOf<User>>{
                 username: username.toLowerCase()
             })
 
@@ -258,7 +263,9 @@ export class UserManager
 
     setPermission = async (permission: RPCPermission) => {
         await this.knexModule.knex('rpcpermissions')
-            .where('rpcname', '=', permission.rpcname)
+            .where(<SomeOf<RPCPermission>>{
+                rpcname: permission.rpcname
+            })
             .update(permission)
 
         await Promise.all(
@@ -276,7 +283,9 @@ export class UserManager
         const perm: RPCPermission = await this.knexModule.knex
             .select(rank)
             .from('rpcpermissions')
-            .where('rpcname', '=', <string>feature)
+            .where(<SomeOf<RPCPermission>>{
+                rpcname: feature
+            })
             .first()
 
         if (!perm) return false
@@ -312,9 +321,7 @@ export class UserManager
                         //getLogger('UserManager#adminLogout#kick').debug(String(e))
                     }
                 })
-                this.allowed = this.allowed.filter(allowed => {
-                    return allowed != token
-                })
+                this.allowed = this.allowed.filter(allowed => allowed != token)
                 delete this.userConnections[username]
             }
         } catch (e) {
@@ -342,9 +349,7 @@ export class UserManager
         throw new Error('login failed')
     }
 
-    getUserRecordByToken(tokenValue: string) {
-        return Object.entries(this.userConnections).find(([k, v]) => v.token.value === tokenValue)
-    }
+    getUserRecordByToken = (tokenValue: string) : [string, UserRecord] => Object.entries(this.userConnections).find(([k, v]) => v.token.value === tokenValue)
 
     getToken = (tokenValue: string): Token | void => {
         const [username, userRecord] = this.getUserRecordByToken(tokenValue)

test/backendTest.ts

@@ -1,7 +1,7 @@
 import { ConnectedSocket, RPCSocket } from "rpclibrary"
 import { Injector } from "../src/backend/Injector/Injector"
 import { FrontworkAdmin } from "../src/backend/Admin/Admin"
-import { TTiles, TPTiles, User, Token } from "../src/backend/Types/Types"
+import { TTiles, TPTiles } from "../src/backend/Types/Types"
 import { IPubSub } from "../src/backend/Components/PubSub/Interface"
 import { PubSub } from "../src/backend/Components/PubSub/PubSub"
 import { EMAIL_VERIFY_SUCCESS, SIGNUP_SUCCESS } from "../src/backend/Types/Strings"
@@ -21,7 +21,7 @@ describe('Frontcraft', () => {
 
     let client: ConnectedSocket<TTiles>
     let server: FrontworkAdmin
-    let privClient: ConnectedSocket<TPTiles>
+    let adminClient: ConnectedSocket<TPTiles>
 
     before(done => {
         server = Injector.resolve<FrontworkAdmin>(FrontworkAdmin)
@@ -105,7 +105,7 @@ describe('Frontcraft', () => {
             new RPCSocket<TPTiles>(8080, "localhost", {
                 path: "/managed"
             }).connect(token.value).then(connectedSocket => {
-                privClient = connectedSocket
+                adminClient = connectedSocket
                 connectedSocket.hook('getUserData', () => [user, token])
                 done()
             }).catch(done)