projeto-hit/backend/src/helpers/SchedulingNotifySendMessage.ts

import SetTicketMessagesAsRead from "../helpers/SetTicketMessagesAsRead";
import ShowTicketService from "../services/TicketServices/ShowTicketService";
import SendWhatsAppMessage from "../services/WbotServices/SendWhatsAppMessage";

import ListSchedulingNotifyService from "../services/SchedulingNotifyServices/ListSchedulingNotifyService";
import DeleteSchedulingNotifyService from "../services/SchedulingNotifyServices/DeleteSchedulingNotifyService";
import { getIO } from "../libs/socket";
import ListWhatsAppsService from "../services/WhatsappService/ListWhatsAppsService";
import path from "path";
import { convertBytes } from "./ConvertBytes";
import { deleteScheduleByTicketIdCache } from "./SchedulingNotifyCache";
import SchedulingNotify from "../models/SchedulingNotify";

const fastFolderSize = require('fast-folder-size')
const { promisify } = require('util')
const fs = require('fs')

const { exec } = require("child_process");

let _fifo: any

let scheduler_monitor: any;
let timeInterval = 5

const monitor = async () => {

    let date = new Date()

    let day = date.getDate().toString().padStart(2, '0');
    let month = (date.getMonth() + 1).toString().padStart(2, '0');
    let year = date.getFullYear();

    let hour = date.getHours()
    let minute = date.getMinutes()

    let fullDate = `${year}-${month}-${day}`;
    let dateParm = `${fullDate} ${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}:00`

    //console.log(dateParm);

    try {

        const { schedulingNotifies, count, hasMore } = await ListSchedulingNotifyService({ searchParam: dateParm, pageNumber: "1" });
   
        if (schedulingNotifies && schedulingNotifies.length > 0) {  

            for (let i = 0; i < schedulingNotifies.length; i++) {


                const ticket = await ShowTicketService(+schedulingNotifies[i].ticketId); 
 
                await new Promise(f => setTimeout(f, 3000));

                if(!ticket.queue){ 
                    await ticket.update({status: 'open'}) 
                }

                // SetTicketMessagesAsRead(ticket);

                await SendWhatsAppMessage({
                    body: schedulingNotifies[i].message, ticket
                });

                await deleteScheduleByTicketIdCache(schedulingNotifies[i].ticketId)

                await DeleteSchedulingNotifyService(schedulingNotifies[i].id)  


            } 
            
        }


        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();

        whatsapps.forEach(async whats => {



            const sourcePath = path.join(__dirname, `../../.wwebjs_auth/`, `session-bd_${whats.id}`)

            if (fs.existsSync(sourcePath)) {

                try {

                    const fastFolderSizeAsync = promisify(fastFolderSize)

                    let size = await fastFolderSizeAsync(sourcePath)

                    size = convertBytes(size)


                    // SESSION MONITORING
                    const io = getIO();
                    io.emit("whatsappSessionMonit", {
                        action: "update",
                        whatsappSessionSize: {
                            id: whats.id,
                            sessionSize: size
                        }
                    });
                }
                catch (err) {
                    console.log('An error occurred while get info from the directory: ', err);
                }

            }
            else {

                // console.log('Directory not found to get size info: ', sourcePath)

            }

        });



    } catch (error) {
        console.log('>>> SchedulingNotifiySendMessage.ts error: ', error)
    }

};


const SchedulingNotifySendMessage = async () => {

    try {
        clearInterval(_fifo);

        await monitor()

    } catch (error) {
        console.log('error on SchedulingNotifySendMessage: ', error)
    }
    finally {
        _fifo = setInterval(SchedulingNotifySendMessage, 5000);
    }
}

_fifo = setInterval(SchedulingNotifySendMessage, 5000);


module.exports = SchedulingNotifySendMessage