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

package/hik-media-buffer.js

@@ -28,25 +28,6 @@ module.exports = function(RED) {
 
         node.status({fill:"grey", shape:"ring", text:"Inizializzazione..."});
 
-        // Formatta la data simulando il fuso orario senza il segno '+'
-        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();
-            const offsetSign = offsetMinutes <= 0 ? '' : '-'; 
-            const offsetHours = pad(Math.floor(Math.abs(offsetMinutes) / 60));
-            const offsetMins = pad(Math.abs(offsetMinutes) % 60);
-            const fusoOrario = `${offsetSign}${offsetHours}:${offsetMins}`;
-            
-            return `${year}-${month}-${day}T${hours}:${minutes}:${seconds} ${fusoOrario}`;
-        }
-
         const nvrAuthAxios = new AxiosDigestAuth({ username: node.user, password: node.pass });
 
         async function getCameraName(channelID) {
@@ -104,7 +85,7 @@ module.exports = function(RED) {
 
         const heartbeatInterval = setInterval(checkCameras, 30000);
 
-        // --- CORE: RICERCA ARCHIVIO GIORNALIERO SIMULANDO CHROME ---
+        // --- NUOVA STRATEGIA INDISTRUTTIBILE: DIRETTA SU STREAMING RTSP STORICO ---
         async function downloadMedia(evento, channelID) {
             const chStr = channelID.toString();
             const nowTime = Date.now();
@@ -116,26 +97,26 @@ module.exports = function(RED) {
             const referenceTime = new Date();
             const timestamp = Math.floor(referenceTime.getTime() / 1000);
 
-            // Generazione dell'intervallo per l'intera giornata corrente
+            // 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 year = referenceTime.getFullYear();
-            const month = pad(referenceTime.getMonth() + 1);
-            const day = pad(referenceTime.getDate());
-
-            const offsetMinutes = referenceTime.getTimezoneOffset();
-            const offsetSign = offsetMinutes <= 0 ? '' : '-'; 
-            const offsetHours = pad(Math.floor(Math.abs(offsetMinutes) / 60));
-            const offsetMins = pad(Math.abs(offsetMinutes) % 60);
-            const fusoOrario = `${offsetSign}${offsetHours}:${offsetMins}`;
-
-            const startTime = `${year}-${month}-${day}T00:00:00 ${fusoOrario}`;
-            const endTime = `${year}-${month}-${day}T23:59:59 ${fusoOrario}`;
-
-            node.status({fill:"yellow", shape:"dot", text:`Ricerca archivio Cam ${channelID}...`});
+            const timeGoBack = new Date(referenceTime.getTime() - (10 * 1000)); // iniziamo 10 secondi prima dello scatto
             
-            // Aspettiamo 4 secondi per dare tempo all'NVR di indicizzare il log su disco
-            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,
@@ -145,108 +126,48 @@ module.exports = function(RED) {
             let fileDaCancellare = [];
 
             try {
-                // SearchID UUID Dinamico ad ogni 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 dal Form Data 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 giornaliera con data stile Chrome...`);
-                const targetUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/eventRecordSearch?format=json`;
-                
-                // Forziamo gli header completi ricavati dall'analisi del client web
-                const curlCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/json; charset=UTF-8" -H "X-Requested-With: XMLHttpRequest" -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 (!jsonResponseRaw) {
-                    node.error("[DEBUG JSON] Nessuna risposta dall'NVR.");
-                    updateNodeStatus();
-                    return;
-                }
-
-                const searchResult = JSON.parse(jsonResponseRaw);
-                const matches = searchResult?.EventSearchResult?.matchList || [];
-
-                if (matches.length === 0) {
-                    node.warn(`[DEBUG JSON] Zero match trovati nell'archivio giornaliero.`);
-                    updateNodeStatus();
-                    return;
-                }
-
-                // Prendiamo il record d'archivio più fresco (l'ultimo registrato)
-                const matchItem = matches[0];
-                const playbackUri = matchItem?.mediaSegmentDescriptor?.playbackURI;
-
-                if (playbackUri) {
-                    node.warn(`[DEBUG JSON] Trovato PlaybackURI: ${playbackUri}`);
-
-                    // --- 1. DOWNLOAD FOTO HISTORIC (GET diretta sulla traccia foto 203) ---
-                    let pictureUrlPath = null;
-                    const urlParamsMatch = playbackUri.match(/\?(.*)/);
-                    if (urlParamsMatch) {
-                        const trackI = (channelID * 100 + 3).toString(); 
-                        pictureUrlPath = `/picture/Streaming/tracks/${trackI}/?${urlParamsMatch[1]}`;
-                    }
-
-                    if (pictureUrlPath) {
-                        node.warn(`[DEBUG FOTO] Scarico lo snapshot nativo d'archivio via 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 scaricata con successo.`);
-                        }
-                    }
-
-                    // --- 2. DOWNLOAD VIDEO HISTORIC VIA RTSP (Taglio a 15 secondi) ---
-                    node.warn(`[DEBUG VIDEO] Recupero lo spezzone video registrato via RTSP...`);
-                    const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
-                    const authenticatedRtspUrl = playbackUri.replace("rtsp://", `rtsp://${node.user}:${node.pass}@`);
+                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).`);
 
-                    // Connessione all'RTSP storico e salvataggio locale dei primi 15 secondi dell'evento
-                    const ffmpegRtspCmd = `ffmpeg -y -rtsp_transport tcp -i "${authenticatedRtspUrl}" -t 15 -c copy -movflags +faststart "${fixedPath}"`;
+                    // --- 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}"`;
 
                     await new Promise((resolve) => {
-                        exec(ffmpegRtspCmd, { timeout: 25000 }, (err) => {
-                            if (err) node.error(`[DEBUG FFMPEG ERRORE]: ${err.message}`);
-                            resolve();
-                        });
+                        exec(ffmpegImgCmd, () => 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] Spezzone video generato con successo.`);
+                    if (fs.existsSync(fullImgPath) && fs.statSync(fullImgPath).size > 100) {
+                        output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
+                        fileDaCancellare.push(fullImgPath);
+                        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 MESSAGGIO FINALE ---
+                // --- SPEDIZIONE PAYLOAD ---
                 if (output.foto_base64 || output.video_base64) {
                     node.send({ payload: output });
                     setTimeout(() => {
@@ -257,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();
         }
 
-        // --- ASCOLTO SULL'ALERT STREAM DELL'NVR ---
+        // --- 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.101",
+  "version": "1.1.102",
   "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
   "keywords": [
     "node-red",