node-red-contrib-hik-media-buffer 1.1.100 → 1.1.102

package/hik-media-buffer.js

@@ -28,27 +28,6 @@ module.exports = function(RED) {
 
         node.status({fill:"grey", shape:"ring", text:"Inizializzazione..."});
 
-        // CLONE PERFETTO DEL FORMATO DATA DI CHROME (Es: 2026-06-23T17:40: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();
-            // Chiariamo l'offset senza inserire il '+' che fa incazzare l'NVR
-            const offsetSign = offsetMinutes <= 0 ? '' : '-'; 
-            const absOffsetMinutes = Math.abs(offsetMinutes);
-            const offsetHours = pad(Math.floor(absOffsetMinutes / 60));
-            const offsetMins = pad(absOffsetMinutes % 60);
-            
-            // NOTA: C'è uno spazio intenzionale prima di offsetSign per replicare il log dell'NVR
-            return `${year}-${month}-${day}T${hours}:${minutes}:${seconds} ${offsetSign}${offsetHours}:${offsetMins}`;
-        }
-
         const nvrAuthAxios = new AxiosDigestAuth({ username: node.user, password: node.pass });
 
         async function getCameraName(channelID) {
@@ -106,7 +85,7 @@ module.exports = function(RED) {
 
         const heartbeatInterval = setInterval(checkCameras, 30000);
 
-        // --- SISTEMA DI SCARICAMENTO SBLOCCATO CON DATA DI CHROME ---
+        // --- NUOVA STRATEGIA INDISTRUTTIBILE: DIRETTA SU STREAMING RTSP STORICO ---
         async function downloadMedia(evento, channelID) {
             const chStr = channelID.toString();
             const nowTime = Date.now();
@@ -117,21 +96,27 @@ module.exports = function(RED) {
             const nomeCamera = await getCameraName(channelID);
             const referenceTime = new Date();
             const timestamp = Math.floor(referenceTime.getTime() / 1000);
-            
-            // Cerchiamo nell'ora corrente (da inizio ora a fine ora) per non fare tutto il giorno
-            const dStart = new Date(referenceTime);
-            dStart.setMinutes(0, 0, 0); 
-            const dEnd = new Date(referenceTime);
-            dEnd.setMinutes(59, 59, 999); 
 
-            const startTime = toJsonDate(dStart);
-            const endTime = toJsonDate(dEnd);
-
-            node.status({fill:"yellow", shape:"dot", text:`Ricerca Evento Cam ${channelID}...`});
+            // Costruiamo la stringa temporale RTSP Hikvision calcolando l'orario di inizio (10 secondi prima di ADESSO)
+            // Il formato richiesto dall'RTSP Hikvision è: AAAAMMGGtHHMMSSz (tutto minuscolo)
+            // Usiamo l'ora UTC per compatibilità nativa con i file system dei flussi video
+            const pad = (num) => String(num).padStart(2, '0');
+            const timeGoBack = new Date(referenceTime.getTime() - (10 * 1000)); // iniziamo 10 secondi prima dello scatto
             
-            // Aspettiamo 4 secondi per essere certi che l'NVR abbia scritto il log a database
-            await new Promise(resolve => setTimeout(resolve, 4000)); 
+            const year = timeGoBack.getUTCFullYear();
+            const month = pad(timeGoBack.getUTCMonth() + 1);
+            const day = pad(timeGoBack.getUTCDate());
+            const hours = pad(timeGoBack.getUTCHours());
+            const minutes = pad(timeGoBack.getUTCMinutes());
+            const seconds = pad(timeGoBack.getUTCSeconds());
             
+            const rtspTimestamp = `${year}${month}${day}t${hours}${minutes}${seconds}z`;
+
+            node.status({fill:"yellow", shape:"dot", text:`Estrazione media Cam ${channelID}...`});
+            
+            // Aspettiamo 5 secondi per dare all'NVR il tempo di scrivere i frame correnti sull'hard disk
+            await new Promise(resolve => setTimeout(resolve, 5000)); 
+
             let output = { 
                 tipo_messaggio: "evento", nome_cliente: node.name, nome_telecamera: nomeCamera, 
                 ip_telecamera: null, tipo_evento: evento, timestamp_epoch: timestamp,
@@ -141,105 +126,45 @@ module.exports = function(RED) {
             let fileDaCancellare = [];
 
             try {
-                // Generazione dinamica di un SearchID UUID valido per la sessione
-                const dynamicSearchId = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
-                    var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
-                    return v.toString(16).toUpperCase();
-                });
+                const trackId = parseInt(channelID) * 100 + 1; // Es: Canale 2 -> traccia 201
+                const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
+                const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
 
-                // Payload clonato identico a quello funzionante di Chrome
-                const searchPayload = {
-                    "EventSearchDescription": {
-                        "searchID": dynamicSearchId,
-                        "searchResultPosition": 0,
-                        "maxResults": 30,
-                        "timeSpanList": [{ "startTime": startTime, "endTime": endTime }],
-                        "type": "all",
-                        "channels": [ parseInt(channelID) ],
-                        "eventType": "behavior",
-                        "behavior": { "behaviorEventType": evento.toLowerCase() }
-                    }
-                };
-
-                const tempJsonPath = path.join(baseStorage, `search_${channelID}_${timestamp}.json`);
-                fs.writeFileSync(tempJsonPath, JSON.stringify(searchPayload), 'utf8');
+                // Costruiamo l'URL RTSP di Playback diretto inserendo le credenziali e il timestamp di inizio
+                const archiveRtspUrl = `rtsp://${node.user}:${node.pass}@${node.host}:554/Streaming/tracks/${trackId}/?starttime=${rtspTimestamp}`;
+                node.warn(`[DEBUG RTSP] Mi collego all'archivio su traccia ${trackId} dall'orario: ${rtspTimestamp}`);
 
-                node.warn(`[DEBUG JSON] Invio query con data stile Chrome...`);
-                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}"`;
+                // --- 1. CATTURA VIDEO DIRECT (Registriamo 15 secondi di archivio) ---
+                const ffmpegRtspCmd = `ffmpeg -y -rtsp_transport tcp -i "${archiveRtspUrl}" -t 15 -c copy -movflags +faststart "${fixedPath}"`;
 
-                let jsonResponseRaw = await new Promise((resolve) => {
-                    exec(curlCommand, (err, stdout) => { resolve(err ? null : stdout); });
+                await new Promise((resolve) => {
+                    exec(ffmpegRtspCmd, { timeout: 25000 }, (err) => {
+                        if (err) node.error(`[DEBUG FFMPEG VIDEO ERRORE]: ${err.message}`);
+                        resolve();
+                    });
                 });
 
-                try { if (fs.existsSync(tempJsonPath)) fs.unlinkSync(tempJsonPath); } catch(e){}
+                if (fs.existsSync(fixedPath) && fs.statSync(fixedPath).size > 1000) {
+                    output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
+                    fileDaCancellare.push(fixedPath);
+                    node.warn(`[DEBUG RTSP] Spezzone video d'archivio estratto con successo (${fs.statSync(fixedPath).size} byte).`);
 
-                if (!jsonResponseRaw) {
-                    node.error("[DEBUG JSON] Nessuna risposta dall'NVR.");
-                    updateNodeStatus();
-                    return;
-                }
+                    // --- 2. GENERAZIONE FOTO DAL VIDEO APPENA SCARICATO ---
+                    // Estraiamo il primo fotogramma utile del video reale registrato su disco dell'evento. Infallibile!
+                    node.warn(`[DEBUG RTSP] Estraggo il fotogramma dell'evento dal video registrato...`);
+                    const ffmpegImgCmd = `ffmpeg -y -i "${fixedPath}" -vframes 1 -q:v 2 "${fullImgPath}"`;
 
-                const searchResult = JSON.parse(jsonResponseRaw);
-                const matches = searchResult?.EventSearchResult?.matchList || [];
-
-                if (matches.length === 0) {
-                    node.warn(`[DEBUG JSON] Zero match trovati nell'intervallo orario con sintassi Chrome.`);
-                    updateNodeStatus();
-                    return;
-                }
-
-                // Prendiamo il record più fresco (il primo restituito)
-                const matchItem = matches[0];
-                const playbackUri = matchItem?.mediaSegmentDescriptor?.playbackURI;
-
-                // --- 1. DOWNLOAD FOTO ORIGINALE DAL PATH NATIVO GET ---
-                let pictureUrlPath = null;
-                if (playbackUri) {
-                    const urlParamsMatch = playbackUri.match(/\?(.*)/);
-                    if (urlParamsMatch) {
-                        const trackI = (channelID * 100 + 3).toString(); // Traccia 203 per le foto
-                        pictureUrlPath = `/picture/Streaming/tracks/${trackI}/?${urlParamsMatch[1]}`;
-                    }
-                }
+                    await new Promise((resolve) => {
+                        exec(ffmpegImgCmd, () => resolve());
+                    });
 
-                if (pictureUrlPath) {
-                    node.warn(`[DEBUG FOTO] Scarico la foto originale 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. DOWNLOAD VIDEO CHIRURGICO VIA RTSP (Taglio forzato a 15 secondi) ---
-                if (playbackUri) {
-                    node.warn(`[DEBUG VIDEO] Aggancio il flusso RTSP temporizzato dell'evento...`);
-                    const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
-                    
-                    // Integriamo utente e password nell'URL RTSP
-                    const authenticatedRtspUrl = playbackUri.replace("rtsp://", `rtsp://${node.user}:${node.pass}@`);
-
-                    // -t 15 ferma Ffmpeg dopo 15 secondi esatti dall'inizio del record, evitando i file da 1GB
-                    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();
-                        });
-                    });
-
-                    if (fs.existsSync(fixedPath) && fs.statSync(fixedPath).size > 1000) {
-                        output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
-                        fileDaCancellare.push(fixedPath);
-                        node.warn(`[DEBUG VIDEO] Video catturato con successo (${fs.statSync(fixedPath).size} byte).`);
+                        node.warn(`[DEBUG RTSP] Foto estratta con successo dal video dell'evento.`);
                     }
+                } else {
+                    node.warn(`[DEBUG RTSP] Impossibile recuperare lo stream video dall'archivio.`);
                 }
 
                 // --- SPEDIZIONE PAYLOAD ---
@@ -253,12 +178,12 @@ module.exports = function(RED) {
                 }
 
             } catch (e) {
-                node.error(`Errore Critico nel Download Cam ${channelID}: ${e.message}`);
+                node.error(`Errore Critico nel recupero RTSP diretto: ${e.message}`);
             }
             updateNodeStatus();
         }
 
-        // --- APERTURA ALERT STREAM (Axios Stream continuo) ---
+        // --- ASCOLTO LIVE STREAM DEGLI ALLARMI ---
         function startAlertStream() {
             if (isClosing) return;
             const url = `${node.protocol}://${node.host}:${node.port}/ISAPI/Event/notification/alertStream`;

package/package.json

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