Featuer/xtg 274 - CRUD acheivements in admin panel (#35)

Author: fredericobraga85

src/api-utils/schemas/gameDev/acheivementsSchemas.ts

@@ -0,0 +1,32 @@
+import Joi from 'joi';
+
+export const getAcheivementByIdResponseSchema = Joi.object({
+  id: Joi.number().required(),
+  _gameTypeId: Joi.number().required(),
+  description: Joi.string().required(),
+  isEnabled: Joi.boolean().required(),
+  targetValue: Joi.number().required(),
+  createdAt: Joi.date().required(),
+  updatedAt: Joi.date().required(),
+}).optional();
+
+export const getAcheivementsResponseSchema = Joi.array()
+  .items(getAcheivementByIdResponseSchema)
+  .optional();
+
+export const postAcheivementRequestSchema = Joi.object({
+  id: Joi.number().optional(),
+  description: Joi.string().required(),
+  isEnabled: Joi.boolean().optional(),
+  targetValue: Joi.number().required(),
+}).required();
+
+export const postAcheivementResponseSchema = Joi.object({
+  id: Joi.number().required(),
+  _gameTypeId: Joi.number().required(),
+  description: Joi.string().required(),
+  isEnabled: Joi.boolean().required(),
+  targetValue: Joi.number().required(),
+  createdAt: Joi.date().required(),
+  updatedAt: Joi.date().required(),
+}).required();

src/models/Achievements.ts

@@ -33,8 +33,8 @@ interface AchievementCreationAttributes {
   description: string;
   isEnabled: boolean;
   targetValue: number;
-  createdAt: Date;
-  updatedAt: Date;
+  createdAt?: Date;
+  updatedAt?: Date;
   _gameTypeId: number;
 }
 
@@ -88,12 +88,11 @@ export class Achievement
   };
 }
 
-interface AchievementEditorData {
-  id: number;
+export interface AchievementEditorData {
+  id?: number;
   description: string;
   isEnabled: boolean;
   targetValue: number;
-  createdAt?: Date;
 }
 
 export function findAchievementById(id: number, transaction?: Transaction) {
@@ -104,25 +103,39 @@ export function findAllAchievementsByGameType(gameTypeId: number, transaction?:
   return Achievement.findAll({ where: { _gameTypeId: gameTypeId }, transaction });
 }
 
+export function getAcheivementByCreator(
+  id: number,
+  _gameTypeId: number,
+  _createdById: number,
+  transaction?: Transaction
+) {
+  return Achievement.findOne({
+    where: {
+      id,
+      _gameTypeId,
+    },
+    include: [
+      {
+        association: Achievement.associations._gameType,
+        attributes: [],
+        where: {
+          _createdById,
+        },
+      },
+    ],
+    transaction,
+  });
+}
+
 export async function createOrUpdateAchievement(
   achievementData: AchievementEditorData,
   gameTypeId: number,
   transaction?: Transaction
 ) {
-  const { id, description, isEnabled, targetValue, createdAt } = achievementData;
-  const valuesToUpdate: AchievementCreationAttributes = {
-    description,
-    isEnabled,
-    targetValue,
-    createdAt: createdAt ?? new Date(),
-    updatedAt: new Date(),
-    _gameTypeId: gameTypeId,
-  };
-
   return Achievement.upsert(
     {
-      id: id ?? undefined,
-      ...valuesToUpdate,
+      ...achievementData,
+      _gameTypeId: gameTypeId,
     },
     { transaction }
   );

src/models/GameType.ts

@@ -15,6 +15,7 @@ import {
 import type { GAME_TYPE } from '../games/consts/global';
 import { generateSecret } from '../utils/cryptography';
 
+import { Achievement } from './Achievements';
 import { LeaderboardEntry } from './LeaderboardEntry';
 
 import { User } from './';
@@ -71,9 +72,13 @@ export class GameType
   @HasMany(() => LeaderboardEntry, '_gameTypeId')
   _leaderboards?: LeaderboardEntry[];
 
+  @HasMany(() => Achievement, '_gameTypeId')
+  _acheivements?: Achievement[];
+
   static associations: {
     _createdBy: Association<GameType, User>;
     _leaderboards: Association<GameType, LeaderboardEntry>;
+    _acheivements: Association<GameType, Achievement>;
   };
 }
 
@@ -92,7 +97,7 @@ export function findGameTypeByClientSecret(clientSecret: string, transaction?: T
 export function findGameTypeById(id: number, transaction?: Transaction) {
   return GameType.findByPk(id, {
     transaction,
-    include: [GameType.associations._leaderboards],
+    include: [GameType.associations._leaderboards, GameType.associations._acheivements],
   });
 }
 

src/modules/gameDevs/gameDevHandlers.ts

@@ -3,6 +3,13 @@ import type { Lifecycle, Request, ResponseToolkit } from '@hapi/hapi';
 
 import type { CustomRequestThis } from '../../api-utils/interfaceAndTypes';
 import { arrayToJSON } from '../../api-utils/utils';
+import type { AchievementEditorData } from '../../models/Achievements';
+import {
+  findAllAchievementsByGameType,
+  getAcheivementByCreator,
+  createOrUpdateAchievement,
+  deleteAchievementById,
+} from '../../models/Achievements';
 import type { IGameEditorData, GameType } from '../../models/GameType';
 import {
   createOrUpdateGameType,
@@ -61,6 +68,8 @@ export const deleteGameTypeHandler: Lifecycle.Method = async (request, h) => {
 };
 
 export const getLeaderboardHandler: Lifecycle.Method = async (request, h) => {
+  await validateGameAuth(request.pre.getAuthUser.id, request.params.gameTypeId);
+
   if (request.params.leaderboardId) {
     const leaderboard = await getLeaderBoardByCreator(
       request.params.leaderboardId,
@@ -111,6 +120,53 @@ export const deleteLeaderboardHandler: Lifecycle.Method = async (request, h) =>
   return h.response({ success: true }).code(200);
 };
 
+export const getAcheivementsHandler: Lifecycle.Method = async (request, h) => {
+  await validateGameAuth(request.pre.getAuthUser.id, request.params.gameTypeId);
+
+  if (request.params.acheivementId) {
+    const acheivement = await getAcheivementByCreator(
+      request.params.acheivementId,
+      request.params.gameTypeId,
+      request.pre.getAuthUser.id
+    );
+
+    if (!acheivement) {
+      throw Boom.notFound('acheivement not found');
+    }
+
+    return h.response(acheivement?.toJSON()).code(200);
+  } else {
+    const acheivements = await findAllAchievementsByGameType(request.params.gameTypeId);
+    return h.response(arrayToJSON(acheivements)).code(200);
+  }
+};
+
+export const upsertAcheivementHandler: Lifecycle.Method = async (request, h) => {
+  const payload = request.payload as AchievementEditorData;
+
+  const game = await validateGameAuth(request.pre.getAuthUser.id, request.params.gameTypeId);
+
+  if (payload.id && game && !game._acheivements?.map((a) => a.id).includes(payload.id)) {
+    throw Boom.forbidden(`acheivement does not belong to gametypeId ${request.params.gameTypeId}`);
+  }
+
+  const [rslt] = await createOrUpdateAchievement({ ...payload }, request.params.gameTypeId);
+
+  return h.response(rslt?.toJSON()).code(200);
+};
+
+export const deleteAcheivementHandler: Lifecycle.Method = async (request, h) => {
+  await validateGameAuth(request.pre.getAuthUser.id, request.params.gameTypeId);
+
+  const rslt = await deleteAchievementById(request.params.acheivementId);
+
+  if (!rslt) {
+    throw Boom.notFound('acheivement not found');
+  }
+
+  return h.response({ success: true }).code(200);
+};
+
 const validateGameAuth = async (
   authUserId: number,
   gameTypeId?: number

src/modules/gameDevs/gameDevRoutes.ts

@@ -2,6 +2,12 @@ import type { ServerRoute } from '@hapi/hapi';
 
 import { getAuthUser } from '../../api-utils/getAuthUser';
 import { CAPABILITIES } from '../../api-utils/interfaceAndTypes';
+import {
+  getAcheivementByIdResponseSchema,
+  getAcheivementsResponseSchema,
+  postAcheivementRequestSchema,
+  postAcheivementResponseSchema,
+} from '../../api-utils/schemas/gameDev/acheivementsSchemas';
 import {
   gamedevGenericSchema,
   multipleGamesSchema,
@@ -21,6 +27,9 @@ import {
   getLeaderboardHandler,
   upsertLeaderboardHandler,
   deleteLeaderboardHandler,
+  getAcheivementsHandler,
+  upsertAcheivementHandler,
+  deleteAcheivementHandler,
 } from './gameDevHandlers';
 
 declare module '@hapi/hapi' {
@@ -211,6 +220,98 @@ export const upsertLeaderboardRoute: ServerRoute = {
   handler: upsertLeaderboardHandler,
 };
 
+//Acheivements
+export const getAcheivementsRoute: ServerRoute = {
+  method: 'GET',
+  path: '/dashboard/game-dev/games/{gameTypeId}/acheivements',
+  options: {
+    description: `Get game's acheivements`,
+    tags: ['api'],
+    bind: {
+      requiredCapabilities: [CAPABILITIES.GAMEDEV_ACTIONS],
+    },
+    pre: [
+      {
+        method: getAuthUser,
+        assign: 'getAuthUser',
+      },
+    ],
+    response: {
+      schema: getAcheivementsResponseSchema,
+    },
+  },
+  handler: getAcheivementsHandler,
+};
+
+export const getAcheivementsByIdRoute: ServerRoute = {
+  method: 'GET',
+  path: '/dashboard/game-dev/games/{gameTypeId}/acheivements/{acheivementId}',
+  options: {
+    description: `Get game's acheivements`,
+    tags: ['api'],
+    bind: {
+      requiredCapabilities: [CAPABILITIES.GAMEDEV_ACTIONS],
+    },
+    pre: [
+      {
+        method: getAuthUser,
+        assign: 'getAuthUser',
+      },
+    ],
+    response: {
+      schema: getAcheivementByIdResponseSchema,
+    },
+  },
+  handler: getAcheivementsHandler,
+};
+
+export const upsertAcheivementsRoute: ServerRoute = {
+  method: 'POST',
+  path: '/dashboard/game-dev/games/{gameTypeId}/acheivements',
+  options: {
+    description: `Add or update a game's acheivement`,
+    tags: ['api'],
+    bind: {
+      requiredCapabilities: [CAPABILITIES.GAMEDEV_ACTIONS],
+    },
+    pre: [
+      {
+        method: getAuthUser,
+        assign: 'getAuthUser',
+      },
+    ],
+    validate: {
+      payload: postAcheivementRequestSchema,
+    },
+    response: {
+      schema: postAcheivementResponseSchema,
+    },
+  },
+  handler: upsertAcheivementHandler,
+};
+
+export const deleteAcheivementsRoute: ServerRoute = {
+  method: 'DELETE',
+  path: '/dashboard/game-dev/games/{gameTypeId}/acheivements/{acheivementId}',
+  options: {
+    description: `Delete a game's acheivement`,
+    tags: ['api'],
+    bind: {
+      requiredCapabilities: [CAPABILITIES.GAMEDEV_ACTIONS],
+    },
+    pre: [
+      {
+        method: getAuthUser,
+        assign: 'getAuthUser',
+      },
+    ],
+    response: {
+      schema: gamedevGenericSchema,
+    },
+  },
+  handler: deleteAcheivementHandler,
+};
+
 export const gameDevRoutes: ServerRoute[] = [
   // 🎮 Games
   getGameTypesRoute,
@@ -221,4 +322,8 @@ export const gameDevRoutes: ServerRoute[] = [
   getLeaderboardByIdRoute,
   upsertLeaderboardRoute,
   deleteLeaderboardRoute,
+  getAcheivementsRoute,
+  getAcheivementsByIdRoute,
+  upsertAcheivementsRoute,
+  deleteAcheivementsRoute,
 ];