WA-api/model/messageModel.js

const qrcode = require("qrcode-terminal");
const fs = require("fs");

// const path = require("path");
const { Client, Chat, Message } = require("whatsapp-web.js");
// const SESSION_FOLDER = path.join(__dirname, "../data/");
// const SESSION_FILE_PATH = path.join(__dirname, "../data/session.json");
// const sessions = require("../api/session_data");
const { parseMultipartData, sanitizeEntity } = require("strapi-utils");

var client;
//Login Session when there is Session File

function callbacks(client, callback, type = "create") {
    // console.log("starting", type);
    let sessionData;
    client.on("auth_failure", (session) => {
        // console.log("auth_failure");
        return callback({
            STATUS: 0,
            TYPE: "AUTH_FAILURE",
            DATA: "SESSION HAS BEEN ENDED , PLEASE CREATE A NEW ONE !",
        });
    });
    client.on("disconnected", async function (session) {
        console.log("disconnected from ", type, session);
        if (session == "UNPAIRED" || session == "CONFLICT") {
            try {
                if (type == "load" && client && client.info) {
                    console.log(getID);
                    getID = await strapi
                        .query("session-data")
                        .findOne({ phonenumber: client.info.wid.user });
                    console.log(getID);
                    if (getID) {
                        let id = getID["id"];
                        await strapi.api["session-data"].services[
                            "session-data"
                        ].delete({ id });
                    }
                    await client.destroy();
                }
            } catch (e) {}
        }
    });

    client.on("ready", async () => {
        // console.log("ready");
        var clientInfo = client.info;
        clientInfo["sessionData"] = sessionData;
        if (type == "create") await client.destroy();
        return callback({
            STATUS: 1,
            TYPE: "READY",
            DATA: type == "create" ? clientInfo : client,
        });
    });
    client.on("message", async (msg) => {
        // console.log("MESSAGE RECEIVED", msg.body);
    });
    client.on("qr", (qr) => {
        return callback({ STATUS: 1, TYPE: "QR_AUTH", DATA: qr });
    });

    client.on("change_state", (state) => {
        // console.log(`state => ${state}`);
    });
    client.on("authenticated", (session) => {
        console.log("authenticated");
        try {
            sessionData = session;
            // fs.writeFileSync(SESSION_FILE_PATH, JSON.stringify(session));
        } catch (e) {
            return callback({
                STATUS: 0,
                TYPE: "AUTHENTICATED_ERROR",
                DATA: e.message,
            });
        }
    });
}

var loadClient = async function (clientSessionData, callback) {
    try {
        // if(!client){
        //     console.log(client.info);
        //     return callback({"STATUS" : 1 , "TYPE" : "READY" , "DATA" : client.info})
        // }
        // let sessionPath = path.join(SESSION_FOLDER, `${phoneNumber}.json`);
        // if (fs.existsSync(sessionPath)) {
        // sessionData = require(sessionPath);

        client = new Client({
            puppeteer: {
                args: ["--no-sandbox", "--disable-setuid-sandbox"],
            },
            session: clientSessionData,
            restartOnAuthFail: true,
        });

        callbacks(client, callback, "load");
        // console.log("initialize");
        client.initialize();
    } catch (e) {
        // console.log(e);
        return callback({
            STATUS: 0,
            TYPE: "ERROR",
            DATA: e.message,
        });
    }
};

function asyncLoadClient(i) {
    return new Promise((resolve, reject) => {
        try {
            loadClient(i["session_data"], async (data) => {
                return resolve(data);
            });
        } catch (e) {
            return reject(e.message);
        }
    });
}

var createNewClient = async function (callback) {
    try {
        client = new Client({
            puppeteer: {
                args: ["--no-sandbox", "--disable-setuid-sandbox"],
            },
        });

        callbacks(client, callback);
        console.log("initialize");
        client.initialize();
        //var clientInfo = await getClientInfo();
        //return clientInfo;
    } catch (e) {
        return callback({ STATUS: 0, TYPE: "READY", DATA: e.message });
    }
};

var sendMessage = async function (client, phone_number, textMessage) {
    try {
        if (!client.info) {
            throw { message: "Client Is Not Ready !" };
        }
        // var phoneNumber = reformatMobilePhone(phone_number);
        // var state = await client.isRegisteredUser(phoneNumber);
        // console.log(state);

        var sending = await client.sendMessage(phone_number, textMessage);
        return { STATUS: 1, DATA: sending };
    } catch (e) {
        console.log(e);
        return { STATUS: 0, DATA: e.message };
    }
};

var getMessagebyId = async function (client, chatId, param = {}) {
    try {
        if (!client.info) {
            throw { message: "Client Is Not Ready !" };
        }
        var chat = await client.getChatById(chatId._serialized);
        var messageList = await chat.fetchMessages(param);
        // console.log(messageList);
        return { STATUS: 1, DATA: messageList };
    } catch (e) {
        // console.log(e);
        return { STATUS: 0, DATA: e.message };
    }
};

var getAllChats = async function (client) {
    try {
        if (!client || !client.info) {
            throw { message: "Client Is Not Ready !" };
        }
        let chatList = await client.getChats();
        return { STATUS: 1, DATA: chatList };
    } catch (e) {
        return { STATUS: 0, DATA: e.message };
    }
};

var getClientInfo = function () {
    try {
        var a;
        while (!a) {
            a = client.info;
        }
        return { STATUS: 1, DATA: a };
    } catch (e) {
        return { STATUS: 0, DATA: e.message };
    }
};

var getClientState = async function () {
    try {
        if (!client.info) {
            throw { message: "Client Is Not Ready !" };
        }
        let state = await client.getState();
        return { STATUS: 1, DATA: state };
    } catch (e) {
        return { STATUS: 0, DATA: e.message };
    }
};

var destroySession = async function (phoneNumber) {
    try {
        if (client && client.info) {
            await client.logout();
            await client.destroy();
            clearFileSession(phoneNumber);
            return { STATUS: 1, DATA: "Session cleared" };
        } else throw { message: "Client Is Not Ready !" };
    } catch (e) {
        return { STATUS: 0, DATA: e.message };
    }
};

function reformatMobilePhone(phoneNumber) {
    var newPhoneNumber;
    if (phoneNumber[0].toString() == "0") {
        newPhoneNumber = "62" + phoneNumber.substring(1) + "@c.us";
    } else if (phoneNumber[0] == "+") {
        newPhoneNumber = phoneNumber.substring(1) + "@c.us";
    } else {
        newPhoneNumber = phoneNumber + "@c.us";
    }

    return newPhoneNumber;
}

function clearFileSession(phoneNumber) {
    try {
        let sessionPath = path.join(SESSION_FOLDER, `${phoneNumber}.json`);
        if (fs.existsSync(sessionPath)) {
            console.log(`clearing session ${phoneNumber}`);
            fs.unlinkSync(sessionPath);
        }
    } catch (e) {
        throw e;
    }
}

module.exports = {
    sendMessage: sendMessage,
    createNewClient: createNewClient,
    loadClient: loadClient,
    getClientInfo: getClientInfo,
    destroySession: destroySession,
    getClientState: getClientState,
    getClientState: getClientState,
    getMessagebyId: getMessagebyId,
    getAllChats: getAllChats,
    asyncLoadClient: asyncLoadClient,
};