Merge pull request #8 from BuidlGuidl/staging

Merge Staging to Master

packages/backend/controllers/Admin.ts

@@ -3,9 +3,10 @@ import Invites from "../models/Invites";
 import bcrypt from "bcrypt";
 import { Request, Response } from "express";
 import jwt from "jsonwebtoken";
-import { JWT_SECRET } from "../backend.config";
 import { ably } from "..";
 
+const JWT_SECRET = process.env.JWT_SECRET || "superhardstring";
+
 async function generateUniqueInvite(length: number) {
   let invites = await Invites.findOne();
 
@@ -40,7 +41,7 @@ async function generateUniqueInvite(length: number) {
 
 export const createGame = async (req: Request, res: Response) => {
   try {
-    const { maxPlayers, diceCount, hiddenChars, privateKey, prize, mode, adminAddress } = req.body;
+    const { diceCount, hiddenChars, privateKey, hiddenPrivateKey, mode, adminAddress } = req.body;
 
     const salt = await bcrypt.genSalt();
     // const privateKeyHash = await bcrypt.hash(privateKey, salt);
@@ -49,12 +50,11 @@ export const createGame = async (req: Request, res: Response) => {
       adminAddress,
       status: "ongoing",
       inviteCode: await generateUniqueInvite(8),
-      maxPlayers,
       diceCount,
       mode,
       privateKey,
+      hiddenPrivateKey,
       hiddenChars,
-      prize,
     });
 
     let token;
@@ -68,6 +68,36 @@ export const createGame = async (req: Request, res: Response) => {
   }
 };
 
+export const restartWithNewPk = async (req: Request, res: Response) => {
+  try {
+    const { diceCount, hiddenChars, privateKey, hiddenPrivateKey, adminAddress } = req.body;
+    const { id } = req.params;
+    const game = await Game.findById(id);
+
+    if (game?.status !== "finished") {
+      return res.status(400).json({ error: "Game is not finished." });
+    }
+
+    game.diceCount = diceCount;
+    game.hiddenChars = hiddenChars;
+    game.privateKey = privateKey;
+    game.hiddenPrivateKey = hiddenPrivateKey;
+    game.mode = "manual";
+    game.adminAddress = adminAddress;
+    game.winner = undefined;
+    game.status = "ongoing";
+
+    const updatedGame = await game.save();
+    console.log(updatedGame);
+
+    const channel = ably.channels.get(`gameUpdate`);
+    channel.publish(`gameUpdate`, updatedGame);
+    res.status(200).json(updatedGame);
+  } catch (err) {
+    res.status(500).json({ error: (err as Error).message });
+  }
+};
+
 export const pauseGame = async (req: Request, res: Response) => {
   try {
     const { id } = req.params;
@@ -167,7 +197,7 @@ export const changeGameMode = async (req: Request, res: Response) => {
     //   return res.status(400).json({ error: "Game is not paused." });
     // }
 
-    if (mode !== "auto" && mode !== "manual") {
+    if (mode !== "auto" && mode !== "manual" && mode !== "brute") {
       return res.status(400).json({ error: "Invalid game mode." });
     }
 
@@ -184,30 +214,6 @@ export const changeGameMode = async (req: Request, res: Response) => {
   }
 };
 
-export const changePrize = async (req: Request, res: Response) => {
-  try {
-    const { gameId } = req.params;
-    const { newPrize } = req.body;
-
-    const game = await Game.findById(gameId);
-
-    if (!game) {
-      return res.status(404).json({ error: "Game not found." });
-    }
-
-    if (game.status !== "ongoing") {
-      return res.status(400).json({ error: "Game is not ongoing." });
-    }
-
-    game.prize = newPrize;
-    const updatedGame = await game.save();
-
-    res.status(200).json(updatedGame);
-  } catch (err) {
-    res.status(500).json({ error: (err as Error).message });
-  }
-};
-
 export const kickPlayer = async (req: Request, res: Response) => {
   try {
     const { id } = req.params;

packages/backend/controllers/Player.ts

@@ -18,10 +18,6 @@ export const join = async (req: Request, res: Response) => {
       return res.status(400).json({ error: "Game is not ongoing." });
     }
 
-    if (game.players.length >= game.maxPlayers) {
-      return res.status(400).json({ error: "Game is full." });
-    }
-
     if (game.players.includes(playerAddress)) {
       return res.status(200).json(game); // Player is already in the game
     }
@@ -32,7 +28,7 @@ export const join = async (req: Request, res: Response) => {
 
     game.players.push(playerAddress);
     const savedGame = await game.save();
-    
+
     const channel = ably.channels.get(`gameUpdate`);
     channel.publish(`gameUpdate`, savedGame);
     res.status(200).json({ token, game: savedGame });

packages/backend/index.ts

@@ -32,7 +32,9 @@ app.use(helmet.crossOriginResourcePolicy({ policy: "cross-origin" }));
 app.use(morgan("common"));
 app.use(bodyParser.json({ limit: "30mb" }));
 app.use(bodyParser.urlencoded({ limit: "30mb", extended: true }));
-app.use(cors());
+app.use(
+  cors(),
+);
 
 /**Ably Setup */
 

packages/backend/models/Game.ts

@@ -15,12 +15,6 @@ const gameSchema = new mongoose.Schema(
       type: String,
       required: true,
     },
-    maxPlayers: {
-      type: Number,
-      required: true,
-      min: 5,
-      max: 30,
-    },
     diceCount: {
       type: Number,
       required: true,
@@ -29,27 +23,26 @@ const gameSchema = new mongoose.Schema(
     },
     mode: {
       type: String,
-      enum: ["auto", "manual"],
+      enum: ["auto", "manual", "brute"],
       required: true,
     },
     privateKey: {
       type: String,
       required: true,
     },
+    hiddenPrivateKey: {
+      type: String,
+      required: false,
+    },
     hiddenChars: {
       type: Object,
       required: true,
     },
-    prize: {
-      type: Number,
-      required: true,
-    },
     players: {
       type: [String],
       default: [],
       validate: {
         validator: function (value: [string]) {
-          // Check if the array only contains unique strings
           const uniqueStrings: string[] = [];
           value.forEach(item => {
             if (!uniqueStrings.includes(item)) {
@@ -58,7 +51,7 @@ const gameSchema = new mongoose.Schema(
           });
           return uniqueStrings.length === value.length;
         },
-        message: "The players array must contain unique strings.",
+        message: "The players array must contain unique addresses.",
       },
     },
     winner: {

packages/backend/models/Player.ts

@@ -34,10 +34,6 @@ const playerSchema = new mongoose.Schema(
       key: String,
       value: String,
     },
-    prize: {
-      type: Number,
-      required: true,
-    },
   },
   { timestamps: true },
 );

packages/backend/package.json

@@ -2,7 +2,8 @@
   "name": "@se-2/backend",
   "version": "0.0.1",
   "scripts": {
-    "backend": "ts-node index.ts"
+    "backend": "ts-node index.ts",
+    "start": "ts-node index.ts"
   },
   "dependencies": {
     "ably": "^1.2.45",

packages/backend/routes/admin.ts

@@ -1,5 +1,5 @@
 import express from "express";
-import { createGame, changeGameMode, pauseGame, resumeGame, kickPlayer } from "../controllers/Admin";
+import { createGame, changeGameMode, pauseGame, resumeGame, kickPlayer, restartWithNewPk } from "../controllers/Admin";
 import { verifyToken } from "../middleware/auth";
 
 const router = express.Router();
@@ -9,5 +9,6 @@ router.patch("/changemode/:id", verifyToken, changeGameMode);
 router.patch("/pause/:id", verifyToken, pauseGame);
 router.patch("/resume/:id", verifyToken, resumeGame);
 router.patch("/kickplayer/:id", verifyToken, kickPlayer);
+router.patch("/restartwithnewpk/:id", verifyToken, restartWithNewPk);
 
 export default router;

packages/backend/vercel.json

@@ -0,0 +1,6 @@
+{
+  "version": 2,
+  "name": "dice-demonstration-backend",
+  "builds": [{ "src": "index.ts", "use": "@vercel/node" }],
+  "routes": [{ "src": "/(.*)", "dest": "/index.ts" }]
+}