node-red-contrib-hik-media-buffer 1.1.53 → 1.1.55

package/hik-media-buffer.js

@@ -112,19 +112,25 @@ module.exports = function(RED) {
             
             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);
             
-            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 per i due endpoint
+            const startTimeZ = toHikDate(new Date(referenceTime.getTime() - (20 * 1000))); // Per XML (es. 2026-06-08T15:00:00Z)
+            const endTimeZ = toHikDate(new Date(referenceTime.getTime() + (20 * 1000)));
+            
+            // Per il JSON creiamo il formato con l'offset del fuso orario italiano "+02:00" (o "+01:00" a seconda di come risponde il sistema)
+            // Sfruttiamo una formattazione pulita per l'orario del JSON dell'NVR
+            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);
@@ -134,13 +140,10 @@ module.exports = function(RED) {
             
             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;
-                }
-            }
+            // Stringhe per i due formati
+            const eventoMinuscolo = evento.toLowerCase(); // "linedetection" o "fielddetection" per il JSON
+            let eventoNVR = "FieldDetection";             // "FieldDetection" o "LineDetection" per l'XML
+            if (eventoMinuscolo.includes("linedetection")) eventoNVR = "LineDetection";
 
             let output = { 
                 tipo_messaggio: "evento",
@@ -156,132 +159,127 @@ 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. 203
             let fileDaCancellare = [];
 
-            try {
-                for (let t of tracks) {
-                    node.warn(`[STEP 4] Elaborazione traccia ${t.label} (ID: ${t.id})`);
-                    
-                    // COSTRUZIONE XML CON FORMATTAZIONE PULITA A LIVELLI (Risolve l'errore "two root tags")
-                    let searchXml = `<?xml version="1.0" encoding="utf-8"?>\n` +
-                                    `<CMSearchDescription>\n` +
-                                    `  <searchID>LAST_EVENT</searchID>\n` +
-                                    `  <trackIDList>\n` +
-                                    `    <trackID>${t.id}</trackID>\n` +
-                                    `  </trackIDList>\n` +
-                                    `  <timeSpanList>\n` +
-                                    `    <timeSpan>\n` +
-                                    `      <startTime>${startTime}</startTime>\n` +
-                                    `      <endTime>${endTime}</endTime>\n` +
-                                    `    </timeSpan>\n` +
-                                    `  </timeSpanList>\n`;
-                    
-                    // Inseriamo il contentTypeList SOLO per la foto, per la ricerca video standard dell'NVR va rimosso!
-                    if (t.isFoto) {
-                        searchXml += `  <contentTypeList>\n` +
-                                    `    <contentType>metadata</contentType>\n` +
-                                    `  </contentTypeList>\n`;
+            // --- PARTE 1: SCARICHIAMO IL VIDEO USANDO IL JSON SUL NUOVO ENDPOINT ---
+            node.warn(`[STEP 4 - VIDEO] Invio POST a eventRecordSearch con JSON dell'ispeziona...`);
+            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
                     }
+                }
+            };
 
-                    searchXml += `  <maxResults>30</maxResults>\n` +
-                                `  <searchResultPostion>0</searchResultPostion>\n` +
-                                `  <metadataList>\n` +
-                                `    <metadataDescriptor>recordType.meta.hikvision.com/${eventoNVR}</metadataDescriptor>\n` +
-                                `  </metadataList>\n` +
-                                `</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>([^<]+)</);
+            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(`[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'
-                            });
+                // Il payload JSON restituisce una struttura differente, estraiamo l'url di download (playbackURI)
+                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 4.1 - VIDEO] Trovato URI video nel JSON: ${rawVideoUri}`);
+                    
+                    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(`[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.`);
+                    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);
                             } 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 4.2 - VIDEO] Nessun URI video trovato nella risposta JSON.`);
                 }
+            } catch (videoErr) {
+                node.error(`[VIDEO ERR] Errore durante la ricerca video JSON: ${videoErr.message}`);
+            }
 
-                if (output.foto_base64 || output.video_base64) {
-                    node.warn(`[STEP 6] Spedizione payload verso Node-RED effettuata con successo!`);
-                    node.send({ payload: output });
+            // --- PARTE 2: SCARICHIAMO LA FOTO USANDO L'XML SUL VECCHIO ENDPOINT ---
+            node.warn(`[STEP 5 - FOTO] Invio POST /search in XML per la 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><searchResultPostion>0</searchResultPostion><metadataList><metadataDescriptor>recordType.meta.hikvision.com/${eventoNVR}</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 5.1 - FOTO] Trovato playbackURI 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);
                 } else {
-                    node.warn(`[STEP 6] Nessun media Base64 popolato, nessun pacchetto inviato a Node-RED.`);
+                    node.warn(`[STEP 5.2 - FOTO] Nessun playbackURI foto trovato nell'XML.`);
                 }
+            } catch (fotoErr) {
+                node.error(`[FOTO ERR] Errore durante la ricerca foto XML: ${fotoErr.message}`);
+            }
 
-            } catch (e) {
-                node.error(`[FATAL ERROR] Blocco principale downloadMedia fallito: ${e.message}`);
+            // --- FINE: INVIO DATI A NODE-RED ---
+            if (output.foto_base64 || output.video_base64) {
+                node.warn(`[STEP 6] Payload multimediale spedito correttamente!`);
+                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 6] Nessun file base64 generato.`);
             }
             node.status({fill:"green", shape:"ring", text:"In ascolto"});
         }

package/package.json

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