node-red-contrib-hik-media-buffer 1.1.80 → 1.1.82

package/hik-media-buffer.js

@@ -1,11 +1,8 @@
-const axios = require('axios');
-const AxiosDigestAuth = require('@mhoc/axios-digest-auth').default;
-const https = require('https');
+const got = require('got'); // Assicurati di aver installato got@11 nel container!
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { exec } = require('child_process');
-const { channel } = require('diagnostics_channel');
 
 module.exports = function(RED) {
     function HikMediaBufferNode(config) {
@@ -18,16 +15,13 @@ module.exports = function(RED) {
         node.protocol = config.protocol || "http";
         node.user = config.user;
         node.pass = config.pass;
-        node.camPass = config.camPass || config.pass;
-        node.cameras = config.cameras || [];
 
-        let streamRequest = null;
+        let activeStream = null;
         let isClosing = false;
         let lastTriggerTime = {};
         let nvrOnline = true;
-        let statoCamera = {}; 
+        let statoCamera = {}; // Indicizzato per ChannelID: true = online, false = offline
 
-        const httpsAgent = new https.Agent({ rejectUnauthorized: false });
         const EventList = ["FieldDetection", "LineDetection"];
 
         // CARTELLA TEMPORANEA 
@@ -38,60 +32,66 @@ module.exports = function(RED) {
 
         function toHikDate(d) { return d.toISOString().split('.')[0] + "Z"; }
 
-        // --- PRENDE IL NOME DELLA TELECAMERA ---
-        async function getCameraName(cam) {
-            const camAuth = new AxiosDigestAuth({ 
-                username: node.user, 
-                password: node.camPass 
-            });
+        // Client base di GOT configurato con il Digest nativo per l'NVR
+        const nvrClient = got.extend({
+            prefixUrl: `${node.protocol}://${node.host}:${node.port}/ISAPI`,
+            username: node.user,
+            password: node.pass,
+            authentication: 'digest',
+            retry: 0,
+            https: {
+                rejectUnauthorized: false
+            }
+        });
 
+        // --- PRENDE IL NOME DELLA TELECAMERA DIRETTAMENTE DALL'NVR ---
+        async function getCameraName(channelID) {
             try {
-                const res = await camAuth.request({
-                    method: 'GET',
-                    url: `${node.protocol}://${cam.ip}:${node.port}/ISAPI/System/Video/inputs/channels/${cam.channel}/overlays/channelNameOverlay`,
-                    timeout: 5000,
-                    httpsAgent: node.protocol === "https" ? httpsAgent : undefined
-                });
-
-                const data = res.data.toString();
+                const res = await nvrClient.get(`System/Video/inputs/channels/${channelID}/overlays/channelNameOverlay`, { timeout: 5000 });
+                const data = res.body.toString();
                 const match = data.match(/<name>([^<]+)<\/name>/i);
-                
-                if (match && match[1]) {
-                    return match[1].trim();
-                } else {
-                    return `Canale_${cam.channel}`;
-                }
-
+                if (match && match[1]) return match[1].trim();
+                return `Canale_${channelID}`;
             } catch (e) {
-                return `Camera_${cam.channel}`; 
+                return `Camera_${channelID}`; 
             }
         }
 
-        // --- CONTROLLO STATUS CAMERE ---
+        // --- CONTROLLO STATUS CAMERE AUTOMATICO DALL'NVR ---
         async function checkCameras() {
-            if (isClosing) return;
-            for (let cam of node.cameras) {
-                const camAuth = new AxiosDigestAuth({ username: node.user, password: node.camPass });
-                try {
-                    await camAuth.request({ 
-                        method: 'GET', 
-                        url: `${node.protocol}://${cam.ip}:${node.port}/ISAPI/System/deviceInfo`,
-                        timeout: 5000,
-                        httpsAgent: node.protocol === "https" ? httpsAgent : undefined
-                    });
-                    if (statoCamera[cam.ip] === false) {
-                        const nomeOnline = await getCameraName(cam);
-                        node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "online", nome_cliente: node.name, nome_telecamera: nomeOnline, ip_telecamera: cam.ip, channel: cam.channel, msg: "Camera ripristinata" } });
-                        statoCamera[cam.ip] = true;
-                    } else if (statoCamera[cam.ip] === undefined) {
-                        statoCamera[cam.ip] = true;
-                    }
-                } catch (e) {
-                    if (statoCamera[cam.ip] !== false) {
-                        node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "offline", nome_cliente: node.name, nome_telecamera: `Camera_${cam.channel}`, ip_telecamera: cam.ip, channel: cam.channel, msg: "Camera non raggiungibile" } });
-                        statoCamera[cam.ip] = false;
+            if (isClosing || !nvrOnline) return;
+            try {
+                // Interroghiamo lo stato di tutti i canali IP proxy sull'NVR
+                const res = await nvrClient.get('ContentMgmt/InputProxy/channels/status', { timeout: 8000 });
+                const xml = res.body.toString();
+
+                // Estraiamo tutti i blocchi <InputProxyChannelStatus> presenti nell'XML dell'NVR
+                const statusBlocks = xml.match(/<InputProxyChannelStatus>[\s\S]*?<\/InputProxyChannelStatus>/gi) || [];
+
+                for (let block of statusBlocks) {
+                    const idMatch = block.match(/<id>(\d+)<\/id>/i);
+                    const statusMatch = block.match(/<online>([^<]+)<\/online>/i);
+
+                    if (idMatch && statusMatch) {
+                        const ch = idMatch[1].trim();
+                        const isOnlineNow = statusMatch[1].trim().toLowerCase() === 'true';
+
+                        if (isOnlineNow && statoCamera[ch] === false) {
+                            // La telecamera è tornata online!
+                            const nomeOnline = await getCameraName(ch);
+                            node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "online", nome_cliente: node.name, nome_telecamera: nomeOnline, channel: ch, msg: "Camera ripristinata" } });
+                            statoCamera[ch] = true;
+                        } else if (!isOnlineNow && statoCamera[ch] !== false && statoCamera[ch] !== undefined) {
+                            // La telecamera si è scollegata! (Ignoriamo il primo avvio se è già scollegata per non intasare di alert)
+                            node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "offline", nome_cliente: node.name, nome_telecamera: `Camera_${ch}`, channel: ch, msg: "Camera scollegata o non raggiungibile dall'NVR" } });
+                            statoCamera[ch] = false;
+                        } else if (statoCamera[ch] === undefined) {
+                            statoCamera[ch] = isOnlineNow;
+                        }
                     }
                 }
+            } catch (e) {
+                node.error(`[DEBUG STATUS] Errore lettura canali da NVR: ${e.message}`);
             }
             updateNodeStatus();
         }
@@ -109,21 +109,15 @@ module.exports = function(RED) {
 
         const heartbeatInterval = setInterval(checkCameras, 30000);
 
-        // --- DOWNLOAD, SALVATAGGIO, CONVERSIONE E RIMOZIONE DOPO 2 MINUTI ---
+        // --- DOWNLOAD MEDIA AUTOMATICO DA EVENTO NVR ---
         async function downloadMedia(evento, channelID) {
-            const camera = node.cameras.find(c => c.channel == channelID);
-            if (!camera) return;
-
-            const nomeCamera = await getCameraName(camera);
-            
+            const chStr = channelID.toString();
             const nowTime = Date.now();
-            if(!lastTriggerTime[camera.ip]){
-                lastTriggerTime[camera.ip] = 0;
-            }
-            if (nowTime - lastTriggerTime[camera.ip] < 5000) return; 
-            lastTriggerTime[camera.ip] = nowTime;
+            if (!lastTriggerTime[chStr]) lastTriggerTime[chStr] = 0;
+            if (nowTime - lastTriggerTime[chStr] < 5000) return; 
+            lastTriggerTime[chStr] = nowTime;
 
-            const camAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
+            const nomeCamera = await getCameraName(channelID);
             const referenceTime = new Date();
             const timestamp = Math.floor(referenceTime.getTime() / 1000);
             const startTime = toHikDate(new Date(referenceTime.getTime() - (10 * 1000)));
@@ -132,73 +126,63 @@ module.exports = function(RED) {
             node.status({fill:"yellow", shape:"dot", text:`Download Cam ${channelID}...`});
             await new Promise(resolve => setTimeout(resolve, 6000));
             
-            const baseUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt`;
-            
-            // struttura del payload per Python
             let output = { 
                 tipo_messaggio: "evento",
                 nome_cliente: node.name, 
                 nome_telecamera: nomeCamera, 
-                ip_telecamera: camera.ip, 
+                ip_telecamera: null, 
                 tipo_evento: evento, 
                 timestamp_epoch: timestamp,
                 stato_telecamera: "ONLINE",
-                channel: channelID.toString(),
+                channel: chStr,
                 foto_base64: null, 
                 video_base64: null 
             };
 
-            
             let fileDaCancellare = [];
 
             try {
-                let searchXml = ``;
-                const trackV = (channelID*100+1).toString();
-                const trackI = (channelID*100+3).toString();
+                const trackV = (channelID * 100 + 1).toString();
+                const trackI = (channelID * 100 + 3).toString();
                 const tracks = [{ id: trackV }, { id: trackI }];
+
                 for (let t of tracks) {
-                    if(t.id===trackV){
+                    let searchXml = ``;
+                    if (t.id === trackV) {
                         searchXml = `<?xml version="1.0" encoding="utf-8"?><CMSearchDescription><searchID>LAST_EVENT</searchID><trackList><trackID>${t.id}</trackID></trackList><timeSpanList><timeSpan><startTime>${startTime}</startTime><endTime>${endTime}</endTime></timeSpan></timeSpanList><maxResults>100</maxResults><searchResultPostion>0</searchResultPostion><metadataList><metadataDescriptor>//recordType.meta.std-cgi.com</metadataDescriptor></metadataList></CMSearchDescription>`;
-
-                    } else{
+                    } else {
                         searchXml = `<?xml version="1.0" encoding="utf-8"?><CMSearchDescription><searchID>LAST_EVENT</searchID><trackIDList><trackID>${t.id}</trackID></trackIDList><timeSpanList><timeSpan><startTime>${startTime}</startTime><endTime>${endTime}</endTime></timeSpan></timeSpanList><contentTypeList><contentType>metadata</contentType></contentTypeList><maxResults>30</maxResults><searchResultPostion>0</searchResultPostion><metadataList><metadataDescriptor>recordType.meta.hikvision.com/${evento}</metadataDescriptor></metadataList></CMSearchDescription>`;
                     }
                     
-                    const resSearch = await camAuth.request({ 
-                        method: 'POST', url: `${baseUrl}/search`, data: searchXml, headers: { "Content-Type": "application/xml" } 
+                    const resSearch = await nvrClient.post('ContentMgmt/search', {
+                        body: searchXml,
+                        headers: { "Content-Type": "application/xml" }
                     });
                     
-                    let xml = resSearch.data.replace(/<(\/?)\w+:/g, "<$1");
+                    let xml = resSearch.body.replace(/<(\/?)\w+:/g, "<$1");
                     const uriMatch = xml.match(/<playbackURI>([^<]+)</);
 
                     if (uriMatch) {
                         const rawUri = uriMatch[1].replace(/&amp;/g, '&');
-                        const resDown = await camAuth.request({ 
-                            method: 'GET',
-                            url: `${baseUrl}/download`, 
-                            data: `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${rawUri.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`, 
-                            responseType: 'arraybuffer'
+                        
+                        const resDown = await nvrClient.post('ContentMgmt/download', {
+                            body: `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${rawUri.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`,
+                            responseType: 'buffer',
+                            headers: { "Content-Type": "application/xml" }
                         });
 
-                        let buffer = Buffer.from(resDown.data);
+                        let buffer = resDown.body;
                         if (t.id === trackI) {
-                            // SALVA FOTO IN LOCALE
                             const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
                             fs.writeFileSync(fullImgPath, buffer);
-                            
-                            // La convertiamo subito in testo per il payload
                             output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
-                            
-                            // Registriamo il file per la distruzione futura
                             fileDaCancellare.push(fullImgPath);
                         } else {
-                            // SALVA VIDEO IN LOCALE-
                             if (buffer.slice(0, 4).toString() === 'IMKH') buffer = buffer.slice(40);
                             const rawPath = path.join(baseStorage, `raw_${timestamp}.mp4`);
                             const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
                             fs.writeFileSync(rawPath, buffer);
                             
-                            // Eseguiamo ffmpeg localmente
                             await new Promise((resolve) => {
                                 exec(`ffmpeg -y -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
                                     if (!err && fs.existsSync(fixedPath)) {
@@ -215,20 +199,12 @@ module.exports = function(RED) {
                     }
                 }
 
-                // Spediamo il pacchetto completo verso l'HTTP Request tramite Node-RED
                 if (output.foto_base64 || output.video_base64) {
                     node.send({ payload: output });
                     
-                    // TIMER A 2 MINUTI PER LA PULIZIA DEL DISCO 
                     setTimeout(() => {
                         for (let file of fileDaCancellare) {
-                            try {
-                                if (fs.existsSync(file)) {
-                                    fs.unlinkSync(file);
-                                }
-                            } catch (err) {
-                                node.error(`Errore durante la pulizia del file temporaneo ${file}: ${err.message}`);
-                            }
+                            try { if (fs.existsSync(file)) fs.unlinkSync(file); } catch (err) {}
                         }
                     }, 120000);
                 }
@@ -242,41 +218,65 @@ module.exports = function(RED) {
         // --- ALERT STREAM ---
         function startAlertStream() {
             if (isClosing) return;
-            const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
-            const url = `${node.protocol}://${node.host}:${node.port}/ISAPI/Event/notification/alertStream`;
-            nvrAuth.request({ method: 'GET', url: url, responseType: 'stream', httpsAgent: node.protocol === "https" ? httpsAgent : undefined })
-            .then(response => {
-                streamRequest = response;
-                if (!nvrOnline) { node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "online", ip: node.host, msg: "NVR Online", nome_cliente: node.name } }); nvrOnline = true; }
+
+            const streamUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/Event/notification/alertStream`;
+            
+            const downloadStream = got.stream(streamUrl, {
+                username: node.user,
+                password: node.pass,
+                authentication: 'digest',
+                https: { rejectUnauthorized: false }
+            });
+
+            activeStream = downloadStream;
+
+            downloadStream.on('response', () => {
+                if (!nvrOnline) { 
+                    node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "online", ip: node.host, msg: "NVR Online", nome_cliente: node.name } }); 
+                    nvrOnline = true; 
+                }
                 updateNodeStatus();
-                response.data.on('data', (chunk) => {
-                    const data = chunk.toString().toLowerCase();
-                    if (data.includes("active")) {
-                        const chMatch = data.match(/<channelid>(\d+)<\/channelid>/i);
-                        if (chMatch) {
-                            let ev = "Unknown";
-                            for (let e of EventList) { if (data.includes(e.toLowerCase())) { ev = e; break; } }
-                            downloadMedia(ev, chMatch[1]);
-                        }
+            });
+
+            downloadStream.on('data', (chunk) => {
+                const data = chunk.toString().toLowerCase();
+                if (data.includes("active")) {
+                    const chMatch = data.match(/<channelid>(\d+)<\/channelid>/i);
+                    if (chMatch) {
+                        let ev = "Unknown";
+                        for (let e of EventList) { if (data.includes(e.toLowerCase())) { ev = e; break; } }
+                        downloadMedia(ev, chMatch[1]);
                     }
-                });
-                response.data.on('error', () => handleNvrError());
-                response.data.on('end', () => !isClosing && setTimeout(startAlertStream, 5000));
-            }).catch(() => handleNvrError());
+                }
+            });
+
+            downloadStream.on('error', (err) => {
+                if (!isClosing) handleNvrError();
+            });
+
+            downloadStream.on('end', () => {
+                if (!isClosing) setTimeout(startAlertStream, 5000);
+            });
         }
 
         function handleNvrError() {
-            if (nvrOnline) { node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "offline", ip: node.host, msg: "NVR Offline", nome_cliente: node.name } }); nvrOnline = false; }
+            if (nvrOnline) { 
+                node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "offline", ip: node.host, msg: "NVR Offline", nome_cliente: node.name } }); 
+                nvrOnline = false; 
+            }
             updateNodeStatus();
             if (!isClosing) setTimeout(startAlertStream, 10000);
         }
 
         startAlertStream();
         setTimeout(checkCameras, 2000); 
+
         node.on('close', (done) => { 
             isClosing = true; 
             clearInterval(heartbeatInterval);
-            if (streamRequest) streamRequest.data.destroy(); 
+            if (activeStream) {
+                try { activeStream.destroy(); } catch(e){}
+            } 
             done(); 
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-hik-media-buffer",
-  "version": "1.1.80",
+  "version": "1.1.82",
   "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
   "keywords": [
     "node-red",