node-red-contrib-hik-media-buffer 1.1.54 → 1.1.56

package/hik-media-buffer.js

@@ -12,7 +12,7 @@ module.exports = function(RED) {
         const node = this;
         
         node.name = config.name || "TEST";
-        node.host = config.host; 
+        node.host = config.host; // IP dell'NVR centrale
         node.port = config.port || "80";
         node.protocol = config.protocol || "http";
         node.user = config.user;
@@ -25,7 +25,11 @@ module.exports = function(RED) {
         let statoCanale = {}; 
 
         const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+        
+        // EventList per l'alertStream
         const EventList = ["FieldDetection", "LineDetection"];
+
+        // CARTELLA TEMPORANEA 
         const baseStorage = path.join(os.tmpdir(), "hik_temp_media");
         if (!fs.existsSync(baseStorage)) fs.mkdirSync(baseStorage, { recursive: true });
 
@@ -33,6 +37,7 @@ module.exports = function(RED) {
 
         function toHikDate(d) { return d.toISOString().split('.')[0] + "Z"; }
 
+        // --- PRENDE IL NOME DEL CANALE DIRETTAMENTE DALL'NVR ---
         async function getCameraName(channelID) {
             const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
             try {
@@ -42,6 +47,7 @@ module.exports = function(RED) {
                     timeout: 5000,
                     httpsAgent: node.protocol === "https" ? httpsAgent : undefined
                 });
+
                 const data = res.data.toString();
                 const match = data.match(/<name>([^<]+)<\/name>/i);
                 return match && match[1] ? match[1].trim() : `Canale_${channelID}`;
@@ -50,9 +56,11 @@ module.exports = function(RED) {
             }
         }
 
+        // --- CONTROLLO STATUS DINAMICO DEI CANALI DIGITALI DALL'NVR ---
         async function checkCameras() {
             if (isClosing) return;
             const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
+            
             try {
                 const res = await nvrAuth.request({ 
                     method: 'GET', 
@@ -60,19 +68,23 @@ module.exports = function(RED) {
                     timeout: 5000,
                     httpsAgent: node.protocol === "https" ? httpsAgent : undefined
                 });
+                
                 nvrOnline = true;
                 const xmlData = res.data.toString();
+
                 const bloccoRegex = /<InputProxyChannelStatus[\s\\S]*?>([\s\S]*?)<\/InputProxyChannelStatus>/gi;
                 let matchBlocco;
 
                 while ((matchBlocco = bloccoRegex.exec(xmlData)) !== null) {
                     const bloccoContenuto = matchBlocco[1];
+                    
                     const idMatch = bloccoContenuto.match(/<id>(\d+)<\/id>/i);
                     const statusMatch = bloccoContenuto.match(/<status>([^<]+)</i);
 
                     if (idMatch && statusMatch) {
                         const ch = idMatch[1];
                         const statusStr = statusMatch[1].toLowerCase();
+                        
                         const isOnline = statusStr.includes("online") || statusStr.includes("recording");
 
                         if (isOnline && statoCanale[ch] === false) {
@@ -106,42 +118,42 @@ module.exports = function(RED) {
 
         const heartbeatInterval = setInterval(checkCameras, 30000);
 
-        // --- DOWNLOAD CON DEBUG COPIOSO ---
+        // --- DOWNLOAD MULTIMEDIALE (XML PER FOTO + JSON PER VIDEO) ---
         async function downloadMedia(evento, channelID) {
             node.warn(`[STEP 1] Inizio downloadMedia. Evento: ${evento}, Canale originario: ${channelID}`);
             
             const nowTime = Date.now();
             if (!lastTriggerTime[channelID]) lastTriggerTime[channelID] = 0;
-            if (nowTime - lastTriggerTime[channelID] < 5000) {
-                node.warn(`[STEP 1] Richiesta bloccata dall'antirimbalzo (meno di 5s dall'ultimo trigger)`);
-                return; 
-            }
+            if (nowTime - lastTriggerTime[channelID] < 5000) return; 
             lastTriggerTime[channelID] = nowTime;
 
             const camAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
             const referenceTime = new Date();
             const timestamp = Math.floor(referenceTime.getTime() / 1000);
             
-            // Ripristinato toHikDate identico a prima (con la Z / UTC che andava)
-            const startTime = toHikDate(new Date(referenceTime.getTime() - (20 * 1000)));
-            const endTime = toHikDate(new Date(referenceTime.getTime() + (20 * 1000)));
-            node.warn(`[STEP 2] Finestra temporale impostata: ${startTime} -> ${endTime}`);
+            // Finestre temporali standard UTC
+            const startTimeZ = toHikDate(new Date(referenceTime.getTime() - (20 * 1000)));
+            const endTimeZ = toHikDate(new Date(referenceTime.getTime() + (20 * 1000)));
+            
+            // Finestre temporali per il JSON dell'NVR (con specifica dell'offset locale, es. "+02:00")
+            const formatJsonDate = (d) => {
+                const pad = (num) => String(num).padStart(2, '0');
+                return `${d.getFullYear()}-${pad(d.getMonth()+1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())} 02:00`;
+            };
+            const startTimeJson = formatJsonDate(new Date(referenceTime.getTime() - (20 * 1000)));
+            const endTimeJson = formatJsonDate(new Date(referenceTime.getTime() + (20 * 1000)));
 
             node.status({fill:"yellow", shape:"dot", text:`Download Cam ${channelID}...`});
             const nomeCamera = await getCameraName(channelID);
             
-            node.warn(`[STEP 3] Attesa di 6 secondi per la scrittura su disco dell'NVR...`);
+            node.warn(`[STEP 2] Attesa di 6 secondi per la scrittura su disco dell'NVR...`);
             await new Promise(resolve => setTimeout(resolve, 6000));
             
             const baseUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt`;
             
-            let eventoNVR = "FieldDetection";
-            for (let e of EventList) {
-                if (evento.toLowerCase() === e.toLowerCase()) {
-                    eventoNVR = e;
-                    break;
-                }
-            }
+            const eventoMinuscolo = evento.toLowerCase(); 
+            let eventoNVR = "FieldDetection";             
+            if (eventoMinuscolo.includes("linedetection")) eventoNVR = "LineDetection";
 
             let output = { 
                 tipo_messaggio: "evento",
@@ -157,112 +169,134 @@ module.exports = function(RED) {
             };
 
             const parsedChannel = parseInt(channelID, 10);
-            const trackVideo = (parsedChannel * 100) + 1; 
-            const trackFoto = (parsedChannel * 100) + 3;  
-            
-            const tracks = [
-                { id: trackVideo.toString(), isFoto: false, label: "VIDEO" }, 
-                { id: trackFoto.toString(), isFoto: true, label: "FOTO" }
-            ];
+            const trackFoto = (parsedChannel * 100) + 3;  // Es. Canale 2 -> 203
             let fileDaCancellare = [];
 
+            // --- PARTE 1: RICERCA E SCARICO VIDEO VIA JSON ---
+            node.warn(`[STEP 3 - VIDEO] Invio query JSON a eventRecordSearch per canale ${parsedChannel}...`);
+            const searchJsonPayload = {
+                "EventSearchDescription": {
+                    "searchID": "BA80CAF2-A1E5-42E3-8624-529C3D6665D7",
+                    "searchResultPosition": 0,
+                    "maxResults": 30,
+                    "timeSpanList": [{
+                        "startTime": startTimeJson,
+                        "endTime": endTimeJson
+                    }],
+                    "type": "all",
+                    "channels": [parsedChannel],
+                    "eventType": "behavior",
+                    "behavior": {
+                        "behaviorEventType": eventoMinuscolo
+                    }
+                }
+            };
+
             try {
-                for (let t of tracks) {
-                    node.warn(`[STEP 4] Elaborazione traccia ${t.label} (ID: ${t.id})`);
+                const resSearchVideo = await camAuth.request({
+                    method: 'POST',
+                    url: `${baseUrl}/eventRecordSearch?format=json`,
+                    data: searchJsonPayload,
+                    headers: { "Content-Type": "application/json" }
+                });
+
+                const resDataStr = JSON.stringify(resSearchVideo.data);
+                const videoUriMatch = resDataStr.match(/rtsp:\/\/[^"]+/i) || resDataStr.match(/\/ISAPI\/ContentMgmt\/download[^"]+/i);
+                
+                if (videoUriMatch) {
+                    let rawVideoUri = videoUriMatch[0].replace(/\\/g, '');
+                    node.warn(`[STEP 3.1 - VIDEO] Trovato URI video nel JSON: ${rawVideoUri}`);
                     
-                    // RIPRISTINATO: XML identico riga per riga a quello vecchio della telecamera, 
-                    // ma usando la stringa di metadato corretta dell'NVR (recordType.meta.hikvision.com)
-                    const 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><maxResults>100</maxResults><metadataList><metadataDescriptor>recordType.meta.hikvision.com/${eventoNVR}</metadataDescriptor></metadataList></CMSearchDescription>`;
-
-                    node.warn(`[STEP 4.1] Invio POST /search per traccia ${t.id}. XML inviato:\n${searchXml}`);
-
-                    try {
-                        const resSearch = await camAuth.request({ 
-                            method: 'POST', 
-                            url: `${baseUrl}/search`, 
-                            data: searchXml, 
-                            headers: { "Content-Type": "application/xml" } 
-                        });
-                        
-                        node.warn(`[STEP 4.2] Risposta ricevuta da /search per traccia ${t.id}: Status ${resSearch.status}`);
-                        
-                        let xml = resSearch.data.replace(/<(\/?)\w+:/g, "<$1");
-                        const uriMatch = xml.match(/<playbackURI>([^<]+)</);
-
-                        if (uriMatch) {
-                            const rawUri = uriMatch[1].replace(/&amp;/g, '&');
-                            node.warn(`[STEP 5] Trovato playbackURI per traccia ${t.id}: ${rawUri}`);
-                            
-                            node.warn(`[STEP 5.1] Invio richiesta GET /download per traccia ${t.id}`);
-                            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'
-                            });
-
-                            node.warn(`[STEP 5.2] Scaricati ${resDown.data.byteLength} byte per traccia ${t.id}`);
-                            let buffer = Buffer.from(resDown.data);
-                            
-                            if (t.isFoto) {
-                                const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
-                                fs.writeFileSync(fullImgPath, buffer);
-                                output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
-                                fileDaCancellare.push(fullImgPath);
-                                node.warn(`[STEP 5.3] Immagine salvata e convertita in Base64.`);
+                    const resDownVideo = await camAuth.request({ 
+                        method: 'GET',
+                        url: `${baseUrl}/download`, 
+                        data: `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${rawVideoUri.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`, 
+                        responseType: 'arraybuffer'
+                    });
+
+                    let videoBuffer = Buffer.from(resDownVideo.data);
+                    if (videoBuffer.slice(0, 4).toString() === 'IMKH') videoBuffer = videoBuffer.slice(40);
+                    
+                    const rawPath = path.join(baseStorage, `raw_${timestamp}.mp4`);
+                    const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
+                    fs.writeFileSync(rawPath, videoBuffer);
+                    
+                    await new Promise((resolve) => {
+                        exec(`ffmpeg -y -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
+                            if (!err && fs.existsSync(fixedPath)) {
+                                output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
+                                fileDaCancellare.push(fixedPath);
+                                node.warn(`[STEP 3.2 - VIDEO] Convertito video con successo.`);
                             } else {
-                                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);
-                                
-                                node.warn(`[STEP 5.3] Video grezzo salvato. Avvio conversione FFMPEG...`);
-                                await new Promise((resolve) => {
-                                    exec(`ffmpeg -y -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
-                                        if (!err && fs.existsSync(fixedPath)) {
-                                            output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
-                                            fileDaCancellare.push(fixedPath);
-                                            node.warn(`[STEP 5.4] Conversione FFMPEG completata con successo.`);
-                                        } else {
-                                            node.warn(`[STEP 5.4] Errore FFMPEG (uso il video grezzo di backup): ${err ? err.message : 'File mancante'}`);
-                                            output.video_base64 = fs.readFileSync(rawPath, { encoding: 'base64' });
-                                        }
-                                        fileDaCancellare.push(rawPath);
-                                        resolve();
-                                    });
-                                });
+                                output.video_base64 = fs.readFileSync(rawPath, { encoding: 'base64' });
                             }
-                        } else {
-                            node.warn(`[STEP 4.3] Nessun playbackURI trovato nel documento di risposta XML per traccia ${t.id}. XML di risposta:\n${resSearch.data}`);
-                        }
-                    } catch (searchError) {
-                        let errorDetails = searchError.message;
-                        if (searchError.response) {
-                            errorDetails += ` | Status: ${searchError.response.status} | Dati Risposta: ${JSON.stringify(searchError.response.data)}`;
-                        }
-                        node.error(`[CATCH TRACCIA ${t.id}] Errore durante la POST di ricerca: ${errorDetails}`);
-                    }
+                            fileDaCancellare.push(rawPath);
+                            resolve();
+                        });
+                    });
+                } else {
+                    node.warn(`[STEP 3.3 - VIDEO] Nessun file video indicizzato per questa finestra temporale.`);
                 }
+            } catch (videoErr) {
+                node.error(`[VIDEO ERR] Errore durante la ricerca JSON: ${videoErr.message}`);
+            }
+
+            // --- PARTE 2: RICERCA E SCARICO FOTO VIA XML (CORRETTO) ---
+            node.warn(`[STEP 4 - FOTO] Invio query XML a /search per traccia foto ${trackFoto}...`);
+            
+            const searchXmlFoto = `<?xml version="1.0" encoding="utf-8"?><CMSearchDescription><searchID>LAST_EVENT</searchID><trackIDList><trackID>${trackFoto}</trackID></trackIDList><timeSpanList><timeSpan><startTime>${startTimeZ}</startTime><endTime>${endTimeZ}</endTime></timeSpan></timeSpanList><contentTypeList><contentType>metadata</contentType></contentTypeList><maxResults>30</maxResults><searchResultPosition>0</searchResultPosition><metadataList><metadataDescriptor>recordType.meta.hikvision.com/timing</metadataDescriptor></metadataList></CMSearchDescription>`;
 
-                if (output.foto_base64 || output.video_base64) {
-                    node.warn(`[STEP 6] Spedizione payload verso Node-RED effettuata con successo!`);
-                    node.send({ payload: output });
+            try {
+                const resSearchFoto = await camAuth.request({ 
+                    method: 'POST', 
+                    url: `${baseUrl}/search`, 
+                    data: searchXmlFoto, 
+                    headers: { "Content-Type": "application/xml" } 
+                });
+                
+                let xml = resSearchFoto.data.replace(/<(\/?)\w+:/g, "<$1");
+                const uriMatch = xml.match(/<playbackURI>([^<]+)</);
+
+                if (uriMatch) {
+                    const rawUriFoto = uriMatch[1].replace(/&amp;/g, '&');
+                    node.warn(`[STEP 4.1 - FOTO] Trovato URI foto: ${rawUriFoto}`);
                     
-                    setTimeout(() => {
-                        for (let file of fileDaCancellare) {
-                            try { if (fs.existsSync(file)) fs.unlinkSync(file); } catch (err) {}
-                        }
-                    }, 120000);
+                    const resDownFoto = await camAuth.request({ 
+                        method: 'GET',
+                        url: `${baseUrl}/download`, 
+                        data: `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${rawUriFoto.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`, 
+                        responseType: 'arraybuffer'
+                    });
+
+                    const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
+                    fs.writeFileSync(fullImgPath, Buffer.from(resDownFoto.data));
+                    output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
+                    fileDaCancellare.push(fullImgPath);
+                    node.warn(`[STEP 4.2 - FOTO] Foto salvata e convertita correttamente.`);
                 } else {
-                    node.warn(`[STEP 6] Nessun media Base64 popolato, nessun pacchetto inviato a Node-RED.`);
+                    node.warn(`[STEP 4.3 - FOTO] Nessuna foto trovata per questa finestra temporale.`);
                 }
+            } catch (fotoErr) {
+                node.error(`[FOTO ERR] Errore durante la ricerca XML: ${fotoErr.message}`);
+            }
 
-            } catch (e) {
-                node.error(`[FATAL ERROR] Blocco principale downloadMedia fallito: ${e.message}`);
+            // --- PARTE 3: SPEDIZIONE VERSO PYTHON ---
+            if (output.foto_base64 || output.video_base64) {
+                node.warn(`[STEP 5] Spedizione payload multimediale completata!`);
+                node.send({ payload: output });
+                
+                setTimeout(() => {
+                    for (let file of fileDaCancellare) {
+                        try { if (fs.existsSync(file)) fs.unlinkSync(file); } catch (err) {}
+                    }
+                }, 120000);
+            } else {
+                node.warn(`[STEP 5] Nessun file multimediale scaricato, nessun pacchetto inviato.`);
             }
-            node.status({fill:"green", shape:"ring", text:"In ascolto"});
+            updateNodeStatus();
         }
 
+        // --- ALERT STREAM ---
         function startAlertStream() {
             if (isClosing) return;
             const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });

package/package.json

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