S25/teresa/matchmaking endpoints

backend/typescript/rest/petRoutes.ts

@@ -11,9 +11,13 @@ import {
   NotFoundError,
 } from "../utilities/errorUtils";
 import { sendResponseByMimeType } from "../utilities/responseUtil";
+import IUserService from "../services/interfaces/userService";
+import UserService from "../services/implementations/userService";
+import { UserDTO } from "../types";
 
 const petRouter: Router = Router();
 const petService: IPetService = new PetService();
+const userService: IUserService = new UserService();
 
 /* Update Pet by id */
 petRouter.put("/:id", petRequestDtoValidators, async (req, res) => {
@@ -140,4 +144,29 @@ petRouter.get("/:id", async (req, res) => {
   }
 });
 
+petRouter.get("/match/pets/:userId", async (req, res) => {
+  const { userId } = req.params;
+
+  if (userId) {
+    if (typeof userId !== "string") {
+      res
+        .status(400)
+        .json({ error: "userId query parameter must be a string." });
+    } else if (Number.isNaN(Number(userId))) {
+      res.status(400).json({ error: "Invalid user ID" });
+    } else {
+      try {
+        const user: UserDTO = await userService.getUserById(userId);
+        await petService.getMatchingPetsForUser(user.colorLevel);
+      } catch (error: unknown) {
+        if (error instanceof NotFoundError) {
+          res.status(400).json({ error: getErrorMessage(error) });
+        } else {
+          res.status(500).json({ error: getErrorMessage(error) });
+        }
+      }
+    }
+  }
+});
+
 export default petRouter;

backend/typescript/rest/userRoutes.ts

@@ -19,12 +19,15 @@ import {
   INTERNAL_SERVER_ERROR_MESSAGE,
 } from "../utilities/errorUtils";
 import { sendResponseByMimeType } from "../utilities/responseUtil";
+import { IPetService, PetResponseDTO } from "../services/interfaces/petService";
+import PetService from "../services/implementations/petService";
 
 const userRouter: Router = Router();
 
 const userService: IUserService = new UserService();
 const emailService: IEmailService = new EmailService(nodemailerConfig);
 const authService: IAuthService = new AuthService(userService, emailService);
+const petService: IPetService = new PetService();
 
 /* Get all users, optionally filter by a userId or email query parameter to retrieve a single user */
 userRouter.get("/", async (req, res) => {
@@ -325,4 +328,29 @@ userRouter.delete("/", async (req, res) => {
     .json({ error: "Must supply one of userId or email as query parameter." });
 });
 
+userRouter.get("/match/users/:petId", async (req, res) => {
+  const { petId } = req.params;
+
+  if (petId) {
+    if (typeof petId !== "string") {
+      res
+        .status(400)
+        .json({ error: "petId query parameter must be a string." });
+    } else if (Number.isNaN(Number(petId))) {
+      res.status(400).json({ error: "Invalid pet ID" });
+    } else {
+      try {
+        const pet: PetResponseDTO = await petService.getPet(petId);
+        await userService.getMatchingUsersForPet(pet.colorLevel);
+      } catch (error: unknown) {
+        if (error instanceof NotFoundError) {
+          res.status(400).json({ error: getErrorMessage(error) });
+        } else {
+          res.status(500).json({ error: getErrorMessage(error) });
+        }
+      }
+    }
+  }
+});
+
 export default userRouter;

backend/typescript/services/implementations/petService.ts

@@ -1,4 +1,4 @@
-import { Transaction } from "sequelize";
+import { Transaction, Op } from "sequelize";
 import PgPet from "../../models/pet.model";
 // import PgTask from "../../models/task.model";
 // import PgTaskTemplate from "../../models/taskTemplate.model";
@@ -14,13 +14,13 @@ import {
 import { getErrorMessage, NotFoundError } from "../../utilities/errorUtils";
 import logger from "../../utilities/logger";
 import { sequelize } from "../../models";
-// import TaskTemplate from "../../models/taskTemplate.model";
-// import { Role } from "../../types";
+// import ActivityType from "../../models/activityType.model";
 
 const Logger = logger(__filename);
 
 class PetService implements IPetService {
   /* eslint-disable class-methods-use-this */
+
   getAgeFromBirthday(birthday: string): number {
     const parsedBirthday = Date.parse(birthday);
     const currentDate = new Date();
@@ -314,6 +314,46 @@ class PetService implements IPetService {
     }
     return id;
   }
+
+  async getMatchingPetsForUser(
+    userColorLevel: number,
+  ): Promise<PetResponseDTO[]> {
+    try {
+      const matchingPets = await PgPet.findAll({
+        where: {
+          color_level: {
+            [Op.lte]: userColorLevel,
+          },
+        },
+      });
+
+      return matchingPets.map((pet) => ({
+        id: pet.id,
+        name: pet.name,
+        animalTag: pet.animal_tag,
+        colorLevel: pet.color_level,
+        status: pet.status,
+        breed: pet.breed,
+        age: pet.birthday ? this.getAgeFromBirthday(pet.birthday) : undefined,
+        weight: pet.weight,
+        sex: pet.sex,
+        photo: pet.photo,
+        careInfo: {
+          id: pet.petCareInfo?.id,
+          safetyInfo: pet.petCareInfo?.safety_info,
+          medicalInfo: pet.petCareInfo?.medical_info,
+          managementInfo: pet.petCareInfo?.management_info,
+        },
+      }));
+    } catch (error) {
+      Logger.error(
+        `Failed to get matching pets for user. Reason = ${getErrorMessage(
+          error,
+        )}`,
+      );
+      throw error;
+    }
+  }
 }
 
 export default PetService;

backend/typescript/services/implementations/userService.ts

@@ -441,6 +441,23 @@ class UserService implements IUserService {
       throw error;
     }
   }
+
+  async getMatchingUsersForPet(petColorLevel: number): Promise<UserDTO[]> {
+    try {
+      const allUsers = await this.getUsers();
+
+      return allUsers.filter(
+        (user: UserDTO) => user.colorLevel >= petColorLevel,
+      );
+    } catch (error) {
+      Logger.error(
+        `Failed to get matching users for pet. Reason = ${getErrorMessage(
+          error,
+        )}`,
+      );
+      throw error;
+    }
+  }
 }
 
 export default UserService;

backend/typescript/services/interfaces/matchmakingService.ts

@@ -0,0 +1,8 @@
+import { PetResponseDTO } from "./petService";
+import { UserDTO } from "../../types";
+
+export interface IMatchmakingService {
+  /* eslint-disable class-methods-use-this */
+  getMatchingPetsForUser(userId: string): Promise<PetResponseDTO[]>;
+  getMatchingUsersForPet(petId: string): Promise<UserDTO[]>;
+}

backend/typescript/services/interfaces/petService.ts

@@ -97,6 +97,14 @@ export interface IPetService {
    */
   deletePet(id: string): Promise<string>;
 
+  /**
+   * get all users in which the pet can be taken care of
+   * @param userColorLevel user's color level
+   * @returns list of pets
+   * @throws Error if matching fails
+   */
+  getMatchingPetsForUser(userColorLevel: number): Promise<PetResponseDTO[]>;
+
   /**
    * retrieve all Pets that match given filter criteria
    * @param query Pet queries

backend/typescript/services/interfaces/userService.ts

@@ -79,6 +79,14 @@ interface IUserService {
    * @throws Error if user deletion fails
    */
   deleteUserByEmail(email: string): Promise<void>;
+
+  /**
+   * Get all pets that a user can take care of
+   * @param petColorLevel pet's color level
+   * @returns list of users
+   * @throws Error if failed to get matching pets
+   */
+  getMatchingUsersForPet(petColorLevel: number): Promise<UserDTO[]>;
 }
 
 export default IUserService;