node-red-contrib-hik-media-buffer 1.1.57 → 1.1.59

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; // IP dell'NVR centrale
+        node.host = config.host; // IP dell'NVR Centrale
         node.port = config.port || "80";
         node.protocol = config.protocol || "http";
         node.user = config.user;
@@ -25,19 +25,19 @@ 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 });
 
         node.status({fill:"grey", shape:"ring", text:"Inizializzazione..."});
 
-        function toHikDate(d) { return d.toISOString().split('.')[0] + "Z"; }
+        // FORMATTAZIONE DATA CORRETTA PER HARD DISK NVR (Rimosso lo zulu 'Z' che mandava in 400 il database)
+        function toHikDate(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())}`;
+        }
 
-        // --- PRENDE IL NOME DEL CANALE DIRETTAMENTE DALL'NVR ---
         async function getCameraName(channelID) {
             const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
             try {
@@ -47,7 +47,6 @@ 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}`;
@@ -56,11 +55,9 @@ 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', 
@@ -68,23 +65,19 @@ 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) {
@@ -118,42 +111,42 @@ module.exports = function(RED) {
 
         const heartbeatInterval = setInterval(checkCameras, 30000);
 
-        // --- DOWNLOAD MULTIMEDIALE (XML PER FOTO + JSON PER VIDEO) ---
+        // --- IL TUO DOWNLOAD MEDIA INIZIALE CORRETTO (100% XML SEPARATO) ---
         async function downloadMedia(evento, channelID) {
-            node.warn(`[STEP 1] Inizio downloadMedia. Evento: ${evento}, Canale originario: ${channelID}`);
+            node.warn(`[warn] [hik-media-buffer:test] [STEP 1] Inizio downloadMedia. Evento: ${evento}, Canale originario: ${channelID}`);
             
             const nowTime = Date.now();
             if (!lastTriggerTime[channelID]) lastTriggerTime[channelID] = 0;
-            if (nowTime - lastTriggerTime[channelID] < 5000) return; 
+            if (nowTime - lastTriggerTime[channelID] < 5000) {
+                node.warn(`[warn] [hik-media-buffer:test] Antirimbalzo bloccato.`);
+                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);
             
-            // 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)));
+            // Generazione finestre temporali pulite per il database dei dischi dell'NVR
+            const startTime = toHikDate(new Date(referenceTime.getTime() - (20 * 1000)));
+            const endTime = toHikDate(new Date(referenceTime.getTime() + (20 * 1000)));
+            node.warn(`[warn] [hik-media-buffer:test] [STEP 2] Finestra temporale impostata: ${startTime} -> ${endTime}`);
 
             node.status({fill:"yellow", shape:"dot", text:`Download Cam ${channelID}...`});
             const nomeCamera = await getCameraName(channelID);
             
-            node.warn(`[STEP 2] Attesa di 6 secondi per la scrittura su disco dell'NVR...`);
+            node.warn(`[warn] [hik-media-buffer:test] [STEP 3] 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`;
             
-            const eventoMinuscolo = evento.toLowerCase(); 
-            let eventoNVR = "FieldDetection";             
-            if (eventoMinuscolo.includes("linedetection")) eventoNVR = "LineDetection";
+            let eventoNVR = "FieldDetection";
+            for (let e of EventList) {
+                if (evento.toLowerCase() === e.toLowerCase()) {
+                    eventoNVR = e;
+                    break;
+                }
+            }
 
             let output = { 
                 tipo_messaggio: "evento",
@@ -169,144 +162,129 @@ module.exports = function(RED) {
             };
 
             const parsedChannel = parseInt(channelID, 10);
-            const trackFoto = (parsedChannel * 100) + 3;  // Es. Canale 2 -> 203
+            const trackVideo = (parsedChannel * 100) + 1; 
+            const trackFoto = (parsedChannel * 100) + 3;  
+            
+            // Le due tracce originali del tuo ciclo
+            const tracks = [
+                { id: trackVideo.toString(), isFoto: false, label: "VIDEO" }, 
+                { id: trackFoto.toString(), isFoto: true, label: "FOTO" }
+            ];
             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 {
-                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}`);
+                for (let t of tracks) {
+                    node.warn(`[warn] [hik-media-buffer:test] [STEP 4] Elaborazione traccia ${t.label} (ID: ${t.id})`);
                     
-                    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'
-                    });
+                    // SEPARAZIONE DEI DESCRITTORI: timing per la traccia video, evento per lo snapshot foto
+                    let descriptorTarget = t.isFoto ? `recordType.meta.hikvision.com/${eventoNVR}` : `recordType.meta.hikvision.com/timing`;
 
-                    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.`);
+                    // LA TUA STRUTTURA XML INIZIALE PULITA E ALLINEATA AI MANUALI NVR
+                    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>30</maxResults><metadataList><metadataDescriptor>${descriptorTarget}</metadataDescriptor></metadataList></CMSearchDescription>`;
+
+                    node.warn(`[warn] [hik-media-buffer:test] [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(`[warn] [hik-media-buffer:test] [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(`[warn] [hik-media-buffer:test] [STEP 5] Trovato playbackURI per traccia ${t.id}: ${rawUri}`);
+                            
+                            node.warn(`[warn] [hik-media-buffer:test] [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(`[warn] [hik-media-buffer:test] [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(`[warn] [hik-media-buffer:test] [STEP 5.3] Immagine salvata e convertita in Base64.`);
                             } else {
-                                output.video_base64 = fs.readFileSync(rawPath, { encoding: 'base64' });
+                                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(`[warn] [hik-media-buffer:test] [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(`[warn] [hik-media-buffer:test] [STEP 5.4] Conversione FFMPEG completata con successo.`);
+                                        } else {
+                                            node.warn(`[warn] [hik-media-buffer:test] [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();
+                                    });
+                                });
                             }
-                            fileDaCancellare.push(rawPath);
-                            resolve();
-                        });
-                    });
-                } else {
-                    node.warn(`[STEP 3.3 - VIDEO] Nessun file video indicizzato per questa finestra temporale.`);
+                        } else {
+                            node.warn(`[warn] [hik-media-buffer:test] [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(`[error] [hik-media-buffer:test] [CATCH TRACCIA ${t.id}] Errore durante la POST di ricerca: ${errorDetails}`);
+                    }
                 }
-            } 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>`;
 
-            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}`);
+                if (output.foto_base64 || output.video_base64) {
+                    node.warn(`[warn] [hik-media-buffer:test] [STEP 6] Spedizione payload verso Node-RED effettuata con successo!`);
+                    node.send({ payload: output });
                     
-                    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.`);
+                    setTimeout(() => {
+                        for (let file of fileDaCancellare) {
+                            try { if (fs.existsSync(file)) fs.unlinkSync(file); } catch (err) {}
+                        }
+                    }, 120000);
                 } else {
-                    node.warn(`[STEP 4.3 - FOTO] Nessuna foto trovata per questa finestra temporale.`);
+                    node.warn(`[warn] [hik-media-buffer:test] [STEP 6] Nessun media Base64 popolato, nessun pacchetto inviato a Node-RED.`);
                 }
-            } catch (fotoErr) {
-                node.error(`[FOTO ERR] Errore durante la ricerca XML: ${fotoErr.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.`);
+            } catch (e) {
+                node.error(`[error] [hik-media-buffer:test] [FATAL ERROR] Blocco principale downloadMedia fallito: ${e.message}`);
             }
             updateNodeStatus();
         }
 
-        // --- ALERT STREAM ---
+        // --- ALERT STREAM ORIGINALE ---
         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; }
                 updateNodeStatus();
+                
                 response.data.on('data', (chunk) => {
+                    if (isClosing) return;
                     const data = chunk.toString().toLowerCase();
                     if (data.includes("active")) {
                         const chMatch = data.match(/<channelid>(\d+)<\/channelid>/i);
@@ -331,10 +309,11 @@ module.exports = function(RED) {
 
         startAlertStream();
         setTimeout(checkCameras, 2000); 
+
         node.on('close', (done) => { 
             isClosing = true; 
             clearInterval(heartbeatInterval);
-            if (streamRequest) streamRequest.data.destroy(); 
+            if (streamRequest && streamRequest.data) streamRequest.data.destroy(); 
             done(); 
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-hik-media-buffer",
-  "version": "1.1.57",
+  "version": "1.1.59",
   "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
   "keywords": [
     "node-red",
@@ -22,6 +22,7 @@
   "dependencies": {
     "@mhoc/axios-digest-auth": "^0.8.0",
     "axios": "^1.6.0",
+    "node-red-contrib-hik-media-buffer": "^1.1.58",
     "xml2js": "^0.6.2"
   }
 }