@vitormnm/node-red-simple-opcua 1.0.2 → 1.0.3

package/server/opcua-server-registry.js

@@ -0,0 +1,270 @@
+"use strict";
+
+const servers = new Map();
+const methodHandlers = new Map();
+const pendingCalls = new Map();
+const accessListeners = new Map();
+const childs = new Map();
+const activeAlarms = new Map();
+
+const serversNames = new Map(); //get serve name for opcua-server-io
+
+function registerServer(node) {
+    servers.set(node.id, node);
+}
+
+function registerServerNames(node) {
+    serversNames.set(node, node);
+}
+
+
+function registerChild(serverName, child) {
+    if (!serverName || !child) {
+        return;
+    }
+
+    childs.set(serverName, child);
+
+    const cleanup = () => {
+        if (childs.get(serverName) === child) {
+            childs.delete(serverName);
+        }
+    };
+
+    child.once("exit", cleanup);
+    child.once("close", cleanup);
+    child.once("disconnect", cleanup);
+}
+
+function unregisterServer(nodeId) {
+    servers.delete(nodeId);
+}
+
+function unregisterServerNames(name) {
+    serversNames.delete(name);
+}
+
+
+function resolveServer(reference) {
+    const activeServers = Array.from(servers.values()).filter((node) => node && node.server);
+
+    if (!reference) {
+        if (activeServers.length === 1) {
+            return activeServers[0];
+        }
+        return null;
+    }
+
+    const normalizedReference = String(reference).trim();
+    return activeServers.find((node) =>
+        node.id === normalizedReference ||
+        node.name === normalizedReference ||
+        node.serverName === normalizedReference
+    ) || null;
+}
+
+function listActiveServers() {
+    return Array.from(serversNames.values())
+
+    // return Array.from(servers.values())
+    //     .filter((node) => node && node.server)
+    //     .map((node) => ({
+    //         id: node.id,
+    //         name: node.name || "",
+    //         serverName: node.serverName || "",
+    //         label: node.name || node.serverName || node.id,
+    //         value: node.serverName || node.name || node.id
+    //     }));
+}
+
+function resolveChild(serverName) {
+    const child = childs.get(serverName);
+
+    if (!child) {
+        return null;
+    }
+
+    if (child.killed || child.exitCode !== null || child.channel === null || !child.connected) {
+        childs.delete(serverName);
+        return null;
+    }
+
+    return child;
+}
+
+function unregisterChild(serverName, child) {
+    if (!serverName) {
+        return;
+    }
+
+    if (child) {
+        if (childs.get(serverName) === child) {
+            childs.delete(serverName);
+        }
+        return;
+    }
+
+    childs.delete(serverName);
+}
+
+function registerMethodHandler(methodName, nodeId) {
+    methodHandlers.set(methodName, nodeId);
+}
+
+function unregisterMethodHandler(methodName) {
+    methodHandlers.delete(methodName);
+}
+
+function emitMethodCall(call) {
+    const nodeId = methodHandlers.get(call.methodName);
+
+    process.send({
+        type: "sendMethod",
+        data: call,
+        nodeId: nodeId
+    });
+    //handler.sendMethodCall(call);
+}
+
+function waitForMethodResponse(callId) {
+    return new Promise((resolve, reject) => {
+        pendingCalls.set(callId, { resolve, reject });
+
+        setTimeout(() => {
+            if (pendingCalls.has(callId)) {
+                pendingCalls.delete(callId);
+                reject(new Error("Timeout waiting method response"));
+            }
+        }, 10000);
+    });
+}
+
+function resolveMethodCall(callId, payload) {
+    const pending = pendingCalls.get(callId);
+
+    if (!pending) {
+        return;
+    }
+
+    pending.resolve(payload);
+    pendingCalls.delete(callId);
+}
+
+function registerAccessListener(listenerId, node) {
+    accessListeners.set(listenerId, node);
+}
+
+// function registerActiveAlarms(alarm, node) {
+
+// const lista = activeAlarms.get(node.id) ?? [];
+// lista.push(alarm);
+// activeAlarms.set(node.id, lista);
+
+
+// }
+
+function registerActiveAlarms(alarm, message, severity, retain, node) {
+
+
+    const alarmNodeId = alarm.nodeId.toString();
+    const lista = activeAlarms.get(node.id) ?? [];
+
+    // remove antigo se já existir
+    const novaLista = lista.filter(
+        x => x.alarm.nodeId.toString() !== alarmNodeId
+    );
+
+    if (retain) {
+        // adiciona novo
+        novaLista.push({
+            alarm,
+            message,
+            severity,
+            retain
+        });
+    }
+
+    // atualiza o map (com ou sem o alarme)
+    activeAlarms.set(node.id, novaLista);
+}
+
+function getActiveAlarms(node) {
+    try {
+
+
+        var lista = activeAlarms.get(node.id) ?? [];
+        var saida = []
+
+
+        lista.forEach(element => {
+
+            const alarmNode = element.alarm
+            const ConditionName = alarmNode.getPropertyByName("ConditionName").readValue().value.value;
+            const SourceName = alarmNode.getPropertyByName("SourceName").readValue().value.value;
+            const isActive = alarmNode.activeState.id.readValue().value.value;
+            const isAcked = alarmNode.ackedState.id.readValue().value.value;
+            const ConfirmedState = alarmNode.confirmedState.id.readValue().value.value;
+
+
+
+            saida.push({
+                activeState: isActive,
+                message: element.message,
+                severity: element.severity,
+                retain: element.retain,
+                sourceName: SourceName,
+                conditionName: ConditionName,
+                ConfirmedState: ConfirmedState,
+                ackedState: isAcked,
+                alarmNode: alarmNode,
+
+            })
+        });
+
+
+        //  return activeAlarms.get(node.id) ?? [];
+        return saida
+
+
+    } catch (error) {
+        console.error("getActiveAlarms")
+        console.error(error)
+    }
+
+}
+
+function unregisterAccessListener(listenerId) {
+    accessListeners.delete(listenerId);
+}
+
+function emitTagAccess(event) {
+    accessListeners.forEach((listener) => {
+        if (!listener || typeof listener.enqueueAccessEvent !== "function") {
+            return;
+        }
+
+        listener.enqueueAccessEvent(event);
+    });
+}
+
+module.exports = {
+    registerServer,
+    registerServerNames,
+    registerChild,
+    unregisterChild,
+    resolveChild,
+    unregisterServer,
+    unregisterServerNames,
+    resolveServer,
+    listActiveServers,
+    registerMethodHandler,
+    unregisterMethodHandler,
+    emitMethodCall,
+    waitForMethodResponse,
+    resolveMethodCall,
+    registerAccessListener,
+    unregisterAccessListener,
+    emitTagAccess,
+    registerActiveAlarms,
+    getActiveAlarms,
+};

package/server/opcua-server.css

@@ -0,0 +1,265 @@
+
+    body.opcua-tree-modal-open {
+        overflow: hidden;
+    }
+
+    .opcua-tree-editor {
+        width: 100%;
+        min-height: 120px;
+    }
+
+    .opcua-tree-modal {
+        position: fixed;
+        inset: 0;
+        z-index: 2000;
+        background: rgba(0, 0, 0, 0.45);
+        padding: 24px;
+        box-sizing: border-box;
+    }
+
+    .opcua-tree-modal__dialog {
+        display: flex;
+        flex-direction: column;
+        width: 100%;
+        height: 100%;
+        background: #f3f3f3;
+        border-radius: 8px;
+        overflow: hidden;
+        box-shadow: 0 8px 24px rgba(0, 0, 0, 0.2);
+    }
+
+    .opcua-tree-modal__header,
+    .opcua-tree-modal__toolbar {
+        display: flex;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 10px;
+        padding: 14px 18px;
+        background: #fff;
+        border-bottom: 1px solid #d9d9d9;
+    }
+
+    .opcua-tree-modal__title {
+        font-size: 18px;
+        font-weight: 600;
+        color: #333;
+    }
+
+    .opcua-tree-modal__header .editor-button-small {
+        margin-left: auto;
+    }
+
+    .opcua-tree-modal__body {
+        flex: 1 1 auto;
+        overflow: auto;
+        padding: 18px;
+    }
+
+    .opcua-tree-search {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+        min-width: 280px;
+        margin-left: auto;
+        padding: 6px 10px;
+        border: 1px solid #d9d9d9;
+        border-radius: 6px;
+        background: #fafafa;
+    }
+
+    .opcua-tree-search input {
+        flex: 1 1 auto;
+        min-width: 120px;
+        border: 0;
+        outline: 0;
+        background: transparent;
+        box-shadow: none;
+        margin: 0;
+    }
+
+    .opcua-tree-search-results {
+        margin-bottom: 12px;
+    }
+
+    .opcua-tree-search-meta {
+        margin-bottom: 10px;
+        color: #666;
+        font-size: 12px;
+    }
+
+    .opcua-tree-search-result {
+        margin-bottom: 8px;
+    }
+
+    .opcua-tree-search-path {
+        margin-bottom: 4px;
+        color: #666;
+        font-size: 12px;
+        font-family: Consolas, monospace;
+    }
+
+    .opcua-tree-group,
+    .opcua-tree-node {
+        border: 1px solid #d9d9d9;
+        border-radius: 4px;
+        background: #fff;
+        margin-bottom: 8px;
+    }
+
+    .opcua-tree-node[data-depth="1"],
+    .opcua-tree-group[data-depth="1"] {
+        margin-left: 2px;
+    }
+
+    .opcua-tree-node[data-depth="2"],
+    .opcua-tree-group[data-depth="2"] {
+        margin-left: 2px;
+    }
+
+    .opcua-tree-node[data-depth="3"],
+    .opcua-tree-group[data-depth="3"] {
+        margin-left: 2px;
+    }
+
+    .opcua-tree-node[data-depth="4"],
+    .opcua-tree-group[data-depth="4"] {
+        margin-left: 2px;
+    }
+
+    .opcua-tree-header {
+        display: flex;
+        align-items: center;
+        flex-wrap: wrap;
+        gap: 4px;
+        padding: 4px 5px;
+        background: #f8f8f8;
+    }
+
+    .opcua-tree-body {
+        padding: 5px;
+        border-top: 1px solid #ededed;
+    }
+
+    .opcua-tree-toggle {
+        width: 24px;
+        height: 24px;
+        border: 0;
+        padding: 0;
+        background: transparent;
+        color: #666;
+        cursor: pointer;
+        flex: 0 0 auto;
+    }
+
+    .opcua-tree-title {
+        min-width: 100px;
+        font-weight: 600;
+        color: #444;
+    }
+
+    .opcua-tree-summary {
+        color: #777;
+        font-size: 12px;
+        white-space: nowrap;
+    }
+
+    .opcua-tree-input {
+        flex: 1 1 auto;
+        min-width: 220px;
+    }
+
+    .opcua-tree-actions {
+        margin-left: auto;
+        display: flex;
+        gap: 6px;
+        align-items: center;
+        flex-wrap: wrap;
+    }
+
+    .opcua-tree-empty {
+        padding: 14px;
+        border: 1px dashed #d9d9d9;
+        border-radius: 4px;
+        background: #fafafa;
+        color: #777;
+        text-align: center;
+    }
+
+    .opcua-tree-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+        gap: 12px;
+    }
+
+    .opcua-tree-grid .form-row {
+        margin-bottom: 0;
+    }
+
+    .opcua-tree-grid .form-row label {
+        width: 100px !important;
+        flex: 0 0 100px;
+    }
+
+    .opcua-tree-grid .form-row input,
+    .opcua-tree-grid .form-row select,
+    .opcua-tree-grid .form-row textarea {
+        width: auto;
+        flex: 1 1 auto;
+        min-width: 0;
+    }
+
+    .opcua-tree-form-row {
+        display: flex;
+        align-items: center;
+        gap: 8px;
+    }
+
+    .opcua-tree-form-row--full {
+        grid-column: 1 / -1;
+    }
+
+    .opcua-tree-divider {
+        grid-column: 1 / -1;
+        border-top: 1px solid #e3e3e3;
+        margin: 2px 0;
+    }
+
+    .opcua-tree-section-title {
+        grid-column: 1 / -1;
+        font-size: 12px;
+        font-weight: 700;
+        text-transform: uppercase;
+        letter-spacing: 0.04em;
+        color: #666;
+        margin-top: 2px;
+    }
+
+    @media (max-width: 900px) {
+        .opcua-tree-modal {
+            padding: 10px;
+        }
+
+        .opcua-tree-search {
+            min-width: 100%;
+            margin-left: 0;
+        }
+
+        .opcua-tree-grid {
+            grid-template-columns: 1fr;
+        }
+
+        .opcua-tree-header {
+            align-items: flex-start;
+        }
+
+        .opcua-tree-title,
+        .opcua-tree-summary,
+        .opcua-tree-input,
+        .opcua-tree-actions {
+            width: 100%;
+        }
+
+        .opcua-tree-actions {
+            margin-left: 0;
+        }
+    }