node-red-contrib-hik-media-buffer 1.1.106 → 1.1.108

package/hik-media-buffer.js

@@ -97,26 +97,17 @@ module.exports = function(RED) {
             const referenceTime = new Date();
             const timestamp = Math.floor(referenceTime.getTime() / 1000);
 
-            // 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
+            // Costruiamo le date giornaliere stile Chrome
             const pad = (num) => String(num).padStart(2, '0');
-            const timeGoBack = new Date(referenceTime.getTime() - (10 * 1000)); // iniziamo 10 secondi prima dello scatto
+            const year = referenceTime.getFullYear();
+            const month = pad(referenceTime.getMonth() + 1);
+            const day = pad(referenceTime.getDate());
             
-            // Generiamo il timestamp con T e Z MAIUSCOLE e SENZA due punti, esattamente come piace a Hikvision
-            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());
-            
-            // Output pulito: 20260624T085731Z
-            const rtspTimestamp = `${year}${month}${day}T${hours}${minutes}${seconds}Z`;
-
-            node.status({fill:"yellow", shape:"dot", text:`Estrazione media Cam ${channelID}...`});
-            await new Promise(resolve => setTimeout(resolve, 5000)); 
+            const startTime = `${year}-${month}-${day}T00:00:00 01:00`;
+            const endTime = `${year}-${month}-${day}T23:59:59 01:00`;
 
+            node.status({fill:"yellow", shape:"dot", text:`Generazione Sessione...`});
+            
             let output = { 
                 tipo_messaggio: "evento", nome_cliente: node.name, nome_telecamera: nomeCamera, 
                 ip_telecamera: null, tipo_evento: evento, timestamp_epoch: timestamp,
@@ -126,50 +117,130 @@ module.exports = function(RED) {
             let fileDaCancellare = [];
 
             try {
-                const trackId = parseInt(channelID) * 100 + 1; 
-                const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
-                const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
-
-                // Cambiamo leggermente l'endpoint usando /channels/ che è più tollerante sul TCP d'archivio
-                const archiveRtspUrl = `rtsp://${node.user}:${node.pass}@${node.host}:554/Streaming/channels/${channelID}01/?starttime=${rtspTimestamp}`;
-                node.warn(`[DEBUG RTSP] Tentativo TCP blindato su: ${archiveRtspUrl}`);
-
-                // -rtsp_transport tcp forza il tunnel stabile senza pacchetti persi
-                // -stimeout imposta il timeout interno della connessione a 20 secondi (in microsecondi)
-                // -fflags +genpts forza FFmpeg a ricostruire i timestamp mancanti ignorando i drop iniziali dell'NVR
-                const ffmpegRtspCmd = `ffmpeg -y -rtsp_transport tcp -stimeout 20000000 -i "${archiveRtspUrl}" -t 15 -fflags +genpts -c:v copy -c:a aac -movflags +faststart "${fixedPath}"`;
-
-                await new Promise((resolve) => {
-                    exec(ffmpegRtspCmd, { timeout: 25000 }, (err) => {
-                        if (err) node.error(`[DEBUG FFMPEG VIDEO ERRORE]: ${err.message}`);
-                        resolve();
-                    });
+                // --- STEP 1: CHIAMATA PRE-LOGIN PER ESTREMARE IL COOKIE WEBSESSION ---
+                // Interroghiamo un endpoint ISAPI leggero in Digest per farci rilasciare il Cookie di sessione
+                const loginRes = await nvrAuthAxios.request({
+                    method: 'GET',
+                    url: `${node.protocol}://${node.host}:${node.port}/ISAPI/Security/sessionLogin/capabilities?format=json`,
+                    timeout: 5000
                 });
 
-                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).`);
+                // Estraiamo il cookie "WebSession" dagli header di risposta
+                const responseHeaders = loginRes.headers['set-cookie'] || [];
+                let webSessionValue = '';
+                let cookieKeyName = 'WebSession';
+
+                for (let cookie of responseHeaders) {
+                    if (cookie.includes('WebSession')) {
+                        const matchCookie = cookie.match(/(WebSession_[a-f0-9]+|WebSession)=([^;]+)/i);
+                        if (matchCookie) {
+                            cookieKeyName = matchCookie[1];
+                            webSessionValue = matchCookie[2];
+                        }
+                    }
+                }
+
+                // Se l'NVR non ha sputato il cookie, ne generiamo uno fittizio in MD5 basandoci sul timestamp
+                // perché in molti firmware basta che l'header esista ed abbia lo stesso valore del cookie!
+                if (!webSessionValue) {
+                    webSessionValue = require('crypto').createHash('md5').update(String(Date.now())).digest('hex');
+                }
+
+                node.warn(`[DEBUG SESSION] Clonazione Cookie -> ${cookieKeyName}=${webSessionValue}`);
+
+                // --- STEP 2: COSTRUZIONE QUERY DIRETTA CON DATI DI CHROME ---
+                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 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');
+
+                // --- STEP 3: LANCE DIRETTO VIA CURL CON I TRE ASSI NELLA MANICA ---
+                // 1. Content-Type form-urlencoded (anche se mandiamo un JSON, come fa Chrome!)
+                // 2. Cookie WebSession inserito a mano
+                // 3. sessiontag identico al valore del cookie
+                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/x-www-form-urlencoded; charset=UTF-8" ` +
+                    `-H "X-Requested-With: XMLHttpRequest" ` +
+                    `-H "sessiontag: ${webSessionValue}" ` +
+                    `-b "${cookieKeyName}=${webSessionValue}" ` +
+                    `-d "@${tempJsonPath}" "${targetUrl}"`;
+
+                node.warn(`[DEBUG JSON] Invio query protetta con token di sessione...`);
+                let jsonResponseRaw = await new Promise((resolve) => { exec(curlCommand, (err, stdout) => resolve(err ? null : stdout)); });
+                
+                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. La sessione non è bastata o i parametri differiscono.`);
+                    updateNodeStatus();
+                    return;
+                }
+
+                // Se arriviamo qui, l'array si è sbloccato!
+                const matchItem = matches[0];
+                const playbackUri = matchItem?.mediaSegmentDescriptor?.playbackURI;
+
+                if (playbackUri) {
+                    node.warn(`[DEBUG JSON] Match sbloccato con successo! URL: ${playbackUri}`);
+                    
+                    // --- DOWNLOAD FOTO NATIVA REGISTRATA SU HDD ---
+                    let pictureUrlPath = null;
+                    const urlParamsMatch = playbackUri.match(/\?(.*)/);
+                    if (urlParamsMatch) {
+                        const trackI = (channelID * 100 + 3).toString(); 
+                        pictureUrlPath = `/picture/Streaming/tracks/${trackI}/?${urlParamsMatch[1]}`;
+                    }
+
+                    if (pictureUrlPath) {
+                        const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
+                        const curlImgCmd = `curl -s -X GET --digest -u "${node.user}:${node.pass}" -b "${cookieKeyName}=${webSessionValue}" -H "sessiontag: ${webSessionValue}" "${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);
+                        }
+                    }
 
-                    // --- 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}"`;
+                    // --- DOWNLOAD VIDEO NATIVO REGISTRATO SU HDD VIA FFMPEG ---
+                    const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
+                    const authenticatedRtspUrl = playbackUri.replace("rtsp://", `rtsp://${node.user}:${node.pass}@`);
+                    const ffmpegRtspCmd = `ffmpeg -y -rtsp_transport tcp -i "${authenticatedRtspUrl}" -t 15 -c:v copy -c:a aac -movflags +faststart "${fixedPath}"`;
 
-                    await new Promise((resolve) => {
-                        exec(ffmpegImgCmd, () => resolve());
-                    });
+                    await new Promise((resolve) => { exec(ffmpegRtspCmd, { timeout: 25000 }, () => resolve()); });
 
-                    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.`);
+                    if (fs.existsSync(fixedPath) && fs.statSync(fixedPath).size > 1000) {
+                        output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
+                        fileDaCancellare.push(fixedPath);
                     }
-                } else {
-                    node.warn(`[DEBUG RTSP] Impossibile recuperare lo stream video dall'archivio.`);
                 }
 
-                // --- SPEDIZIONE PAYLOAD ---
                 if (output.foto_base64 || output.video_base64) {
                     node.send({ payload: output });
                     setTimeout(() => {
@@ -180,7 +251,7 @@ module.exports = function(RED) {
                 }
 
             } catch (e) {
-                node.error(`Errore Critico nel recupero RTSP diretto: ${e.message}`);
+                node.error(`Errore session-cloner: ${e.message}`);
             }
             updateNodeStatus();
         }

package/package.json

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