zbx_mediatypes_whatsapp_connectzap_to_group.yaml

zabbix_export:
  version: "6.4"
  media_types:
    - name: "WhatsApp (ConnectZap API - To Group)"
      type: WEBHOOK
      parameters:
        - name: Authorization
          value: "<token_api>"
        - name: Message
          value: "{ALERT.MESSAGE}"
        - name: ParseMode
          value: ""
        - name: Subject
          value: "{ALERT.SUBJECT}"
        - name: To
          value: "{ALERT.SENDTO}"
        - name: Url
          value: "http://localhost:8080"
      attempts: "1"
      script: |
        var WhatsApp = {
            baseurl: null,
            Authorization: null,
            to: null,
            message: null,
            proxy: null,
            parse_mode: null,

            escapeMarkup: function (str, mode) {
                switch (mode) {
                    case 'markdown':
                        return str.replace(/([_*\[`])/g, '\\$&');

                    case 'markdownv2':
                        return str.replace(/([_*\[\]()~`>#+\-=|{}.!])/g, '\\$&');

                    case 'html':
                        return str.replace(/<(\s|[^a-z\/])/g, '&lt;$1');

                    default:
                        return str;
                }
            },

            sendMessage: function () {
                var params = {
                    SessionName: WhatsApp.Authorization,
                    groupId: WhatsApp.to,
                    msg: WhatsApp.message,
                },
                data,
                response,
                request = new HttpRequest(),
                url = WhatsApp.baseurl + '/sistema/sendTextGrupo';

                if (WhatsApp.parse_mode !== null) {
                    params['parse_mode'] = WhatsApp.parse_mode;
                }

                if (WhatsApp.proxy) {
                    request.setProxy(WhatsApp.proxy);
                }

                request.addHeader('Content-Type: application/json');
                data = JSON.stringify(params);

                // Remove replace() function if you want to see the exposed token in the log file.
                Zabbix.log(4, '[WhatsApp Webhook] URL: ' + url);
                Zabbix.log(4, '[WhatsApp Webhook] params: ' + data);
                response = request.post(url, data);
                Zabbix.log(4, '[WhatsApp Webhook] HTTP code: ' + request.getStatus());

                if (request.getStatus() == 200 || request.getStatus() == 201 || request.getStatus() == 202) {
                    // we did it. lets just exit for now.
                    Zabbix.log(4, '[WhatsApp Webhook] request sent successfully');
                    return;
                } else {
                    throw 'Unknown error. Check debug log for more information.';
                }
            }
        };

        try {
            var params = JSON.parse(value);

            if (typeof params.Url === 'undefined') {
                throw 'Incorrect value is given for parameter "Url": parameter is missing';
            }

            if (typeof params.Authorization === 'undefined') {
                throw 'Incorrect value is given for parameter "Authorization": parameter is missing';
            }

            if (typeof params.To === 'undefined') {
                throw 'Incorrect value is given for parameter "to": parameter is missing';
            }

            if (typeof params.Message === 'undefined') {
                throw 'Incorrect value is given for parameter "message": parameter is missing';
            }

            WhatsApp.baseurl = params.Url;
            WhatsApp.Authorization = params.Authorization;

            if (params.HTTPProxy) {
                WhatsApp.proxy = params.HTTPProxy;
            } 

            params.ParseMode = params.ParseMode.toLowerCase();
            
            if (['markdown', 'html', 'markdownv2'].indexOf(params.ParseMode) !== -1) {
                WhatsApp.parse_mode = params.ParseMode;
            }

            WhatsApp.to = params.To;
            WhatsApp.message = params.Subject + '\n' + params.Message;

            if (['markdown', 'html', 'markdownv2'].indexOf(params.ParseMode) !== -1) {
                WhatsApp.message = WhatsApp.escapeMarkup(WhatsApp.message, params.ParseMode);
            }

            WhatsApp.sendMessage();

            return 'OK';
        }
        catch (error) {
            Zabbix.log(4, '[WhatsApp Webhook] notification failed: ' + error);
            throw 'Sending failed: ' + error + '.';
        }
      timeout: 10s
      description: |
        Template de Alertas do Zabbix
        
        Alertas de Problemas (Triggers)
           Fonte do Evento: TRIGGERS
           Modo de Operação: PROBLEM
           Assunto: "Problem: {EVENT.NAME}"
           Mensagem:
             Início do problema às `{EVENT.TIME}` em `{EVENT.DATE}`
             Nome do problema: `{EVENT.NAME}`
             Host: `{HOST.NAME}`
             Severidade: `{EVENT.SEVERITY}`
             Dados operacionais: `{EVENT.OPDATA}`
             ID original do problema: `{EVENT.ID}`
             URL do Trigger: `{TRIGGER.URL}`
        
        Alertas de Recuperação (Triggers)
           Fonte do Evento: TRIGGERS
           Modo de Operação: RECOVERY
           Assunto: "Resolved in {EVENT.DURATION}: {EVENT.NAME}"
           Mensagem:
             Problema resolvido em `{EVENT.DURATION}` às `{EVENT.RECOVERY.TIME}` em `{EVENT.RECOVERY.DATE}`
             Nome do problema: `{EVENT.NAME}`
             Host: `{HOST.NAME}`
             Severidade: `{EVENT.SEVERITY}`
             ID original do problema: `{EVENT.ID}`
             URL do Trigger: `{TRIGGER.URL}`
        
        Atualizações de Problemas (Triggers)
           Fonte do Evento: TRIGGERS
           Modo de Operação: UPDATE
           Assunto: "Updated problem: {EVENT.NAME}"
           Mensagem:
             `{USER.FULLNAME}` `{EVENT.UPDATE.ACTION}` o problema em `{EVENT.UPDATE.DATE}` `{EVENT.UPDATE.TIME}`.
             Mensagem de atualização: `{EVENT.UPDATE.MESSAGE}`
             Status atual do problema: `{EVENT.STATUS}`, reconhecimento: `{EVENT.ACK.STATUS}`.
        
        Descoberta de Dispositivos (Discovery)
           Fonte do Evento: DISCOVERY
           Modo de Operação: PROBLEM
           Assunto: "Discovery: {DISCOVERY.DEVICE.STATUS} {DISCOVERY.DEVICE.IPADDRESS}"
           Mensagem:
             Regra de descoberta: `{DISCOVERY.RULE.NAME}`
             IP do dispositivo: `{DISCOVERY.DEVICE.IPADDRESS}`
             DNS do dispositivo: `{DISCOVERY.DEVICE.DNS}`
             Status do dispositivo: `{DISCOVERY.DEVICE.STATUS}`
             Tempo de atividade do dispositivo: `{DISCOVERY.DEVICE.UPTIME}`
             Nome do serviço do dispositivo: `{DISCOVERY.SERVICE.NAME}`
             Porta do serviço do dispositivo: `{DISCOVERY.SERVICE.PORT}`
             Status do serviço do dispositivo: `{DISCOVERY.SERVICE.STATUS}`
             Tempo de atividade do serviço do dispositivo: `{DISCOVERY.SERVICE.UPTIME}`
        
        Auto-registro de Hosts (Auto Registration)
           Fonte do Evento: AUTOREGISTRATION
           Modo de Operação: PROBLEM
           Assunto: "Autoregistration: {HOST.HOST}"
           Mensagem:
             Nome do host: `{HOST.HOST}`
             IP do host: `{HOST.IP}`
             Porta do agente: `{HOST.PORT}`
      message_templates:
        - event_source: TRIGGERS
          operation_mode: PROBLEM
          subject: "*Problem:* {EVENT.NAME}"
          message: |
            *Problem started:* {EVENT.TIME} on {EVENT.DATE}
            *Problem name:* {EVENT.NAME}
            *Host:* {HOST.NAME}
            *Severity:* {EVENT.SEVERITY}
            *Operational data:* {EVENT.OPDATA}
            *Original problem ID:* {EVENT.ID}
            {TRIGGER.URL}
        - event_source: TRIGGERS
          operation_mode: RECOVERY
          subject: "*Resolved:* {EVENT.DURATION}: {EVENT.NAME}"
          message: |
            *Problem resolved:* {EVENT.DURATION} at {EVENT.RECOVERY.TIME} on {EVENT.RECOVERY.DATE}
            *Problem name: {EVENT.NAME}
            *Host:* {HOST.NAME}
            *Severity:* {EVENT.SEVERITY}
            *Original problem ID*: {EVENT.ID}
            {TRIGGER.URL}
        - event_source: TRIGGERS
          operation_mode: UPDATE
          subject: "*Updated problem:* {EVENT.NAME}"
          message: |
            {USER.FULLNAME} {EVENT.UPDATE.ACTION} problem at {EVENT.UPDATE.DATE} {EVENT.UPDATE.TIME}.
            {EVENT.UPDATE.MESSAGE}

            Current problem status is {EVENT.STATUS}, acknowledged: {EVENT.ACK.STATUS}.
        - event_source: DISCOVERY
          operation_mode: PROBLEM
          subject: "*Discovery:* {DISCOVERY.DEVICE.STATUS} {DISCOVERY.DEVICE.IPADDRESS}"
          message: |
            *Discovery rule:* {DISCOVERY.RULE.NAME}

            *Device IP:* {DISCOVERY.DEVICE.IPADDRESS}
            *Device DNS:* {DISCOVERY.DEVICE.DNS}
            *Device status:* {DISCOVERY.DEVICE.STATUS}
            *Device uptime:* {DISCOVERY.DEVICE.UPTIME}

            *Device service name:* {DISCOVERY.SERVICE.NAME}
            *Device service port:* {DISCOVERY.SERVICE.PORT}
            *Device service status:* {DISCOVERY.SERVICE.STATUS}
            *Device service uptime:* {DISCOVERY.SERVICE.UPTIME}
        - event_source: AUTOREGISTRATION
          operation_mode: PROBLEM
          subject: "Autoregistration: {HOST.HOST}"
          message: |
            *Host name:* {HOST.HOST}
            *Host IP:* {HOST.IP}
            *Agent port:* {HOST.PORT}