node-opcua-alarm-condition 2.119.0

package/source/client_alarm_list.ts

@@ -0,0 +1,112 @@
+import { EventEmitter } from "events";
+import { assert } from "node-opcua-assert";
+import { NodeId } from "node-opcua-nodeid";
+import { EventStuff } from "./event_stuff";
+import { ClientAlarm } from "./client_alarm";
+
+export interface ClientAlarmList {
+    on(eventName: "alarmChanged", handler: (alarm: ClientAlarm) => void): this;
+    on(eventName: "alarmDeleted", handler: (alarm: ClientAlarm) => void): this;
+    on(eventName: "newAlarm", handler: (alarm: ClientAlarm) => void): this;
+
+    emit(eventName: "alarmChanged", alarm: ClientAlarm): boolean;
+    emit(eventName: "newAlarm", alarm: ClientAlarm): boolean;
+    emit(eventName: "alarmDeleted", alarm: ClientAlarm): boolean;
+}
+// maintain a set of alarm list for a client
+export class ClientAlarmList extends EventEmitter implements Iterable<ClientAlarm> {
+    private _map: { [key: string]: ClientAlarm } = {};
+
+    public constructor() {
+        super();
+    }
+
+    public [Symbol.iterator](): Iterator<ClientAlarm> {
+        let pointer = 0;
+        const components = Object.values(this._map);
+        return {
+            next(): IteratorResult<ClientAlarm> {
+                if (pointer >= components.length) {
+                    return {
+                        done: true,
+                        value: components[pointer++]
+                    };
+                } else {
+                    return {
+                        done: false,
+                        value: components[pointer++]
+                    };
+                }
+            }
+        };
+    }
+
+    public alarms(): ClientAlarm[] {
+        return Object.values(this._map);
+    }
+
+    public update(eventField: EventStuff): void {
+        // Spec says:
+        // Clients shall check for multiple Event Notifications for a ConditionBranch to avoid
+        // overwriting a new state delivered together with an older state from the Refresh
+        // process.
+
+        const { conditionId, eventType } = eventField;
+        assert(conditionId, "must have a valid conditionId ( verify that event is a acknowledgeable type");
+        const alarm = this.findAlarm(conditionId.value, eventType.value);
+
+        if (!alarm) {
+            const key = this.makeKey(conditionId.value, eventType.value);
+            const newAlarm = new ClientAlarm(eventField);
+            this._map[key] = newAlarm;
+            this.emit("newAlarm", newAlarm);
+            this.emit("alarmChanged", newAlarm);
+        } else {
+            alarm.update(eventField);
+            this.emit("alarmChanged", alarm);
+        }
+    }
+    public removeAlarm(eventField: EventStuff): void {
+        const { conditionId, eventType } = eventField;
+        const alarm = this.findAlarm(conditionId.value, eventType.value);
+        if (alarm) {
+            alarm.update(eventField);
+            this._removeAlarm(alarm);
+        }
+    }
+
+    public get length(): number {
+        return Object.keys(this._map).length;
+    }
+    public purgeUnusedAlarms(): void {
+        const alarms = this.alarms();
+        for (const alarm of alarms) {
+            if (!alarm.getRetain()) {
+                this._removeAlarm(alarm);
+            }
+        }
+    }
+
+    private _removeAlarm(alarm: ClientAlarm) {
+        this.emit("alarmDeleted", alarm);
+        this.deleteAlarm(alarm.conditionId, alarm.eventType);
+    }
+
+    private makeKey(conditionId: NodeId, eventType: NodeId) {
+        return conditionId.toString() + "|" + eventType.toString();
+    }
+    private findAlarm(conditionId: NodeId, eventType: NodeId): ClientAlarm | null {
+        const key = this.makeKey(conditionId, eventType);
+        const _c = this._map[key];
+        return _c || null;
+    }
+    private deleteAlarm(conditionId: NodeId, eventType: NodeId): boolean {
+        const key = this.makeKey(conditionId, eventType);
+        const _c = this._map[key];
+        if (_c) {
+            delete this._map[key];
+            return true;
+        }
+        return false;
+    }
+}

package/source/client_alarm_tools_dump_event.ts

@@ -0,0 +1,66 @@
+import chalk from "chalk";
+import { AttributeIds } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { IBasicSessionReadAsyncSimple } from "node-opcua-pseudo-session";
+import { DataType, Variant, VariantLike } from "node-opcua-variant";
+import { make_traceLog } from "node-opcua-debug";
+
+const traceLog = make_traceLog("ClientAlarmTool");
+
+/**
+ *
+ * @param session
+ * @param fields
+ * @param eventFields
+ */
+export async function dumpEvent(session: IBasicSessionReadAsyncSimple, fields: string[], eventFields: Variant[]): Promise<void> {
+    async function getBrowseName(_session: IBasicSessionReadAsyncSimple, nodeId: NodeId): Promise<string> {
+        const dataValue = await _session.read({
+            attributeId: AttributeIds.BrowseName,
+            nodeId
+        });
+        if (dataValue.statusCode.isGood()) {
+            const browseName = dataValue.value.value.name!;
+            return browseName;
+        } else {
+            return "???";
+        }
+    }
+    function w(str: string, l: number): string {
+        return (str || "").toString().padEnd(l, " ").substring(0, l);
+    }
+    async function __dumpEvent1(_session: IBasicSessionReadAsyncSimple, _fields: any, variant: VariantLike, index: number) {
+        if (variant.dataType === DataType.Null) {
+            return;
+        }
+        if (variant.dataType === DataType.NodeId) {
+            const name = await getBrowseName(_session, variant.value);
+            traceLog(
+                chalk.yellow(w(name, 30), w(_fields[index], 25)),
+                chalk.cyan(w(DataType[variant.dataType], 10).toString()),
+                chalk.cyan.bold(name),
+                "(",
+                w(variant.value, 20),
+                ")"
+            );
+        } else {
+            // tslint:disable-next-line: no-console
+            traceLog(
+                chalk.yellow(w("", 30), w(_fields[index], 25)),
+                chalk.cyan(w(DataType[variant.dataType as number], 10).toString()),
+                variant.value
+            );
+        }
+    }
+
+    async function __dumpEvent(_session: IBasicSessionReadAsyncSimple, _fields: string[], _eventFields: Variant[]) {
+        let index = 0;
+        const promises = [];
+        for (const variant of _eventFields) {
+            promises.push(__dumpEvent1(_session, _fields, variant, index));
+            index++;
+        }
+        await Promise.all(promises);
+    }
+    await __dumpEvent(session, fields, eventFields);
+}

package/source/event_stuff.ts

@@ -0,0 +1,65 @@
+import { NodeId } from "node-opcua-nodeid";
+import { lowerFirstLetter } from "node-opcua-utils";
+import { Variant } from "node-opcua-variant";
+
+import { make_warningLog } from "node-opcua-debug";
+const warningLog = make_warningLog(__filename);
+
+export interface TVariant<T> extends Variant {
+    value: T;
+}
+export interface TTwoStateStatus extends TVariant<string> {
+    id: TVariant<boolean>;
+}
+export interface EventStuff {
+    conditionId: TVariant<NodeId>;
+    eventType: TVariant<NodeId>;
+    eventId: TVariant<Buffer>;
+    retain: TVariant<boolean>;
+    activeState: TTwoStateStatus;
+    ackedState: TTwoStateStatus;
+    confirmedState: TTwoStateStatus;
+    conditionName?: TVariant<string>;
+}
+
+
+/**
+ * @private
+ */
+export function fieldsToJson(fields: string[], eventFields: Variant[], flat?: boolean): EventStuff {
+
+    function setProperty(_data: Record<string, unknown>, fieldName: string, value: Variant) {
+        let name: string;
+        if (!fieldName || value === null) {
+            return;
+        }
+        if (!flat) {
+            const f = fieldName.split(".");
+            if (f.length === 1) {
+                fieldName = lowerFirstLetter(fieldName);
+                _data[fieldName] = value;
+            } else {
+                for (let i = 0; i < f.length - 1; i++) {
+                    name = lowerFirstLetter(f[i]);
+                    _data[name] = _data[name] || {};
+                    _data = _data[name] as Record<string, unknown>;
+                }
+                name = lowerFirstLetter(f[f.length - 1]);
+                _data[name] = value;
+            }
+        } else {
+            const name = fieldName.split(".").map(lowerFirstLetter).join(".");
+            _data[name] = value;
+        }
+    }
+    if (fields.length > eventFields.length) {
+        warningLog("warning fields.length !==  eventFields.length", fields.length, eventFields.length);
+    }
+    const data: any = {};
+    for (let index = 0; index < fields.length; index++) {
+        const variant = eventFields[index];
+        setProperty(data, fields[index], variant);
+    }
+
+    return data;
+}

package/source/extract_condition_fields.ts

@@ -0,0 +1,12 @@
+import { NodeIdLike } from "node-opcua-nodeid";
+import { ISessionForExtractField, extractFields, simpleBrowsePathsToString } from "node-opcua-pseudo-session";
+
+export async function extractConditionFields(session: ISessionForExtractField, conditionNodeId: NodeIdLike): Promise<string[]> {
+    // conditionNodeId could be a Object of type ConditionType
+    // or it could be directly a ObjectType which is a subType of ConditionType
+    const p = await extractFields(session, conditionNodeId);
+    const fields1 = simpleBrowsePathsToString(p.map((a) => a.path));
+    // add this field which will always be added
+    fields1.push("ConditionId");
+    return fields1;
+}

package/source/index.ts

@@ -0,0 +1,8 @@
+export * from "./acknowledge_all_conditions";
+export * from "./call_condition_refresh";
+export * from "./call_method_condition";
+export * from "./client_alarm_list";
+export * from "./client_alarm_tools_dump_event";
+export * from "./client_alarm";
+export * from "./event_stuff";
+export * from "./extract_condition_fields";