node-red-contrib-hik-media-buffer 1.1.114 → 1.1.115

package/hik-snapshot.js

@@ -1,106 +1,320 @@
 const axios = require('axios');
+const AxiosDigestAuth = require('@mhoc/axios-digest-auth').default;
 const https = require('https');
-const mhocDigestSnapshot = require('@mhoc/axios-digest-auth');
-const DigestAuthClass = mhocDigestSnapshot.default;
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { exec } = require('child_process');
 
 module.exports = function(RED) {
-    function HikSnapshotNode(config) {
+    function HikMediaBufferNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
-
-        // Recuperiamo il nome del nodo dalla configurazione (se vuoto usa l'host)
-        node.nodeName = config.name || `NVR_${config.host}`;
-
-        node.protocol = config.protocol || "http";
+        
+        node.name = config.name || "TEST";
         node.host = config.host;
         node.port = config.port || "80";
+        node.protocol = config.protocol || "http";
         node.user = config.user;
         node.pass = config.pass;
-        node.maxChannels = parseInt(config.channel) || 1;
+
+        let streamRequest = null;
+        let isClosing = false;
+        let lastTriggerTime = {};
+        let nvrOnline = true;
+        let statoCamera = {}; 
 
         const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+        const EventList = ["FieldDetection", "LineDetection"];
 
-        node.on('input', async function(msg) {
-            if (msg.payload !== true) return;
+        // CARTELLA TEMPORANEA 
+        const baseStorage = path.join(os.tmpdir(), "hik_temp_media");
+        if (!fs.existsSync(baseStorage)) fs.mkdirSync(baseStorage, { recursive: true });
 
-            node.status({fill: "blue", shape: "dot", text: "Verifica canali..."});
+        node.status({fill:"grey", shape:"ring", text:"Inizializzazione..."});
 
-            const digest = new DigestAuthClass({
-                username: node.user, 
-                password: node.pass
-            });
-            
-            const data = new Date();
-            const year = data.getFullYear();
-            const month = data.getMonth() + 1;
-            const day = data.getDate(); 
+        function toHikDate(d) { return d.toISOString().split('.')[0] + "Z"; }
+
+        // --- PRENDE IL NOME REALE DELLA TELECAMERA DALL'NVR ---
+        async function getCameraNameFromNVR(channelID) {
+            const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
+            try {
+                const res = await nvrAuth.request({
+                    method: 'GET',
+                    url: `${node.protocol}://${node.host}:${node.port}/ISAPI/System/Video/inputs/channels/${channelID}`,
+                    timeout: 5000,
+                    httpsAgent: node.protocol === "https" ? httpsAgent : undefined
+                });
 
-            let snapshotResults = []; 
+                const data = res.data.toString();
+                // Cerchiamo il tag channelName che contiene il nome impostato sull'NVR
+                const match = data.match(/<channelName>([^<]+)<\/channelName>/i);
+                if (match && match[1]) return match[1].trim();
+                return `Canale ${channelID}`;
+            } catch (e) {
+                return `Canale ${channelID}`; 
+            }
+        }
 
-            for (let i = 1; i <= node.maxChannels; i++) {
-                const chanId = i + "01";
-                const snapUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/Streaming/channels/${chanId}/picture`;
-                const recordUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/record/tracks/${chanId}/dailyDistribution`;
+        // --- CONTROLLO STATUS CAMERE (ONLINE/OFFLINE) INTERROGANDO L'NVR ---
+        async function checkCameras() {
+            if (isClosing || !nvrOnline) return;
+            const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
+            try {
+                const res = await nvrAuth.request({ 
+                    method: 'GET', 
+                    url: `${node.protocol}://${node.host}:${node.port}/ISAPI/System/Video/inputs/channels`,
+                    timeout: 8000,
+                    httpsAgent: node.protocol === "https" ? httpsAgent : undefined
+                });
                 
-                const recordXml = `<?xml version="1.0" encoding="utf-8"?><trackDailyParam><year>${year}</year><monthOfYear>${month}</monthOfYear><dayOfMonth>${day}</dayOfMonth></trackDailyParam>`;
-
-                let resCanale = {
-                    name: node.nodeName, // <--- INIEZIONE RIGIDA DEL NOME DEL CONDOMINIO
-                    channel: i,
-                    photo: null,
-                    snapOk: false,
-                    isRecording: false
+                const xml = res.data.toString();
+                const channelBlocks = xml.match(/<VideoInputChannel>[\s\S]*?<\/VideoInputChannel>/g) || [];
+                
+                for (let block of channelBlocks) {
+                    const idMatch = block.match(/<id>(\d+)<\/id>/i);
+                    // Hikvision usa il tag <online> true/false per lo stato della telecamera IP accoppiata
+                    const onlineMatch = block.match(/<online>([^<]+)<\/online>/i) || block.match(/<onLine>([^<]+)<\/onLine>/i);
+                    
+                    if (idMatch) {
+                        const ch = idMatch[1];
+                        // Se il tag dice true è online, altrimenti se dice false (o manca) è offline
+                        const isOnline = onlineMatch ? onlineMatch[1].trim().toLowerCase() === "true" : true;
+                        
+                        if (isOnline && statoCamera[ch] === false) {
+                            const nomeOnline = await getCameraNameFromNVR(ch);
+                            node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "online", nome_cliente: node.name, nome_telecamera: nomeOnline, ip_telecamera: node.host, channel: ch, msg: "Camera ripristinata" } });
+                            statoCamera[ch] = true;
+                        } else if (!isOnline && statoCamera[ch] !== false) {
+                            node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "offline", nome_cliente: node.name, nome_telecamera: `Camera ${ch}`, ip_telecamera: node.host, channel: ch, msg: "Camera non raggiungibile" } });
+                            statoCamera[ch] = false;
+                        } else if (statoCamera[ch] === undefined) {
+                            statoCamera[ch] = isOnline;
+                        }
+                    }
+                }
+            } catch (e) {
+                node.error(`Errore durante il check delle camere: ${e.message}`);
+            }
+            updateNodeStatus();
+        }
+
+        function updateNodeStatus() {
+            const offlineCams = Object.values(statoCamera).filter(v => v === false).length;
+            if (!nvrOnline) {
+                node.status({fill:"red", shape:"ring", text:"NVR Offline"});
+            } else if (offlineCams > 0) {
+                node.status({fill:"yellow", shape:"dot", text: `${offlineCams} Cam Offline`});
+            } else {
+                node.status({fill:"green", shape:"ring", text:"In ascolto"});
+            }
+        }
+
+        const heartbeatInterval = setInterval(checkCameras, 30000);
+
+        // --- DOWNLOAD CON URL E BODY SECONDO SPECIFICHE ---
+        async function downloadMedia(evento, channelID) {
+            const nowTime = Date.now();
+            if (!lastTriggerTime[channelID]) lastTriggerTime[channelID] = 0;
+            if (nowTime - lastTriggerTime[channelID] < 5000) return; 
+            lastTriggerTime[channelID] = nowTime;
+
+            const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
+            const referenceTime = new Date();
+            const timestamp = Math.floor(referenceTime.getTime() / 1000);
+            
+            const videoTrackID = (parseInt(channelID) * 100) + 1; 
+
+            // Recupera il nome reale prima di inviare l'allarme
+            const nomeCamera = await getCameraNameFromNVR(channelID);
+            node.status({fill:"yellow", shape:"dot", text:`Download Cam ${channelID}...`});
+            
+            const startSearchStr = referenceTime.toISOString().split('T')[0] + "T00:00:00 01:00";
+            const endSearchStr = referenceTime.toISOString().split('T')[0] + "T23:59:59 01:00";
+
+            let output = { 
+                tipo_messaggio: "evento",
+                nome_cliente: node.name, 
+                nome_telecamera: nomeCamera, 
+                ip_telecamera: node.host, 
+                tipo_evento: evento, 
+                timestamp_epoch: timestamp,
+                stato_telecamera: "ONLINE",
+                channel: channelID.toString(),
+                foto_base64: null, 
+                video_base64: null 
+            };
+
+            let fileDaCancellare = [];
+
+            try {
+                // 1. SCARICAMENTO IMMAGINE
+                const payloadFoto = {
+                    "EventSearchDescription": {
+                        "searchID": "C5AFEE35-B1E0-4C01-83F8-47FD77892E4A",
+                        "searchResultPosition": 0,
+                        "maxResults": 30,
+                        "timeSpanList": [{
+                            "startTime": startSearchStr,
+                            "endTime": endSearchStr
+                        }],
+                        "type": "all",
+                        "channels": [parseInt(channelID)],
+                        "eventType": "behavior",
+                        "behavior": { "behaviorEventType": "linedetection" }
+                    }
                 };
 
-                // 1. SNAPSHOT
-                try {
-                    const responseSnap = await digest.request({
+                const resFotoSearch = await nvrAuth.request({
+                    method: 'POST',
+                    url: `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/eventRecordSearch?format=json`,
+                    data: payloadFoto,
+                    headers: { "Content-Type": "application/json" },
+                    httpsAgent: node.protocol === "https" ? httpsAgent : undefined
+                });
+
+                if (resFotoSearch.data?.EventSearchResult?.Targets?.[0]?.pictureUrl) {
+                    const urlFotoGrezzo = resFotoSearch.data.EventSearchResult.Targets[0].pictureUrl;
+                    
+                    const resDownFoto = await nvrAuth.request({
                         method: 'GET',
-                        url: snapUrl,
+                        url: urlFotoGrezzo,
                         responseType: 'arraybuffer',
-                        httpsAgent: node.protocol === 'https' ? httpsAgent : undefined,
-                        timeout: 5000
+                        httpsAgent: node.protocol === "https" ? httpsAgent : undefined
                     });
-                    resCanale.photo = responseSnap.data;
-                    resCanale.snapOk = true;
-                } catch (err) {
-                    resCanale.snapError = err.message;
+
+                    const fullImgPath = path.join(baseStorage, `img_${timestamp}_ch${channelID}.jpg`);
+                    fs.writeFileSync(fullImgPath, Buffer.from(resDownFoto.data));
+                    output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
+                    fileDaCancellare.push(fullImgPath);
                 }
 
-                // 2. RECORDING
-                try {
-                    const responseRec = await digest.request({
-                        method: 'POST',
-                        url: recordUrl,
-                        data: recordXml,
-                        headers: { 'Content-Type': 'application/xml' },
-                        httpsAgent: node.protocol === 'https' ? httpsAgent : undefined,
-                        timeout: 5000
+                // 2. SCARICAMENTO VIDEO
+                const startVideoSearch = referenceTime.toISOString().split('T')[0] + "T00:00:00Z";
+                const endVideoSearch = referenceTime.toISOString().split('T')[0] + "T23:59:59Z";
+
+                const payloadVideoSearch = `<?xml version="1.0" encoding="utf-8"?>
+                <CMSearchDescription>
+                    <searchID>CEC13F0F-1AEA-4474-A2DA-CFFF332C7C5B</searchID>
+                    <trackList><trackID>${videoTrackID}</trackID></trackList>
+                    <timeSpanList>
+                        <timeSpan>
+                            <startTime>${startVideoSearch}</startTime>
+                            <endTime>${endVideoSearch}</endTime>
+                        </timeSpan>
+                    </timeSpanList>
+                    <maxResults>100</maxResults>
+                    <searchResultPostion>0</searchResultPostion>
+                    <metadataList><metadataDescriptor>//recordType.meta.std-cgi.com</metadataDescriptor></metadataList>
+                </CMSearchDescription>`;
+
+                const resVideoSearch = await nvrAuth.request({
+                    method: 'POST',
+                    url: `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/search`,
+                    data: payloadVideoSearch,
+                    headers: { "Content-Type": "application/xml" },
+                    httpsAgent: node.protocol === "https" ? httpsAgent : undefined
+                });
+
+                const xmlString = resVideoSearch.data.toString();
+                const uriMatch = xmlString.match(/<playbackURI>([\s\S]*?)<\/playbackURI>/i);
+
+                if (uriMatch && uriMatch[1]) {
+                    const playbackURIGrezzo = uriMatch[1].trim();
+
+                    const payloadDownload = `<?xml version="1.0" encoding="UTF-8"?>
+                    <downloadRequest>
+                        <playbackURI>${playbackURIGrezzo}</playbackURI>
+                    </downloadRequest>`;
+
+                    const resDownVideo = await nvrAuth.request({
+                        method: 'GET',
+                        url: `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/download`,
+                        data: payloadDownload,
+                        headers: { "Content-Type": "application/xml" },
+                        responseType: 'arraybuffer',
+                        httpsAgent: node.protocol === "https" ? httpsAgent : undefined
+                    });
+
+                    let bufferVideo = Buffer.from(resDownVideo.data);
+                    if (bufferVideo.slice(0, 4).toString() === 'IMKH') bufferVideo = bufferVideo.slice(40);
+
+                    const rawPath = path.join(baseStorage, `raw_${timestamp}_ch${channelID}.mp4`);
+                    const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
+                    fs.writeFileSync(rawPath, bufferVideo);
+
+                    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 {
+                                output.video_base64 = fs.readFileSync(rawPath, { encoding: 'base64' });
+                            }
+                            fileDaCancellare.push(rawPath);
+                            resolve();
+                        });
                     });
-                    const xmlOutput = responseRec.data.toString();
-                    const regex = new RegExp(`<id>${day}</id>[^]*?<record>true</record>`);
-                    resCanale.isRecording = regex.test(xmlOutput);
-                } catch (err) {
-                    resCanale.recError = err.message;
                 }
 
-                snapshotResults.push(resCanale);
-                await new Promise(resolve => setTimeout(resolve, 200));
+                if (output.foto_base64 || output.video_base64) {
+                    node.send({ payload: output });
+                    
+                    setTimeout(() => {
+                        for (let file of fileDaCancellare) {
+                            try {
+                                if (fs.existsSync(file)) fs.unlinkSync(file);
+                            } catch (err) {}
+                        }
+                    }, 120000);
+                }
+
+            } catch (e) {
+                node.error(`Errore Download Cam ${channelID}: ${e.message}`);
             }
+            updateNodeStatus();
+        }
 
-            msg.payload = snapshotResults;
-            node.send(msg);
+        // --- ALERT STREAM ---
+        function startAlertStream() {
+            if (isClosing) return;
+            const nvrAuth = new AxiosDigestAuth({ username: node.user, password: node.pass });
+            const url = `${node.protocol}://${node.host}:${node.port}/ISAPI/Event/notification/alertStream`;
+            nvrAuth.request({ method: 'GET', url: url, responseType: 'stream', httpsAgent: node.protocol === "https" ? httpsAgent : undefined })
+            .then(response => {
+                streamRequest = response;
+                if (!nvrOnline) { node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "online", ip: node.host, msg: "NVR Online", nome_cliente: node.name } }); nvrOnline = true; }
+                updateNodeStatus();
+                response.data.on('data', (chunk) => {
+                    const data = chunk.toString().toLowerCase();
+                    if (data.includes("active")) {
+                        const chMatch = data.match(/<channelid>(\d+)<\/channelid>/i);
+                        if (chMatch) {
+                            let ev = "Unknown";
+                            for (let e of EventList) { if (data.includes(e.toLowerCase())) { ev = e; break; } }
+                            downloadMedia(ev, chMatch[1]);
+                        }
+                    }
+                });
+                response.data.on('error', () => handleNvrError());
+                response.data.on('end', () => !isClosing && setTimeout(startAlertStream, 5000));
+            }).catch(() => handleNvrError());
+        }
 
-            // Conteggi per lo stato del nodo
-            const snapCount = snapshotResults.filter(v => v.snapOk).length;
-            const recCount = snapshotResults.filter(v => v.isRecording).length;
-            
-            node.status({
-                fill: (snapCount === node.maxChannels && recCount === node.maxChannels) ? "green" : "yellow", 
-                shape: "dot", 
-                text: `Snap: ${snapCount}/${node.maxChannels} | Rec: ${recCount}/${node.maxChannels}`
-            });
+        function handleNvrError() {
+            if (nvrOnline) { node.send({ payload: { tipo_messaggio: "status", stato_telecamera: "offline", ip: node.host, msg: "NVR Offline", nome_cliente: node.name } }); nvrOnline = false; }
+            updateNodeStatus();
+            if (!isClosing) setTimeout(startAlertStream, 10000);
+        }
+
+        startAlertStream();
+        setTimeout(checkCameras, 2000); 
+        node.on('close', (done) => { 
+            isClosing = true; 
+            clearInterval(heartbeatInterval);
+            if (streamRequest) streamRequest.data.destroy(); 
+            done(); 
         });
     }
-    RED.nodes.registerType("hik-snapshot", HikSnapshotNode);
+    RED.nodes.registerType("hik-media-buffer", HikMediaBufferNode);
 };

package/package.json

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