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

package/hik-media-buffer.js

@@ -97,18 +97,17 @@ module.exports = function(RED) {
             const referenceTime = new Date();
             const timestamp = Math.floor(referenceTime.getTime() / 1000);
 
-            function toXmlDate(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())}Z`;
-            }
-
-            // Cerchiamo il record video da 2 minuti prima a 1 minuto dopo l'evento
-            const startTime = toXmlDate(new Date(referenceTime.getTime() - (2 * 60 * 1000)));
-            const endTime = toXmlDate(new Date(referenceTime.getTime() + (1 * 60 * 1000)));
-
-            node.status({fill:"yellow", shape:"dot", text:`Ricerca file NVR...`});
-            await new Promise(resolve => setTimeout(resolve, 5000)); // Aspetta che l'NVR crei il file
+            // Costruiamo le date giornaliere stile Chrome
+            const pad = (num) => String(num).padStart(2, '0');
+            const year = referenceTime.getFullYear();
+            const month = pad(referenceTime.getMonth() + 1);
+            const day = pad(referenceTime.getDate());
+            
+            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,
@@ -118,68 +117,130 @@ module.exports = function(RED) {
             let fileDaCancellare = [];
 
             try {
-                const trackId = parseInt(channelID) * 100 + 1; 
-                const searchXml = `<?xml version="1.0" encoding="utf-8"?><CMSearchDescription><searchID>00000000-0000-0000-0000-000000000000</searchID><trackList><trackID>${trackId}</trackID></trackList><timeSpanList><timeSpan><startTime>${startTime}</startTime><endTime>${endTime}</endTime></timeSpan></timeSpanList><maxResults>1</maxResults></CMSearchDescription>`.trim();
+                // --- 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
+                });
 
-                const tempXmlPath = path.join(baseStorage, `search_xml_${channelID}_${timestamp}.xml`);
-                fs.writeFileSync(tempXmlPath, searchXml, 'utf8');
+                // 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 targetUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/search`;
-                const curlSearch = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/xml" -d "@${tempXmlPath}" "${targetUrl}"`;
+                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() }
+                    }
+                };
 
-                let xmlResponseRaw = await new Promise((resolve) => { exec(curlSearch, (err, stdout) => resolve(err ? null : stdout)); });
-                try { if (fs.existsSync(tempXmlPath)) fs.unlinkSync(tempXmlPath); } catch(e){}
+                const tempJsonPath = path.join(baseStorage, `search_${channelID}_${timestamp}.json`);
+                fs.writeFileSync(tempJsonPath, JSON.stringify(searchPayload), 'utf8');
 
-                const playbackUriMatch = xmlResponseRaw ? xmlResponseRaw.match(/<playbackURI>([^<]+)<\/playbackURI>/i) : null;
+                // --- 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)); });
                 
-                if (!playbackUriMatch) {
-                    node.warn(`[DEBUG HTTP] Nessun file trovato nell'archivio per la cam ${channelID}.`);
+                try { if (fs.existsSync(tempJsonPath)) fs.unlinkSync(tempJsonPath); } catch(e){}
+
+                if (!jsonResponseRaw) {
+                    node.error("[DEBUG JSON] Nessuna risposta dall'NVR.");
                     updateNodeStatus();
                     return;
                 }
 
-                const playbackUri = playbackUriMatch[1].trim();
-                node.warn(`[DEBUG HTTP] Trovato URI d'archivio: ${playbackUri}`);
+                const searchResult = JSON.parse(jsonResponseRaw);
+                const matches = searchResult?.EventSearchResult?.matchList || [];
 
-                const rawVideoPath = path.join(baseStorage, `raw_${channelID}_${timestamp}.mp4`);
-                const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
-                const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
+                if (matches.length === 0) {
+                    node.warn(`[DEBUG JSON] Zero match trovati. La sessione non è bastata o i parametri differiscono.`);
+                    updateNodeStatus();
+                    return;
+                }
 
-                // --- 1. DOWNLOAD DIRETTO VIA HTTP (ISAPI DOWNLOAD) ---
-                // Scarichiamo il file video originale memorizzato sull'NVR usando l'API di download nativa
-                node.warn(`[DEBUG HTTP] Avvio download del file originale dall'hard disk...`);
-                const downloadUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/download?playbackURI=${encodeURIComponent(playbackUri)}`;
-                const curlDownloadCmd = `curl -s -X GET --digest -u "${node.user}:${node.pass}" "${downloadUrl}" -o "${rawVideoPath}"`;
+                // 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]}`;
+                    }
 
-                await new Promise((resolve) => { exec(curlDownloadCmd, () => resolve()); });
+                    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);
+                        }
+                    }
 
-                if (fs.existsSync(rawVideoPath) && fs.statSync(rawVideoPath).size > 5000) {
-                    node.warn(`[DEBUG HTTP] File scaricato (${fs.statSync(rawVideoPath).size} byte). Lo ritaglio in locale...`);
+                    // --- 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}"`;
 
-                    // --- 2. TAGLIO LOCALE E CONVERSIONE AUDIO CON FFMPEG ---
-                    // Visto che il file è sul tuo PC, FFmpeg lavora in locale (velocità istantanea, zero timeout di rete!)
-                    const ffmpegCutCmd = `ffmpeg -y -i "${rawVideoPath}" -t 15 -c:v copy -c:a aac -movflags +faststart "${fixedPath}"`;
-                    await new Promise((resolve) => { exec(ffmpegCutCmd, () => resolve()); });
+                    await new Promise((resolve) => { exec(ffmpegRtspCmd, { timeout: 25000 }, () => resolve()); });
 
-                    if (fs.existsSync(fixedPath)) {
+                    if (fs.existsSync(fixedPath) && fs.statSync(fixedPath).size > 1000) {
                         output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
                         fileDaCancellare.push(fixedPath);
-
-                        // --- 3. ESTRAZIONE FOTO DAL VIDEO REGISTRATO ---
-                        const ffmpegImgCmd = `ffmpeg -y -i "${fixedPath}" -vframes 1 -q:v 2 "${fullImgPath}"`;
-                        await new Promise((resolve) => { exec(ffmpegImgCmd, () => resolve()); });
-
-                        if (fs.existsSync(fullImgPath)) {
-                            output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
-                            fileDaCancellare.push(fullImgPath);
-                        }
                     }
-                    fileDaCancellare.push(rawVideoPath);
-                } else {
-                    node.warn(`[DEBUG HTTP] Il download del file da NVR è fallito o il file è vuoto.`);
                 }
 
-                // --- SPEDIZIONE PAYLOAD ---
                 if (output.foto_base64 || output.video_base64) {
                     node.send({ payload: output });
                     setTimeout(() => {
@@ -190,7 +251,7 @@ module.exports = function(RED) {
                 }
 
             } catch (e) {
-                node.error(`Errore nel download HTTP d'archivio: ${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.107",
+  "version": "1.1.108",
   "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
   "keywords": [
     "node-red",