node-red-contrib-hik-media-buffer 1.0.0

package/hik-media-buffer.html

@@ -0,0 +1,97 @@
+<script type="text/javascript">
+    RED.nodes.registerType('hik-media-buffer', {
+        category: 'Hikvision',
+        color: '#00b4d8',
+        defaults: {
+            name: { value: "" },
+            host: { value: "", required: true },
+            protocol: { value: "http" },
+            port: { value: "80", required: true },
+            user: { value: "admin", required: true },
+            pass: { value: "" },
+            camPass: { value: "" },
+            cameras: { value: [] }
+        },
+        inputs: 0,
+        outputs: 1,
+        icon: "font-awesome/fa-bell",
+        label: function() { return this.name || "Hik Multi Cam"; },
+        oneditprepare: function() {
+            $("#node-input-cameras-container").css('min-height','150px').editableList({
+                addItem: function(container, i, data) {
+                    var row = $('<div/>').appendTo(container);
+                    $('<input/>',{class:"node-input-camera-channel",type:"text",placeholder:"Canale (es. 1)",style:"width:30%; margin-right:5px;"}).appendTo(row).val(data.channel);
+                    $('<input/>',{class:"node-input-camera-ip",type:"text",placeholder:"IP Telecamera",style:"width:60%;"}).appendTo(row).val(data.ip);
+                },
+                removable: true,
+                sortable: true
+            });
+            if (this.cameras) {
+                this.cameras.forEach(function(cam) {
+                    $("#node-input-cameras-container").editableList('addItem', cam);
+                });
+            }
+        },
+        oneditsave: function() {
+            var cams = $("#node-input-cameras-container").editableList('items');
+            var node = this;
+            node.cameras = [];
+            cams.each(function(i) {
+                var cam = $(this);
+                var o = {
+                    channel: cam.find(".node-input-camera-channel").val(),
+                    ip: cam.find(".node-input-camera-ip").val()
+                };
+                if (o.channel && o.ip) node.cameras.push(o);
+            });
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="hik-media-buffer">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Nome</label>
+        <input type="text" id="node-input-name">
+    </div>
+    
+    <hr>
+    <h4>Configurazione NVR (Ascolto Allarmi)</h4>
+    <div class="form-row">
+        <label for="node-input-host"><i class="fa fa-globe"></i> IP NVR</label>
+        <input type="text" id="node-input-host" placeholder="Es: 192.168.1.100">
+    </div>
+    <div class="form-row">
+        <label for="node-input-user"><i class="fa fa-user"></i> Utente</label>
+        <input type="text" id="node-input-user">
+    </div>
+    <div class="form-row">
+        <label for="node-input-pass"><i class="fa fa-lock"></i> Password NVR</label>
+        <input type="password" id="node-input-pass">
+    </div>
+    <div class="form-row">
+        <label for="node-input-protocol"><i class="fa fa-shield"></i> Protocollo</label>
+        <select id="node-input-protocol" style="width: 70%">
+            <option value="http">HTTP</option>
+            <option value="https">HTTPS</option>
+        </select>
+    </div>
+    <div class="form-row">
+        <label for="node-input-port"><i class="fa fa-plug"></i> Porta</label>
+        <select id="node-input-port" style="width: 70%">
+            <option value="80">80</option>
+            <option value="443">443</option>
+            <option value="8000">8000</option>
+            <option value="8008">8008</option>
+        </select>
+    </div>
+
+    <hr>
+    <h4>Elenco Telecamere (Download)</h4>
+    <div class="form-row node-input-cameras-container-row">
+        <ol id="node-input-cameras-container"></ol>
+    </div>
+    <div class="form-row">
+        <label for="node-input-camPass"><i class="fa fa-key"></i> Password Telecamera</label>
+        <input type="password" id="node-input-camPass" placeholder="Password comune alle telecamere">
+    </div>
+</script>

package/hik-media-buffer.js

@@ -0,0 +1,224 @@
+const axios = require('axios');
+const AxiosDigestAuth = require('@mhoc/axios-digest-auth').default;
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { exec } = require('child_process');
+
+module.exports = function(RED) {
+    function HikMediaBufferNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+        
+        // --- ASSEGNAZIONE PROPRIETÀ AL NODO ---
+        node.host = config.host;
+        node.port = config.port || "80";
+        node.protocol = config.protocol || "http";
+        node.user = config.user;
+        node.pass = config.pass;
+        node.camPass = config.camPass || config.pass; // Usa pass dell'NVR se quella cam specifica non c'è
+        node.cameras = config.cameras || [];
+        // --------------------------------------
+
+        let streamRequest = null;
+        let isClosing = false;
+        let lastTriggerTime = 0;
+        
+        // Stati di connessione
+        let nvrOnline = true;
+        let statoCamera = {}; // Memorizza lo stato { "IP": true/false }
+
+        const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+        const tempDir = os.tmpdir();
+        const EventList = ["FieldDetection", "LineDetection"];
+
+        node.status({fill:"grey", shape:"ring", text:"Inizializzazione..."});
+
+        function toHikDate(d) { return d.toISOString().split('.')[0] + "Z"; }
+   
+        // --- CONTROLLO SE LE TELECAMERE SONO ONLINE ---
+        async function checkCameras() {
+            if (isClosing) return;
+            for (let cam of node.cameras) {
+                const camAuth = new AxiosDigestAuth({ 
+                    username: node.user, 
+                    password: node.camPass 
+                });
+                try {
+                    await camAuth.request({ 
+                        method: 'GET', 
+                        url: `${node.protocol}://${cam.ip}:${node.port}/ISAPI/System/deviceInfo`,
+                        timeout: 5000,
+                        httpsAgent: node.protocol === "https" ? httpsAgent : undefined
+                    });
+
+                    if (statoCamera[cam.ip] === false) {
+                        node.send({ payload: { status: "online", ip: cam.ip, channel: cam.channel, msg: "Camera ripristinata" } });
+                        statoCamera[cam.ip] = true;
+                    } else if (statoCamera[cam.ip] === undefined) {
+                        statoCamera[cam.ip] = true;
+                    }
+                } catch (e) {
+                    if (statoCamera[cam.ip] !== false) {
+                        node.send({ payload: { status: "offline", ip: cam.ip, channel: cam.channel, msg: "Camera non raggiungibile" } });
+                        statoCamera[cam.ip] = false;
+                    }
+                }
+            }
+            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);
+
+        // --- FUNZIONE DOWNLOAD ---
+        async function downloadMedia(evento, channelID) {
+            const camera = node.cameras.find(c => c.channel == channelID);
+            if (!camera) return;
+
+            const nowTime = Date.now();
+            if (nowTime - lastTriggerTime < 10000) return; 
+            lastTriggerTime = nowTime;
+
+            const camAuth = new AxiosDigestAuth({ 
+                username: node.user, 
+                password: node.camPass 
+            });
+            const referenceTime = new Date();
+            const startTime = toHikDate(new Date(referenceTime.getTime() - (10 * 1000)));
+            const endTime = toHikDate(new Date(referenceTime.getTime() + (10 * 1000)));
+
+            node.status({fill:"yellow", shape:"dot", text:`Download Cam ${channelID}...`});
+            await new Promise(resolve => setTimeout(resolve, 6000));
+            
+            const baseUrl = `${node.protocol}://${camera.ip}:${node.port}/ISAPI/ContentMgmt`;
+            let output = { ip: camera.ip, channel: channelID, event: evento, videoPath: null, imageBuffer: null };
+
+            try {
+                const tracks = [{ name: "termicoV", id: "201" }, { name: "termico", id: "203" }];
+                for (let t of tracks) {
+                    const searchXml = `<?xml version="1.0" encoding="utf-8"?>
+<CMSearchDescription>
+    <searchID>LAST_EVENT</searchID>
+    <trackIDList><trackID>${t.id}</trackID></trackIDList>
+    <timeSpanList><timeSpan><startTime>${startTime}</startTime><endTime>${endTime}</endTime></timeSpan></timeSpanList>
+    <maxResults>100</maxResults>
+    <searchResultPostion>0</searchResultPostion>
+    <metadataList><metadataDescriptor>//recordType.meta.std-cgi.com/${evento}</metadataDescriptor></metadataList>
+</CMSearchDescription>`;
+
+                    const resSearch = await camAuth.request({ 
+                        method: 'POST',
+                        url: `${baseUrl}/search`, 
+                        data: searchXml, 
+                        headers: { "Content-Type": "application/xml" } 
+                    });
+                    
+                    let xml = resSearch.data.replace(/<(\/?)\w+:/g, "<$1");
+                    const uriMatch = xml.match(/<playbackURI>([^<]+)</);
+
+                    if (uriMatch) {
+                        const rawUri = uriMatch[1].replace(/&amp;/g, '&');
+                        const resDown = await camAuth.request({ 
+                            method: 'GET', url: `${baseUrl}/download`, 
+                            data: `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${rawUri.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`, 
+                            responseType: 'arraybuffer'
+                        });
+
+                        let buffer = Buffer.from(resDown.data);
+                        if (t.id === "203") {
+                            output.imageBuffer = buffer;
+                        } else {
+                            if (buffer.slice(0, 4).toString() === 'IMKH') buffer = buffer.slice(40);
+                            const rawPath = path.join(tempDir, `raw_${Date.now()}.mp4`);
+                            const fixedPath = path.join(tempDir, `hik_v_${channelID}_${Date.now()}.mp4`);
+                            fs.writeFileSync(rawPath, buffer);
+                            await new Promise((resolve) => {
+                                exec(`ffmpeg -y -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
+                                    if (!err) {
+                                        output.videoPath = fixedPath;
+                                        try { fs.unlinkSync(rawPath); } catch(e) {}
+                                    } else { output.videoPath = rawPath; }
+                                    resolve();
+                                });
+                            });
+                            setTimeout(() => { if (output.videoPath && fs.existsSync(output.videoPath)) fs.unlinkSync(output.videoPath); }, 180000);
+                        }
+                    }
+                }
+                if (output.imageBuffer || output.videoPath) node.send({ payload: output });
+            } catch (e) {
+                node.error(`Errore Download Cam ${channelID}: ${e.message}`);
+            }
+            updateNodeStatus();
+        }
+
+        // --- GESTIONE NVR 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: { status: "online", ip: node.host, msg: "NVR Online" } });
+                    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());
+        }
+
+        function handleNvrError() {
+            if (nvrOnline) {
+                node.send({ payload: { status: "offline", ip: node.host, msg: "NVR Offline" } });
+                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-media-buffer", HikMediaBufferNode);
+};

package/hik-snapshot.html

@@ -0,0 +1,70 @@
+<script type="text/javascript">
+    RED.nodes.registerType('hik-snapshot', {
+        category: 'Hikvision',
+        color: '#00b4d8',
+        defaults: {
+            name: { value: "" },
+            host: { value: "", required: true },
+            channel: {value: "", required: true},
+            protocol: { value: "http" },
+            port: { value: "80", required: true },
+            user: { value: "admin", required: true },
+            pass: { value: "" },
+
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "font-awesome/fa-picture-o",
+        label: function() { return this.name || "Hik Snapshot"; },
+        
+    });
+</script>
+
+<script type="text/html" data-template-name="hik-snapshot">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Nome</label>
+        <input type="text" id="node-input-name">
+    </div>
+    
+    <hr>
+    <h4>Configurazione NVR</h4>
+    <div class="form-row">
+        <label for="node-input-host"><i class="fa fa-globe"></i> IP NVR</label>
+        <input type="text" id="node-input-host" placeholder="Es: 192.168.1.100">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-channel"><i class="fa fa-list-ol"></i> Numero Canali</label>
+        <input type="number" id="node-input-channel" min="1" max="64">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-user"><i class="fa fa-user"></i> Utente</label>
+        <input type="text" id="node-input-user">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-pass"><i class="fa fa-lock"></i> Password NVR</label>
+        <input type="password" id="node-input-pass">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-protocol"><i class="fa fa-shield"></i> Protocollo</label>
+        <select id="node-input-protocol" style="width: 70%">
+            <option value="http">HTTP</option>
+            <option value="https">HTTPS</option>
+        </select>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-port"><i class="fa fa-plug"></i> Porta</label>
+        <select id="node-input-port" style="width: 70%">
+            <option value="80">80</option>
+            <option value="443">443</option>
+            <option value="85">85</option>
+            <option value="8000">8000</option>
+            <option value="8008">8008</option>
+        </select>
+    </div>
+
+</script>

package/hik-snapshot.js

@@ -0,0 +1,102 @@
+const axios = require('axios');
+const https = require('https');
+const mhocDigestSnapshot = require('@mhoc/axios-digest-auth');
+const DigestAuthClass = mhocDigestSnapshot.default;
+
+module.exports = function(RED) {
+    function HikSnapshotNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        node.protocol = config.protocol || "http";
+        node.host = config.host;
+        node.port = config.port || "80";
+        node.user = config.user;
+        node.pass = config.pass;
+        node.maxChannels = parseInt(config.channel) || 1;
+
+        const httpsAgent = new https.Agent({ rejectUnauthorized: false });
+
+        node.on('input', async function(msg) {
+            if (msg.payload !== true) return;
+
+            node.status({fill: "blue", shape: "dot", text: "Verifica canali..."});
+
+            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(); 
+
+            let snapshotResults = []; 
+
+            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`;
+                
+                const recordXml = `<?xml version="1.0" encoding="utf-8"?><trackDailyParam><year>${year}</year><monthOfYear>${month}</monthOfYear><dayOfMonth>${day}</dayOfMonth></trackDailyParam>`;
+
+                let resCanale = {
+                    channel: i,
+                    photo: null,
+                    snapOk: false,
+                    isRecording: false
+                };
+
+                // 1. SNAPSHOT
+                try {
+                    const responseSnap = await digest.request({
+                        method: 'GET',
+                        url: snapUrl,
+                        responseType: 'arraybuffer',
+                        httpsAgent: node.protocol === 'https' ? httpsAgent : undefined,
+                        timeout: 5000
+                    });
+                    resCanale.photo = responseSnap.data;
+                    resCanale.snapOk = true;
+                } catch (err) {
+                    resCanale.snapError = err.message;
+                }
+
+                // 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
+                    });
+                    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));
+            }
+
+            msg.payload = snapshotResults;
+            node.send(msg);
+
+            // 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}`
+            });
+        });
+    }
+    RED.nodes.registerType("hik-snapshot", HikSnapshotNode);
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "node-red-contrib-hik-media-buffer",
+  "version": "1.0.0",
+  "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
+  "node-red": {
+    "nodes": {
+      "hik-media-buffer": "hik-media-buffer.js",
+      "hik-snapshot": "hik-snapshot.js"
+    }
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "@mhoc/axios-digest-auth": "^0.8.0",
+    "xml2js": "^0.6.2"
+  }
+}