مشاهدة ملف: waserver.js

// const makeWASocket = require('@whiskeysockets/baileys')
const { join } = require('path')
const { makeWASocket, useMultiFileAuthState, makeInMemoryStore, Browsers, DisconnectReason, delay } = require('@whiskeysockets/baileys')
const { rmSync, readdir } = require('fs');
const { request } = require('./request');


const sessionPath = (filename = '') => {
    return join(__dirname, "sessions", filename);
}
const sessions = new Map();

const scan = async function (device_id, socket = null) {

    const { state, saveCreds } = await useMultiFileAuthState(sessionPath(device_id))

    const sock = makeWASocket({
        printQRInTerminal: false,
        auth: state,
        version: [2, 2323, 4],
        browser: Browsers.ubuntu('Chrome'),
    });
    const store = makeInMemoryStore({})
    store.readFromFile(sessionPath(device_id + "_store.json"))
    store.bind(sock.ev);

    sessions.set(device_id, {
        ...sock,
        store: store
    })
    sock.ev.on('creds.update', saveCreds)

    sock.ev.on('connection.update', async (update) => {
        const { connection, lastDisconnect } = update;
        const statusCode = lastDisconnect?.["error"]?.['output']?.["statusCode"];
        if (connection === 'close') {
            let shouldReconnect = (lastDisconnect.error)?.output?.statusCode !== DisconnectReason.loggedOut
            if (statusCode == DisconnectReason.restartRequired) {
                shouldReconnect = true;
            }
            if (statusCode == DisconnectReason.connectionClosed) {
                shouldReconnect = true;
            }
            if (statusCode == DisconnectReason.timedOut) {
                shouldReconnect = true;
            }
            if (statusCode == DisconnectReason.loggedOut) {
                if (socket && socket.connected) {
                    socket.emit('logout');
                }
                removeSession(device_id);
                request('post', 'change/device/status', { device_id: device_id, status: 'inactive' })
            }
            if (shouldReconnect) {
                scan(device_id, socket)
            }
        } else if (connection === 'open') {
            //console.log('opened connection')
        }

        if (update.qr) {
            // const qrCode = await toDataURL(update.qr);
            if (socket && socket.connected) {
                socket.emit('qrcode', { id: device_id, code: update.qr })
            }
        }
        if(update.isNewLogin && update.qr==undefined && socket && socket.connected){
            socket.emit('scanned',{id:device_id});
        }
    })

    sock.ev.on('messages.upsert', async (m) => {
        m=m.messages[0];
        if (!m | !m.message) return; // if there is no text or media message
        if (m.key.fromMe) return; // if from me then return

        const messageFrom=m.key.remoteJid.split('@');
        const isFromSingleUser=messageFrom[1]=='s.whatsapp.net';

        if(!isFromSingleUser) return;
        
        const messageType = Object.keys(m.message)[0]// get what type of message it is -- text, image, video

        const from=messageFrom[0];
        let message=m.message[messageType];

        if(message.text){
            message=message.text;
        }
        
        //console.log(from,device_id,message);

        request('post','inbound',{from:from,to:device_id,message:message}).then((res)=>{
            //console.log(res);
        }).catch((e)=>{
            console.log(e);
        })

    })

    sock.ev.on('messages.update',(updates)=>{
        //console.log("message update",updates)
        let data={};
        updates.forEach((value)=>{
            const messageId=value?.key?.id;
            const fromMe=value?.key?.fromMe;
            const status=value?.update?.status;
            if(messageId && fromMe && status){
                if(status==4){
                    data[""+value.key.id]="delivered";
                }
                
            }
        })

        if(Object.keys(data).length){
            request('post', 'change/message/status', { data:data})
        }

    })


}

const init = () => {
    console.log("triggering init on whatsapp server")
    readdir(sessionPath(), (err, sessionPath) => {
        if (err) {
            throw err;
        }
        
        for (const pathName of sessionPath) {
            if (pathName=='.gitignore' | pathName.includes("_store.json")) {
                continue;
            }
            scan(pathName)
        }

    });
}

const saveSessions = () => {
    sessions.forEach((session, device_id) => {
        session.store.writeToFile(sessionPath(device_id + "_store.json"));
    })
}
const getSession = device_id => {
    return sessions.get(device_id) ?? null;
};

const removeSession = (device_id) => {
    rmSync(sessionPath(device_id), { recursive: true, force: true });
    rmSync(sessionPath(device_id + "_store.json"), { force: true });
    sessions.delete(device_id);
}

const send = async (session, to, text, d = 2000) => {
    try {
        await delay(parseInt(d));
        return session.sendMessage(to, { text: text });
    } catch {
        return Promise.reject(null);
    }
}
const formatNumber = number => {
    if (number.endsWith("@s.whatsapp.net")) {
        return number;
    }
    let phone = number.replace(/\D/g, '');
    return phone += "@s.whatsapp.net";
};

module.exports = { init, scan, send, sessions, saveSessions, formatNumber };