chore: update md files

ESPACO-LAZER-IAM.MD

@@ -17,22 +17,66 @@
     - 1: Da para fazer
     - 2: Tem que analisar
   - Users
-    - [] CheckUser (1)
+    - [ ] CheckUser (1)
-    - [] CreateUser (1)
+    - [ ] CreateUser (1)
-    - [] DeleteUser (1)
+    - [ ] DeleteUser (1)
-    - [] UpdateUser (1)
+    - [ ] UpdateUser (1)
-    - [] ListAllUsers **OPCIONAL**
+    - [ ] ResetPassword (1)
-    - [] LockUser (2)
+    - [ ] LockUser (2)
-    - [] UnlockUser (2)
+    - [ ] UnlockUser (2)
-    - [] ResetPassword (2)
+    - [ ] ListAllUsers **OPCIONAL**
   - Rights
-    - [] CheckUserRight (1)
+    - [ ] CheckUserRight (1)
-    - [] CreateRight (1)
+    - [ ] CreateRight (1)
-    - [] UpdateRight (1)
+    - [ ] UpdateRight (1)
-    - [] DeleteRight (1)
+    - [ ] DeleteRight (1)
-    - [] GetAllRights **OPCIONAL**
+    - [ ] GetAllRights **OPCIONAL**
   - Users X Rights
-    - [] LinkUserAndUserRight (1)
+    - [ ] LinkUserAndUserRight (1)
-    - [] UnlinkUserAndUserRight (1)
+    - [ ] UnlinkUserAndUserRight (1)
-    - [] GetAllUserRights **OPCIONAL**
+    - [ ] GetAllUserRights **OPCIONAL**
   
+# Atribuições
+
+- Henrriky
+  - [ ] Verify token middleware
+  - [X] CheckUser (1)
+      - [ ] Routes
+      - [X] Controller
+      - [X] Service
+      - [X] Error handling
+  - [X] CreateUser (1)
+      - [ ] Routes
+      - [X] Controller
+      - [X] Service
+      - [X] Error handling
+  - [X] DeleteUser (1)
+      - [ ] Routes
+      - [X] Controller
+      - [X] Service
+      - [X] Error handling
+  - [X] UpdateUser (1)
+      - [ ] Routes
+      - [X] Controller
+      - [X] Service
+      - [X] Error handling
+  - [X] ResetPassword (1)
+      - [ ] Routes
+      - [X] Controller
+      - [X] Service
+      - [X] Error handling
+  - [X] LinkUserAndUserRight (1)
+      - [ ] Routes
+      - [X] Controller
+      - [X] Service
+      - [X] Error handling
+  - [X] UnlinkUserAndUserRight (1)
+      - [ ] Routes
+      - [X] Controller
+      - [X] Service
+      - [X] Error handling
+  - [X] CheckUserRight (1)
+      - [ ] Routes
+      - [X] Controller
+      - [X] Service
+      - [X] Error handling

backend/src/controllers/IAMControllerEL.ts

@@ -24,291 +24,344 @@ import { splitDateTime } from "../helpers/SplitDateTime";
 import ListUserByWhatsappQueuesService from "../services/UserServices/ListUserByWhatsappQueuesService";
 import { getSettingValue } from "../helpers/WhaticketSettings";
 import { setBotInfo } from "../helpers/SetBotInfo";
+import { logger } from "../utils/logger";
+import ResetPasswordService from "../services/UserServices/ResetPassword";
+import CheckUserRightService from "../services/UserServices/CheckUserRightService";
+import UnlinkUserRightService from "../services/UserServices/UnlinkUserRight";
+import LinkUserRightService from "../services/UserServices/LinkUserRight";
 
-type IndexQuery = {
+interface IAMResponse {
-  searchParam: string;
+  return_code: string
-  pageNumber: string;
+  return_msg: string
-  profile?: string;
+}
-  userId: string;
+
+//TODO: REVIEW CREATE USER
+export const createUser = async (req: Request, res: Response<IAMResponse & { user_created: "1" | "0" }>): Promise<Response> => {
+  try {
+    const { user_id, user_first_name, user_tax_id } = req.body;
+    //user_id ou cria uma tabela nova ou um atributo novo
+    const user = await CreateUserService({
+      email: user_tax_id,
+      password: "padrao",
+      name: user_first_name,
+    });
+
+    if (user) {
+      const { id, name } = user;
+      await set(`user:${id}`, { id, name });
+    }
+
+    const io = getIO();
+    io.emit("user", {
+      action: "create",
+      user
+    });
+
+    await startWhoIsOnlineMonitor();
+
+    return res.status(204).json({
+      return_code: "204",
+      return_msg: `User ${user_id} created`,
+      user_created: "1"
+    });
+  } catch (error) {
+    if (error instanceof AppError) {
+      logger.warn(error);
+      return res.status(error.statusCode).json({
+        return_code: String(error.statusCode),
+        return_msg: error.message,
+        user_created: "0",
+      });
+    }
+
+    return res.status(500).json({
+      return_code: "500",
+      return_msg: "Internal server error",
+      user_created: "0",
+    });
+  }
 };
 
-export const index = async (req: Request, res: Response): Promise<Response> => {
+export const checkUser = async (req: Request, res: Response<IAMResponse & { user_exists: "1" | "0" }>): Promise<Response> => {
-  const { searchParam, pageNumber, profile } = req.query as IndexQuery;
+  try {
+    const { user_id } = req.body;
+    await ShowUserService(user_id);
+    return res.status(200).json({
+      return_code: "200",
+      return_msg: "",
+      user_exists: "1"
+    });
+  } catch (error) {
 
-  const { users, count, hasMore } = await ListUsersService({
+    if (error instanceof AppError) {
-    searchParam,
+      logger.warn(error);
-    pageNumber,
+      return res.status(error.statusCode).json({
-    profile
+        return_code: String(error.statusCode),
-  });
+        return_msg: error.message,
+        user_exists: "0",
+      });
+    }
 
-  if (req.user.profile !== "master") {
+    return res.status(500).json({
-    let auxUsers: Array<object> = [];
+      return_code: "500",
+      return_msg: "Internal server error",
+      user_exists: "0",
+    });
+  }
+};
 
-    // for (var user of users) {
+//TODO: REVIEW DELETE USER
-    //   if (user.profile !== 'master') {
+export const deleteUser = async (req: Request, res: Response<IAMResponse & { user_removed: "1" | "0" }>): Promise<Response> => {
-    //     auxUsers.push(user)
+  try {
+    const { user_id } = req.body;
+
+    await DeleteUserService(user_id);
+
+    del(`user:${user_id}`);
+
+    const io = getIO();
+    io.emit("user", {
+      action: "delete",
+      user_id
+    });
+
+    //test del
+    await stopWhoIsOnlineMonitor();
+
+    io.emit("onlineStatus", {
+      action: "delete",
+      userOnlineTime: user_id
+    });
+
+    await startWhoIsOnlineMonitor();
+    return res.status(200).json({
+      return_code: "200",
+      return_msg: `User ${user_id} deleted`,
+      user_removed: "1",
+    });
+
+  } catch (error) {
+    if (error instanceof AppError) {
+      logger.warn(error);
+      return res.status(error.statusCode).json({
+        return_code: String(error.statusCode),
+        return_msg: error.message,
+        user_removed: "0",
+      });
+    }
+
+    return res.status(500).json({
+      return_code: "500",
+      return_msg: "Internal server error",
+      user_removed: "0",
+    });
+  }
+};
+
+//TODO: REVIEW UPDATE USER
+export const updateUser = async (req: Request, res: Response<IAMResponse & { user_updated: "1" | "0" }>): Promise<Response> => {
+  try {
+    const { user_id, user_first_name, user_tax_id } = req.body;
+    // const dateToday = splitDateTime(new Date(format(new Date(), "yyyy-MM-dd HH:mm:ss", { locale: ptBR })));
+    // const currentDate = new Date();
+    // const tenMonthsAgo = subMonths(currentDate, 10);
+    // const formattedDate = format(tenMonthsAgo, "yyyy-MM-dd");
+    // console.log("dateToday.fullDate: ", dateToday.fullDate);
+    // console.log("formattedDate 10 months ago: ", formattedDate);
+
+    // const openByUserOnQueue: any[] = await CountTicketsByUserQueue({
+    //   startDate: formattedDate,
+    //   endDate: dateToday.fullDate,
+    //   status: "open",
+    //   clientChatStart: true,
+    //   userId: userId
+    // });
+    // let userQueuesAttendance = [];
+
+    // if ((openByUserOnQueue && openByUserOnQueue.length) > 0) {
+    //   userQueuesAttendance = openByUserOnQueue.filter(
+    //     (e: any) => !userData.queueIds.includes(e.queueId)
+    //   );
+
+    //   if (userQueuesAttendance && userQueuesAttendance.length > 0) {
+    //     const queueInAttendance = userQueuesAttendance.map(e => e.queueId);
+    //     const mergedSet = new Set([...userData.queueIds, ...queueInAttendance]);
+
+    //     userData.queueIds = Array.from(mergedSet);
     //   }
     // }
+    const userData = {
+      email: user_tax_id,
+      name: user_first_name,
+    }
+    // email?: string;
+    // name?: string;
+    // password?: string;
+    // positionCompany?: string;
+    // profile?: string;
+    // queueIds?: number[];
+    let user: any = await UpdateUserService({ userData, userId: user_id });
+    await setBotInfo(user);
 
-    for (var user of users) {
+    if (user) {
-      if (user.profile !== "master") {
+      const { id, name } = user;
-        if (req.user.profile == "supervisor" && user.profile == "admin")
+      await set(`user:${id}`, { id, name });
-          continue;
-
-        auxUsers.push(user);
-      }
     }
 
-    return res.json({ users: auxUsers, count, hasMore });
+    const io = getIO();
-  }
+    io.emit("user", {
-
+      action: "update",
-  return res.json({ users, count, hasMore });
+      user
-
-  //   const { users, count, hasMore } = await ListUsersService({
-  //     searchParam,
-  //     pageNumber
-  //   });
-
-  //   if(req.user.profile!=='master'){
-
-  //     let auxUsers: Array<object>  = [];
-
-  //     for (var user of users) {
-  //       if(user.profile!=='master'){
-  //         auxUsers.push(user)
-  //       }
-  //     }
-
-  //     return res.json({ users: auxUsers, count, hasMore });
-  //  }
-
-  //   return res.json({ users, count, hasMore });
-};
-
-export const all = async (req: Request, res: Response): Promise<Response> => {
-  let { userId, profile }: any = req.query as IndexQuery;
-
-  console.log(
-    "userId: ",
-    userId,
-    " | profile: ",
-    profile,
-    ' | getSettingValue("queueTransferByWhatsappScope")?.value: ',
-    getSettingValue("queueTransferByWhatsappScope")?.value
-  );
-
-  if (getSettingValue("queueTransferByWhatsappScope")?.value == "enabled") {
-    if (!userId) return res.json({ users: [], queues: [] });
-
-    const obj = await ListUserByWhatsappQueuesService(
-      userId,
-      '"admin", "user", "supervisor"'
-    );
-
-    const usersByWhatsqueue = obj.users;
-    const queues = obj.queues;
-
-    let userIds = usersByWhatsqueue.map((w: any) => w.userId);
-
-    const users = await ListUser({
-      userIds
     });
 
-    return res.json({ users, queues });
+    // user.userQueuesAttendance = userQueuesAttendance;
-  } else {
+    return res.status(200).json({
-    const users = await ListUser({
+      return_code: "200",
-      profile
+      return_msg: `User ${user_id} updated`,
+      user_updated: "1"
     });
-    return res.json({ users });
+  } catch (error) {
-  }
+    if (error instanceof AppError) {
-};
+      logger.warn(error);
-
+      return res.status(error.statusCode).json({
-export const store = async (req: Request, res: Response): Promise<Response> => {
+        return_code: String(error.statusCode),
-  const { email, password, name, profile, positionCompany, queueIds } =
+        return_msg: error.message,
-    req.body;
+        user_updated: "0",
-
+      });
-  console.log("===========> req.url: ", req.url);
-
-  if (
-    req.url === "/user" &&
-    getSettingValue("userCreation")?.value == "disabled" &&
-    req.user.profile == "admin"
-  ) {
-    throw new AppError("ERR_NO_PERMISSION", 403);
-  } else if (
-    req.url === "/signup" &&
-    getSettingValue("userCreation")?.value == "disabled"
-  ) {
-    throw new AppError("ERR_USER_CREATION_DISABLED", 403);
-  } else if (req.user.profile !== "master") {
-    throw new AppError("ERR_NO_PERMISSION", 403);
-  }
-
-  const user = await CreateUserService({
-    email,
-    password,
-    name,
-    positionCompany,
-    profile,
-    queueIds
-  });
-
-  if (user) {
-    const { id, name } = user;
-    await set(`user:${id}`, { id, name });
-  }
-
-  const io = getIO();
-  io.emit("user", {
-    action: "create",
-    user
-  });
-
-  // await stopWhoIsOnlineMonitor()
-  await startWhoIsOnlineMonitor();
-
-  return res.status(200).json(user);
-};
-
-export const show = async (req: Request, res: Response): Promise<Response> => {
-  const { userId } = req.params;
-
-  const user = await ShowUserService(userId);
-
-  return res.status(200).json(user);
-};
-
-export const logoutUser = async (
-  req: Request,
-  res: Response
-): Promise<Response> => {
-  const { userId } = req.params;
-
-  await stopWhoIsOnlineMonitor();
-
-  let onlineTime = {
-    userId: userId,
-    status: "logout..."
-  };
-
-  const io = getIO();
-  io.emit("onlineStatus", {
-    action: "logout",
-    userOnlineTime: onlineTime
-  });
-
-  await startWhoIsOnlineMonitor();
-  //
-
-  return res.status(200).json({});
-};
-
-export const update = async (
-  req: Request,
-  res: Response
-): Promise<Response> => {
-  if (
-    req.user.profile !== "admin" &&
-    req.user.profile !== "master" &&
-    req.user.profile !== "supervisor"
-  ) {
-    throw new AppError("ERR_NO_PERMISSION", 403);
-  }
-
-  const { userId } = req.params;
-  const userData = req.body;
-
-  const dateToday = splitDateTime(
-    new Date(format(new Date(), "yyyy-MM-dd HH:mm:ss", { locale: ptBR }))
-  );
-
-  const currentDate = new Date();
-  const tenMonthsAgo = subMonths(currentDate, 10);
-  const formattedDate = format(tenMonthsAgo, "yyyy-MM-dd");
-  console.log("dateToday.fullDate: ", dateToday.fullDate);
-  console.log("formattedDate 10 months ago: ", formattedDate);
-
-  const openByUserOnQueue: any[] = await CountTicketsByUserQueue({
-    startDate: formattedDate,
-    endDate: dateToday.fullDate,
-    status: "open",
-    clientChatStart: true,
-    userId: userId
-  });
-
-  // console.log('------> openByUserOnQueue: ', openByUserOnQueue)
-  // console.log()
-  // console.log('------> 1 userData.queueIds: ', userData.queueIds)
-
-  let userQueuesAttendance = [];
-
-  if ((openByUserOnQueue && openByUserOnQueue.length) > 0) {
-    userQueuesAttendance = openByUserOnQueue.filter(
-      (e: any) => !userData.queueIds.includes(e.queueId)
-    );
-
-    if (userQueuesAttendance && userQueuesAttendance.length > 0) {
-      const queueInAttendance = userQueuesAttendance.map(e => e.queueId);
-
-      const mergedSet = new Set([...userData.queueIds, ...queueInAttendance]);
-
-      // Convert the Set back to an array
-      userData.queueIds = Array.from(mergedSet);
-
-      // console.log('------> 2 userData.queueIds: ', userData.queueIds)
     }
+
+    return res.status(500).json({
+      return_code: "500",
+      return_msg: "Internal server error",
+      user_updated: "0",
+    });
   }
-
-  let user: any = await UpdateUserService({ userData, userId });
-
-  await setBotInfo(user);
-
-  if (user) {
-    const { id, name } = user;
-    await set(`user:${id}`, { id, name });
-  }
-
-  const io = getIO();
-  io.emit("user", {
-    action: "update",
-    user
-  });
-
-  user.userQueuesAttendance = userQueuesAttendance;
-
-  return res.status(200).json(user);
 };
 
-export const remove = async (
+export const resetPassword = async (req: Request, res: Response<IAMResponse & { password_set: "1" | "0" }>): Promise<Response> => {
-  req: Request,
+  try {
-  res: Response
+    const { user_id, user_password } = req.body;
-): Promise<Response> => {
-  const { userId } = req.params;
 
-  if (req.user.profile !== "master") {
+    await ResetPasswordService({
-    throw new AppError("ERR_NO_PERMISSION", 403);
+      userPassword: user_password,
+      userId: user_id
+    })
+
+    return res.status(200).json({
+      return_code: "200",
+      return_msg: `User has the password changed`,
+      password_set: "1"
+    });
+  } catch (error) {
+    if (error instanceof AppError) {
+      logger.warn(error);
+      return res.status(error.statusCode).json({
+        return_code: String(error.statusCode),
+        return_msg: error.message,
+        password_set: "0",
+      });
+    }
+
+    return res.status(500).json({
+      return_code: "500",
+      return_msg: "Internal server error",
+      password_set: "0",
+    });
   }
 
-  await DeleteUserService(userId);
+};
-
+
-  del(`user:${userId}`);
+export const linkUserRight = async (req: Request, res: Response<IAMResponse & { user_right_linked: "1" | "0" }>): Promise<Response> => {
-
+  try {
-  const io = getIO();
+    const { user_id, user_right_title, } = req.body;
-  io.emit("user", {
+
-    action: "delete",
+    await LinkUserRightService({
-    userId
+      userProfile: user_right_title,
-  });
+      userId: user_id
-
+    })
-  //test del
+
-  await stopWhoIsOnlineMonitor();
+    return res.status(200).json({
-
+      return_code: "200",
-  io.emit("onlineStatus", {
+      return_msg: `User ${user_id} associated`,
-    action: "delete",
+      user_right_linked: "1"
-    userOnlineTime: userId
+    });
-  });
+  } catch (error) {
-
+    if (error instanceof AppError) {
-  await startWhoIsOnlineMonitor();
+      logger.warn(error);
-  //
+      return res.status(error.statusCode).json({
-
+        return_code: String(error.statusCode),
-  return res.status(200).json({ message: "User deleted" });
+        return_msg: error.message,
+        user_right_linked: "0",
+      });
+    }
+
+    return res.status(500).json({
+      return_code: "500",
+      return_msg: "Internal server error",
+      user_right_linked: "0",
+    });
+  }
+};
+
+export const unlinkUserRight = async (req: Request, res: Response<IAMResponse & { user_right_unlinked: "1" | "0" }>): Promise<Response> => {
+  try {
+    const { user_id, user_right_title } = req.body;
+
+    await UnlinkUserRightService({
+      userProfile: user_right_title,
+      userId: user_id
+    })
+
+    return res.status(200).json({
+      return_code: "200",
+      return_msg: `User ${user_id} deassociated`,
+      user_right_unlinked: "1",
+    });
+  } catch (error) {
+    if (error instanceof AppError) {
+      logger.warn(error);
+      return res.status(error.statusCode).json({
+        return_code: String(error.statusCode),
+        return_msg: error.message,
+        user_right_unlinked: "0",
+      });
+    }
+
+    return res.status(500).json({
+      return_code: "500",
+      return_msg: "Internal server error",
+      user_right_unlinked: "0",
+    });
+  }
+};
+
+export const checkUserRight = async (req: Request, res: Response<IAMResponse & { user_right_exists: "1" | "0" }>): Promise<Response> => {
+  try {
+    const { user_id, user_right_title } = req.body;
+
+    const userHasRight = await CheckUserRightService({
+      userProfileToCompare: user_right_title,
+      userId: user_id
+    })
+
+    return res.status(200).json({
+      return_code: "200",
+      return_msg: "",
+      user_right_exists: userHasRight ? "1" : "0",
+    });
+  } catch (error) {
+    if (error instanceof AppError) {
+      logger.warn(error);
+      return res.status(error.statusCode).json({
+        return_code: String(error.statusCode),
+        return_msg: error.message,
+        user_right_exists: "0",
+      });
+    }
+    return res.status(500).json({
+      return_code: "500",
+      return_msg: "Internal server error",
+      user_right_exists: "0",
+    });
+  }
 };

backend/src/middleware/verifyAPIKey.ts

@@ -0,0 +1,23 @@
+import { Request, Response, NextFunction } from "express";
+import AppError from "../errors/AppError";
+const verifyAPIKey = (req: Request, res: Response, next: NextFunction): void => {
+  const authHeader = req.headers.authorization; 
+
+  if (!authHeader) {
+    throw new AppError("ERR_SESSION_EXPIRED", 401);
+  }
+
+  const [, token] = authHeader.split(" ");  
+
+  const apiKeyIsValid = token === process.env.TOKEN_REMOTE_TICKET_CREATION
+  if (!apiKeyIsValid) {
+    throw new AppError(
+      "Invalid token",
+      401
+    );
+  }
+
+  return next();
+};
+
+export default verifyAPIKey;

backend/src/routes/iamRoutesEL.ts

@@ -1,23 +1,19 @@
 import { Router } from "express";
 
-import isAuth from "../middleware/isAuth";
 import * as IAMControllerEL from "../controllers/IAMControllerEL";
+import verifyAPIKey from "../middleware/verifyAPIKey";
 
 const iamRoutesEL = Router();
 
+iamRoutesEL.post("/IAM/users", verifyAPIKey, IAMControllerEL.createUser);
+iamRoutesEL.put("/IAM/users", verifyAPIKey, IAMControllerEL.updateUser); 
+iamRoutesEL.delete("/IAM/users", verifyAPIKey, IAMControllerEL.deleteUser); 
+iamRoutesEL.get("/IAM/users/check", verifyAPIKey, IAMControllerEL.checkUser); 
 
-iamRoutesEL.get("/users/all", isAuth, IAMControllerEL.all);
+iamRoutesEL.patch("/IAM/users/rights/link", verifyAPIKey, IAMControllerEL.linkUserRight); 
+iamRoutesEL.patch("/IAM/users/rights/unlink", verifyAPIKey, IAMControllerEL.unlinkUserRight);
+iamRoutesEL.post("/IAM/users/rights/check", verifyAPIKey, IAMControllerEL.checkUserRight); 
 
-iamRoutesEL.get("/users", isAuth, IAMControllerEL.index); 
+iamRoutesEL.patch("/IAM/users/reset-password", verifyAPIKey, IAMControllerEL.resetPassword); 
-
-iamRoutesEL.post("/users", isAuth, IAMControllerEL.store); 
-
-iamRoutesEL.put("/users/:userId", isAuth, IAMControllerEL.update);
-
-iamRoutesEL.get("/users/:userId", isAuth, IAMControllerEL.show);
-
-iamRoutesEL.get("/users/logout/:userId", isAuth, IAMControllerEL.logoutUser);
-
-iamRoutesEL.delete("/users/:userId", isAuth, IAMControllerEL.remove);
 
 export default iamRoutesEL;

backend/src/services/UserServices/CheckUserRightService.ts

@@ -0,0 +1,33 @@
+import * as Yup from "yup";
+import AppError from "../../errors/AppError";
+import ShowUserService from "./ShowUserService";
+
+interface CheckUserRightServiceRequest {
+  userProfileToCompare: string;
+  userId: string | number;
+}
+
+type CheckUserRightServiceResponse = boolean;
+
+const CheckUserRightService = async ({userProfileToCompare, userId}: CheckUserRightServiceRequest): Promise<CheckUserRightServiceResponse> => {
+  try {
+    const user = await ShowUserService(userId);
+    const schema = Yup.object().shape({
+      userId: Yup.string().required(),
+      userProfile: Yup.string().oneOf(['admin', 'user', 'supervisor', 'master']).required()
+    });
+    try {
+      await schema.validate({ userId, userProfile: userProfileToCompare });
+    } catch (err: any) {
+      throw new AppError(err.message);
+    }
+
+    return (user.profile == userProfileToCompare) ? true : false
+
+  } catch (error: any) {
+    console.error('===> Error on CheckUserRightService.ts file: \n', error)
+    throw new AppError(error.message);
+  }
+};
+
+export default CheckUserRightService;

backend/src/services/UserServices/LinkUserRight.ts

@@ -0,0 +1,33 @@
+import * as Yup from "yup";
+import AppError from "../../errors/AppError";
+import ShowUserService from "./ShowUserService";
+
+interface LinkUserRightServiceRequest {
+  userProfile: string;
+  userId: string | number;
+}
+const LinkUserRightService = async ({userProfile, userId}: LinkUserRightServiceRequest): Promise<void> => {
+  try {
+    const user = await ShowUserService(userId);
+    const schema = Yup.object().shape({
+      userId: Yup.string().required(),
+      userProfile: Yup.string().oneOf(['admin', 'user', 'supervisor']).required()
+    });
+    try {
+      await schema.validate({ userId, userProfile });
+    } catch (err: any) {
+      throw new AppError(err.message);
+    }
+
+    await user.update({
+      profile: userProfile
+    });
+
+    await user.reload();
+  } catch (error: any) {
+    console.error('===> Error on LinkUserRightService.ts file: \n', error)
+    throw new AppError(error.message);
+  }
+};
+
+export default LinkUserRightService;

backend/src/services/UserServices/ResetPassword.ts

@@ -0,0 +1,32 @@
+import * as Yup from "yup";
+import AppError from "../../errors/AppError";
+import ShowUserService from "./ShowUserService";
+
+interface ResetPasswordServiceRequest {
+  userPassword: string;
+  userId: string | number;
+}
+const ResetPasswordService = async ({userPassword, userId}: ResetPasswordServiceRequest): Promise<void> => {
+  try {
+    const user = await ShowUserService(userId);
+    const schema = Yup.object().shape({
+      password: Yup.string(),
+    });
+    try {
+      await schema.validate({ password: userPassword });
+    } catch (err: any) {
+      throw new AppError(err.message);
+    }
+
+    await user.update({
+      userPassword,
+    });
+
+    await user.reload();
+  } catch (error: any) {
+    console.error('===> Error on ResetPasswordService.ts file: \n', error)
+    throw new AppError(error.message);
+  }
+};
+
+export default ResetPasswordService;

backend/src/services/UserServices/UnlinkUserRight.ts

@@ -0,0 +1,33 @@
+import * as Yup from "yup";
+import AppError from "../../errors/AppError";
+import ShowUserService from "./ShowUserService";
+
+interface UnlinkUserRightServiceRequest {
+  userProfile: string;
+  userId: string | number;
+}
+const UnlinkUserRightService = async ({userProfile, userId}: UnlinkUserRightServiceRequest): Promise<void> => {
+  try {
+    const user = await ShowUserService(userId);
+    const schema = Yup.object().shape({
+      userId: Yup.string().required(),
+      userProfile: Yup.string().oneOf(['user'])
+    });
+    try {
+      await schema.validate({ userId, userProfile });
+    } catch (err: any) {
+      throw new AppError(err.message);
+    }
+
+    await user.update({
+      profile: userProfile || "user"
+    });
+
+    await user.reload();
+  } catch (error: any) {
+    console.error('===> Error on UnlinkUserRightService.ts file: \n', error)
+    throw new AppError(error.message);
+  }
+};
+
+export default UnlinkUserRightService;