Create GET all maze actions endpoint (#48)

Author: pfeifferjack

src/@types/hackthelab.d.ts

@@ -222,6 +222,34 @@ declare module "hackthelab" {
     score: number;
   }
 
+  interface UserActions {
+    userId: number;
+    userName: string;
+    actions: ACtion[];
+  }
+
+  /**
+   * @swagger
+   * components:
+   *   schemas:
+   *     AllActionResponseItem:
+   *       type: object
+   *       properties:
+   *         userId:
+   *           type: string
+   *         userName:
+   *           type: string
+   *         actions:
+   *           type: array
+   *           items:
+   *             $ref: '#/components/schemas/Action'
+   *         score:
+   *           type: number
+   */
+  interface AllActionResponseItem extends UserActions {
+    score: number;
+  }
+
   /**
    * @swagger
    * components:

src/controllers/maze-controller/getActions.ts

@@ -1,5 +1,5 @@
 import { ActionsResponse, MazeRequest } from "hackthelab";
-import { MazeService } from "services";
+import { MazeService, ScoreService } from "services";
 import { asyncHandler } from "utils";
 import { rethrowOrCreateError } from "utils/create-error";
 import { matchedData, param } from "utils/custom-validator";
@@ -48,7 +48,7 @@ const getActions = asyncHandler(async (req, res) => {
 
   try {
     const actions = await MazeService.getActions(data.userId, maze.id);
-    const score = MazeService.getScore(data.userId, maze, actions);
+    const score = ScoreService.calculateScore(actions);
 
     const response: ActionsResponse = {
       actions,

src/controllers/maze-controller/getAllActions.ts

@@ -0,0 +1,50 @@
+import { AllActionResponseItem, MazeRequest } from "hackthelab";
+import { MazeService, ScoreService } from "services";
+import { asyncHandler } from "utils";
+import { rethrowOrCreateError } from "utils/create-error";
+
+/**
+ * @swagger
+ * /v1/maze/{mazeId}/actions:
+ *   get:
+ *     tags: [Maze (ADMIN)]
+ *     summary: Returns recorded actions and a maze.
+ *     parameters:
+ *       - $ref: '#/components/parameters/MazeRequestPathBase'
+ *     responses:
+ *       200:
+ *         description: Actions successful
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 $ref: '#/components/schemas/AllActionResponseItem'
+ *       400:
+ *         $ref: '#/components/responses/BadRequest'
+ *       401:
+ *         $ref: '#/components/responses/Unauthorized'
+ *       403:
+ *         $ref: '#/components/responses/Forbidden'
+ *       500:
+ *         $ref: '#/components/responses/ServerError'
+ */
+const getAllActions = asyncHandler(async (req, res) => {
+  const { maze } = req as MazeRequest;
+
+  try {
+    const actions = await MazeService.getAllActions(maze.id);
+
+    const response: AllActionResponseItem[] = actions.map(user => ({
+      ...user,
+      score: ScoreService.calculateScore(user.actions),
+    }));
+
+    res.status(200).json(response);
+  } catch (e) {
+    console.error(e);
+    throw rethrowOrCreateError(e, 500, "Server Error", "An error occurred while trying to fetch actions.");
+  }
+});
+
+export default getAllActions;

src/controllers/maze-controller/maze-controller.ts

@@ -3,6 +3,7 @@ import { Router } from "express";
 import { hasRole, mazePathSchema, resolveMaze, validate } from "middleware/interceptors";
 import { Controller } from "../index";
 import getActions, { actionsSchema } from "./getActions";
+import getAllActions from "./getAllActions";
 import getMaze from "./getMaze";
 import getMazes, { mazesSchema } from "./getMazes";
 import putMaze, { mazeUpdateSchema } from "./putMaze";
@@ -23,6 +24,7 @@ export class MazeController implements Controller {
     const mazeMiddleware = [validate(mazePathSchema), resolveMaze];
 
     router.put("/maze/:mazeId", hasRole(Role.Developer), validate(mazeUpdateSchema), mazeMiddleware, putMaze);
+    router.get("/maze/:mazeId/actions", hasRole(Role.Admin), ...mazeMiddleware, getAllActions);
     router.get("/maze/:mazeId/actions/:userId", hasRole(Role.Admin), ...mazeMiddleware, validate(actionsSchema), getActions);
     router.get("/maze/:mazeId", hasRole(Role.Developer), ...mazeMiddleware, getMaze);
     router.get("/mazes", validate(mazesSchema), getMazes);

src/controllers/rat-controller/getActions.ts

@@ -1,5 +1,5 @@
 import { ActionsResponse, MazeRequest } from "hackthelab";
-import { MazeService } from "services";
+import { MazeService, ScoreService } from "services";
 import { asyncHandler, rethrowOrCreateError } from "utils";
 
 /**
@@ -31,7 +31,7 @@ const getActions = asyncHandler(async (req, res) => {
 
   try {
     const actions = await MazeService.getActions(user.id, maze.id);
-    const score = MazeService.getScore(user.id, maze, actions);
+    const score = ScoreService.calculateScore(actions);
 
     const response: ActionsResponse = {
       actions,

src/data/repository/action-repository.ts

@@ -1,11 +1,27 @@
 import { ActionType } from "@enums";
 import { pgQuery } from "data/db";
-import { Action, Coordinate } from "hackthelab";
+import { Action, Coordinate, UserActions } from "hackthelab";
 
-export const getAll = (userId: number, mazeId: string): Promise<Action[]> => {
+export const getAllForUserMaze = (userId: number, mazeId: string): Promise<Action[]> => {
   return pgQuery("SELECT * FROM actions WHERE user_id = $1 AND maze_id = $2 ORDER BY time_ts DESC", [userId, mazeId]);
 };
 
+export const GetAllForMaze = (mazeId: string): Promise<UserActions[]> => {
+  return pgQuery(
+    `
+SELECT a.user_id,
+       u.name                           AS user_name,
+       JSON_AGG(a.* ORDER BY a.time_ts) AS actions
+FROM actions a
+         JOIN users u
+              ON a.user_id = u.id
+WHERE a.maze_id = $1
+GROUP BY a.user_id, u.name;
+        `,
+    [mazeId],
+  );
+};
+
 export const deleteForUserMaze = async (userId: number, mazeId: string): Promise<void> => {
   await pgQuery("DELETE FROM actions WHERE user_id = $1 AND maze_id = $2", [userId, mazeId]);
 };

src/services/maze-service.ts

@@ -1,14 +1,18 @@
-import { ActionType, Environment } from "@enums";
+import { Environment } from "@enums";
 import { ActionRepository, MazeRepository } from "data/repository";
-import { Action, AdminCell, AdminMaze, Coordinate, Maze, MazeDictionary } from "hackthelab";
+import { Action, AdminCell, AdminMaze, Coordinate, Maze, MazeDictionary, UserActions } from "hackthelab";
 
 const mazeStore: { [key in Environment]: MazeDictionary } = {
   [Environment.Competition]: {},
   [Environment.Sandbox]: {},
 };
 
 export const getActions = (userId: number, mazeId: string): Promise<Action[]> => {
-  return ActionRepository.getAll(userId, mazeId);
+  return ActionRepository.getAllForUserMaze(userId, mazeId);
+};
+
+export const getAllActions = async (mazeId: string): Promise<UserActions[]> => {
+  return ActionRepository.GetAllForMaze(mazeId);
 };
 
 export const getMazes = async (): Promise<MazeDictionary> => {
@@ -63,53 +67,3 @@ export const setLocked = async (mazeId: string, locked: boolean): Promise<void>
 export const isLocked = async (mazeId: string): Promise<boolean> => {
   return (await getMazeById(mazeId)).locked;
 };
-
-export const getScore = (userId: number, maze: Maze, actions: Action[]): number => {
-  const EXIT_BONUS = 5000;
-  const CHEESE_BONUS = 1000;
-  const HARVEST_BONUS = 2500;
-  const MOVE_PENALTY = 2;
-  const ACTION_PENALTY = 1;
-
-  // Get the maze open spaces
-  // const openSpaceCount = maze.cells.length - wallCount.length;
-
-  // Get stats based on the rat's actions
-  const numOfActions = actions.length;
-
-  let numOfMoves = 0;
-  let numOfCheeseEaten = 0;
-  let numOfCheeseHarvested = 0;
-  let didExit = false;
-
-  actions.forEach(action => {
-    if (action.success) {
-      switch (action.actionType) {
-        case ActionType.Move:
-          numOfMoves++;
-          break;
-        case ActionType.Eat:
-          numOfCheeseEaten++;
-          break;
-        case ActionType.Exit:
-          didExit = true;
-          break;
-        case ActionType.Drop:
-          numOfCheeseHarvested++;
-          break;
-      }
-    }
-  });
-
-  // Calculate the score
-  const exitBonus = didExit ? EXIT_BONUS : 0;
-  const cheeseBonus = numOfCheeseEaten * CHEESE_BONUS;
-  const harvestBonus = numOfCheeseHarvested * HARVEST_BONUS;
-  const actionPenalty = numOfActions * ACTION_PENALTY;
-  const movePenalty = numOfMoves * MOVE_PENALTY;
-
-  const netScore = exitBonus + cheeseBonus + harvestBonus - (actionPenalty + movePenalty);
-
-  // Add up everything, but don't let the score go below 0.
-  return Math.max(0, netScore);
-};

src/services/score-service.ts

@@ -1,24 +1,22 @@
-import { ActionType, CellType, Environment, Role } from "@enums";
+import { ActionType, Environment, Role } from "@enums";
 import { pgQuery } from "data/db";
 import { UserRepository } from "data/repository";
-import { Action, Award, Maze, RankingResult, Score } from "hackthelab";
+import { Action, Award, RankingResult, Score } from "hackthelab";
 import { MazeService, ScoreService } from "services";
 
-export const getScore = (userId: number, maze: Maze, actions: Action[]): number => {
-  const MOVE_EFFICIENCY_BONUS = 2500;
+export const calculateScore = (actions: Action[]): number => {
   const EXIT_BONUS = 5000;
   const CHEESE_BONUS = 1000;
+  const HARVEST_BONUS = 2500;
+  const MOVE_PENALTY = 2;
   const ACTION_PENALTY = 1;
 
-  // Get the maze open spaces
-  const wallCount = maze.cells.filter(cell => cell.type === CellType.Wall);
-  const openSpaceCount = maze.cells.length - wallCount.length;
-
   // Get stats based on the rat's actions
   const numOfActions = actions.length;
 
   let numOfMoves = 0;
   let numOfCheeseEaten = 0;
+  let numOfCheeseHarvested = 0;
   let didExit = false;
 
   actions.forEach(action => {
@@ -33,18 +31,28 @@ export const getScore = (userId: number, maze: Maze, actions: Action[]): number
         case ActionType.Exit:
           didExit = true;
           break;
+        case ActionType.Drop:
+          numOfCheeseHarvested++;
+          break;
       }
     }
   });
 
   // Calculate the score
   const exitBonus = didExit ? EXIT_BONUS : 0;
-  const moveEfficiencyBonus = didExit ? Math.max(0, ((openSpaceCount - numOfMoves) / openSpaceCount) * MOVE_EFFICIENCY_BONUS) : 0;
   const cheeseBonus = numOfCheeseEaten * CHEESE_BONUS;
+  const harvestBonus = numOfCheeseHarvested * HARVEST_BONUS;
   const actionPenalty = numOfActions * ACTION_PENALTY;
+  const movePenalty = numOfMoves * MOVE_PENALTY;
+
+  const bonuses = exitBonus + cheeseBonus + harvestBonus;
+  const penalties = actionPenalty + movePenalty;
+
+  // Calculate the net score
+  const netScore = bonuses - penalties;
 
   // Add up everything, but don't let the score go below 0.
-  return Math.floor(Math.max(0, exitBonus + moveEfficiencyBonus + cheeseBonus - actionPenalty));
+  return Math.max(0, netScore);
 };
 
 // Returns the rankings for all participants for the given maze ids
@@ -72,7 +80,7 @@ export const getRankings = async (environment: Environment): Promise<RankingResu
       }
 
       const actions = await MazeService.getActions(userId, mazeId);
-      const score = ScoreService.getScore(userId, mazes[mazeId], actions);
+      const score = ScoreService.calculateScore(actions);
 
       totalScore += score;
     }