projeto-hit/backend/src/controllers/TicketController.ts

import { Request, Response } from "express";
import { getIO } from "../libs/socket";

import CreateTicketService from "../services/TicketServices/CreateTicketService";
import DeleteTicketService from "../services/TicketServices/DeleteTicketService";
import ListTicketsService from "../services/TicketServices/ListTicketsService";
import ShowTicketService from "../services/TicketServices/ShowTicketService";
import UpdateTicketService from "../services/TicketServices/UpdateTicketService";
import SendWhatsAppMessage from "../services/WbotServices/SendWhatsAppMessage";
import ShowWhatsAppService from "../services/WhatsappService/ShowWhatsAppService";
import ShowStatusChatEndService from '../services/StatusChatEndService/ShowStatusChatEndService'

import CreateSchedulingNotifyService from "../services/SchedulingNotifyServices/CreateSchedulingNotifyService";
import ListSchedulingNotifyContactService from "../services/SchedulingNotifyServices/ListSchedulingNotifyContactService";

import { isScheduling } from "../helpers/CheckSchedulingReminderNotify"

import ptBR from 'date-fns/locale/pt-BR';
import { splitDateTime } from "../helpers/SplitDateTime";
import format from 'date-fns/format';

import ListTicketsServiceCache from "../services/TicketServices/ListTicketServiceCache";

import { searchTicketCache, loadTicketsCache, } from '../helpers/TicketCache'
import { Op } from "sequelize";



type IndexQuery = {
  searchParam: string;
  pageNumber: string;
  status: string;
  date: string;
  showAll: string;
  withUnreadMessages: string;
  queueIds: string;
  unlimited?: string;
  searchParamContent?: string
};

interface TicketData {
  contactId: number;
  status: string;
  queueId: number;
  userId: number;
  whatsappId?: string | number
  msg?: string,
  transfer?: boolean | undefined,
  fromMe?: boolean
}


import ListStatusChatEndService from "../services/StatusChatEndService/ListStatusChatEndService";
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";
import axios from "axios";
import User from "../models/User";
import CheckContactOpenTickets from "../helpers/CheckContactOpenTickets";
import QueuesByUser from "../services/UserServices/ShowQueuesByUser";
import GetDefaultWhatsApp from "../helpers/GetDefaultWhatsApp";
import { getWbot } from "../libs/wbot";
import endPointQuery from "../helpers/old_EndPointQuery";
import Contact from "../models/Contact";
import BotIsOnQueue from "../helpers/BotIsOnQueue";
import { setMessageAsRead } from "../helpers/SetMessageAsRead";

export const index = async (req: Request, res: Response): Promise<Response> => {

  const {
    pageNumber,
    status,
    date,
    searchParam,
    showAll,
    queueIds: queueIdsStringified,
    withUnreadMessages,
    unlimited,
    searchParamContent
  } = req.query as IndexQuery;


  const userId = req.user.id;

  let queueIds: number[] = [];

  if (queueIdsStringified) {
    queueIds = JSON.parse(queueIdsStringified);
  }

  const { tickets, count, hasMore } = await ListTicketsService({
    searchParam,
    pageNumber,
    status,
    date,
    showAll,
    userId,
    queueIds,
    withUnreadMessages,
    unlimited,
    searchParamContent
  });

  return res.status(200).json({ tickets, count, hasMore });
};

export const store = async (req: Request, res: Response): Promise<Response> => {
  const { contactId, status, userId, msg, queueId }: TicketData = req.body;

  const botInfo = await BotIsOnQueue('botqueue')

  let ticket = await Ticket.findOne({
    where: {
      [Op.or]: [
        { contactId, status: 'queueChoice' },
        { contactId, status: 'open', userId: botInfo.userIdBot }
      ]
    }
  });

  if (ticket) {
    await UpdateTicketService({ ticketData: { status: 'open', userId: userId, queueId }, ticketId: ticket.id });

  }
  else {
    ticket = await CreateTicketService({ contactId, status, userId, queueId });
  }

  const io = getIO();
  io.to(ticket.status).emit("ticket", {
    action: "update",
    ticket
  });
  //  


  //  const ticket = await CreateTicketService({ contactId, status, userId });

  // const io = getIO();
  // io.to(ticket.status).emit("ticket", {
  //   action: "update",
  //   ticket
  // });

  return res.status(200).json(ticket);
};


export const show = async (req: Request, res: Response): Promise<Response> => {
  const { ticketId } = req.params;

  const contact = await ShowTicketService(ticketId);

  const { statusChatEnd, count, hasMore } = await ListStatusChatEndService({ searchParam: "", pageNumber: "1" });

  //////////////////
  const schedulesContact = await ListSchedulingNotifyContactService(contact.contact.number);
  /////////////////


  return res.status(200).json({ contact, statusChatEnd, schedulesContact });
};

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


export const update = async (req: Request, res: Response): Promise<Response> => {

  console.log('ENTROU NO UPDATE TICKET CONTROLLER')

  const { ticketId } = req.params;

  const userOldInfo = await Ticket.findByPk(ticketId)

  let ticket2 = {}

  if (req.body['status'] === "closed") {

    const { status, userId, schedulingNotifyData } = req.body;

    // lembrete
    const scheduleData = JSON.parse(schedulingNotifyData)

    const statusChatEndName = await ShowStatusChatEndService(scheduleData.statusChatEndId)

    const { ticket } = await UpdateTicketService({
      ticketData: { 'status': status, 'userId': userId, 'statusChatEnd': statusChatEndName.name },
      ticketId
    });


    if (scheduleData.farewellMessage) {
      const whatsapp = await ShowWhatsAppService(ticket.whatsappId);

      const { farewellMessage } = whatsapp;

      if (farewellMessage) {
        await SendWhatsAppMessage({ body: farewellMessage, ticket });
      }
    }


    //  lembrete                              // agendamento
    if (scheduleData.statusChatEndId === '2' || scheduleData.statusChatEndId === '3') {


      if (isScheduling(scheduleData.schedulingDate, scheduleData.schedulingTime)) {
        console.log('*** É AGENDAMENTO!')
      }
      else {
        console.log('*** É LEMBRETE!')
      }

      const schedulingNotifyCreate = await CreateSchedulingNotifyService(
        {
          ticketId: scheduleData.ticketId,
          statusChatEndId: scheduleData.statusChatEndId,
          schedulingDate: scheduleData.schedulingDate,
          schedulingTime: scheduleData.schedulingTime,
          message: scheduleData.message
        }
      )
    }

    ticket2 = ticket

  }
  else {

    // Para aparecer pendente para todos usuarios que estao na fila
    if (req.body.transfer) {
      req.body.userId = null
    }

    let ticketData: TicketData = req.body;

    // console.log('ticketData: ', ticketData)
    // console.log('ticketData.transfer', ticketData.transfer)

    // return res.send()


    // if (ticketData.transfer) {

    //   const defaultWhatsapp: any = await GetDefaultWhatsApp(ticketData.userId);

    //   const _ticket: any = await Ticket.findByPk(ticketId)

    //   if (defaultWhatsapp && ticketData.status != 'open') {

    //     await CheckContactOpenTickets(_ticket.dataValues.contactId, defaultWhatsapp.dataValues.id)

    //   }

    //   ticketData.whatsappId = defaultWhatsapp.dataValues.id

    // }

    console.log('--------> ticketData.status: ', ticketData.status, ' | ticketData.fromMe: ', ticketData.fromMe)


    const { ticket } = await UpdateTicketService({
      ticketData,
      ticketId,
    });


    if (ticketData.status == 'open' && !ticketData.fromMe) {

      await setMessageAsRead(ticket);

    }

    console.log('ticket.unreadMessages: ', ticket.unreadMessages)

    if (ticketData.userId) {

      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

  }




  if (userOldInfo) {

    const dateToday = splitDateTime(new Date(format(new Date(), 'yyyy-MM-dd HH:mm:ss', { locale: ptBR })))

    if (userOldInfo.userId) {

      TicketEmiterSumOpenClosedByUser(userOldInfo.userId.toString(), dateToday.fullDate, dateToday.fullDate)

    }

  }



  return res.status(200).json(ticket2);
};





// export const update = async (
//   req: Request,
//   res: Response
// ): Promise<Response> => {
//   const { ticketId } = req.params;
//   const ticketData: TicketData = req.body;

//   const { ticket } = await UpdateTicketService({
//     ticketData,
//     ticketId
//   });

//   if (ticket.status === "closed") {
//     const whatsapp = await ShowWhatsAppService(ticket.whatsappId);

//     const { farewellMessage } = whatsapp;

//     if (farewellMessage) {
//        await SendWhatsAppMessage({ body: farewellMessage, ticket });
//     }
//   }


//   return res.status(200).json(ticket);
// };

export const remove = async (
  req: Request,
  res: Response
): Promise<Response> => {
  const { ticketId } = req.params;

  const ticket = await DeleteTicketService(ticketId);

  const io = getIO();
  io.to(ticket.status)
    .to(ticketId)
    .to("notification")
    .emit("ticket", {
      action: "delete",
      ticketId: +ticketId
    });

  return res.status(200).json({ message: "ticket deleted" });
};
// export async function setMessageAsRead(ticket: Ticket) {
//   const wbot_url = await getWbot(ticket.whatsappId);

//   console.log('wbot_url: ', wbot_url, ' | ticket.contact.number: ', ticket.contact.number);

//   await endPointQuery(`${wbot_url}/api/sendSeen`, { number: `${ticket.contact.number}@${ticket.isGroup ? "g" : "c"}.us` });
// }