projeto-hit/TEST_SERVER1/whats/app.js

1265 lines
32 KiB
JavaScript
Raw Normal View History

'use strict'
const { initIO } = require("./helpers/socket")
const { ObjectId } = require('mongodb')
const backup_session = require('./helpers/backup_session')
const restore = require('./helpers/restore')
const dbcloud = require('./funcs/dbcloud.js')
const { Client, Location, List, Buttons, LocalAuth } = require('whatsapp-web.js/index')
const qrencode = require('qr-encode')
const axios = require('axios').default
const bodyparser = require('body-parser')
const path = require('path')
const fs = require('fs')
const express = require('express')
const FormData = require('form-data')
// const { MessageMedia } = require('./node_modules/whatsapp-web.js/src/structures');
let whatsappWebGlobalPath = path.join(process.env.NODE_PATH, 'whatsapp-web.js', '/src/structures')
whatsappWebGlobalPath = whatsappWebGlobalPath.replace(':', '')
console.log('whatsappWebGlobalPath: ', whatsappWebGlobalPath)
console.log('process.env.NODE_PATH: ', process.env.NODE_PATH)
const { MessageMedia } = require(whatsappWebGlobalPath)
const logger = require('logger')
const dotenv = require('dotenv')
dotenv.config({ path: '.env' })
const mime = require('mime')
const qrcode = require('qrcode-terminal')
const omnihit = require('./funcs/omnihit.js')
const { allowedNodeEnvironmentFlags } = require('process')
const checkInternetConnection = require('./helpers/checkIntenet')
const mongo = require('./funcs/mongoConn')
const db = mongo.db(process.env.DB_MONGO_NAME)
let auxCampaignMessage = ''
require("./funcs/tools.js")()
let scheduler_messages_outbound
let scheduler_monitor
let scheduler_monitor_cell
let scheduler_campaign_monitor
let scheduler_internet_conn
let client
// const PORT = 80;
let sendSeen = false
let unreadMessaesProcess
const { imageUpload } = require('./helpers/image-uploader')
var QRCODE = "0"
var mobileuid
var destroy
var changeInternetConn = true
let asking_qrcode = false
const dbcc = require('./helpers/mysql_conn.js')
const removeDir = require('./helpers/remove_dir')
// (async()=>{
// backup_session(destroy)
// clearTimeout(destroy)
// })
// console.log('PASSOU............')
// return
// Sleep
const sleep = (ms) => {
return new Promise((resolve) => setTimeout(resolve, ms))
}
function getRandomNumber(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min
}
const app = express()
app.use(express.static(path.join(__dirname, 'public')))
//app.use(bodyparser.urlencoded({ extended: true }));
app.use(bodyparser.json())
const sessionName = process.env.MOBILEUID
// console.log('DIRNAME: ', path.join(__dirname, '.wwebjs_auth', 'session-omnihit_sesssion'))
//TEST DEL
console.log('process.env.CLIENT_URL: ', process.env.CLIENT_URL)
console.log('1')
// Connect to server
var io = require('socket.io-client')
// const socket = initIO('http://localhost:8024')
const socketIo = io(process.env.CLIENT_URL, { reconnect: true, maxHttpBufferSize: 1e8 })
socketIo.on('connect', async function () {
console.log('Made socket connection', socketIo.id)
console.log('process.env.WHATSAPP_ID: ', process.env.WHATSAPP_ID)
socketIo.emit('joinWhatsSession', process.env.WHATSAPP_ID)
sendSeen = true
if (mobileuid) {
console.log('Socket conectado com o cliente: ', mobileuid)
setTimeout(async () => {
console.log('Entro no syncUnreadMessages ON CONNECTED SOCKET')
await syncUnreadMessages(client)
client.sendPresenceAvailable()
}, 5000)
}
})
socketIo.on('message_from_server', function () {
console.log('message_from_server data: ')
})
// socketIo.on('disconnect', function () {
// console.log('disconnect');
// });
// var count = 0
// // Send a message to the server 3 seconds after initial connection.
// setInterval(function () {
// // socketIo.emit('message_from_client', 'Sent an event from the client!');
// const data = {
// id: "64d7fa0ce984e1cb781baee0",
// sent: count
// }
// socketIo.emit("campaign_message_sent", data)
// count++
// }, 3000)
socketIo.on('connect_error', async function (err) {
console.log('connection errror', err)
sendSeen = false
if (mobileuid) {
client.sendPresenceUnavailable()
}
})
//
const wwebVersion = '2.2402.5';
//NOVA OPÇÃO MD
client = new Client({
authStrategy: new LocalAuth({ clientId: 'omnihit_sesssion' }),
puppeteer: { args: ['--no-sandbox', '--disable-setuid-sandbox'], executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable' },
webVersionCache: {
type: 'remote',
remotePath: `https://raw.githubusercontent.com/wppconnect-team/wa-version/main/html/${wwebVersion}.html`,
},
})
client.initialize()
client.on("qr", async qr => {
console.log("Session:", sessionName)
// Generate and scan this code with your phone
QRCODE = qr
qrcode.generate(qr, { small: true })
console.log('QR RECEIVED', qr)
// omnihit.qrcode(process.env.MOBILEUID, process.env.MOBILENAME, qr);
// omnihit.monitor(process.env.MOBILEUID, process.env.MOBILENAME, "STARTUP");
asking_qrcode = true
await new Promise((resolve, reject) => {
dbcc.query("UPDATE Whatsapps SET qrcode = ?, status = ?, retries = ? where id = ?", [qr, 'qrcode', 0, process.env.WHATSAPP_ID],
function (err, result) {
if (err) {
console.log("ERROR: " + err)
reject(err)
}
else {
resolve(result)
}
})
})
let url = process.env.CLIENT_URL + '/whatsapp/connection/qrcode'
try {
let response = await axios.post(url, { whatsappId: process.env.WHATSAPP_ID })
} catch (error) {
console.log('There was an error on POST THE DATA TO URL: ', url, '\n' + error)
}
})
client.on("authenticated", async session => {
console.log(`Session: ${sessionName} AUTHENTICATED`)
})
client.on("auth_failure", async msg => {
console.log(
`Session: ${sessionName} AUTHENTICATION FAILURE! Reason: ${msg}`
)
2023-04-17 13:05:22 +00:00
// omnihit.monitor(process.env.MOBILEUID, process.env.MOBILENAME, "AUTHFAILURE");
//reject(new Error("Error starting whatsapp session."));
})
client.on("ready", async () => {
console.log(`Session: ${sessionName} READY`)
// console.log('>>>>>>>>>>>>>> ready client.ts MOBILE NUMBER: ', client.info["wid"]["user"])
mobileuid = client.info["wid"]["user"]
console.log(new Date().toISOString() + " >>> Mobile UID ::: " + mobileuid)
// logger.info(`Session: ${sessionName} READY`);
const whatsapp = await new Promise((resolve, reject) => {
dbcc.query("SELECT * from Whatsapps where id = ?", [process.env.WHATSAPP_ID], (err, result) => {
if (err) {
reject(err)
}
else {
resolve(result)
}
})
})
if (whatsapp[0]['name'].includes(client.info["wid"]["user"])) {
console.log('-----------------> THIS IS THE RIGHT NUMBER')
}
else {
console.log('-----------------> THIS IS THE WRONG NUMBER')
let read_number = client.info["wid"]["user"]
let url = process.env.CLIENT_URL + '/whatsapp/connection/number'
try {
await client.logout()
let response = await axios.post(url, { number: read_number })
} catch (error) {
console.log('There was an error on POST THE DATA TO URL: ', url, '\n' + error)
}
return
}
if (process.env.OLD_MOBILEUID) {
const ticketSettingsId = await new Promise((resolve, reject) => {
dbcc.query("select id from SettingTickets where number = ?", [process.env.OLD_MOBILEUID,], (err, result) => {
if (err) {
reject(err)
}
else {
// resolve(result)
const idArray = result.map(row => row.id)
resolve(idArray)
}
})
})
if (ticketSettingsId?.length > 0) {
await new Promise((resolve, reject) => {
const idsToUpdate = ticketSettingsId // Assuming ticketSettingsId is an array of IDs
// Create placeholders for the IN clause based on the number of elements in idsToUpdate
const placeholders = Array(idsToUpdate.length).fill('?').join(',')
dbcc.query(
`UPDATE SettingTickets SET number = ? WHERE id IN (${placeholders})`,
[client.info["wid"]["user"], ...idsToUpdate], // Spread the array to pass individual values
function (err, result) {
if (err) {
console.log("ERROR: " + err)
reject(err)
} else {
resolve(result)
}
}
)
})
}
}
await new Promise((resolve, reject) => {
dbcc.query("UPDATE Whatsapps SET qrcode = ?, status = ?, retries = ?, number = ? where id = ?", ["", 'CONNECTED', 0, client.info["wid"]["user"], process.env.WHATSAPP_ID],
function (err, result) {
if (err) {
console.log("ERROR: " + err)
reject(err)
}
else {
resolve(result)
}
})
})
let url = process.env.CLIENT_URL + '/whatsapp/connection/qrcode'
try {
let response = await axios.post(url, { whatsappId: process.env.WHATSAPP_ID })
} catch (error) {
console.log('There was an error on POST THE DATA TO URL: ', url, '\n' + error)
}
console.log('SEND SEEN: ', sendSeen)
await syncUnreadMessages(client)
if (sendSeen) {
client.sendPresenceAvailable()
}
// if(asking_qrcode){
// // backup_session(destroy, 120000, true)
// }
backup_session(destroy, 120000, false)
asking_qrcode = false
console.log('PASSOU............')
})
async function read() {
let chats = await client.getState()
console.log(chats)
}
client.on("message_create", async msg => {
2023-04-08 22:28:32 +00:00
// if (msg.hasMedia && msg.fromMe)
// return
if (msg.fromMe && msg.type === "chat" && auxCampaignMessage.trim() == msg?.body?.trim()) {
console.log('IGNORED MESSAGE SENT CAMPAIGN')
return
}
await handleMessage(msg)
})
client.on("media_uploaded", async msg => {
console.log('Entrou no midia upload')
let msgContact = null
let media = null
if (msg.fromMe) {
msgContact = await client.getContactById(msg.to)
}
else {
msgContact = await msg.getContact()
}
const chat = await msg.getChat()
msgContact.getProfilePicUrl = await msgContact.getProfilePicUrl()
let quotedMsg = await msg.getQuotedMessage()
if (msg.hasMedia) {
media = await msg.downloadMedia()
}
let data = {
id: process.env.WHATSAPP_ID,
msg: msg,
msgContact: msgContact,
chat: chat,
quotedMsg: quotedMsg ? quotedMsg.id.id : null,
media: media
}
socketIo.emit("media_uploaded", data)
})
client.on("message_ack", async (msg, ack) => {
const campaigSend = await db.collection('campaignsends').findOne({ whatsapp_msg_id: msg.id.id })
if (campaigSend && ack == 3) {
const updateResult = await db.collection('campaignsends').updateOne({ _id: ObjectId(campaigSend._id) },
{
$set: {
read: new Date(new Date() + "UTC"),
ack: ack
}
})
// console.log('RESULT ACK UPDATE: ', updateResult)
const read = await db.collection('campaignsends').countDocuments({ campaignId: ObjectId(campaigSend.campaignId), ack: 3 })
const data = {
id: ObjectId(campaigSend.campaignId),
read: read
}
console.log('DATA ACK READ MESSAGE CAMPAIGN: ', data)
socketIo.emit("campaign_message_sent", data)
return
}
else if (campaigSend && (ack == 2 || ack == 1)) {
return
}
let data = {
whatsappId: process.env.WHATSAPP_ID,
id: msg.id.id,
ack: ack
}
socketIo.emit("message_ack", data)
})
socketIo.on('send_message', async data => {
console.log('#')
console.log('--------------> send_message from number: ', mobileuid)
console.log('--------------> send_message to number: ', data.msg.number)
console.log('--------------> send_message body: ', data.msg.body)
console.log('--------------> send_message quotedMessageId: ', data.msg.quotedMessageId)
console.log('--------------> send_message linkPreview: ', data.msg.linkPreview)
console.log('#')
const sentMessage = await client.sendMessage(data.msg.number, data.msg.body, { quotedMessageId: data.msg.quotedMessageId, linkPreview: data.msg.linkPreview })
// console.log('=====================> sentMessage: ', sentMessage)
})
socketIo.on('send_media', async data => {
console.log('#')
console.log('--------------> send_message from number: ', mobileuid)
console.log('--------------> send_message to number: ', data.msg.number)
// console.log('--------------> send_message media: ', data.msg.media);
console.log('--------------> send_message sendAudioAsVoice: ', data.msg.sendAudioAsVoice)
console.log('--------------> data.msg.media.mimetype: ', data.msg.media.mimetype)
console.log('--------------> data.msg.media.filename: ', data.msg.media.filename)
console.log('#')
let media = new MessageMedia(data.msg.media.mimetype, data.msg.media.data, data.msg.media.file)
if (media && !media.filename)
media.filename = data.msg.media.filename
const sentMessage = await client.sendMessage(data.msg.number, media, { sendAudioAsVoice: data.msg.sendAudioAsVoice })
// const fullFilename = process.cwd() + process.env.MEDIA_DOWNLOAD_IN + data.msg.media.filename;
// console.log('fullFIlename: ', fullFilename)
// fs.writeFileSync(fullFilename, data.msg.media.data, { encoding: 'base64' });
})
client.on("change_state", async newState => {
let omnihit_url = process.env.CLIENT_URL + '/whatsapp/connection/monitor'
// logger.info(`Monitor session: ${sessionName}, ${newState}`);
console.log('>>>>>>>>>>>>>> change_state wbotMonitor.ts MOBILE NUMBER: ', client.info["wid"]["user"])
let data = {
action: 'change_state',
whatsappId: process.env.WHATSAPP_ID
}
await whatsappMonitor(newState, omnihit_url, data)
})
client.on("disconnected", async reason => {
let omnihit_url = process.env.CLIENT_URL + '/whatsapp/connection/monitor'
console.log('>>>>>>>>>>>>>> change_state wbotMonitor.ts MOBILE NUMBER: ', client.info["wid"]["user"])
let data = {
action: 'disconnected',
whatsappId: process.env.WHATSAPP_ID,
reason: reason
}
await removeDir(path.join(__dirname, '.wwebjs_auth', 'session-omnihit_sesssion'))
setTimeout(() => {
process.exit()
}, 3000)
await whatsappMonitor('OPENING', omnihit_url, data)
})
app.get('/', function (req, res) { return res.send('Express + TypeScript Server') })
app.post('/start', function (req, res) {
client.initialize()
res.send("OK")
})
app.post('/qr', function (req, res) {
res.send(QRCODE)
})
app.post('/api/getWbotMessage', async (req, res) => {
const { number, messageId, limit } = req.body
console.log('number: ', number, ' | limit: ', limit)
const wbotChat = await client.getChatById(number)
const fetchWbotMessagesGradually = async () => {
const chatMessages = await wbotChat.fetchMessages({ limit })
const msgFound = chatMessages.find(msg => msg.id.id === messageId)
if (!msgFound && limit < 100) {
limit += 20
return fetchWbotMessagesGradually()
}
return msgFound
}
try {
const msgFound = await fetchWbotMessagesGradually()
if (!msgFound) {
res.status(404).json({ message: "Cannot found message within 100 last messages" })
return
}
res.status(200).json({ message: "ok", data: msgFound })
} catch (err) {
console.log('ERR_FETCH_WAPP_MSG: ', err)
res.status(404).json({ message: "ERR_FETCH_WAPP_MSG" })
}
})
app.post('/api/disconnect', async (req, res) => {
try {
console.log('Restaring the session.........')
await removeDir(path.join(__dirname, '.wwebjs_auth', 'session-omnihit_sesssion'))
await client.logout()
setTimeout(() => {
process.exit()
}, 3000)
} catch (error) {
console.log('There was an error on try disconnect the whatsapp: ', error)
}
res.status(200).json({ message: "ok" })
})
app.post('/api/DeleteWhatsAppMessage', async (req, res) => {
const { number, messageId, limit } = req.body
console.log('number: ', number, ' | messageId: ', messageId, ' | limit: ', limit)
try {
const messageToDelete = await getWbotMessage(messageId, number, limit)
await messageToDelete.delete(true)
res.status(200).json({ message: "ok", data: messageToDelete })
return
} catch (error) {
2023-04-24 17:15:07 +00:00
console.log('There was an error on try delete the massage: ', error)
res.status(500).json({ message: "There was an error on trying delete the message" })
return
}
})
app.post('/api/GetProfilePicUrl', async (req, res) => {
const { number } = req.body
console.log('THE NUMBER: ', number)
const profilePicUrl = await client.getProfilePicUrl(`${number}@c.us`)
res.status(200).json({ message: "ok", data: profilePicUrl })
})
app.post('/api/restore', async (req, res) => {
await restore(client)
res.status(200).json({ message: "ok" })
})
app.post('/api/sendSeen', async (req, res) => {
let stat
const { number } = req.body
try {
stat = await client.getState()
// await syncUnreadMessages(client)
const wbotChat = await client.getChatById(number)
wbotChat.sendSeen()
// const chatMessages = await wbotChat.fetchMessages({ limit: 100 });
// console.log('=============> wbotChat: ', chatMessages)
} catch (err) {
let terr = err.message
stat = (terr.search('Session closed') > -1 ? 'SESSIONCLOSED' : 'UNKNOWN')
}
res.status(200).json({ message: "ok" })
})
app.get('/api/connection/status', async (req, res) => {
let stat
try {
stat = await client.getState()
} catch (err) {
let terr = err.message
stat = (terr.search('Session closed') > -1 ? 'SESSIONCLOSED' : 'UNKNOWN')
}
res.status(200).json({ message: "ok", data: stat })
})
const syncUnreadMessages = async (wbot) => {
console.log('ENTROU NO UNREAD MESSAGES +++++++++++++=')
const chats = await wbot.getChats()
/* eslint-disable no-restricted-syntax */
/* eslint-disable no-await-in-loop */
for (const chat of chats) {
// console.log('chat: ', chat)
if (chat.unreadCount > 0) {
const unreadMessages = await chat.fetchMessages({
limit: chat.unreadCount
})
for (const msg of unreadMessages) {
// console.log('--BACKEND MSG: ', msg)
if (!sendSeen) {
return
}
await handleMessage(msg, wbot)
}
console.log(':::::::::::::::::::::::::::::PASSOU')
await chat.sendSeen()
}
}
}
const getWbotMessage = async (messageId, number, limit,) => {
const wbotChat = await client.getChatById(number)
const fetchWbotMessagesGradually = async () => {
const chatMessages = await wbotChat.fetchMessages({ limit })
const msgFound = chatMessages.find(msg => msg.id.id === messageId)
if (!msgFound && limit < 100) {
limit += 20
return fetchWbotMessagesGradually()
}
return msgFound
}
try {
const msgFound = await fetchWbotMessagesGradually()
if (!msgFound) {
return null
}
return msgFound
} catch (err) {
console.log('ERR_FETCH_WAPP_MSG: ', err)
}
return null
}
async function whatsappMonitor(newState, omnihit_url, data) {
const whatsapp = await whatsappUpdateStatus(newState)
if (whatsapp && whatsapp.affectedRows) {
console.log('whatsapp status update affectedRows: ', whatsapp.affectedRows)
}
// console.log(' whatsappwhatsappwhatsappwhatsapp: ', whatsapp)
try {
let response = await axios.post(omnihit_url, data)
} catch (error) {
console.log('There was an error on POST THE DATA TO URL: ', omnihit_url, '\n' + error)
}
}
async function whatsappUpdateStatus(newState) {
return await new Promise((resolve, reject) => {
dbcc.query("UPDATE Whatsapps SET status = ? where id = ?", [newState, process.env.WHATSAPP_ID],
function (err, result) {
if (err) {
console.log("ERROR: " + err)
reject(err)
}
else {
resolve(result)
}
})
})
}
async function handleMessage(msg) {
console.log('Entrou no message_create')
let msgContact = null
let media = null
if (msg.fromMe) {
2024-06-13 20:53:07 +00:00
console.log('MSG FROM ME')
msgContact = await client.getContactById(msg.to)
}
else {
2024-06-13 20:53:07 +00:00
console.log('MSG FROM CLIENT')
console.log('################# RECEIVING MESSAGE FROM: ', msg.from, ' to ', msg.to)
msgContact = await msg.getContact()
}
const chat = await msg.getChat()
msgContact.getProfilePicUrl = await msgContact.getProfilePicUrl()
let quotedMsg = await msg.getQuotedMessage()
if (msg.hasMedia) {
media = await msg.downloadMedia()
}
let data = {
id: process.env.WHATSAPP_ID,
msg: msg,
msgContact: msgContact,
chat: chat,
quotedMsg: quotedMsg ? quotedMsg.id.id : null,
2024-06-13 20:53:07 +00:00
media: media,
getContactById: msg.fromMe ? await client.getContactById(msg.to) : await client.getContactById(msg.from)
}
socketIo.emit("message_create", data)
}
async function getlabels() {
var ret = await client.getContactById('551721379544-1625752306@g.us')
//createGroup('The books', ['551100000000@c.us']);
console.log("-- Chats --------------------------------")
console.log(ret)
return ret
}
function base64_encode(file) {
// read binary data
var bitmap = fs.readFileSync(file)
// convert binary data to base64 encoded string
return new Buffer(bitmap).toString('base64')
}
function getBase64(url) {
return axios
.get(url, {
responseType: 'arraybuffer'
})
.then(response => Buffer.from(response.data, 'binary').toString('base64'))
}
function downloadMedia(url) {
let base64 = axios.get(url, { response: "arraybuffer" }).toString("base64")
console.log("-- BASE64 -------------------------------")
console.log(base64)
return base64
}
async function validate(mobile, cb) {
// let ret = await client.isRegisteredUser(mobile);
let ret = await client.isRegisteredUser(`${mobile}@c.us`)
// ///////////////////////////////////////////////////// 5571992888229 casaes
let _validNumber = null
console.log('******** mobile: ', mobile)
try {
_validNumber = (await client.getNumberId(`${mobile}@c.us`)).user
} catch (err) {
console.log(`Error number: ${err}`)
}
console.log('_validNumber: ', _validNumber)
////////////////////////////////////////////////////////////////////
cb({ isValid: ret, number: _validNumber })
// cb(ret)
}
app.post('/api/validate', (req, res) => {
console.log('ENTROU')
let mobile = req.body['mobile']
console.log(new Date() + " >>> Validating Registration Number ::: " + mobile + " on WhatsApp ...")
validate(mobile, function (e) {
res.send(e)
})
})
app.post('/api/chat', (req, res) => {
let mobile = req.body['mobile']
let message = req.body['message']
console.log(new Date() + " >>> Send Message ::: " + mobile + " ...")
client.sendMessage(mobile, message)
res.send('OK')
})
app.post('/group', function (req, res) {
//var ret = client.createGroup("Prueba", ["55@c.us"]);
var ret = getlabels()
res.send(ret)
})
app.post('/stop', function (req, res) {
client.destroy()
res.send("OK")
})
app.post('/api/status', function (req, res) {
res.send("OK")
})
async function monitor() {
let _nextime = 0
try {
clearInterval(scheduler_monitor)
let stat
if (mobileuid != undefined) {
try {
stat = await client.getState()
} catch (err) {
let terr = err.message
stat = (terr.search('Session closed') > -1 ? 'SESSIONCLOSED' : 'UNKNOWN')
}
// omnihit.monitor(process.env.MOBILEUID, process.env.MOBILENAME, stat);
_nextime = 30000
} else {
_nextime = 10000
}
console.log(`WHATSAPP_ID: ${process.env.WHATSAPP_ID} | CLIENT MOBILEUID: ${mobileuid} | NAME: ${process.env.MOBILENAME} | ENV MOBILEUID: ${process.env.MOBILEUID} | STATUS: ${stat} | INTERNET: ${changeInternetConn}`)
if (stat && stat === 'CONNECTED') {
const result = await whatsappUpdateStatus('CONNECTED')
if (result)
console.log(`Update status to CONNECTED WHATSAPP_ID: ${process.env.WHATSAPP_ID} => result.affectedRows: ${result.affectedRows}`)
}
} catch (error) {
//new Date(new Date() + 'UTC')
// console.log(new Date().toISOString() + " >>> ", error);
console.log(new Date(new Date() + 'UTC') + " >>> ", error)
} finally {
scheduler_monitor = setInterval(monitor, _nextime)
}
}
const sendCampaignMessage = async () => {
try {
clearInterval(scheduler_campaign_monitor)
let internetConnection = await checkInternetConnection()
if (!internetConnection) {
changeInternetConn = false
} else {
changeInternetConn = true
}
// let stat
// try {
// stat = await client.getState()
// } catch (err) {
// stat = (err?.message?.search('Session closed') > -1 ? 'SESSIONCLOSED' : 'UNKNOWN')
// }
// console.log('===========> stat: ', stat)
if (mobileuid != undefined && internetConnection) {
auxCampaignMessage = ''
const campaign = await db.collection('campaigns').findOne({ 'campaign.whatsapp_sender': process.env.MOBILEUID, 'app.status': 'running' })
if (!campaign)
return
const campaigSend = await db.collection('campaignsends').findOne({ campaignId: ObjectId(campaign._id), ack: 1 })
if (!campaigSend) {
const countCampaignSend = await db.collection('campaignsends').countDocuments()
if (countCampaignSend && countCampaignSend > 0) {
await db.collection('campaigns').updateOne({ _id: ObjectId(campaign._id) },
{
$set: {
'app.status': 'success'
}
})
const data = {
id: ObjectId(campaign._id),
status: 'success'
}
socketIo.emit("campaign_message_sent", data)
}
return
}
if (campaign.campaign?.textToSeconds &&
campaign.campaign?.message &&
campaign.campaign.message.trim().length > 0) {
let msgMs = Math.round((campaign.campaign.message.trim().length * 0.1) * 1000)
console.log('AWAITING MESSAGE TEXT LENGTH TO MILISECONDS: ', msgMs)
await sleep(msgMs)
}
if (campaign.campaign?.secondStart && campaign.campaign?.secondEnd) {
let randomTime = getRandomNumber(campaign.campaign.secondStart, campaign.campaign.secondEnd) * 1000
console.log('AWAITING RANDOM TIME TO SEND CAMPAIGN MESSAGE: ', randomTime)
await sleep(randomTime)
}
auxCampaignMessage = campaign.campaign.message
const sentMessage = await client.sendMessage(`${campaigSend.number}@c.us`, campaign.campaign.message)
if (sentMessage) {
const updateResult = await db.collection('campaignsends').updateOne({ _id: ObjectId(campaigSend._id) },
{
$set: {
whatsapp_msg_id: sentMessage.id.id,
sender: process.env.MOBILEUID,
delivered: new Date(new Date() + "UTC"),
ack: 2
}
})
// console.log('RESULT: ', updateResult)
const sent = await db.collection('campaignsends').countDocuments({ campaignId: ObjectId(campaign._id), $or: [{ ack: 2 }, { ack: 3 }] })
const data = {
id: ObjectId(campaign._id),
sent
}
socketIo.emit("campaign_message_sent", data)
}
}
} catch (error) {
console.log('error on sendCampaignMessage: ', error)
}
finally {
scheduler_campaign_monitor = setInterval(sendCampaignMessage, 3000)
}
}
async function monitorCell() {
try {
clearInterval(scheduler_monitor_cell)
// let _contact_mobile = "5511954803572@c.us";
let _message = new Date(new Date() + 'UTC')
if (client.info && client.info["wid"]["user"]) {
client.sendMessage(`${process.env.MONITOR_NUMBER}@c.us`, _message)
}
} catch (error) {
console.log(`Error on send monitor message to number ${process.env.MONITOR_NUMBER} from monitorCell function: ${error}`)
} finally {
scheduler_monitor_cell = setInterval(monitorCell, 1800000)
}
}
async function internetMonitor() {
try {
clearInterval(scheduler_internet_conn)
if (!changeInternetConn) {
console.log('INTERNET IS OFFLINE. THE PM2 WILL RESTORE THE PROCESS')
process.exit()
}
} catch (error) {
console.log(`Error on try kill the process from internetMonitor function`)
} finally {
scheduler_internet_conn = setInterval(internetMonitor, 60000)
}
}
function comercialBuss(until_hour) {
const _hour = new Date().getHours()
console.log(' _hour: ', _hour)
// const _minute = new Date().getMinutes()
// const _second = new Date().getSeconds()
if (_hour >= until_hour) {
console.log('Trying send message into comercial buss!')
return
}
}
scheduler_monitor = setInterval(monitor, 10000)
// scheduler_campaign_monitor = setInterval(sendCampaignMessage, 3000)
// scheduler_internet_conn = setInterval(internetMonitor, 60000)
app.listen(process.env.PORT || 8003, function () {
console.log("\u26A1[server]: Server is running at Port ::: " + process.env.PORT || 8003)
})
process.on('uncaughtException', function (err) {
console.error(' ')
console.error('----- ' + (new Date).toUTCString() + ' ----------------------------------')
console.error('Erro uncaughtException: ', err.message)
console.error(err.stack)
console.error(' ')
return
});