node-red-contrib-hik-media-buffer 1.1.65 → 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,150 +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})`);
-                    
-                    const evMinuscolo = eventoNVR.toLowerCase();
-
-                    if (t.isFoto) {
-                        // --- SE È LA FOTO: USA IL TUO XML ORIGINALE IDENTICO ---
-                        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/${evMinuscolo}</metadataDescriptor></metadataList></CMSearchDescription>`;
-                        
-                        node.warn(`[warn] [hik-media-buffer:test] [STEP 4.1] Invio POST XML /search per FOTO. XML:\n${searchXml}`);
-                        
-                        try {
-                            const resSearch = await camAuth.request({ 
-                                method: 'POST', 
-                                url: `${baseUrl}/search`, 
-                                data: searchXml, 
-                                headers: { "Content-Type": "application/xml" } 
-                            });
-                            
-                            let xml = resSearch.data.replace(/<(\/?)\w+:/g, "<$1");
-                            const uriMatch = xml.match(/<playbackURI>([^<]+)</);
-                            if (uriMatch) {
-                                const rawUri = uriMatch[1].replace(/&amp;/g, '&');
-                                await scaricaIlFile(rawUri, t.isFoto);
-                            }
-                        } catch (err) {
-                            node.error(`[error] [hik-media-buffer:test] Errore FOTO XML: ${err.message}`);
-                        }
-
-                    } else {
-                        // --- SE È IL VIDEO: USA IL JSON DELL'ISPEZIONA NVR CHE ANDAVA ---
-                        // Adattiamo le date al formato del JSON dell'NVR (senza Z, con spazio offset se necessario, o UTC pulito)
-                        const startTimeJson = startTime.replace('Z', ' 02:00'); // adatta al fuso orario del tuo NVR se serve, o lascialo Z
-                        const endTimeJson = endTime.replace('Z', ' 02:00');
-
-                        const searchJsonPayload = {
-                            "EventSearchDescription": {
-                                "searchID": "BA80CAF2-A1E5-42E3-8624-529C3D6665D7",
-                                "searchResultPosition": 0,
-                                "maxResults": 30,
-                                "timeSpanList": [{
-                                    "startTime": startTime.replace('Z', ''), // Prova formato pulito senza Z richiesto dal JSON
-                                    "endTime": endTime.replace('Z', '')
-                                }],
-                                "type": "all",
-                                "channels": [parsedChannel],
-                                "eventType": "behavior",
-                                "behavior": {
-                                    "behaviorEventType": evMinuscolo
-                                }
-                            }
-                        };
-
-                        node.warn(`[warn] [hik-media-buffer:test] [STEP 4.1] Invio POST JSON /eventRecordSearch per VIDEO...`);
-                        
-                        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, '');
-                                await scaricaIlFile(rawVideoUri, t.isFoto);
-                            }
-                        } catch (err) {
-                            node.error(`[error] [hik-media-buffer:test] Errore VIDEO JSON: ${err.message}`);
-                        }
+            // --- 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
                     }
                 }
+            };
 
-            // Funzione interna di supporto per evitare duplicazione di codice di download
-            async function scaricaIlFile(playbackUri, isFoto) {
-                node.warn(`[warn] [hik-media-buffer:test] [STEP 5] Scarico traccia. URI: ${playbackUri}`);
-                const resDown = await camAuth.request({ 
-                    method: 'GET',
-                    url: `${baseUrl}/download`, 
-                    data: `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${playbackUri.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`, 
-                    responseType: 'arraybuffer'
+            node.warn(`[warn] [hik-media-buffer:test] Invio query JSON a eventRecordSearch per canale ${parsedChannel}...`);
+
+            try {
+                const resSearchVideo = await camAuth.request({
+                    method: 'POST',
+                    url: `${baseUrl}/eventRecordSearch?format=json`,
+                    data: searchJsonPayload,
+                    headers: { "Content-Type": "application/json" }
                 });
 
-                let buffer = Buffer.from(resDown.data);
-                if (isFoto) {
-                    const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
-                    fs.writeFileSync(fullImgPath, buffer);
-                    output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
-                    fileDaCancellare.push(fullImgPath);
-                } else {
-                    if (buffer.slice(0, 4).toString() === 'IMKH') buffer = buffer.slice(40);
+                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'
+                    });
+
+                    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, buffer);
+                    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) => {
-                        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);
+                        // 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 {
+                                node.warn(`[warn] [hik-media-buffer:test] Errore FFMPEG, invio video originale grezzo: ${err.message}`);
                                 output.video_base64 = fs.readFileSync(rawPath, { encoding: 'base64' });
                             }
-                            fileDaCancellare.push(rawPath);
                             resolve();
                         });
                     });
-                }
-            }
-
-                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);
                 } 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.65",
+  "version": "1.1.66",
   "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
   "keywords": [
     "node-red",