@bonsaif/bonsaif-wa/src/index.js

Utileria para poder consumir servicios de WhatsApp CloudApi

'use strict'

const fetch = require ('node-fetch');
const logger = require('./Logger');
const fs = require('fs');

class WAMetaService{

    tokenAcceso = '';
    app_id = '';
    identificadorNumTel = '';
    identificadorCtaWA = '';
    version = "";
    debug = false;
    VERSION_DEFAULT = "v16.0";

    constructor (options){
        this.tokenAcceso = options.tokenAcceso;
        this.app_id = options.app_id;
        this.identificadorNumTel = options.identificadorNumTel;
        this.identificadorCtaWA = options.identificadorCtaWA;
        this.version = options.version || this.VERSION_DEFAULT;
        this.debug = options.debug || this.debug;
        //logger.DEBUG = this.debug;
        logger.DEBUG = this.debug;
    }

    getTemplates(filterTemplate){
        const tag = `ServiceGetTemplates`;
        logger.log(tag);

        let categoryFilter = "";
        let contentFilter  ="";
        let languageFilter = "";
        let nameFilter = "";
        let name_or_contentFilter = "";
        let quality_scoreFilter  = "";
        let statusFilter = "";
        let limit = "300";

        if(filterTemplate.category != undefined){
            categoryFilter = filterTemplate.category;
        }
        if(filterTemplate.content != undefined){
            contentFilter = filterTemplate.content;
        }
        if(filterTemplate.language != undefined){
            languageFilter = filterTemplate.language;
        }
        if(filterTemplate.name != undefined){
            nameFilter = filterTemplate.name;
        }
        if(filterTemplate.name_or_content != undefined){
            name_or_contentFilter = filterTemplate.name_or_content;
        }
        if(filterTemplate.quality_score != undefined){
            quality_scoreFilter = filterTemplate.quality_score;
        }
        if(filterTemplate.status != undefined){
            statusFilter = filterTemplate.status;
        }

        if(filterTemplate.limit != undefined){
            limit = filterTemplate.limit;
        }
        
        const url_message_templates = `https://graph.facebook.com/${this.version}/${this.identificadorCtaWA}/message_templates?fields=category,content,language,name,quality_score,status&category=${categoryFilter}&content=${contentFilter}&language=${languageFilter}&name=${nameFilter}&name_or_content=${name_or_contentFilter}&quality_score=${quality_scoreFilter}&status=${statusFilter}&limit=${limit}`;
        let obj = {
        object: {
            method: 'GET',
            headers: {
              'Accept': 'application/json',
              'Content-Type': 'application/json',
              'Authorization': 'Bearer ' + this.tokenAcceso,
            }
          }
        }

        logger.log(`${tag} url ${url_message_templates}`);

        return fetch(url_message_templates,obj.object);
    }

    getTemplate(name,language,status){
        const tag = `ServiceGetTemplate`;
        logger.log(tag);

        let nameTemplate = name;
        let languageTemplate = language;
        let statusTempalte = status;
      
        const url_message_templates = `https://graph.facebook.com/${this.version}/${this.identificadorCtaWA}/message_templates?name=${nameTemplate}&language=${languageTemplate}&status=${statusTempalte}`;
        let obj = {
        object: {
            method: 'GET',
            headers: {
              'Accept': 'application/json',
              'Content-Type': 'application/json',
              'Authorization': 'Bearer ' + this.tokenAcceso,
            }
          }
        }

        return fetch(url_message_templates,obj.object);
    }

    insertTemplate(template,bBody = false){
        const tag = `ServiceInsertTemplate`;
        logger.log(tag);

        let components= JSON.stringify(template.components); 

        let url_message_templates = "";
        let bodyMeta = {};
        let decodeComponents = "";

        if(bBody === true){
            url_message_templates = `https://graph.facebook.com/${this.version}/${this.identificadorCtaWA}/message_templates`;

            bodyMeta = {
                allow_category_change: true,
                name: template.name,
                language: template.language,
                category: template.category,
                components: template.components
            }

        }else{
            components = encodeURIComponent(components);
            url_message_templates = `https://graph.facebook.com/${this.version}/${this.identificadorCtaWA}/message_templates?name=${template.name}&language=${template.language}&category=${template.category}&components=${components}&access_token=${this.tokenAcceso}`;
        }

        let obj = {
            object: {
                method: 'POST',
                headers: {
                  'Accept': 'application/json',
                  'Content-Type': 'application/json',
                  'Authorization': 'Bearer ' + this.tokenAcceso,
                }
            }
        }
    
        if(bBody === true){
            obj.object.body = JSON.stringify(bodyMeta);
        }

        return fetch(url_message_templates,obj.object)
            .then(res => res.json())
            .then(data =>{
                logger.log(data)
                return data;
            }).catch(error => {
                logger.log(tag + 'error al procesar api', error); 
            });   
    }

    updateTemplate(template,bBody = false){
        const tag = "ServiceUpdateTemplate";
        logger.log(tag)
        const components= JSON.stringify(template.components);
        const id = template.id;

        const url_message_templates = `https://graph.facebook.com/${this.version}/${id}?components=${components}&access_token=${this.tokenAcceso}`;

        logger.log(url_message_templates);

        let obj = {
            object: {
                method: 'POST',
                headers: {
                  'Accept': 'application/json',
                  'Content-Type': 'application/json',
                  'Authorization': 'Bearer ' + this.tokenAcceso,
                }
            }
        }

        if(bBody === true){
            obj.object.body = JSON.stringify(bodyMeta);
        }
        
        return fetch(url_message_templates, obj.object)
            .then(res => res.json())
            .then(data =>{
                logger.log(data)
                return data;
            }).catch(error => {
                logger.log(tag + 'error al procesar api', error); 
            });
    }

    deleteTemplate(name){
        const tag = "ServiceDeleteTemplate";

        const url_message_templates = `https://graph.facebook.com/${this.version}/${this.identificadorCtaWA}/message_templates?name=${name}&access_token=${this.tokenAcceso}`;

        let obj = {
            object: {
                method: 'DELETE',
                headers: {
                  'Accept': 'application/json',
                  'Content-Type': 'application/json',
                  'Authorization': 'Bearer ' + this.tokenAcceso,
                }
            }
        }
        
        return fetch(url_message_templates, obj.object)
            .then(res => res.json())
            .then(data =>{
                logger.log(data)
                return data;
            }).catch(error => {
                logger.log(tag + 'error al procesar api', error); 
            });
    }

    checkTemplateStatus(template){
        const tag = "checkTemplateStatus";

        console.log(tag);

        const url_message_templates = `https://graph.facebook.com/${this.version}/${this.identificadorCtaWA}/message_templates?fields=category,content,language,name,quality_score,status`

        let obj = {
            object: {
                method: 'GET',
                headers: {
                  'Accept': 'application/json',
                  'Content-Type': 'application/json',
                  'Authorization': 'Bearer ' + this.tokenAcceso,
                }
            }
        }

        return fetch(url_message_templates,obj.object)
        .then(res => res.json())
        .then(data =>{
                console.log(data);
                data.data.map(elem => {
                    console.log(elem);
                })
                return data;
            }).catch(error => {
            console.log(tag + 'error al procesar api', error); 
        });
    }

    getFileUploadSessionID(fileObj){
        const tag = "getFileUploadSessionID";
        const {file_size, file_type, file} = fileObj;
        // const url = `https://graph.facebook.com/${this.version}/483415689962601/uploads?file_length=${file_size}&file_type=${file_type}&access_token=${this.tokenAcceso}`;
        const url = `https://graph.facebook.com/${this.version}/${this.app_id}/uploads?file_length=${file_size}&file_type=${file_type}&access_token=${this.tokenAcceso}`;

        let obj = {
            object: {
                method: 'POST',
                headers: {
                  'Accept': 'application/json',
                  'Content-Type': 'application/json',
                  'Authorization': 'Bearer ' + this.tokenAcceso,
                }
            }
        }

        return fetch(url, obj.object)
            .then(res => res.json())
            .then(async data =>{
                console.log(data);
                const uploadID = await this.uploadFile(data.id, file);

                return uploadID;
            }).catch(error => {
                console.log(tag + 'error al procesar api', error); 
            });
    }

    async uploadFile(uploadID, file){
        const tag = "uploadFile";
        console.log(tag);
        console.log("# ~ file: index.js:253 ~ WAMetaService ~ uploadFile ~ uploadID", uploadID);

        const url = `https://graph.facebook.com/${this.version}/${uploadID}`;

        const dataFinal =  fs.readFileSync(file.path);

        var requestOptions = {
            method: 'POST',
            headers: {
                'Authorization': 'OAuth ' + this.tokenAcceso,
                "file_offset": "0",
                "Content-Type": file.type,
                "Content-Length" : file.size
            },
            body: dataFinal,
            redirect: 'follow'
        };

        return fetch(url, requestOptions)
            .then(response => response.json())
            .then(result => {
                console.log(result);
                return result;
            })
            .catch(error => console.log('error', error));

    }

    getAccountDetails(){
        const tag = `getAccountDetails`;
        logger.log(tag);

        const url = `https://graph.facebook.com/${this.version}/${this.identificadorCtaWA}/phone_numbers?access_token=${this.tokenAcceso}`;
        
        let requestOptions = {
            method: 'GET',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': 'Bearer ' + this.tokenAcceso,
            }
        }

        return fetch(url, requestOptions)
            .then(response => response.json())
            .then(result => {
                if (result.error) { return [] }

                const data = result.data;

                if (data.length>0) {
                    const found = data.find(element => element.id == this.identificadorNumTel);
                    return found;
                }else{
                    return [];
                }

            })
            .catch(error => console.log('error', error));
    }

    async sendMessageMeta(body){
        const tag = `ServiceSendMessageMeta`;
        logger.log(tag);

        const respMeta = new Array();
        const resp = new Array();

        const url_send_message = `https://graph.facebook.com/${this.version}/${this.identificadorNumTel}/messages`;

        if(typeof body === 'object' && Array.isArray(body)){

            for(let index = 0; index < body.length; index ++){
                let bodyMessage = JSON.stringify(body[index])
                
                let obj = {
                    object: {
                        method: 'POST',
                        redirect: 'follow',
                        body: bodyMessage,
                        headers: {
                        'Accept': 'application/json',
                        'Content-Type': 'application/json',
                        'Authorization': 'Bearer ' + this.tokenAcceso
                        }
                    }
                }

                respMeta[index] = await fetch(url_send_message, obj.object)
                    .then(res => res.json())
                    .then(data =>{
                        return data;                      
                    }).catch(error => {
                        logger.log(tag + 'error al enviar mensaje', error);
                    });

                    resp[index] = [{body: body[index], resp: respMeta[index]}]
                }

                return resp;
        }else{
            logger.log(tag + ' Metodo de entrada no es un Array');
        }
    }

    sendMessageTemplate(bodyMessage){
        const tag = `sendMessageTemplate`;
        logger.log(tag);
        const url_send_message = `https://graph.facebook.com/${this.version}/${this.identificadorNumTel}/messages`;
        
        let obj = {
            method: 'POST',
            redirect: 'follow',
            body: JSON.stringify(bodyMessage),
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Cache-Control': 'max-age=3600',//Para mantenerlo en cache por 3600 segundos para alguna peticion posterior que utlice imagenes/documentos/videos
                'Authorization': 'Bearer ' + this.tokenAcceso
            }
        }

        return fetch(url_send_message, obj);
    }
}

module.exports = {WAMetaService};