Merge pull request #10 from AdrianoRobson/features

Features

backend/src/controllers/ReportController.ts

@@ -10,7 +10,7 @@ import User from "../models/User";
 import Queue from "../models/Queue";
 import UserOnlineTime from "../models/UserOnlineTime";
 
-import { Op, Sequelize,literal } from "sequelize";
+import { Op, Sequelize, literal } from "sequelize";
 import format from 'date-fns/format';
 import ptBR from 'date-fns/locale/pt-BR';
 import { splitDateTime } from "../helpers/SplitDateTime";
@@ -19,12 +19,19 @@ import ListUserParamiterService from "../services/UserServices/ListUserParamiter
 
 import ShowUserServiceReport from "../services/UserServices/ShowUserServiceReport";
 
+import CountTicketsByUserQueue from "../services/UserServices/CountTicketsByUserQueue";
+
+import ShowQueuesByUser from "../services/UserServices/ShowQueuesByUser";
+import { filter } from "bluebird";
+
+
 
 type IndexQuery = {
   userId: string;
   startDate: string;
   endDate: string;
-  };
+  pageNumber: string;
+};
 
 
 export const reportUserByDateStartDateEnd = async (req: Request, res: Response): Promise<Response> => {
@@ -33,17 +40,21 @@ export const reportUserByDateStartDateEnd = async (req: Request, res: Response):
     throw new AppError("ERR_NO_PERMISSION", 403);
   }
 
-    const { userId, startDate, endDate } = req.query as IndexQuery  
+  const { userId, startDate, endDate, pageNumber } = req.query as IndexQuery
 
 
-    const data_query = await ShowTicketReport(userId, startDate, endDate);  
+  console.log('PAGE NUMBER: ', pageNumber)
 
-    return res.status(200).json(data_query);
 
+  const { tickets, count, hasMore } = await ShowTicketReport({ userId, startDate, endDate, pageNumber });
+
+  // return res.status(200).json(data_query);
+
+  return res.status(200).json({ tickets, count, hasMore });
 };
 
 
-export const reportUserService= async (req: Request, res: Response): Promise<Response> => {  
+export const reportUserService = async (req: Request, res: Response): Promise<Response> => {
 
   if (req.user.profile !== "master" && req.user.profile !== "admin") {
     throw new AppError("ERR_NO_PERMISSION", 403);
@@ -51,49 +62,153 @@ export const reportUserService= async (req: Request, res: Response): Promise<Res
   const { userId, startDate, endDate } = req.query as IndexQuery
 
 
-    let usersProfile = await ListUserParamiterService({profile: 'user'})
+  let usersProfile = await ListUserParamiterService({ profile: 'user' })
 
-    const sumUserOlineTime = await ShowUserServiceReport({startDate, endDate, userId});
+  const sumUserOlineTime = await ShowUserServiceReport({ startDate, endDate, userId });
-    const closedByUser =     await ShowUserServiceReport({startDate, endDate, ticketStatus: 'closed', userId});
+  const closedByUser = await ShowUserServiceReport({ startDate, endDate, ticketStatus: 'closed', userId });
-    const openByUser =       await ShowUserServiceReport({startDate, endDate, ticketStatus: 'open', userId});  
+  const openByUser = await ShowUserServiceReport({ startDate, endDate, ticketStatus: 'open', userId });
 
   let dateTime = splitDateTime(new Date(format(new Date(), 'yyyy-MM-dd HH:mm:ss', { locale: ptBR })))
   const onlineUsers = await ListUserOnlineOffline({ date: dateTime.fullDate })
 
+  const openByUserOnQueue = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'open', clientChatStart: true })
+  const openByUserOutQueue = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'open', clientChatStart: false })
 
-    usersProfile.map((user:any) => {
+  const closedByUserOnQueue = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'closed', clientChatStart: true })
+  const closedUserOutQueue = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'closed', clientChatStart: false })
 
-       let index = sumUserOlineTime.findIndex((e:any) => e.userId == user.id)
+  // let openQueueInOut = openByUserOnQueue.concat(openByUserOutQueue)
+  // let closedQueueInOut = closedByUserOnQueue.concat(closedUserOutQueue)
+
+
+  const queuesByUser = await ShowQueuesByUser({ profile: 'user' })
+
+  let openCloseOnQueue = openByUserOnQueue.concat(closedByUserOnQueue)
+  let openCloseOutQueue = openByUserOutQueue.concat(closedUserOutQueue)
+
+  for (let i = 0; i < queuesByUser.length; i++) {
+    
+    queuesByUser[i].countOpen = 0
+    queuesByUser[i].countClosed = 0
+
+    for (let x = 0; x < openCloseOnQueue.length; x++) {
+      if ((queuesByUser[i].userId == openCloseOnQueue[x].userId) &&
+        (queuesByUser[i].queueId == openCloseOnQueue[x].queueId && openCloseOnQueue[x].status == 'open')) {
+        queuesByUser[i].countOpen = openCloseOnQueue[x].totAttendance
+      }
+      else if ((queuesByUser[i].userId == openCloseOnQueue[x].userId) &&
+        (queuesByUser[i].queueId == openCloseOnQueue[x].queueId && openCloseOnQueue[x].status == 'closed')) {
+        queuesByUser[i].countClosed = openCloseOnQueue[x].totAttendance
+      }
+      
+    }
+  }
+
+
+  // console.log('queuesByUser: ', queuesByUser)
+
+
+
+  // console.log('queuesByUser: ',queuesByUser)
+  // console.log()
+  // console.log('CLIENT START TRUE openByUserOnQueue: ', openByUserOnQueue) 
+  // console.log()
+  // console.log('CLIENT START FALSE openByUserOutQueue: ', openByUserOutQueue) 
+  // console.log()
+  // console.log('CLIENT START TRUE closedByUserOnQueue: ', closedByUserOnQueue) 
+  // console.log()
+  // console.log('CLIENT START FALSE closedUserOutQueue: ', closedUserOutQueue) 
+
+
+  usersProfile.map((user: any) => {
+
+    let index = sumUserOlineTime.findIndex((e: any) => e.userId == user.id)
 
     if (index != -1) {
       user.sumOnlineTime = sumUserOlineTime[index];
     }
 
-       index = closedByUser.findIndex((e:any) => e.userId == user.id)
+    index = closedByUser.findIndex((e: any) => e.userId == user.id)
 
     if (index != -1) {
       user.sumClosed = closedByUser[index];
     }
 
-       index = openByUser.findIndex((e:any) => e.userId == user.id)
+    index = openByUser.findIndex((e: any) => e.userId == user.id)
 
     if (index != -1) {
       user.sumOpen = openByUser[index]
     }
 
 
-       index = onlineUsers.findIndex((e:any) => e.userId == user.id)
+     
+
+
+    // let openByUserOut = openQueueInOut.filter((e: any) => e.userId == user.id && !e.queueName)
+    // let openByUserIn = openQueueInOut.filter((e: any) => e.userId == user.id && e.queueName)
+
+    // if (openByUserOut && openByUserOut.length > 0) {
+    //   user.openTicketByUserOut = openByUserOut
+    // }
+    // if (openByUserIn && openByUserIn.length > 0) {
+    //   user.openTicketByUserIn = openByUserIn
+    // }
+
+    // let closedByUserOut = closedQueueInOut.filter((e: any) => e.userId == user.id && !e.queueName)
+    // let closedByUserIn = closedQueueInOut.filter((e: any) => e.userId == user.id && e.queueName)
+
+    // if (closedByUserOut && closedByUserOut.length > 0) {
+    //   user.closedTicketByUserOut = closedByUserOut
+    // }
+    // if (closedByUserIn && closedByUserIn.length > 0) {
+    //   user.closedTicketByUserIn = closedByUserIn
+    // }
+
+
+
+
+
+    // OPEN, CLOSED TICKETS STARTED BY USERS
+    let openClosedOutQueue = {}
+    let open = openCloseOutQueue.filter((e) => e.userId == user.id && e.status == 'open')
+    let closed = openCloseOutQueue.filter((e) => e.userId == user.id && e.status == 'closed')
+
+    openClosedOutQueue = {
+      ...openClosedOutQueue,
+      userId: user.id,
+      countOpen: open && open.length > 0 ? open[0].totAttendance : 0,
+      countClosed: closed && closed.length > 0 ? closed[0].totAttendance : 0
+    }
+
+    user.openClosedOutQueue = openClosedOutQueue
+
+
+    // OPEN, CLOSED TICKETS STARTED BY CLIENTS
+    let openClosedInQueue = queuesByUser.filter((e) => e.userId == user.id)
+
+    if (openClosedInQueue && openClosedInQueue.length > 0) {
+      user.openClosedInQueue = openClosedInQueue 
+    }
+
+
+
+
+
+
+
+
+    index = onlineUsers.findIndex((e: any) => e.userId == user.id)
 
     if (index != -1) {
       user.statusOnline = onlineUsers[index]
     }
 
-       if(startDate.length>0 && startDate.split('-').length == 3){
+    if (startDate.length > 0 && startDate.split('-').length == 3) {
       let date = startDate.split('-')
       user.startDate = `${date[2]}/${date[1]}/${date[0]}`
     }
 
-       if(endDate.length>0 && endDate.split('-').length == 3){
+    if (endDate.length > 0 && endDate.split('-').length == 3) {
       let date = endDate.split('-')
       user.endDate = `${date[2]}/${date[1]}/${date[0]}`
     }
@@ -124,4 +239,3 @@ export const reportMessagesUserByDateStartDateEnd = async (req: Request, res: Re
 
 
 
- 

backend/src/controllers/TicketController.ts

@@ -21,6 +21,8 @@ import format from 'date-fns/format';
 
 
 
+
+
 type IndexQuery = {
   searchParam: string;
   pageNumber: string;
@@ -44,8 +46,12 @@ import ListStatusChatEndService from "../services/StatusChatEndService/ListStatu
 import Ticket from "../models/Ticket";
 import ShowUserServiceReport from "../services/UserServices/ShowUserServiceReport";
 import TicketEmiterSumOpenClosedByUser from "../helpers/OnlineReporEmiterInfoByUser";
+import CountTicketService from "../services/TicketServices/CountTicketService";
+import CountTicketsByUserQueue from "../services/UserServices/CountTicketsByUserQueue";
+import ShowUserService from "../services/UserServices/ShowUserService";
 
 export const index = async (req: Request, res: Response): Promise<Response> => {  
+
   const {
     pageNumber,
     status,
@@ -58,7 +64,6 @@ export const index = async (req: Request, res: Response): Promise<Response> => {
   } = req.query as IndexQuery; 
 
 
-
   const userId = req.user.id;
 
   let queueIds: number[] = [];
@@ -138,6 +143,17 @@ export const show = async (req: Request, res: Response): Promise<Response> => {
 };
 
 
+export const count = async (req: Request, res: Response): Promise<Response> => { 
+
+  type indexQ = { status: string; date?: string; }; 
+  const {status, date} = req.query as IndexQuery
+
+  const ticketCount = await CountTicketService(status, date);    
+
+  return res.status(200).json(ticketCount); 
+};
+
+
 
 
 
@@ -221,12 +237,15 @@ export const update = async (req: Request, res: Response): Promise<Response> =>
       ticketId
     });
 
+    const dateToday = splitDateTime(new Date(format(new Date(), 'yyyy-MM-dd HH:mm:ss', { locale: ptBR }))) 
+    TicketEmiterSumOpenClosedByUser(ticketData.userId.toString(), dateToday.fullDate, dateToday.fullDate) 
+
     ticket2 = ticket
 
   }
 
 
-  // test del 
+  
 
   if (userOldInfo) {
 
@@ -234,12 +253,15 @@ export const update = async (req: Request, res: Response): Promise<Response> =>
 
     if (userOldInfo.userId) {
 
+      // console.log('FECHOU...')
+
       TicketEmiterSumOpenClosedByUser(userOldInfo.userId.toString(), dateToday.fullDate, dateToday.fullDate) 
+       
     }
 
   }
 
-  //
+ 
 
   return res.status(200).json(ticket2);
 };
@@ -248,7 +270,6 @@ export const update = async (req: Request, res: Response): Promise<Response> =>
 
 
 
-
 // export const update = async (
 //   req: Request,
 //   res: Response

backend/src/database/seeds/20220221193811-create-scheduling-data.ts

@@ -6,7 +6,7 @@ module.exports = {
       "StatusChatEnds",
       [     
         {
-          name: "SEM RETORNO DO CLIENTE",
+          name: "FINALIZADO",
           createdAt: new Date(),
           updatedAt: new Date()
         },

backend/src/helpers/OnlineReporEmiterInfoByUser.ts

@@ -3,14 +3,64 @@ import { splitDateTime } from "../helpers/SplitDateTime";
 import format from 'date-fns/format';
 import ShowUserServiceReport from '../services/UserServices/ShowUserServiceReport';
 import { getIO } from "../libs/socket";
+import CountTicketsByUserQueue from "../services/UserServices/CountTicketsByUserQueue";
+import ShowQueuesByUser from '../services/UserServices/ShowQueuesByUser';
+
+// import CountTicketsByUserQueue from "../services/UserServices/CountTicketsByUserQueue";
 
 
 const TicketEmiterSumOpenClosedByUser = async (userId: string, startDate: string, endDate: string) => {
 
-    const openByUser: any[] = await ShowUserServiceReport({ startDate: startDate, endDate:endDate, ticketStatus: 'open', userId: userId.toString() });
+    const openByUser: any[] = await ShowUserServiceReport({ startDate: startDate, endDate: endDate, ticketStatus: 'open', userId: userId.toString() });
-    const closedByUser: any[] = await ShowUserServiceReport({ startDate: endDate, endDate:endDate, ticketStatus: 'closed', userId: userId.toString() });
+    const closedByUser: any[] = await ShowUserServiceReport({ startDate: endDate, endDate: endDate, ticketStatus: 'closed', userId: userId.toString() });
+
+
+    const openByUserOnQueue: any[] = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'open', clientChatStart: true, userId: userId })
+    const openByUserOutQueue: any[] = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'open', clientChatStart: false, userId: userId })
+
+    const closedByUserOnQueue: any[] = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'closed', clientChatStart: true, userId: userId })
+    const closedUserOutQueue: any[] = await CountTicketsByUserQueue({ startDate: startDate, endDate: endDate, status: 'closed', clientChatStart: false, userId: userId })
+
+
+
+    const queuesByUser = await ShowQueuesByUser({ profile: 'user', userId: userId })
+
+    let openCloseOnQueue = openByUserOnQueue.concat(closedByUserOnQueue)
+    let openCloseOutQueue = openByUserOutQueue.concat(closedUserOutQueue)
+ 
+
+      // OPEN, CLOSED TICKETS STARTED BY CLIENTS
+    for (let i = 0; i < queuesByUser.length; i++) {
+
+        queuesByUser[i].countOpen = 0
+        queuesByUser[i].countClosed = 0
+
+        for (let x = 0; x < openCloseOnQueue.length; x++) {
+            if ((queuesByUser[i].userId == openCloseOnQueue[x].userId) &&
+                (queuesByUser[i].queueId == openCloseOnQueue[x].queueId && openCloseOnQueue[x].status == 'open')) {
+                queuesByUser[i].countOpen = openCloseOnQueue[x].totAttendance
+            }
+            else if ((queuesByUser[i].userId == openCloseOnQueue[x].userId) &&
+                (queuesByUser[i].queueId == openCloseOnQueue[x].queueId && openCloseOnQueue[x].status == 'closed')) {
+                queuesByUser[i].countClosed = openCloseOnQueue[x].totAttendance
+            }
+
+        }
+    } 
+ 
+
+    // OPEN, CLOSED TICKETS STARTED BY USERS
+    let openClosedOutQueue = {}
+    let open = openCloseOutQueue.filter((e) =>  e.status == 'open')
+    let closed = openCloseOutQueue.filter((e) => e.status == 'closed')
+
+    openClosedOutQueue = {
+        ...openClosedOutQueue,
+        userId: userId,
+        countOpen: open && open.length > 0 ? open[0].totAttendance : 0,
+        countClosed: closed && closed.length > 0 ? closed[0].totAttendance : 0
+    }  
 
-    //openByUser :  [ { id: 13, status: 'online' } ]  
 
     const io = getIO();
     io.emit("onlineStatus", {
@@ -18,6 +68,11 @@ const TicketEmiterSumOpenClosedByUser = async (userId: string, startDate: string
         userOnlineTime: {
             sumOpen: openByUser.length > 0 ? openByUser[0] : { userId: userId, count: '' },
             sumClosed: closedByUser.length > 0 ? closedByUser[0] : { userId: userId, count: '' },
+
+            openClosedOutQueue: openClosedOutQueue,
+            openClosedInQueue: queuesByUser
+
+
         }
     });
 

backend/src/helpers/SchedulingNotifySendMessage.ts

@@ -13,6 +13,8 @@ const fastFolderSize = require('fast-folder-size')
 const { promisify } = require('util')
 const fs = require('fs')
 
+const { exec } = require("child_process");
+
 let scheduler_monitor: any;
 let timeInterval = 5
 
@@ -53,6 +55,35 @@ const monitor = async () => {
         }
 
 
+        exec("df -h /", (error: any, stdout: any, stderr: any) => {
+
+            if (error) {
+                console.log(`exec error: ${error.message}`);
+                return;
+            }
+            if (stderr) {
+                console.log(`exec stderr: ${stderr}`);
+                return;
+            }
+
+            stdout = stdout.split(/\r?\n/)  
+            stdout = stdout[1].trim().split(/\s+/) 
+              
+            // DISK SPACE MONITORING
+            const io = getIO();
+            io.emit("diskSpaceMonit", {
+                action: "update",
+                diskSpace: {
+                    size: stdout[1],
+                    used: stdout[2],
+                    available: stdout[3],
+                    use: stdout[4]
+                }
+            });
+
+        });
+
+
 
         // WHATS SESSION SIZE MONITORING
         const whatsapps = await ListWhatsAppsService();

backend/src/routes/ticketRoutes.ts

@@ -6,6 +6,8 @@ import * as TicketController from "../controllers/TicketController";
 const ticketRoutes = express.Router(); 
 
 
+ticketRoutes.get("/tickets/count", isAuth, TicketController.count); 
+
 ticketRoutes.get("/tickets", isAuth, TicketController.index);   
 
 ticketRoutes.get("/tickets/:ticketId", isAuth, TicketController.show);

backend/src/server.ts

@@ -16,4 +16,4 @@ StartAllWhatsAppsSessions();
 gracefulShutdown(server);
 
 startSchedulingMonitor(5000)
-startWhoIsOnlineMonitor(5000)
+startWhoIsOnlineMonitor(2000)

backend/src/services/TicketServices/CountTicketService.ts

@@ -0,0 +1,50 @@
+import Ticket from "../../models/Ticket";
+import AppError from "../../errors/AppError";  
+import { Op, where } from "sequelize"; 
+import { Sequelize } from "sequelize"; 
+
+import { format } from "date-fns";
+import ptBR from 'date-fns/locale/pt-BR';
+
+import { splitDateTime } from "../../helpers/SplitDateTime";
+const dateToday = splitDateTime(new Date(format(new Date(), 'yyyy-MM-dd HH:mm:ss', { locale: ptBR })))
+
+const CountTicketService = async (status: string, date?: string): Promise<any> => {
+
+    let where_clause = {}
+
+    if (date) {
+        where_clause = {
+            createdAt: {
+                [Op.gte]: date + ' 00:00:00.000000',
+                [Op.lte]: date + ' 23:59:59.999999'
+              }
+        }
+    }
+    else {
+        // where_clause = {
+        //     createdAt: {
+        //         [Op.gte]: dateToday.fullDate + ' 00:00:00.000000',
+        //         [Op.lte]: dateToday.fullDate + ' 23:59:59.999999'
+        //       }
+        // }
+    } 
+    
+
+    where_clause = { ...where_clause, status: status }  
+
+    const ticket = await Ticket.findAll({
+        where: where_clause, 
+        raw: true,
+        attributes: [[Sequelize.fn("COUNT", Sequelize.col("Ticket.status")), "count"]],
+    });
+
+
+    if (!ticket) {
+        throw new AppError("ERR_NO_TICKET_FOUND", 404);
+    }
+
+    return ticket[0];
+};
+
+export default CountTicketService;

backend/src/services/TicketServices/ListTicketsService.ts

@@ -39,7 +39,7 @@ const ListTicketsService = async ({
   showAll,
   userId,
   withUnreadMessages,
-  unlimited='false'
+  unlimited = 'false'
 }: Request): Promise<Response> => {
   let whereCondition: Filterable["where"] = {
     [Op.or]: [{ userId }, { status: "pending" }],
@@ -47,6 +47,8 @@ const ListTicketsService = async ({
   };
   let includeCondition: Includeable[];
 
+
+
   includeCondition = [
     {
       model: Contact,
@@ -65,20 +67,21 @@ const ListTicketsService = async ({
   }
 
   if (status) {
+
+    whereCondition = { ...whereCondition, status };
+
+    // console.log('TEST unlimited: ', unlimited)
+
+    if (unlimited === 'true' && status !== 'pending') { 
+
       whereCondition = {
         ...whereCondition,
-      status
+        createdAt: {
-    };
+          [Op.gte]: dateToday.fullDate + ' 00:00:00.000000',
-
+          [Op.lte]: dateToday.fullDate + ' 23:59:59.999999'
-    // if (unlimited) {
+        }
-    //   whereCondition = {
+      }
-    //     ...whereCondition,
+    }
-    //     createdAt: {
-    //       [Op.gte]: dateToday.fullDate + ' 00:00:00.000000',
-    //       [Op.lte]: dateToday.fullDate + ' 23:59:59.999999'
-    //     }
-    //   }
-    // }
 
   }
 
@@ -92,11 +95,7 @@ const ListTicketsService = async ({
         as: "messages",
         attributes: ["id", "body"],
         where: {
-          body: where(
+          body: where(fn("LOWER", col("body")), "LIKE", `%${sanitizedSearchParam}%`)
-            fn("LOWER", col("body")),
-            "LIKE",
-            `%${sanitizedSearchParam}%`
-          )
         },
         required: false,
         duplicating: false
@@ -107,19 +106,13 @@ const ListTicketsService = async ({
       ...whereCondition,
       [Op.or]: [
         {
-          "$contact.name$": where(
+          "$contact.name$": where(fn("LOWER", col("contact.name")), "LIKE", `%${sanitizedSearchParam}%`)
-            fn("LOWER", col("contact.name")),
-            "LIKE",
-            `%${sanitizedSearchParam}%`
-          )
         },
+        
         { "$contact.number$": { [Op.like]: `%${sanitizedSearchParam}%` } },
+
         { 
-          "$message.body$": where(
+          "$message.body$": where(fn("LOWER", col("body")), "LIKE", `%${sanitizedSearchParam}%`) 
-            fn("LOWER", col("body")),
-            "LIKE",
-            `%${sanitizedSearchParam}%`
-          )
         }
       ]
     };

backend/src/services/TicketServices/ShowTicketReport.ts

@@ -16,12 +16,31 @@ import { startOfDay, endOfDay, parseISO, getDate} from "date-fns";
 import { string } from "yup/lib/locale";
 import Whatsapp from "../../models/Whatsapp";
 
+interface Request {
+  userId: string | number;
+  startDate: string;
+  endDate: string;
+  pageNumber?: string;
+}
+
+
+interface Response {
+  tickets: Ticket[];
+  count: number;
+  hasMore: boolean;
+}
+
 //Report by user, startDate, endDate
-const ShowTicketReport = async (id: string | number, startDate: string, endDate: string): Promise<Ticket[]> => {   
+const ShowTicketReport = async ({
+  userId,
+  startDate,
+  endDate,
+  pageNumber = "1"
+}: Request): Promise<Response> => {   
   
   let where_clause = {}
 
-  if(id=='0'){ 
+  if(userId=='0'){ 
     where_clause = {      
       createdAt: {
         [Op.gte]: startDate+' 00:00:00.000000',
@@ -31,7 +50,7 @@ const ShowTicketReport = async (id: string | number, startDate: string, endDate:
   }
   else{
     where_clause = {  
-      userid: id,    
+      userid: userId,    
       createdAt: {
         [Op.gte]: startDate+' 00:00:00.000000',
         [Op.lte]: endDate  +' 23:59:59.999999'
@@ -40,11 +59,14 @@ const ShowTicketReport = async (id: string | number, startDate: string, endDate:
   }
 
  
+  const limit = 40;
+  const offset = limit * (+pageNumber - 1);
   
-  
+  const {count, rows: tickets} = await Ticket.findAndCountAll({  
-  const ticket = await Ticket.findAll({  
 
     where: where_clause ,
+    limit,
+    offset,
     //attributes: ['id', 'status', 'createdAt', 'updatedAt'],
 
     attributes: ['id', 'status', 'statusChatEnd', [Sequelize.fn("DATE_FORMAT",Sequelize.col("Ticket.createdAt"),"%d/%m/%Y %H:%i:%s"),"createdAt"], 
@@ -82,14 +104,20 @@ const ShowTicketReport = async (id: string | number, startDate: string, endDate:
       },
     ], 
 
+    order: [
+      ['id', 'ASC']
+    ]  
+   
   });  
 
+  const hasMore = count > offset + tickets.length;
  
-  if (!ticket) {
+  
+  if (!tickets) {
     throw new AppError("ERR_NO_TICKET_FOUND", 404);
   }
 
-  return ticket;
+  return {tickets, count, hasMore};
 }; 
 
 export default ShowTicketReport;

backend/src/services/UserServices/CountTicketsByUserQueue.ts

@@ -0,0 +1,73 @@
+
+import { Sequelize, } from "sequelize";
+
+const dbConfig = require("../../config/database");
+const sequelize = new Sequelize(dbConfig);
+
+const { QueryTypes } = require('sequelize');
+
+interface Request {
+    startDate: string;
+    endDate: string;
+    status: string;
+    clientChatStart: boolean;
+    userId?: string | number;
+}
+
+const CountTicketsByUserQueue = async ({ startDate, endDate, status, clientChatStart, userId }: Request): Promise<any[]> => {
+
+    let usersQueueInfo = []
+
+    if (clientChatStart) {
+
+        if (userId) {
+            // CONSULTANDO POR CONVERSAS INICIADAS PELO CLIENTE 
+            usersQueueInfo = await sequelize.query(`select Users.id as userId, Tickets.status, Queues.id as queueId, Queues.name as queueName, \
+            (select count(id) from Tickets where userId = Users.id and Tickets.status = '${status}' and Tickets.queueId = Queues.id \
+            and (date(Tickets.createdAt) BETWEEN '${startDate} 00:00:00.000000' AND '${endDate} 23:59:59.999999')) as totAttendance \
+            from Tickets inner join Users inner join Queues on Tickets.queueId = Queues.id and Tickets.userId = Users.id and Tickets.status = '${status}' \
+            and (date(Tickets.createdAt) BETWEEN '${startDate} 00:00:00.000000' AND '${endDate} 23:59:59.999999') and Users.id = '${userId}' group by Users.email, Queues.name;`, { type: QueryTypes.SELECT });
+
+        } else {
+
+            // CONSULTANDO POR CONVERSAS INICIADAS PELO CLIENTE 
+            usersQueueInfo = await sequelize.query(`select Users.id as userId, Tickets.status, Queues.id as queueId, Queues.name as queueName, \
+             (select count(id) from Tickets where userId = Users.id and Tickets.status = '${status}' and Tickets.queueId = Queues.id \
+             and (date(Tickets.createdAt) BETWEEN '${startDate} 00:00:00.000000' AND '${endDate} 23:59:59.999999')) as totAttendance \
+             from Tickets inner join Users inner join Queues on Tickets.queueId = Queues.id and Tickets.userId = Users.id and Tickets.status = '${status}' \
+             and (date(Tickets.createdAt) BETWEEN '${startDate} 00:00:00.000000' AND '${endDate} 23:59:59.999999') group by Users.email, Queues.name;`, { type: QueryTypes.SELECT });
+
+        }
+    }
+    else {
+
+        if (userId) {
+            // CONSULTANDO POR CONVERSAS INICIADAS PELO ATENDENTE 
+            usersQueueInfo = await sequelize.query(`select Users.id as userId, Tickets.status, \
+            (select count(id) from Tickets where userId = Users.id and Tickets.status = '${status}' and Tickets.queueId is null \
+            and (date(Tickets.createdAt) BETWEEN '${startDate} 00:00:00.000000' AND '${endDate} 23:59:59.999999')) as totAttendance \
+            from Tickets inner join Users on \
+            Tickets.queueId is null and Tickets.userId = Users.id and Tickets.status = '${status}' \
+            and (date(Tickets.createdAt) BETWEEN '${startDate} 00:00:00.000000' AND '${endDate} 23:59:59.999999') and Users.id = '${userId}' group by Users.email;`, { type: QueryTypes.SELECT });
+        }
+        else {
+            // CONSULTANDO POR CONVERSAS INICIADAS PELO ATENDENTE 
+            usersQueueInfo = await sequelize.query(`select Users.id as userId, Tickets.status, \
+            (select count(id) from Tickets where userId = Users.id and Tickets.status = '${status}' and Tickets.queueId is null \
+            and (date(Tickets.createdAt) BETWEEN '${startDate} 00:00:00.000000' AND '${endDate} 23:59:59.999999')) as totAttendance \
+            from Tickets inner join Users on \
+            Tickets.queueId is null and Tickets.userId = Users.id and Tickets.status = '${status}' \
+            and (date(Tickets.createdAt) BETWEEN '${startDate} 00:00:00.000000' AND '${endDate} 23:59:59.999999') group by Users.email;`, { type: QueryTypes.SELECT });
+        }
+
+
+    }
+
+    return usersQueueInfo;
+};
+
+export default CountTicketsByUserQueue;
+
+
+
+

backend/src/services/UserServices/CreateOrUpdateOnlineUserService.ts

@@ -118,6 +118,7 @@ const CreateOrUpdateUserOnlineTime = async ({
                 console.log('UpdatedAt string: ', updatedAtString)
                 // 
                 
+
                 io.emit("onlineStatus", {
                     action: "update",
                     userOnlineTime: {

backend/src/services/UserServices/ListUserParamiterService.ts

@@ -1,33 +1,35 @@
 
 import { Op, Sequelize } from "sequelize";
+import Queue from "../../models/Queue";
 import User from "../../models/User";
+import UserQueue from "../../models/UserQueue";
 
 interface Request {
   userId?: string | number;
   profile?: string;
-  }
+}
 
 
-const ListUser = async ({profile, userId}: Request): Promise<User[]> => {
+const ListUser = async ({ profile, userId }: Request): Promise<User[]> => {
 
   let where_clause = {}
 
-    if(userId && profile){ 
+  if (userId && profile) {
     where_clause = {
       [Op.and]: [
-            {userId: userId},
+        { userId: userId },
-            {profile: profile} 
+        { profile: profile }
       ]
     }
   }
-    else if(userId){ 
+  else if (userId) {
     where_clause = {
       [Op.and]: [
-              {userId: userId}, 
+        { userId: userId },
       ]
     }
   }
-    else if(profile){
+  else if (profile) {
     where_clause = {
       profile: profile
     }
@@ -36,9 +38,25 @@ const ListUser = async ({profile, userId}: Request): Promise<User[]> => {
 
   const users = await User.findAll({
     where: where_clause,
-    raw:true,
+    raw: true,
     attributes: ['id', 'name', 'email'],
  
+
+    // include: [
+    //   {
+    //     model: UserQueue,
+    //     separate: true,
+
+    //     attributes: ['id',],
+
+    //     order: [
+    //       ['createdAt', 'ASC']
+    //     ]
+    //   },
+    // ], 
+
+
+
     order: [["id", "ASC"]],
   })
 
@@ -51,4 +69,3 @@ export default ListUser;
 
 
 
- 

backend/src/services/UserServices/ShowQueuesByUser.ts

@@ -0,0 +1,40 @@
+
+import { Sequelize, } from "sequelize";
+
+const dbConfig = require("../../config/database");
+const sequelize = new Sequelize(dbConfig);
+
+const { QueryTypes } = require('sequelize');
+
+interface Request {
+    profile: string;
+    userId?: string | number;
+}
+
+const QueuesByUser = async ({ profile, userId }: Request): Promise<any[]> => {
+
+    let queueByUsersInfo = []
+
+    if (userId) {
+        // CONSULTANDO FILAS PELO ID DO USUARIO
+        queueByUsersInfo = await sequelize.query(`select UserQueues.userId, UserQueues.queueId, Users.name, 
+            Queues.name, Queues.color from UserQueues inner join Users inner join Queues on
+            UserQueues.queueId = Queues.id and  UserQueues.userId = Users.id and Users.id = '${userId}' and Users.profile = '${profile}' order by userId, queueId;`, { type: QueryTypes.SELECT });
+
+    } else {
+
+        // CONSULTANDO FILAS PELO USUARIO
+        queueByUsersInfo = await sequelize.query(`select UserQueues.userId, UserQueues.queueId, Users.name, 
+            Queues.name, Queues.color from UserQueues inner join Users inner join Queues on
+            UserQueues.queueId = Queues.id and  UserQueues.userId = Users.id  and Users.profile = '${profile}' order by userId, queueId;`, { type: QueryTypes.SELECT });
+
+    }
+
+    return queueByUsersInfo;
+};
+
+export default QueuesByUser;
+
+
+
+

backend/src/services/UserServices/ShowUserServiceReport.ts

@@ -106,6 +106,8 @@ const ShowUserServiceReport = async ({
   }
 
 
+  // console.log('>>>>>>>>>>>>>> objQuery: ', objQuery)
+
 
 
   if (!objQuery) {

backend/src/services/WbotServices/wbotMessageListener.ts

@@ -825,6 +825,7 @@ const handleMsgAck = async (msg: WbotMessage, ack: MessageAck) => {
       action: "update",
       message: messageToUpdate
     });
+    
   } catch (err) {
     Sentry.captureException(err);
     logger.error(`Error handling message ack. Err: ${err}`);

frontend/src/components/MessagesList/index.js

@@ -362,15 +362,17 @@ const MessagesList = ({ ticketId, isGroup }) => {
     socket.on("connect", () => socket.emit("joinChatBox", ticketId));
 
     socket.on("appMessage", (data) => {
+      
       if (data.action === "create") {
         dispatch({ type: "ADD_MESSAGE", payload: data.message });  
 
-        // console.log('* NOVA MENSAGEM CAP: ', data.message) 
-
         scrollToBottom();
       }
 
       if (data.action === "update") {
+
+        console.log('2 THIS IS THE DATA: ', data)
+
         dispatch({ type: "UPDATE_MESSAGE", payload: data.message });
       }
     });

frontend/src/components/Report/MTable/index.js

@@ -4,36 +4,76 @@ import MaterialTable from 'material-table';
 import Modal from '../Modal'
 import { render } from '@testing-library/react';
 
+import chat from '@material-ui/icons/Chat';
+
+// import Button from "@material-ui/core/Button"; 
+
 import React from 'react';
 
 const MTable = (props) => {
 
-  const [selectedRow, setSelectedRow] = useState(null);
+  const tableRef = React.useRef(); 
  
+  const openInNewTab = url => {
+    window.open(url, '_blank', 'noopener,noreferrer');
+  }; 
+   
+  const [selectedRow, setSelectedRow] = useState(null); 
 
   //const dataLoad =    props.data.map((dt) => { return { ...dt }}); 
   const dataLoad = props.data.map(({ user, ...others }) => ({ ...others, 'user': user ? user : { name: 'Aguardando atendente', email: '' } }));
 
   const columnsLoad = props.columns.map((column) => { return { ...column } });
  
+
   useEffect(() => {
 
     console.log(`You have clicked the button ${selectedRow} times`)
 
+    // console.log('TABLE REF: ', tableRef)
+
   }, [selectedRow]);
 
+
+  useEffect(() => {
+
+    if (!tableRef.current) return 
+
+    const element = tableRef.current.tableContainerDiv.current;
+
+    element.addEventListener('scroll', props.handleScroll);
+
+    return () => {
+      element.removeEventListener('scroll', props.handleScroll);
+    };
+
+  }, [props]);
+
+
+
+
+
+
   return (
 
+    <>
+      {/* <Button onClick={handleTest}>Toggle</Button> */}
+
+      {/* <CircularProgress /> */}
+
       <MaterialTable
         title={props.table_title}
         columns={columnsLoad}
         data={dataLoad}
-
         maxWidth={true}
 
+        tableRef={tableRef}   
+
+        localization={{ header: { actions: props.hasChild ? 'Ticket' : null },}}
+
         onRowClick={(evt, selectedRow) => {
 
-        if(props.removeClickRow){
+          if (props.removeClickRow) {
             return
           }
 
@@ -56,23 +96,52 @@ const MTable = (props) => {
         }
         }
 
+
+        actions={[
+          (rowData) => {  
+
+            if(props.hasChild){
+              return {
+                icon: chat,
+                tooltip: `Ticket id ${rowData.id}`,
+                disable: false,
+                onClick: (event, rowData) => {
+   
+                  openInNewTab(`/tickets/${rowData.id}`) 
+  
+                }
+              }
+            } 
+          }
+        ]}
+
         options={{
           search: true,
           selection: false,
           paging: false,
           padding: 'dense',
+
+          exportButton: props.hasChild ? true : null,
+          exportAllData: true,
+
           sorting: true ? props.hasChild : false,
-        //loadingType: 'linear',
+          // loadingType: 'circular',
           searchFieldStyle: {
             width: 300,
           },
 
           pageSize: 20,
+
           headerStyle: {
             position: "sticky",
             top: "0"
           },
+
           maxBodyHeight: "400px",
+          // minBodyHeight: "85vh", //FIXME to calculate dynamic height, needed for correct scroll position identification
+          // maxBodyHeight: "85vh",
+
+
 
           rowStyle: rowData => ({
             fontSize: 12,
@@ -80,6 +149,9 @@ const MTable = (props) => {
           })
         }}
       />
+    </>
+
+
   );
 
 };

frontend/src/components/TicketsList/index.js

@@ -12,6 +12,7 @@ import useTickets from "../../hooks/useTickets";
 import { i18n } from "../../translate/i18n";
 import { AuthContext } from "../../context/Auth/AuthContext"; 
  
+
 const useStyles = makeStyles(theme => ({
 	ticketsListWrapper: {
 		position: "relative",
@@ -134,8 +135,8 @@ const reducer = (state, action) => {
 
 			// console.log('&&&&&&& UPDATE_TICKET_UNREAD_MESSAGES ticket: ',ticket, ' |\n MESSAGE: ', message) 
 
-			if(!message.fromMe){
+			if (!message.fromMe) {
-				ticket.unreadMessages +=1
+				ticket.unreadMessages += 1
 			}
 
 			state[ticketIndex] = ticket;
@@ -195,6 +196,9 @@ const TicketsList = (props) => {
 
 	useEffect(() => {
 		if (!status && !searchParam) return;
+
+		// console.log('lllllllllllllllllllllllllllllllll')
+
 		dispatch({
 			type: "LOAD_TICKETS",
 			payload: tickets,
@@ -221,6 +225,7 @@ const TicketsList = (props) => {
 		});
 
 		socket.on("ticket", data => { 
+
 			if (data.action === "updateUnread") {
 				dispatch({
 					type: "RESET_UNREAD",
@@ -286,6 +291,7 @@ const TicketsList = (props) => {
 	};
 
 	const handleScroll = e => {
+
 		if (!hasMore || loading) return;
 
 		const { scrollTop, scrollHeight, clientHeight } = e.currentTarget;

frontend/src/components/TicketsManager/index.js

@@ -125,7 +125,6 @@ const TicketsManager = () => {
 
   const handleSearch = (e) => {
     const searchedTerm = e.target.value.toLowerCase().trim();
-    console.log(searchedTerm)
 
     clearTimeout(searchTimeout);
 

frontend/src/hooks/useWhatsApps/index.js

@@ -39,6 +39,19 @@ const reducer = (state, action) => {
 	}
 
 
+	// if (action.type === "UPDATE_DISK_SPACE_MONIT") {
+	// 	const whatsApp = action.payload;
+	// 	const whatsAppIndex = state.findIndex(s => s.id === whatsApp.id);
+
+	// 	if (whatsAppIndex !== -1) { 
+	// 		state[whatsAppIndex].sessionSize = whatsApp.sessionSize;
+	// 		return [...state];
+	// 	} else {
+	// 		return [whatsApp, ...state];
+	// 	}
+	// }
+
+
 	if (action.type === "UPDATE_WHATSAPPS_SESSION_MONIT") {
 		const whatsApp = action.payload;
 		const whatsAppIndex = state.findIndex(s => s.id === whatsApp.id);
@@ -108,10 +121,6 @@ const useWhatsApps = () => {
 			}
 		}); 
 
-
-
-		//test del
-
 		socket.on("whatsappSessionMonit", data => {
 			if (data.action === "update") {
 
@@ -121,7 +130,7 @@ const useWhatsApps = () => {
 			}
 		}); 
 		 
-		//
+ 
 
 		return () => {
 			socket.disconnect();

frontend/src/pages/Connections/index.js

@@ -1,7 +1,9 @@
-import React, { useState, useCallback, useContext } from "react";
+import React, { useState, useCallback, useEffect, useContext } from "react";
 import { toast } from "react-toastify";
 import { format, parseISO } from "date-fns";
 
+import openSocket from "socket.io-client";
+
 import { makeStyles } from "@material-ui/core/styles";
 import { green } from "@material-ui/core/colors";
 import {
@@ -111,6 +113,8 @@ const Connections = () => {
 	const [selectedWhatsApp, setSelectedWhatsApp] = useState(null);
 	const [confirmModalOpen, setConfirmModalOpen] = useState(false);
 
+	const [diskSpaceInfo, setDiskSpaceInfo] = useState({});
+
 
 
 
@@ -324,6 +328,23 @@ const Connections = () => {
 		);
 	};
 
+
+	useEffect(() => {
+		const socket = openSocket(process.env.REACT_APP_BACKEND_URL);
+
+		socket.on("diskSpaceMonit", data => {
+			if (data.action === "update") {
+
+				setDiskSpaceInfo(data.diskSpace)
+
+			}
+		});
+
+		return () => {
+			socket.disconnect();
+		};
+	}, []);
+
 	return (
 
 		<Can
@@ -355,7 +376,10 @@ const Connections = () => {
 					/>
 
 					<MainHeader>
+
+
 						<Title>{i18n.t("connections.title")}</Title>
+
 						<MainHeaderButtonsWrapper>
 							<Can
 								role={user.profile}
@@ -370,10 +394,51 @@ const Connections = () => {
 								)}
 							/>
 						</MainHeaderButtonsWrapper>
+
+
 					</MainHeader>
 
 
 					<Paper className={classes.mainPaper} variant="outlined">
+						<>
+
+							<Can
+								role={user.profile}
+								perform="space-disk-info:show"
+								yes={() => (
+									<>
+									<Table size="small">
+									<TableHead>
+										<TableRow>
+											<TableCell align="center">
+												Size
+											</TableCell>
+											<TableCell align="center">
+												Used
+											</TableCell>
+											<TableCell align="center">
+												Available
+											</TableCell>
+											<TableCell align="center">
+												Use%
+											</TableCell>
+										</TableRow>
+									</TableHead>
+	
+									<TableBody>
+										<TableRow>
+											<TableCell align="center">{diskSpaceInfo.size}</TableCell>
+											<TableCell align="center">{diskSpaceInfo.used}</TableCell>
+											<TableCell align="center">{diskSpaceInfo.available}</TableCell>
+											<TableCell align="center">{diskSpaceInfo.use}</TableCell>
+										</TableRow>
+									</TableBody>
+								</Table> 
+								<br />
+								</>
+								)}
+							/> 
+
 							<Table size="small">
 								<TableHead>
 									<TableRow>
@@ -557,6 +622,8 @@ const Connections = () => {
 									)}
 								</TableBody>
 							</Table>
+
+						</>
 					</Paper>
 				</MainContainer>
 			)}

frontend/src/pages/Contacts/index.js

@@ -36,17 +36,23 @@ import { AuthContext } from "../../context/Auth/AuthContext";
 import { Can } from "../../components/Can";
 
 const reducer = (state, action) => {
+
+
   if (action.type === "LOAD_CONTACTS") {
+
     const contacts = action.payload;
     const newContacts = [];
 
     contacts.forEach((contact) => {
+     
       const contactIndex = state.findIndex((c) => c.id === contact.id);
+      
       if (contactIndex !== -1) {
         state[contactIndex] = contact;
       } else {
         newContacts.push(contact);
       }
+
     });
 
     return [...state, ...newContacts];
@@ -210,6 +216,9 @@ const Contacts = () => {
   const handleScroll = (e) => {
     if (!hasMore || loading) return;
     const { scrollTop, scrollHeight, clientHeight } = e.currentTarget;
+
+    // console.log('scrollTop: ',  scrollTop, ' | scrollHeight: ', scrollHeight,  ' | clientHeight: ', clientHeight)
+
     if (scrollHeight - (scrollTop + 100) < clientHeight) {
       loadMore();
     }

frontend/src/pages/Dashboard/Chart.js

@@ -16,11 +16,18 @@ import { i18n } from "../../translate/i18n";
 import Title from "./Title";
 import useTickets from "../../hooks/useTickets";
 
-const Chart = () => {
+const Chart = (props) => {
 	const theme = useTheme();
 
 	const date = useRef(new Date().toISOString());
-	const { tickets } = useTickets({ date: date.current });
+	const { tickets } = useTickets({ date: date.current, unlimited: "true" });
+
+	
+
+	// useEffect(()=>{
+	// 	console.log('kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk')
+	// },[props.change])
+	
 
 	const [chartData, setChartData] = useState([
 		{ time: "08:00", amount: 0 },
@@ -42,10 +49,7 @@ const Chart = () => {
 			let aux = [...prevState];
 
 			aux.forEach(a => {
-				tickets.forEach(ticket => {
+				tickets.forEach(ticket => { format(startOfHour(parseISO(ticket.createdAt)), "HH:mm") === a.time && a.amount++; });
-					format(startOfHour(parseISO(ticket.createdAt)), "HH:mm") === a.time &&
-						a.amount++;
-				});
 			});
 
 			return aux;
@@ -54,8 +58,7 @@ const Chart = () => {
 
 	return (
 		<React.Fragment>
-			<Title>{`${i18n.t("dashboard.charts.perDay.title")}${
+			<Title>{`${i18n.t("dashboard.charts.perDay.title")}${tickets.length
-				tickets.length
 				}`}</Title>
 			<ResponsiveContainer>
 				<BarChart

frontend/src/pages/Dashboard/index.js

@@ -22,6 +22,10 @@ import openSocket from "socket.io-client";
 
 import api from "../../services/api";
 
+import openSocket from "socket.io-client";
+
+import api from "../../services/api";
+
 import { Can } from "../../components/Can";
 import CardUser from "../../components/DashboardUser/CardUser";
 import TableUser from "../../components/DashboardUser/TableUser";
@@ -197,6 +201,152 @@ const reducer = (state, action) => {
   }
 };
 
+
+const reducer = (state, action) => {
+
+	if (action.type === "DELETE_USER_STATUS") {
+
+		const userId = action.payload;
+
+		const userIndex = state.findIndex((u) => `${u.id}` === `${userId}`);
+
+		if (userIndex !== -1) {
+			state.splice(userIndex, 1);
+		}
+
+		return [...state];
+	}
+
+
+
+	if (action.type === 'LOAD_QUERY') {
+
+		const queries = action.payload
+		const newQueries = []
+
+		queries.forEach((query) => {
+
+			const queryIndex = state.findIndex((q) => q.id === query.id)
+
+			if (queryIndex !== -1) {
+				state[queryIndex] = query
+			}
+			else {
+				newQueries.push(query)
+			}
+
+		})
+
+		return [...state, ...newQueries]
+	}
+
+	if (action.type === "UPDATE_STATUS_ONLINE") {
+
+		let onlineUser = action.payload
+		let index = -1
+
+		let onlySumOpenClosed = false
+
+		if (onlineUser.sumOpen || onlineUser.sumClosed) {
+			index = state.findIndex((e) => ((onlineUser.sumOpen && e.id === onlineUser.sumOpen.userId) || (onlineUser.sumClosed && e.id === onlineUser.sumClosed.userId)))
+
+			onlySumOpenClosed = true
+		}
+		else {
+			index = state.findIndex((e) => `${e.id}` === `${onlineUser.userId}`)
+		}
+
+
+		if (index !== -1) {
+
+			if (!onlySumOpenClosed) {
+
+				if (!("statusOnline" in state[index])) {
+
+					state[index].statusOnline = onlineUser
+
+				}
+				else if ("statusOnline" in state[index]) {
+
+					state[index].statusOnline['status'] = onlineUser.status
+
+				}
+
+			}
+
+
+			if ("onlineTime" in onlineUser) {
+
+				if ("sumOnlineTime" in state[index]) {
+					state[index].sumOnlineTime['sum'] = (onlineUser.onlineTime).split(" ")[1]
+				}
+				else if (!("sumOnlineTime" in state[index])) {
+					state[index].sumOnlineTime = { userId: onlineUser.userId, sum: (onlineUser.onlineTime).split(" ")[1] }
+				}
+			}
+
+
+			if (onlineUser.sumOpen) {
+
+				if ("sumOpen" in state[index]) {
+					// console.log(' >>>>>>>>>>>>>>>>>> sumOpen 1  | state[index].sumOpen["count"]: ', state[index].sumOpen['count'], '  |  onlineUser.sumOpen.count: ', onlineUser.sumOpen.count)
+					state[index].sumOpen['count'] = onlineUser.sumOpen.count
+				} else if (!("sumOpen" in state[index])) {
+					// console.log(' >>>>>>>>>>>>>>>>>> sumOpen 1')
+					state[index].sumOpen = onlineUser.sumOpen
+				}
+
+			}
+
+			if (onlineUser.sumClosed) {
+
+				if ("sumClosed" in state[index]) {
+					// console.log(' >>>>>>>>>>>>>>>>>> sumClosed 1  | state[index].sumClosed["count"]: ', state[index].sumClosed['count'], '  |  onlineUser.sumClosed.count: ', onlineUser.sumClosed.count)
+					state[index].sumClosed['count'] = onlineUser.sumClosed.count
+				} else if (!("sumClosed" in state[index])) {
+					// console.log(' >>>>>>>>>>>>>>>>>> sumOpen 1')
+					state[index].sumClosed = onlineUser.sumClosed
+				}
+
+			}
+			
+			
+
+			if(onlineUser.openClosedInQueue){ 
+				state[index].openClosedInQueue  = onlineUser.openClosedInQueue
+			}
+			if(onlineUser.openClosedOutQueue){ 
+				state[index].openClosedOutQueue  = onlineUser.openClosedOutQueue
+			}
+
+
+
+			// if(onlineUser.closedTicketByUserIn){ 
+			// 	state[index].closedTicketByUserIn  = onlineUser.closedTicketByUserIn
+			// }
+			// if(onlineUser.closedTicketByUserOut){ 
+			// 	state[index].closedTicketByUserOut  = onlineUser.closedTicketByUserOut
+			// }
+			// if(onlineUser.openTicketByUserIn){  
+			// 	state[index].openTicketByUserIn  = onlineUser.openTicketByUserIn
+			// }
+			// if(onlineUser.openTicketByUserOut){ 
+			// 	state[index].openTicketByUserOut  = onlineUser.openTicketByUserOut
+			// }
+
+		}
+		return [...state]
+
+	}
+
+	if (action.type === "RESET") {
+		return [];
+	}
+
+}
+
+
+
 const Dashboard = () => {
   const classes = useStyles();
   const [usersOnlineInfo, dispatch] = useReducer(reducer, []);

frontend/src/pages/Report/index.js

@@ -18,8 +18,11 @@ import MaterialTable from 'material-table';
 
 import LogoutIcon from '@material-ui/icons/CancelOutlined';
 
+ 
+
 import { CSVLink } from "react-csv";
 
+// import CircularProgress from '@mui/material/CircularProgress';
 
 import openSocket from "socket.io-client";
 
@@ -117,7 +120,6 @@ const reducerQ = (state, action) => {
 
   if (action.type === 'LOAD_QUERY') {
 
-
     const queries = action.payload
     const newQueries = []
 
@@ -301,19 +303,26 @@ let columnsData = [
 
   { title: 'Criado', field: 'createdAt' },
   //{title: 'Atualizado', field: 'updatedAt'},
-  {title: 'Status de encerramento', field: 'statusChatEnd'}];
+  { title: 'Status de encerramento', field: 'statusChatEnd' }];
 
 
 const Report = () => {
 
   const csvLink = useRef()
 
+
   const { user: userA } = useContext(AuthContext);
 
   //-------- 
   const [searchParam] = useState("");
-  //const [loading, setLoading] = useState(false);
+
-  //const [hasMore, setHasMore] = useState(false); 
+  const [loading, setLoading] = useState(false);
+  const [hasMore, setHasMore] = useState(false);
+  const [pageNumberTickets, setTicketsPageNumber] = useState(1);
+  const [totalCountTickets, setTotalCountTickets] = useState(0);
+
+
+
   const [pageNumber, setPageNumber] = useState(1);
   const [users, dispatch] = useReducer(reducer, []);
   //const [columns, setColums] = useState([]) 
@@ -336,7 +345,7 @@ const Report = () => {
   useEffect(() => {
     dispatch({ type: "RESET" });
     dispatchQ({ type: "RESET" })
-
+    setTicketsPageNumber(1)
     setPageNumber(1);
   }, [searchParam, profile]);
 
@@ -380,20 +389,24 @@ const Report = () => {
 
     const delayDebounceFn = setTimeout(() => {
 
+      setLoading(true);
       const fetchQueries = async () => {
         try {
 
           if (reportOption === '1') {
 
-            const dataQuery = await api.get("/reports/", { params: { userId, startDate, endDate }, });
+            const { data } = await api.get("/reports/", { params: { userId, startDate, endDate, pageNumber: pageNumberTickets }, });
-            dispatchQ({ type: "RESET" })
-            dispatchQ({ type: "LOAD_QUERY", payload: dataQuery.data });
 
-            //setLoading(false);
+            // console.log('dataQuery: ', data)
+            // console.log('pageNumberTickets: ', pageNumberTickets)
 
-           // console.log('dataQuery: ', dataQuery.data)
+            // dispatchQ({ type: "RESET" })
+            dispatchQ({ type: "LOAD_QUERY", payload: data.tickets });
+
+            setHasMore(data.hasMore);
+            setTotalCountTickets(data.count)
+            setLoading(false);
 
-           // console.log()
 
           }
           else if (reportOption === '2') {
@@ -404,7 +417,7 @@ const Report = () => {
 
             //setLoading(false);
 
-          //  console.log('REPORT 2 dataQuery : ', dataQuery.data)
+            console.log('REPORT 2 dataQuery : ', dataQuery.data)
 
             //console.log()
 
@@ -420,7 +433,7 @@ const Report = () => {
     }, 500);
     return () => clearTimeout(delayDebounceFn);
 
-  }, [userId, startDate, endDate, reportOption]);
+  }, [userId, startDate, endDate, reportOption, pageNumberTickets, totalCountTickets]);
 
 
   // Get from child 1
@@ -464,27 +477,15 @@ const Report = () => {
   }, [reportOption]) 
   
 
-  // useEffect(() => {
-
-  // console.log('>>>>>>>>>>>>>>>>>> New query: ', query)
-
-  // }, [query])
-
-
-
-  // test del  
-
   const handleCSVMessages = () => { 
 
-    // setLoading(true); 
-
     const fetchQueries = async () => {
 
       try {
 
         const dataQuery = await api.get("/reports/messages", { params: { userId, startDate, endDate }, });
 
-        // console.log('dataQuery messages: ', dataQuery.data) 
+        console.log('dataQuery messages: ', dataQuery.data) 
 
         if (dataQuery.data.length > 0) {
 
@@ -499,15 +500,10 @@ const Report = () => {
             }
           } 
 
-          //  console.log('dataCSVFormat: ', dataCSVFormat)
-
           setDataCSV(dataCSVFormat)
           setIsMount(false); 
-          // setDataCSV(dataQuery.data)
         } 
 
-        // setLoading(false);  
-
       } catch (err) {
         console.log(err);
       }
@@ -542,16 +538,9 @@ const Report = () => {
 
       socket.on("onlineStatus", (data) => {  
 
-        //  setLoading(true);  
-
-
         let date = new Date().toLocaleDateString('pt-BR').split('/')
         let dateToday = `${date[2]}-${date[1]}-${date[0]}`  
 
-      //  console.log('date: ', new Date(startDate).toLocaleDateString('pt-BR'))
-       // console.log('date2: ', startDate)
-
-
         if (data.action === "logout" || (data.action === "update" &&
           ((`${startDate}` === `${endDate}`) && (`${endDate}` === `${dateToday}`) && (`${startDate}` === `${dateToday}`)))) {
 
@@ -564,8 +553,6 @@ const Report = () => {
           dispatchQ({ type: "DELETE_USER_STATUS", payload: data.userOnlineTime });
         } 
 
-        //  setLoading(false);
-
       });
 
       socket.on("user", (data) => {
@@ -581,9 +568,13 @@ const Report = () => {
       };
 
     }
+    else if (reportOption === "1") {
+      dispatchQ({ type: "RESET" })
+      setTicketsPageNumber(1)
+    }
 
 
-  }, [reportOption, startDate, endDate]);
+  }, [reportOption, startDate, endDate, userId]);
 
 
   //   const handleDeleteRows = (id) => {
@@ -610,6 +601,7 @@ const Report = () => {
 
     setData(query.map((column) => { return { ...column } })) 
      
+
   }, [query])
 
   const handleLogouOnlineUser = async (userId) => {
@@ -625,6 +617,30 @@ const Report = () => {
   };
 
 
+  const loadMore = () => {
+    setTicketsPageNumber((prevState) => prevState + 1);
+  };
+
+  const handleScroll = (e) => {
+
+    if (!hasMore || loading) return;
+
+    const { scrollTop, scrollHeight, clientHeight } = e.currentTarget;
+
+    // console.log('scrollTop: ', scrollTop,
+    //   ' | scrollHeight: ', scrollHeight,
+    //   ' | clientHeight: ', clientHeight,
+    //   ' | scrollHeight - (scrollTop + 1): ', scrollHeight - (scrollTop + 1))
+
+    if (scrollHeight - (scrollTop + 1) < clientHeight) {  
+
+      loadMore();
+
+      // e.currentTarget.scrollTo(0, 200);
+    }
+  };
+
+
   return (
 
     <Can
@@ -639,7 +655,7 @@ const Report = () => {
               return { 'value': obj.id, 'label': obj.name }
             })} /></Item>
 
-            <Item><DatePicker1 func={datePicker1Value} minDate={true} startEmpty={false} title={'Data inicio'} /></Item>
+            <Item><DatePicker1 func={datePicker1Value} minDate={false} startEmpty={false} title={'Data inicio'} /></Item>
             <Item><DatePicker2 func={datePicker2Value} minDate={false} startEmpty={false} title={'Data fim'} /></Item>
 
             <Item sx={{ display: 'grid', gridColumn: '4 / 5', }}>
@@ -651,13 +667,15 @@ const Report = () => {
               {reportOption === '1' &&
 
                 <div>
-                  {/* <Button
+                  <Button style={{display: "none"}}
                     variant="contained" 
                     color="primary"
-                    onClick={(e) => handleCSVMessages()}
+                    onClick={(e) => {  
+                      handleCSVMessages()  
+                    }}
                   >
                     {"CSV ALL"}
-                  </Button> */}
+                  </Button>
 
                   <div>
                     <CSVLink
@@ -674,10 +692,6 @@ const Report = () => {
 
             </Item> 
 
-
-
-
-
           </Box>
 
           <Box sx={{
@@ -688,11 +702,22 @@ const Report = () => {
 
               {reportOption === '1' &&
 
+                // <div onScroll={handleScroll} style={{ height: 400, overflowY: "scroll" }}> 
+                // </div>  
+
+                <>
+
                   <MTable data={query}
                     columns={columnsData}
                     hasChild={true}
                     removeClickRow={false}
+
+                    handleScroll={handleScroll}
+
                     table_title={'Atendimento por atendentes'} />
+
+                </>
+
               }
               {reportOption === '2' &&
 
@@ -711,7 +736,7 @@ const Report = () => {
                     [
 
                       // { title: 'Foto', field: 'ticket.contact.profilePicUrl', render: rowData => <img src={rowData['ticket.contact.profilePicUrl']} alt="imagem de perfil do whatsapp" style={{ width: 40, borderRadius: '50%' }} /> },
-                      { title: 'Nome', field: 'name', cellStyle: {whiteSpace: 'nowrap'}, },
+                      { title: 'Nome', field: 'name', cellStyle: { whiteSpace: 'nowrap' }, },
 
                       {
                         title: 'Status', field: 'statusOnline.status',

frontend/src/rules.js

@@ -29,6 +29,7 @@ const rules = {
 			"show-icon-add-queue",
 			"show-icon-edit-queue",
 			"show-icon-delete-queue",
+			"space-disk-info:show",
 			
 
 			"drawer-admin-items:view",