node-red-contrib-hik-media-buffer 1.1.92 → 1.1.94

package/hik-media-buffer.js

@@ -23,21 +23,33 @@ module.exports = function(RED) {
         let nvrOnline = true;
         let statoCamera = {}; 
 
-        const EventList = ["FieldDetection", "LineDetection"];
         const baseStorage = path.join(os.tmpdir(), "hik_temp_media");
         if (!fs.existsSync(baseStorage)) fs.mkdirSync(baseStorage, { recursive: true });
 
         node.status({fill:"grey", shape:"ring", text:"Inizializzazione..."});
 
-        // Funzione data ISO standard con la Z che Chrome usa nell'NVR
-        function toHikDate(d) { 
-            return d.toISOString().split('.')[0] + "Z"; 
+        // Formatta la data nel formato ISO locale richiesto dal JSON dell'NVR (Es: 2026-06-22T14:41:00+02:00)
+        function toJsonDate(d) {
+            const pad = (num) => String(num).padStart(2, '0');
+            const year = d.getFullYear();
+            const month = pad(d.getMonth() + 1);
+            const day = pad(d.getDate());
+            const hours = pad(d.getHours());
+            const minutes = pad(d.getMinutes());
+            const seconds = pad(d.getSeconds());
+            
+            const offsetMinutes = d.getTimezoneOffset();
+            const offsetSign = offsetMinutes <= 0 ? '+' : '-';
+            const absOffsetMinutes = Math.abs(offsetMinutes);
+            const offsetHours = pad(Math.floor(absOffsetMinutes / 60));
+            const offsetMins = pad(absOffsetMinutes % 60);
+            
+            return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${offsetSign}${offsetHours}:${offsetMins}`;
         }
 
-        // Axios Digest usato solo per le GET leggere (Stream eventi e nomi canali)
         const nvrAuthAxios = new AxiosDigestAuth({ username: node.user, password: node.pass });
 
-        // --- RECUPERA IL NOME DELLA TELECAMERA DALL'NVR ---
+        // --- RECUPERA IL NOME DELLA TELECAMERA ---
         async function getCameraName(channelID) {
             try {
                 const res = await nvrAuthAxios.request({
@@ -48,12 +60,10 @@ module.exports = function(RED) {
                 const match = res.data.toString().match(/<name>([^<]+)<\/name>/i);
                 if (match && match[1]) return match[1].trim();
                 return `Canale_${channelID}`;
-            } catch (e) {
-                return `Camera_${channelID}`; 
-            }
+            } catch (e) { return `Camera_${channelID}`; }
         }
 
-        // --- CONTROLLO STATUS CANERE DIRETTAMENTE DALL'NVR ---
+        // --- CONTROLLO STATUS TELECAMERE CONNESSE ALL'NVR ---
         async function checkCameras() {
             if (isClosing || !nvrOnline) return;
             try {
@@ -80,31 +90,23 @@ module.exports = function(RED) {
                         } else if (!isOnlineNow && statoCamera[ch] !== false && statoCamera[ch] !== undefined) {
                             node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "offline", nome_cliente: node.name, nome_telecamera: `Camera_${ch}`, channel: ch, msg: "Camera scollegata dall'NVR" } });
                             statoCamera[ch] = false;
-                        } else if (statoCamera[ch] === undefined) {
-                            statoCamera[ch] = isOnlineNow;
-                        }
+                        } else if (statoCamera[ch] === undefined) { statoCamera[ch] = isOnlineNow; }
                     }
                 }
-            } catch (e) {
-                // Silenzioso
-            }
+            } catch (e) {}
             updateNodeStatus();
         }
 
         function updateNodeStatus() {
             const offlineCams = Object.values(statoCamera).filter(v => v === false).length;
-            if (!nvrOnline) {
-                node.status({fill:"red", shape:"ring", text:"NVR Offline"});
-            } else if (offlineCams > 0) {
-                node.status({fill:"yellow", shape:"dot", text: `${offlineCams} Cam Offline`});
-            } else {
-                node.status({fill:"green", shape:"ring", text:"In ascolto"});
-            }
+            if (!nvrOnline) { node.status({fill:"red", shape:"ring", text:"NVR Offline"}); }
+            else if (offlineCams > 0) { node.status({fill:"yellow", shape:"dot", text: `${offlineCams} Cam Offline`}); }
+            else { node.status({fill:"green", shape:"ring", text:"In ascolto"}); }
         }
 
         const heartbeatInterval = setInterval(checkCameras, 30000);
 
-        // --- DOWNLOAD MEDIA SBLOCCATO VIA cURL ---
+        // --- CORE RESCUE: RICERCA EVENTO JSON, CATTURA FOTO HTTP E VIDEO RTSP ---
         async function downloadMedia(evento, channelID) {
             const chStr = channelID.toString();
             const nowTime = Date.now();
@@ -115,13 +117,15 @@ module.exports = function(RED) {
             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)));
-            const endTime = toHikDate(new Date(referenceTime.getTime() + (10 * 1000)));
+            
+            // Nuova finestra temporale larga: cerca da 10 minuti fa a 2 minuti nel futuro per compensare i disallineamenti di orario
+            const startTime = toJsonDate(new Date(referenceTime.getTime() - (10 * 60 * 1000)));
+            const endTime = toJsonDate(new Date(referenceTime.getTime() + (2 * 60 * 1000)));
 
-            node.status({fill:"yellow", shape:"dot", text:`Download Cam ${channelID}...`});
+            node.status({fill:"yellow", shape:"dot", text:`Ricerca Evento Cam ${channelID}...`});
             
-            // Aspettiamo che l'NVR scriva il file fisicamente sul disco
-            await new Promise(resolve => setTimeout(resolve, 6000));
+            // Aspettiamo 3 secondi per dare tempo all'NVR di indicizzare l'evento sul log
+            await new Promise(resolve => setTimeout(resolve, 3000)); 
             
             let output = { 
                 tipo_messaggio: "evento", nome_cliente: node.name, nome_telecamera: nomeCamera, 
@@ -132,131 +136,120 @@ module.exports = function(RED) {
             let fileDaCancellare = [];
 
             try {
-                const trackV = (channelID * 100 + 1).toString(); // Es: Canale 2 -> 201
-                const trackI = (channelID * 100 + 3).toString(); // Es: Canale 2 -> 203
-                const tracks = [{ id: trackV }, { id: trackI }];
-
-                for (let t of tracks) {
-                    let searchXml = ``;
-                    if (t.id === trackV) {
-                        searchXml = `<?xml version="1.0" encoding="utf-8"?><CMSearchDescription><searchID>23D1C3CB-8C68-41C0-8A89-2BCF5765B5D2</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>`.trim();
-                    } else {
-                        searchXml = `<?xml version="1.0" encoding="utf-8"?><CMSearchDescription><searchID>23D1C3CB-8C68-41C0-8A89-2BCF5765B5D2</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>`.trim();
+                // Generazione del Payload JSON per interrogare il registro eventi dell'NVR
+                const searchPayload = {
+                    "EventSearchDescription": {
+                        "searchID": "D57A6C81-7FCB-4015-8156-71A54B486925",
+                        "searchResultPosition": 0,
+                        "maxResults": 10,
+                        "timeSpanList": [{ "startTime": startTime, "endTime": endTime }],
+                        "type": "all",
+                        "channels": [ parseInt(channelID) ],
+                        "eventType": "behavior",
+                        "behavior": { "behaviorEventType": evento.toLowerCase() }
                     }
-                    
-                    // Salviamo l'XML su un file temporaneo per non far incazzare la shell con i caratteri < e >
-                    const tempXmlPath = path.join(baseStorage, `search_${t.id}_${timestamp}.xml`);
-                    fs.writeFileSync(tempXmlPath, searchXml, 'utf8');
-
-                    node.warn(`[DEBUG] Eseguo ricerca traccia ${t.id} tramite cURL via file temporaneo...`);
-
-                    // Usiamo -d "@path" così cURL si legge il file da solo senza passare i simboli alla shell
-                    const targetUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/search`;
-                    const curlCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/xml; charset=UTF-8" -d "@${tempXmlPath}" "${targetUrl}"`;
-
-                    let xmlResponse = await new Promise((resolve) => {
-                        exec(curlCommand, (err, stdout, stderr) => {
-                            if (err) {
-                                node.error(`[CRASH cURL]: ${err.message} | STDERR: ${stderr}`);
-                                resolve(null);
-                            } else {
-                                resolve(stdout);
-                            }
-                        });
-                    });
+                };
 
-                    // Cancelliamo subito il file XML temporaneo di ricerca
-                    try { if (fs.existsSync(tempXmlPath)) fs.unlinkSync(tempXmlPath); } catch(e){}
+                const tempJsonPath = path.join(baseStorage, `search_${channelID}_${timestamp}.json`);
+                fs.writeFileSync(tempJsonPath, JSON.stringify(searchPayload), 'utf8');
 
-                    node.warn(`[DEBUG NVR RESP] Risposta grezza per traccia ${t.id}:`);
-                    node.warn(xmlResponse); 
+                node.warn(`[DEBUG JSON] Interrogo il log eventi dell'NVR per canale ${channelID}...`);
+                const targetUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/eventRecordSearch?format=json`;
+                const curlCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/json" -d "@${tempJsonPath}" "${targetUrl}"`;
 
-                    if (!xmlResponse || xmlResponse.includes("400 Bad Request") || xmlResponse.includes("401 Unauthorized")) {
-                        node.error(`[DEBUG NVR ERRORE] Risposta KO da curl su traccia ${t.id}`);
-                        continue;
-                    }
+                let jsonResponseRaw = await new Promise((resolve) => {
+                    exec(curlCommand, (err, stdout) => { resolve(err ? null : stdout); });
+                });
 
-                    let xml = xmlResponse.replace(/<(\/?)\w+:/g, "<$1");
-                    const uriMatch = xml.match(/<playbackURI>([^<]+)</);
+                try { if (fs.existsSync(tempJsonPath)) fs.unlinkSync(tempJsonPath); } catch(e){}
 
-                    if (uriMatch) {
-                        const rawUri = uriMatch[1].replace(/&amp;/g, '&');
-                        const downXml = `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${rawUri.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`.trim();
-                        
-                        const tempDownXmlPath = path.join(baseStorage, `down_${t.id}_${timestamp}.xml`);
-                        fs.writeFileSync(tempDownXmlPath, downXml, 'utf8');
+                if (!jsonResponseRaw) {
+                    node.error("[DEBUG JSON] Nessuna risposta ricevuta dall'NVR.");
+                    updateNodeStatus();
+                    return;
+                }
 
-                        const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
-                        const rawPath = path.join(baseStorage, `raw_${timestamp}.mp4`);
-                        const targetFilePath = (t.id === trackI) ? fullImgPath : rawPath;
+                const searchResult = JSON.parse(jsonResponseRaw);
+                const matches = searchResult?.EventSearchResult?.matchList || [];
 
-                        const downUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/download`;
-                        const curlDownCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/xml; charset=UTF-8" -d "@${tempDownXmlPath}" "${downUrl}" -o "${targetFilePath}"`;
+                if (matches.length === 0) {
+                    node.warn(`[DEBUG JSON] Nessun match trovato nel database per la Cam ${channelID} in questa finestra temporale.`);
+                    updateNodeStatus();
+                    return;
+                }
+
+                // Estraiamo il record dell'evento
+                const matchItem = matches[0];
+                const playbackUri = matchItem?.mediaSegmentDescriptor?.playbackURI;
+
+                // --- 1. CATTURA DELLA FOTO ORIGINALE (URL /picture/ intercettato da Chrome) ---
+                let pictureUrlPath = null;
+                if (playbackUri) {
+                    const urlParamsMatch = playbackUri.match(/\?(.*)/);
+                    if (urlParamsMatch) {
+                        const trackI = (channelID * 100 + 3).toString(); // Es: Canale 2 -> traccia foto 203
+                        pictureUrlPath = `/picture/Streaming/tracks/${trackI}/?${urlParamsMatch[1]}`;
+                    }
+                }
 
-                        node.warn(`[DEBUG] Eseguo download traccia ${t.id} tramite cURL...`);
-                        await new Promise((resolve) => {
-                            exec(curlDownCommand, () => resolve());
+                if (pictureUrlPath) {
+                    node.warn(`[DEBUG FOTO] Scarico la foto nativa dell'evento via HTTP GET...`);
+                    const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
+                    const curlImgCmd = `curl -s -X GET --digest -u "${node.user}:${node.pass}" "${node.protocol}://${node.host}:${node.port}${pictureUrlPath}" -o "${fullImgPath}"`;
+                    
+                    await new Promise((resolve) => { exec(curlImgCmd, () => resolve()); });
+                    
+                    if (fs.existsSync(fullImgPath) && fs.statSync(fullImgPath).size > 100) {
+                        output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
+                        fileDaCancellare.push(fullImgPath);
+                        node.warn(`[DEBUG FOTO] Foto catturata con successo (${fs.statSync(fullImgPath).size} byte).`);
+                    }
+                }
+
+                // --- 2. CATTURA DELLO SPEZZONE VIDEO (Via RTSP con Ffmpeg per tagliare a 15 secondi) ---
+                if (playbackUri) {
+                    node.warn(`[DEBUG VIDEO] Aggancio il flusso RTSP dell'evento registrato...`);
+                    const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
+                    
+                    // Iniettiamo le credenziali admin:pass all'interno dell'URL RTSP dell'NVR
+                    const authenticatedRtspUrl = playbackUri.replace("rtsp://", `rtsp://${node.user}:${node.pass}@`);
+
+                    // -t 15 costringe Ffmpeg a registrare solo 15 secondi dall'orario di inizio dell'evento, poi chiude il rubinetto!
+                    const ffmpegRtspCmd = `ffmpeg -y -rtsp_transport tcp -i "${authenticatedRtspUrl}" -t 15 -c copy -movflags +faststart "${fixedPath}"`;
+
+                    await new Promise((resolve) => {
+                        exec(ffmpegRtspCmd, { timeout: 25000 }, (err) => {
+                            if (err) node.error(`[DEBUG FFMPEG ERRORE]: ${err.message}`);
+                            resolve();
                         });
+                    });
 
-                        try { if (fs.existsSync(tempDownXmlPath)) fs.unlinkSync(tempDownXmlPath); } catch(e){}
-
-                        if (fs.existsSync(targetFilePath) && fs.statSync(targetFilePath).size > 0) {
-                            if (t.id === trackI) {
-                                output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
-                                fileDaCancellare.push(fullImgPath);
-                            } else {
-                                const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
-                                
-                                // Tagliamo via l'header proprietario IMKH se presente
-                                let fileStats = fs.statSync(rawPath);
-                                if (fileStats.size > 40) {
-                                    let fd = fs.openSync(rawPath, 'r');
-                                    let magicBuffer = Buffer.alloc(4);
-                                    fs.readSync(fd, magicBuffer, 0, 4, 0);
-                                    fs.closeSync(fd);
-                                    
-                                    if (magicBuffer.toString() === 'IMKH') {
-                                        // Taglio dell'header senza leggere tutto in memoria (evita crash su file giganti)
-                                        exec(`ffmpeg -y -ss 00:00:00 -i "${rawPath}" -c copy -map 0 -an "${fixedPath}"`, () => {}); 
-                                    }
-                                }
-
-                                node.warn(`[DEBUG] Ritaglio il video dell'evento a 10 secondi per non saturare la memoria...`);
-                                // USIAMO FFMPEG PER PRENDERE SOLO GLI ULTIMI 10 SECONDI ED EVITARE IL FILE DA 1GB IN BASE64
-                                await new Promise((resolve) => {
-                                    exec(`ffmpeg -y -sseof -10 -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
-                                        if (!err && fs.existsSync(fixedPath) && fs.statSync(fixedPath).size > 0) {
-                                            // Leggiamo il file tagliato che ora peserà pochissimo!
-                                            output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
-                                            fileDaCancellare.push(fixedPath);
-                                        } else {
-                                            node.error(`[DEBUG FFMPEG] Impossibile tagliare il video, traccia troppo pesante.`);
-                                        }
-                                        fileDaCancellare.push(rawPath);
-                                        resolve();
-                                    });
-                                });
-                            }
-                        }
+                    if (fs.existsSync(fixedPath) && fs.statSync(fixedPath).size > 1000) {
+                        output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
+                        fileDaCancellare.push(fixedPath);
+                        node.warn(`[DEBUG VIDEO] Spezzone video catturato con successo (${fs.statSync(fixedPath).size} byte).`);
+                    } else {
+                        node.warn(`[DEBUG VIDEO] Flusso RTSP non catturato o spezzone non pronto.`);
                     }
                 }
 
+                // --- INVIO PAYLOAD FINALE A NODE-RED ---
                 if (output.foto_base64 || output.video_base64) {
                     node.send({ payload: output });
                     setTimeout(() => {
                         for (let file of fileDaCancellare) {
                             try { if (fs.existsSync(file)) fs.unlinkSync(file); } catch (err) {}
                         }
-                    }, 120000);
+                    }, 60000); // Pulisce i file locali dopo 1 minuto
                 }
 
             } catch (e) {
-                node.error(`Errore Download Cam ${channelID}: ${e.message}`);
+                node.error(`Errore Critico nel Download Cam ${channelID}: ${e.message}`);
             }
             updateNodeStatus();
         }
 
-        // --- ALERT STREAM DI VEDETTA (Super Stabile con Axios) ---
+        // --- ASCOLTO ALLARMI IN LIVE STREAM (Axios Stream) ---
         function startAlertStream() {
             if (isClosing) return;
             const url = `${node.protocol}://${node.host}:${node.port}/ISAPI/Event/notification/alertStream`;
@@ -275,10 +268,8 @@ module.exports = function(RED) {
                     if (data.toLowerCase().includes("active")) {
                         const chMatch = data.match(/<channelID>(\d+)<\/channelID>/i);
                         if (chMatch) {
-                            let ev = "Unknown";
-                            for (let e of EventList) { 
-                                if (data.toLowerCase().includes(e.toLowerCase())) { ev = e; break; } 
-                            }
+                            let ev = "LineDetection"; 
+                            if (data.toLowerCase().includes("fielddetection")) ev = "FieldDetection";
                             downloadMedia(ev, chMatch[1]);
                         }
                     }

package/package.json

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