Merge branch 'master' of github.com:AdrianoRobson/projeto-hit

Feat lojas

.gitignore

@@ -40,7 +40,10 @@ WWebJS
 .env.development.local
 .env.test.local
 .env.production.local
+.env.save
+nano.save
 
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
+

backend/src/controllers/IAMControllerEL.ts

@@ -0,0 +1,494 @@
+import { Request, Response } from "express";
+import { getIO } from "../libs/socket";
+import { Op } from "sequelize";
+import CreateUserService from "../services/UserServices/CreateUserService";
+import UpdateUserService from "../services/UserServices/UpdateUserService";
+import DeleteUserService from "../services/UserServices/DeleteUserService";
+import { del, get, set } from "../helpers/RedisClient";
+
+import {
+  startWhoIsOnlineMonitor,
+  stopWhoIsOnlineMonitor
+} from "../helpers/WhoIsOnlineMonitor";
+
+import User from "../models/User";
+
+export const createUser = async (
+  req: Request,
+  res: Response
+): Promise<Response> => {
+  const { user_id, user_first_name, user_tax_id, user_email, user_title }: any =
+    req.body;
+
+  const invalid = invalidProperties(req.body, [
+    "user_id",
+    "user_tax_id",
+    "user_first_name"
+  ]);
+
+  if (invalid) {
+    return res.status(400).json(response("1", `${invalid}`, "0", "createUser"));
+  }
+
+  const auxUser = await User.findOne({ where: { secondaryId: user_id } });
+
+  if (auxUser) {
+    return res
+      .status(400)
+      .json(
+        response("1", `The user ${user_id} already exist`, "0", "createUser")
+      );
+  }
+
+  const user = await CreateUserService({
+    email: user_tax_id || user_email,
+    password: "12345",
+    name: user_first_name,
+    positionCompany: user_title,
+    profile: "user",
+    ignoreThrow: true
+  });
+
+  if (user?.error) {
+    return res
+      .status(user?.status)
+      .json(response("0", `${user?.msg}`, "0", "createUser"));
+  }
+
+  if (!user?.error) {
+    const _user = await User.findByPk(user.id);
+    _user?.update({ secondaryId: user_id });
+
+    const { id, name } = user;
+    await set(`user:${id}`, { id, name });
+
+    const io = getIO();
+    io.emit("user", {
+      action: "create",
+      user
+    });
+
+    await startWhoIsOnlineMonitor();
+  }
+
+  return res
+    .status(200)
+    .json(response("1", `User ${user_id} created`, "1", "createUser"));
+};
+
+export const deleteUser = async (
+  req: Request,
+  res: Response
+): Promise<Response> => {
+  const { user_id }: any = req.body;
+
+  const invalid = invalidProperties(req.body, ["user_id"]);
+
+  if (invalid) {
+    return res.status(400).json(response("1", `${invalid}`, "0", "deleteUser"));
+  }
+
+  const _user = await User.findOne({ where: { secondaryId: user_id } });
+
+  if (_user) {
+    const user = await DeleteUserService(_user.id, true);
+
+    if (user?.error) {
+      return res
+        .status(user?.status)
+        .json(response("0", `${user?.msg}`, "0", "deleteUser"));
+    }
+
+    if (!user?.error) {
+      del(`user:${_user.id}`);
+
+      const io = getIO();
+      io.emit("user", {
+        action: "delete",
+        userId: _user.id
+      });
+
+      await stopWhoIsOnlineMonitor();
+
+      io.emit("onlineStatus", {
+        action: "delete",
+        userOnlineTime: _user.id
+      });
+
+      await startWhoIsOnlineMonitor();
+
+      return res
+        .status(200)
+        .json(response("1", `User ${user_id} deleted`, "1", "deleteUser"));
+    }
+  }
+
+  return res
+    .status(500)
+    .json(response("0", "Internal server error", "0", "deleteUser"));
+};
+
+export const listAllUsers = async (
+  req: Request,
+  res: Response
+): Promise<Response> => {
+  const _users: any = await User.findAll({
+    where: {
+      secondaryId: {
+        [Op.ne]: ""
+      }
+    },
+    attributes: ["secondaryId", "name"]
+  });
+
+  if (_users) {
+    const user_list = _users.map((user: any) => {
+      const { secondaryId, name } = user;
+      return { user_id: secondaryId, full_name: name };
+    });
+
+    return res
+      .status(200)
+      .json(response("1", "Success", user_list, "listAllUsers"));
+  }
+
+  return res
+    .status(500)
+    .json(response("0", "Internal server error", [], "listAllUsers"));
+};
+
+export const checkUser = async (
+  req: Request,
+  res: Response
+): Promise<Response> => {
+  const { user_id }: any = req.body;
+
+  const invalid = invalidProperties(req.body, ["user_id"]);
+
+  if (invalid) {
+    return res.status(400).json(response("1", `${invalid}`, "0", "checkUser"));
+  }
+
+  const _user = await User.findOne({ where: { secondaryId: user_id } });
+
+  if (_user) {
+    return res
+      .status(200)
+      .json(response("1", `User ${user_id} exist`, "1", "checkUser"));
+  }
+
+  return res
+    .status(404)
+    .json(response("1", `User ${user_id} not exist`, "0", "checkUser"));
+};
+
+export const updateUser = async (
+  req: Request,
+  res: Response
+): Promise<Response> => {
+  const { user_id, user_first_name, user_tax_id, user_email, user_title }: any =
+    req.body;
+
+  const invalid = invalidProperties(req.body, ["user_id"]);
+
+  if (invalid) {
+    return res.status(400).json(response("1", `${invalid}`, "0", "checkUser"));
+  }
+
+  const _user: any = await User.findOne({ where: { secondaryId: user_id } });
+
+  if (!_user)
+    return res
+      .status(404)
+      .json(response("1", `User ${user_id} not exist`, "0", "updateUser"));
+
+  const userData = {
+    email: user_tax_id || user_email,
+    name: user_first_name,
+    positionCompany: user_title
+  };
+
+  let user: any = await UpdateUserService({
+    userData,
+    userId: _user.id,
+    ignoreThrow: true
+  });
+
+  if (user?.error) {
+    return res
+      .status(user?.status)
+      .json(response("0", `${user?.msg}`, "0", "updateUser"));
+  }
+
+  if (user) {
+    const { id, name } = user;
+    await set(`user:${id}`, { id, name });
+  }
+
+  const io = getIO();
+  io.emit("user", {
+    action: "update",
+    user
+  });
+
+  return res
+    .status(200)
+    .json(response("1", `User ${user_id} updated`, "1", "updateUser"));
+};
+
+export const resetPassword = async (
+  req: Request,
+  res: Response
+): Promise<Response> => {
+  const { user_id, user_password }: any = req.body;
+
+  const invalid = invalidProperties(req.body, ["user_id", "user_password"]);
+
+  if (invalid) {
+    return res
+      .status(400)
+      .json(response("1", `${invalid}`, "0", "resetPassword"));
+  }
+
+  const _user = await User.findOne({ where: { secondaryId: user_id } });
+
+  if (!_user) {
+    return res
+      .status(404)
+      .json(response("1", `User ${user_id} not exist`, "0", "resetPassword"));
+  }
+
+  const userData = {
+    password: user_password,
+    email: _user.email
+  };
+
+  let user: any = await UpdateUserService({
+    userData,
+    userId: _user.id,
+    ignoreThrow: true
+  });
+
+  if (user?.error) {
+    return res
+      .status(user?.status)
+      .json(response("0", `${user?.msg}`, "0", "resetPassword"));
+  }
+
+  await logoutUser(_user.id);
+
+  return res
+    .status(200)
+    .json(
+      response("1", `User ${user_id} password updated`, "1", "resetPassword")
+    );
+};
+
+export const linkUserAndUserRight = async (
+  req: Request,
+  res: Response
+): Promise<Response> => {
+  const { user_id, user_right_id, user_right_title }: any = req.body;
+
+  const invalid = invalidProperties(req.body, ["user_id", "user_right_id"]);
+
+  if (invalid) {
+    return res
+      .status(400)
+      .json(response("1", `${invalid}`, "0", "linkUserAndUserRight"));
+  }
+
+  if (
+    (user_right_id &&
+      !["admin", "user", "supervisor"].includes(
+        user_right_id?.trim().toLocaleLowerCase()
+      )) ||
+    (user_right_title &&
+      !["admin", "user", "supervisor"].includes(
+        user_right_title?.trim().toLocaleLowerCase()
+      ))
+  ) {
+    return res
+      .status(400)
+      .json(
+        response(
+          "1",
+          `The user profile ${
+            user_right_title || user_right_id
+          } provided by the property user_right_title or user_right_id does not match the following profiles: admin, user, supervisor`,
+          "0",
+          "linkUserAndUserRight"
+        )
+      );
+  }
+
+  const _user: any = await User.findOne({ where: { secondaryId: user_id } });
+
+  if (!_user)
+    return res
+      .status(404)
+      .json(
+        response("1", `User ${user_id} not exist`, "0", "linkUserAndUserRight")
+      );
+
+  const userData = {
+    profile: user_right_title || user_right_id,
+    email: _user.email
+  };
+
+  let user: any = await UpdateUserService({
+    userData,
+    userId: _user.id,
+    ignoreThrow: true
+  });
+
+  if (user?.error) {
+    return res
+      .status(user?.status)
+      .json(response("0", `${user?.msg}`, "0", "linkUserAndUserRight"));
+  }
+
+  await logoutUser(_user.id);
+
+  return res
+    .status(200)
+    .json(
+      response(
+        "1",
+        `User ${user_id} associated with ${
+          user_right_title || user_right_id
+        } profile`,
+        "1",
+        "linkUserAndUserRight"
+      )
+    );
+};
+
+export const checkUserRight = async (
+  req: Request,
+  res: Response
+): Promise<Response> => {
+  const { user_id, user_right_id, user_right_title }: any = req.body;
+
+  const invalid = invalidProperties(req.body, ["user_id", "user_right_id"]);
+
+  if (invalid) {
+    return res
+      .status(400)
+      .json(response("1", `${invalid}`, "0", "checkUserRight"));
+  }
+
+  if (
+    (user_right_id &&
+      !["admin", "user", "supervisor"].includes(
+        user_right_id?.trim().toLocaleLowerCase()
+      )) ||
+    (user_right_title &&
+      !["admin", "user", "supervisor"].includes(
+        user_right_title?.trim().toLocaleLowerCase()
+      ))
+  ) {
+    return res
+      .status(400)
+      .json(
+        response(
+          "1",
+          `The user profile ${
+            user_right_title || user_right_id
+          } provided by the property user_right_title or user_right_id does not match the following profiles: admin, user, supervisor`,
+          "0",
+          "checkUserRight"
+        )
+      );
+  }
+
+  const _user: any = await User.findOne({
+    where: {
+      secondaryId: user_id
+    }
+  });
+
+  if (!_user)
+    return res
+      .status(404)
+      .json(response("1", `User ${user_id} not exist`, "0", "checkUserRight"));
+
+  if (
+    (user_right_id && _user.profile != user_right_id) ||
+    (user_right_title && _user.profile != user_right_title)
+  ) {
+    return res
+      .status(403)
+      .json(
+        response(
+          "1",
+          `User ${user_id} does not have this profile`,
+          "0",
+          "checkUserRight"
+        )
+      );
+  }
+
+  return res
+    .status(200)
+    .json(
+      response(
+        "1",
+        `User ${user_id} has ${user_right_title || user_right_id} profile`,
+        "1",
+        "checkUserRight"
+      )
+    );
+};
+
+async function logoutUser(userId: any) {
+  await stopWhoIsOnlineMonitor();
+
+  let onlineTime = {
+    userId: `${userId}`,
+    status: "logout..."
+  };
+
+  const io = getIO();
+  io.emit("onlineStatus", {
+    action: "logout",
+    userOnlineTime: onlineTime
+  });
+
+  await startWhoIsOnlineMonitor();
+}
+
+function response(code: string, msg: string, obj: any, type: string) {
+  let payload = { return_code: code, return_msg: msg };
+
+  switch (type) {
+    case "createUser":
+      return { ...payload, user_created: obj };
+    case "deleteUser":
+      return { ...payload, user_removed: obj };
+    case "listAllUsers":
+      return { ...payload, user_list: obj };
+    case "checkUser":
+      return { ...payload, user_exists: obj };
+    case "updateUser":
+      return { ...payload, user_updated: obj };
+    case "resetPassword":
+      return { ...payload, password_set: obj };
+    case "linkUserAndUserRight":
+      return { ...payload, user_right_linked: obj };
+    case "checkUserRight":
+      return { ...payload, user_right_exists: obj };
+    default:
+      return payload;
+  }
+}
+
+function invalidProperties(body: any, pros: any[]) {
+  for (const field of pros) {
+    console.log("body[field]: ", body[field], " field: ", field);
+    if (!body[field]) {
+      return `${field} is required`;
+    }
+  }
+  return false;
+}

backend/src/database/migrations/20240315203708-add-secondaryId-to-users.ts

@@ -0,0 +1,14 @@
+import { QueryInterface, DataTypes } from "sequelize";
+
+module.exports = {
+  up: (queryInterface: QueryInterface) => {
+    return queryInterface.addColumn("Users", "secondaryId", {
+      type: DataTypes.STRING,
+      allowNull: true 
+    });
+  },
+
+  down: (queryInterface: QueryInterface) => {
+    return queryInterface.removeColumn("Users", "secondaryId");
+  }
+};

backend/src/errors/AppError.ts

@@ -1,5 +1,5 @@
 class AppError {
-  public readonly message: string;
+  public message: string;
 
   public readonly statusCode: number;
 

backend/src/helpers/CheckContactOpenTickets.ts

@@ -1,6 +1,7 @@
 import { Op } from "sequelize";
 import AppError from "../errors/AppError";
 import Ticket from "../models/Ticket";
+import User from "../models/User";
 import ListWhatsAppsNumber from "../services/WhatsappService/ListWhatsAppsNumber";
 import { getSettingValue } from "./WhaticketSettings";
 import ListWhatsAppsForQueueService from "../services/WhatsappService/ListWhatsAppsForQueueService";
@@ -38,8 +39,13 @@ const CheckContactOpenTickets = async (
 
   if (ticket) {
     if (handle) return true;
+    const userName = await User.findOne({
+      where:{ id: ticket.userId }
+     });
+    const error = new AppError("ERR_OTHER_OPEN_TICKET");
+    error.message = `Erro: já existe um ticket criado com esse contato. Responsável: ${userName? userName.name.toUpperCase() : 'Aguardando'}`;
      
-    throw new AppError("ERR_OTHER_OPEN_TICKET");
+    throw error;
   }
 
   

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_IAM_HORACIUS_EL
+  if (!apiKeyIsValid) {
+    throw new AppError(
+      "Invalid token",
+      401
+    );
+  }
+
+  return next();
+};
+
+export default verifyAPIKey;

backend/src/models/User.ts

@@ -45,6 +45,9 @@ class User extends Model<User> {
   @Column
   positionCompany: string;
 
+  @Column
+  secondaryId: string;
+
   @Default("admin")
   @Column
   profile: string;

backend/src/routes/iamRoutesEL.ts

@@ -0,0 +1,56 @@
+import { Router } from "express";
+
+import * as IAMControllerEL from "../controllers/IAMControllerEL";
+import verifyAPIKey from "../middleware/verifyAPIKey";
+
+const iamRoutesEL = Router();
+
+iamRoutesEL.post(
+  "/iam/horacius/createUser",
+  verifyAPIKey,
+  IAMControllerEL.createUser
+);
+
+iamRoutesEL.put(
+  "/iam/horacius/updateUser",
+  verifyAPIKey,
+  IAMControllerEL.updateUser
+);
+
+iamRoutesEL.delete(
+  "/iam/horacius/deleteUser",
+  verifyAPIKey,
+  IAMControllerEL.deleteUser
+);
+
+iamRoutesEL.get(
+  "/iam/horacius/listAllUsers",
+  verifyAPIKey,
+  IAMControllerEL.listAllUsers
+);
+
+iamRoutesEL.get(
+  "/iam/horacius/checkUser",
+  verifyAPIKey,
+  IAMControllerEL.checkUser
+);
+
+iamRoutesEL.patch(
+  "/iam/horacius/linkUserAndUserRight",
+  verifyAPIKey,
+  IAMControllerEL.linkUserAndUserRight
+);
+ 
+iamRoutesEL.post(
+  "/iam/horacius/linkUserAndUserRight",
+  verifyAPIKey,
+  IAMControllerEL.checkUserRight
+);
+
+iamRoutesEL.patch(
+  "/iam/horacius/resetPassword",
+  verifyAPIKey,
+  IAMControllerEL.resetPassword
+);
+
+export default iamRoutesEL;

backend/src/routes/index.ts

@@ -14,10 +14,12 @@ import reportRoutes from "./reportRoutes";
 import schedulingNotifiyRoutes from "./SchedulingNotifyRoutes";
 import statusChatEndRoutes from "./statusChatEndRoutes";
 import wbotMonitorRoutes from "./wbotMonitorRoutes";
+import iamRoutesEL from "./iamRoutesEL";
 
 const routes = Router();    
 
 
+routes.use(iamRoutesEL);
 routes.use(userRoutes);
 routes.use("/auth", authRoutes);
 routes.use(settingRoutes);

backend/src/services/UserServices/CreateUserService.ts

@@ -11,6 +11,7 @@ interface Request {
   positionCompany?: string;
   queueIds?: number[];
   profile?: string;
+  ignoreThrow?: boolean;
 }
 
 interface Response {
@@ -27,15 +28,17 @@ const CreateUserService = async ({
   name,
   positionCompany,
   queueIds = [],
-  profile = "master"
+  profile = "master",
-}: Request): Promise<Response> => {
+  ignoreThrow = false
-
+}: Request): Promise<Response | any> => {
   try {
-
     const schema = Yup.object().shape({
       name: Yup.string().required().min(2),
 
-      email: Yup.string().required().trim().test(
+      email: Yup.string()
+        .required()
+        .trim()
+        .test(
           "Check-email",
           "An user with this email already exists.",
           async value => {
@@ -65,6 +68,8 @@ const CreateUserService = async ({
     try {
       await schema.validate({ email, password, name });
     } catch (err: any) {
+      if (ignoreThrow) return { error: true, msg: err.message, status: 400 };
+
       throw new AppError(err.message);
     }
 
@@ -86,12 +91,14 @@ const CreateUserService = async ({
     const serializedUser = SerializeUser(user);
 
     return serializedUser;
-
   } catch (error: any) {
-    console.error('===> Error on CreateUserService.ts file: \n', error)
+    console.error("===> Error on CreateUserService.ts file: \n", error);
+
+    if (ignoreThrow)
+      return { error: true, msg: "Create user error", status: 500 };
+
     throw new AppError(error.message);
   }
-
 };
 
 export default CreateUserService;

backend/src/services/UserServices/DeleteUserService.ts

@@ -2,14 +2,24 @@ import User from "../../models/User";
 import AppError from "../../errors/AppError";
 import Ticket from "../../models/Ticket";
 import UpdateDeletedUserOpenTicketsStatus from "../../helpers/UpdateDeletedUserOpenTicketsStatus";
-import { set } from "../../helpers/RedisClient"
+import { set } from "../../helpers/RedisClient";
 
-const DeleteUserService = async (id: string | number): Promise<void> => {
+const DeleteUserService = async (
+  id: string | number,
+  ignoreThrow = false
+): Promise<void | any> => {
   const user = await User.findOne({
     where: { id }
   });
 
   if (!user) {
+    if (ignoreThrow)
+      return {
+        error: true,
+        msg: `No user found with this id ${id}`,
+        status: 404
+      };
+
     throw new AppError("ERR_NO_USER_FOUND", 404);
   }
 

backend/src/services/UserServices/UpdateUserService.ts

@@ -16,6 +16,7 @@ interface UserData {
 interface Request {
   userData: UserData;
   userId: string | number;
+  ignoreThrow?: boolean;
 }
 
 interface Response {
@@ -27,11 +28,10 @@ interface Response {
 
 const UpdateUserService = async ({
   userData,
-  userId
+  userId,
-}: Request): Promise<Response | undefined> => {
+  ignoreThrow = false
-
+}: Request): Promise<Response | undefined | any> => {
   try {
-
     const user = await ShowUserService(userId);
 
     const schema = Yup.object().shape({
@@ -40,28 +40,41 @@ const UpdateUserService = async ({
       profile: Yup.string(),
       password: Yup.string(),
 
-      email: Yup.string().trim().required().test(
+      email: Yup.string()
+        .trim()
+        .required()
+        .test(
           "Check-email",
           "An user with this email already exists.",
           async value => {
-
             if (!value) return false;
 
-          const emailExists = await User.findOne({ where: { email: value }, raw: true, attributes: ['email', 'id'] });
+            const emailExists = await User.findOne({
+              where: { email: value },
+              raw: true,
+              attributes: ["email", "id"]
+            });
 
             if (emailExists && user.id != emailExists?.id) {
-
+              console.error(
-            console.error('The email already exists in another user profile!')
+                "The email already exists in another user profile!"
+              );
               return !emailExists;
             }
 
-          return true
+            return true;
           }
-      ),
+        )
-
     });
 
-    const { email, password, profile, name, positionCompany, queueIds = [] } = userData;
+    const {
+      email,
+      password,
+      profile,
+      name,
+      positionCompany,
+      queueIds = []
+    } = userData;
 
     try {
       await schema.validate({ email, password, profile, name });
@@ -69,7 +82,6 @@ const UpdateUserService = async ({
       throw new AppError(err.message);
     }
 
-
     await user.update({
       email,
       password,
@@ -91,13 +103,18 @@ const UpdateUserService = async ({
     };
 
     return serializedUser;
+  } catch (err: any) {
+    console.error("===> Error on UpdateUserService.ts file: \n", err);
 
-  } catch (error: any) {
+    if (ignoreThrow)
-    console.error('===> Error on UpdateUserService.ts file: \n', error)
+      return {
-    throw new AppError(error.message);
+        error: true,
+        msg: err.message,
+        status: 500
+      };
+
+    throw new AppError(err.message);
   }
-
-
 };
 
 export default UpdateUserService;

backend/src/services/WbotServices/wbotMessageListener.ts

@@ -409,7 +409,7 @@ const verifyQueue = async (
     //test del transfere o  atendimento se entrar na ura infinita
     const repet: any = await mostRepeatedPhrase(ticket.id);
 
-    if (repet.occurrences > 4) {
+    if (repet.occurrences > 10) {
       await UpdateTicketService({
         ticketData: { status: "pending", queueId: queues[0].id },
         ticketId: ticket.id
@@ -884,7 +884,7 @@ const handleMessage = async (
 
       console.log("repet.occurrences: ", repet.occurrences);
 
-      if (repet.occurrences > 4) {
+      if (repet.occurrences > 10) {
         await transferTicket(0, wbot, ticket);
 
         await SendWhatsAppMessage({

frontend/src/components/NotificationsPopOver/index.js

@@ -217,12 +217,18 @@ const NotificationsPopOver = () => {
 			}
 		})
 
+		socket.on('notifyPeding', data =>{
+			handleNotifications("", data);
+		});
+
 		return () => {
 			socket.disconnect()
 		}
 	}, [user])
 
-	const handleNotifications = data => {
+	const handleNotifications = (data, notify) => {
+		let isQueue = false;
+		if(!notify){
 			const { message, contact, ticket } = data
 
 			const options = {
@@ -253,7 +259,34 @@ const NotificationsPopOver = () => {
 				}
 				return [notification, ...prevState]
 			})
+		}else{
+			user.queues.forEach(queue =>{
+				if(queue.id === notify.data.queue?.id){
+					isQueue = true;
+				}
+			})
+		}
+		if(!isQueue && notify){
+			return;
+		}else{
+			const notification = new Notification(`${i18n.t("tickets.notification.messagePeding")} ${notify.data.queue?.name}`);
+			notification.onclick = e => {
+				e.preventDefault()
+				window.focus()
+				historyRef.current.push(`/tickets`)
+			}
 
+			setDesktopNotifications(prevState => {
+				const notfiticationIndex = prevState.findIndex(
+					n => n.tag === notification.tag
+				)
+				if (notfiticationIndex !== -1) {
+					prevState[notfiticationIndex] = notification
+					return [...prevState]
+				}
+				return [notification, ...prevState]
+			})
+		}
 		soundAlertRef.current()
 	}
 

frontend/src/translate/languages/en.js

@@ -241,6 +241,7 @@ const messages = {
         },
         notification: {
           message: "Message from",
+          messagePeding: "new ticket in queue",
         },
         tabs: {
           open: { title: "Inbox" },

frontend/src/translate/languages/es.js

@@ -245,6 +245,7 @@ const messages = {
         },
         notification: {
           message: "Mensaje de",
+          messagePeding: "Nuevo billete en cola",
         },
         tabs: {
           open: { title: "Bandeja" },

frontend/src/translate/languages/pt.js

@@ -244,6 +244,7 @@ const messages = {
         },
         notification: {
           message: "Mensagem de",
+          messagePeding: "Novo ticket na fila",
         },
         tabs: {
           open: { title: "Inbox" },