node-red-contrib-hik-media-buffer 1.1.64 → 1.1.66

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; 
         node.port = config.port || "80";
         node.protocol = config.protocol || "http";
         node.user = config.user;
@@ -32,12 +32,6 @@ module.exports = function(RED) {
 
         node.status({fill:"grey", shape:"ring", text:"Inizializzazione..."});
 
-        function toHikDate(d) {
-            const pad = (num) => String(num).padStart(2, '0');
-            // Genera esattamente: YYYY-MM-DDTHH:mm:ssZ
-            return `${d.getUTCFullYear()}-${pad(d.getUTCMonth()+1)}-${pad(d.getUTCDate())}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}Z`;
-        }
-
         async function getCameraName(channelID) {
             const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
             try {
@@ -111,49 +105,42 @@ module.exports = function(RED) {
 
         const heartbeatInterval = setInterval(checkCameras, 30000);
 
-        // --- IL TUO DOWNLOAD MEDIA INIZIALE CORRETTO (100% XML SEPARATO) ---
+        // --- STRATEGIA DI DOWNLOAD MULTIMEDIALE 100% JSON + FFMPEG EXTRACTION ---
         async function downloadMedia(evento, channelID) {
-            node.warn(`[warn] [hik-media-buffer:test] [STEP 1] Inizio downloadMedia. Evento: ${evento}, Canale originario: ${channelID}`);
+            node.warn(`[warn] [hik-media-buffer:test] [TRIGGER] Ricevuto evento. Evento: ${evento}, Canale originario: ${channelID}`);
             
             const nowTime = Date.now();
             if (!lastTriggerTime[channelID]) lastTriggerTime[channelID] = 0;
-            if (nowTime - lastTriggerTime[channelID] < 5000) {
-                node.warn(`[warn] [hik-media-buffer:test] Antirimbalzo bloccato.`);
-                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);
             
-            // 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}`);
+            // Orario formattato per il database JSON dell'NVR (Ora locale con indicazione fuso 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() - (15 * 1000)));
+            const endTimeJson = formatJsonDate(new Date(referenceTime.getTime() + (15 * 1000)));
 
             node.status({fill:"yellow", shape:"dot", text:`Download Cam ${channelID}...`});
             const nomeCamera = await getCameraName(channelID);
             
-            node.warn(`[warn] [hik-media-buffer:test] [STEP 3] Attesa di 6 secondi per la scrittura su disco dell'NVR...`);
+            node.warn(`[warn] [hik-media-buffer:test] Attesa scrittura file su Hard Disk (6s)...`);
             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 evMinuscolo = evento.toLowerCase(); 
 
             let output = { 
                 tipo_messaggio: "evento",
                 nome_cliente: node.name, 
                 nome_telecamera: nomeCamera, 
                 ip_telecamera: node.host, 
-                tipo_evento: eventoNVR, 
+                tipo_evento: evMinuscolo.includes("linedetection") ? "LineDetection" : "FieldDetection", 
                 timestamp_epoch: timestamp,
                 stato_telecamera: "ONLINE",
                 channel: channelID.toString(),
@@ -162,113 +149,109 @@ module.exports = function(RED) {
             };
 
             const parsedChannel = parseInt(channelID, 10);
-            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 = [];
 
-            try {
-                for (let t of tracks) {
-                    node.warn(`[warn] [hik-media-buffer:test] [STEP 4] Elaborazione traccia ${t.label} (ID: ${t.id})`);
+            // --- STRUTTURA JSON DALL'ISPEZIONA NVR NATIVO ---
+            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": evMinuscolo
+                    }
+                }
+            };
 
-                    // Questo è il TUO XML ORIGINALE, non è stato toccato un singolo tag.
-                    // Cambia solo il contenuto testuale del descriptor per puntare all'NVR in minuscolo e senza i doppi slash che facevano scattare il "two root tags"
-                    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(`[warn] [hik-media-buffer:test] Invio query JSON a eventRecordSearch per canale ${parsedChannel}...`);
 
-                    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>([^<]+)</);
+            try {
+                const resSearchVideo = await camAuth.request({
+                    method: 'POST',
+                    url: `${baseUrl}/eventRecordSearch?format=json`,
+                    data: searchJsonPayload,
+                    headers: { "Content-Type": "application/json" }
+                });
 
-                        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'
-                            });
+                const resDataStr = JSON.stringify(resSearchVideo.data);
+                // Estrae l'RTSP playbackURI o l'endpoint di download dal JSON di risposta
+                const videoUriMatch = resDataStr.match(/rtsp:\/\/[^"]+/i) || resDataStr.match(/\/ISAPI\/ContentMgmt\/download[^"]+/i);
+                
+                if (videoUriMatch) {
+                    let rawVideoUri = videoUriMatch[0].replace(/\\/g, '');
+                    node.warn(`[warn] [hik-media-buffer:test] Trovato playbackURI video nel JSON: ${rawVideoUri}`);
+                    
+                    // Scarichiamo il filmato dall'NVR
+                    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'
+                    });
 
-                            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.`);
+                    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`);
+                    const extractedImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
+                    
+                    fs.writeFileSync(rawPath, videoBuffer);
+                    fileDaCancellare.push(rawPath);
+                    
+                    node.warn(`[warn] [hik-media-buffer:test] Esecuzione FFMPEG simultanea (Estrazione frame JPG + conversione video MP4)...`);
+                    await new Promise((resolve) => {
+                        // FFMPEG estrae il primo secondo in JPG e indicizza il video in FastStart in un colpo solo
+                        exec(`ffmpeg -y -i "${rawPath}" -ss 00:00:01 -vframes 1 "${extractedImgPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
+                            if (!err) {
+                                if (fs.existsSync(extractedImgPath)) {
+                                    output.foto_base64 = fs.readFileSync(extractedImgPath, { encoding: 'base64' });
+                                    fileDaCancellare.push(extractedImgPath);
+                                    node.warn(`[warn] [hik-media-buffer:test] Foto estratta dal video correttamente.`);
+                                }
+                                if (fs.existsSync(fixedPath)) {
+                                    output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
+                                    fileDaCancellare.push(fixedPath);
+                                    node.warn(`[warn] [hik-media-buffer:test] Video ottimizzato convertito correttamente.`);
+                                }
                             } 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(`[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();
-                                    });
-                                });
+                                node.warn(`[warn] [hik-media-buffer:test] Errore FFMPEG, invio video originale grezzo: ${err.message}`);
+                                output.video_base64 = fs.readFileSync(rawPath, { encoding: 'base64' });
                             }
-                        } 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}`);
-                    }
-                }
-
-                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 });
-                    
-                    setTimeout(() => {
-                        for (let file of fileDaCancellare) {
-                            try { if (fs.existsSync(file)) fs.unlinkSync(file); } catch (err) {}
-                        }
-                    }, 120000);
+                            resolve();
+                        });
+                    });
                 } else {
-                    node.warn(`[warn] [hik-media-buffer:test] [STEP 6] Nessun media Base64 popolato, nessun pacchetto inviato a Node-RED.`);
+                    node.warn(`[warn] [hik-media-buffer:test] Nessun file video trovato nel database JSON dell'NVR.`);
                 }
+            } catch (videoErr) {
+                node.error(`[error] [hik-media-buffer:test] Errore critico durante la ricerca JSON: ${videoErr.message}`);
+            }
 
-            } catch (e) {
-                node.error(`[error] [hik-media-buffer:test] [FATAL ERROR] Blocco principale downloadMedia fallito: ${e.message}`);
+            // --- SPEDIZIONE VERSO PYTHON ---
+            if (output.foto_base64 || output.video_base64) {
+                node.warn(`[warn] [hik-media-buffer:test] 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(`[warn] [hik-media-buffer:test] Nessun file multimediale generato.`);
             }
             updateNodeStatus();
         }
 
-        // --- ALERT STREAM ORIGINALE ---
+        // --- 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.64",
+  "version": "1.1.66",
   "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
   "keywords": [
     "node-red",