node-opcua-address-space 2.51.0

package/src/ua_view_impl.ts

@@ -0,0 +1,54 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+import { NodeClass } from "node-opcua-data-model";
+import { AttributeIds } from "node-opcua-data-model";
+import { DataValue, DataValueLike } from "node-opcua-data-value";
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType } from "node-opcua-variant";
+import { ISessionContext, UAView  } from "node-opcua-address-space-base";
+
+import { SessionContext } from "../source/session_context";
+import { BaseNodeImpl, InternalBaseNodeOptions } from "./base_node_impl";
+
+export interface InternalViewOptions extends InternalBaseNodeOptions {
+    containsNoLoops?: boolean;
+}
+
+export class UAViewImpl extends BaseNodeImpl implements UAView {
+
+    public readonly nodeClass = NodeClass.View;
+    public readonly containsNoLoops: boolean;
+    public readonly eventNotifier: number;
+
+    constructor(options: InternalViewOptions) {
+        super(options);
+        this.containsNoLoops = !!options.containsNoLoops;
+        this.eventNotifier = 0;
+    }
+
+    public readAttribute(context: ISessionContext | null, attributeId: AttributeIds): DataValue {
+
+        context = context || SessionContext.defaultContext;
+   
+        const options: DataValueLike = {};
+
+        switch (attributeId) {
+
+            case AttributeIds.EventNotifier:
+                options.value = { dataType: DataType.UInt32, value: this.eventNotifier };
+                options.statusCode = StatusCodes.Good;
+                break;
+
+            case AttributeIds.ContainsNoLoops:
+                options.value = { dataType: DataType.Boolean, value: this.containsNoLoops };
+                options.statusCode = StatusCodes.Good;
+                break;
+
+            default:
+               return super.readAttribute(context, attributeId);
+        }
+        return new DataValue(options);
+    }
+}

package/testHelpers.d.ts

@@ -0,0 +1 @@
+export * from "./distHelpers";

package/testHelpers.js

@@ -0,0 +1 @@
+module.exports = require("./distHelpers");

package/test_helpers/add_event_generator_object.ts

@@ -0,0 +1,71 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType, Variant } from "node-opcua-variant";
+import { INamespace, UAObject, ISessionContext, MethodFunctorCallback } from "node-opcua-address-space-base";
+import { UAFolder   } from "node-opcua-nodeset-ua";
+
+export function add_eventGeneratorObject(namespace: INamespace, parentFolder: UAFolder | string) {
+    const myEvtType = namespace.addEventType({
+        browseName: "MyEventType",
+        subtypeOf: "BaseEventType" // should be implicit
+    });
+
+    const myObject = namespace.addObject({
+        browseName: "EventGeneratorObject",
+        eventNotifier: 1,
+        organizedBy: parentFolder
+    });
+
+    myObject.addReference({
+        nodeId: myEvtType,
+        referenceType: "AlwaysGeneratesEvent"
+    });
+
+    const method = namespace.addMethod(myObject, {
+        browseName: "EventGeneratorMethod",
+        inputArguments: [
+            {
+                dataType: DataType.String,
+                description: { text: "Event Message" },
+                name: "message"
+            },
+            {
+                dataType: DataType.UInt32,
+                description: { text: "Event Severity" },
+                name: "severity"
+            }
+        ],
+        outputArguments: []
+    });
+
+    method.bindMethod((inputArguments: Variant[], context: ISessionContext, callback: MethodFunctorCallback) => {
+        // xx console.log("In Event Generator Method");
+        // xx console.log(this.toString());
+        // xx console.log(context.object.toString());
+
+        // xx console.log("inputArguments ", inputArguments[0].toString());
+
+        const message = inputArguments[0].value || "Hello from Event Generator Object";
+        const severity = inputArguments[1].value || 0;
+
+        const myEventType = namespace.addressSpace.findEventType("MyEventType", namespace.index)!;
+        (context.object as UAObject).raiseEvent(myEventType, {
+            message: {
+                dataType: DataType.LocalizedText,
+                value: { text: message }
+            },
+            severity: {
+                dataType: DataType.UInt32,
+                value: severity
+            }
+        });
+        // console.log(require("util").inspect(context).toString());
+        const callMethodResult = {
+            outputArguments: [],
+            statusCode: StatusCodes.Good
+        };
+        callback(null, callMethodResult);
+    });
+}

package/test_helpers/alarms_and_conditions_demo.ts

@@ -0,0 +1,147 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+import { AddressSpace, UAExclusiveLimitAlarmImpl, UAObject, UAVariable} from "..";
+import { UANonExclusiveLimitAlarmEx , UAExclusiveLimitAlarmEx } from "..";
+
+export interface IAlarmTestData {
+    tankLevel: UAVariable;
+    tankLevelCondition: UAExclusiveLimitAlarmEx;
+    tankLevel2: UAVariable;
+    tankLevelCondition2: UANonExclusiveLimitAlarmEx;
+    tankTripCondition: null;
+}
+
+export function construct_demo_alarm_in_address_space(test: IAlarmTestData, addressSpace: AddressSpace) {
+    
+    const a = addressSpace as any;
+    if (a.construct_demo_alarm_in_address_space_called) {
+        return;
+    }
+    a.construct_demo_alarm_in_address_space_called = true;
+
+    addressSpace.installAlarmsAndConditionsService();
+
+    const namespace = addressSpace.getOwnNamespace();
+
+    const tank = namespace.addObject({
+        browseName: "Tank",
+        description: "The Object representing the Tank",
+        eventNotifier: 0x01,
+        notifierOf: addressSpace.rootFolder.objects.server,
+        organizedBy: addressSpace.rootFolder.objects
+    });
+    assert(tank.getNotifiers().length === 0, "expecting a notifier now");
+
+    const tankLevel = namespace.addVariable({
+        browseName: "TankLevel",
+        componentOf: tank,
+        dataType: "Double",
+        description: "Fill level in percentage (0% to 100%) of the water tank",
+        eventSourceOf: tank,
+        value: { dataType: "Double", value: 0.5 }
+    });
+    //    assert(tank.getNotifiers().length === 1, "expecting a notifier now");
+
+    // --------------------------------------------------------------------------------
+    // Let's create a exclusive Limit Alarm that automatically raise itself
+    // when the tank level is out of limit
+    // --------------------------------------------------------------------------------
+
+    const exclusiveLimitAlarmType = addressSpace.findEventType("ExclusiveLimitAlarmType");
+    if (!exclusiveLimitAlarmType) {
+        throw new Error("cannot find ExclusiveLimitAlarmType in namespace 0");
+    }
+
+    const tankLevelCondition = namespace.instantiateExclusiveLimitAlarm(exclusiveLimitAlarmType, {
+        browseName: "TankLevelCondition",
+        componentOf: tank,
+        conditionName: "TankLevelCondition",
+        conditionSource: tankLevel,
+
+        highHighLimit: 0.9,
+        highLimit: 0.8,
+
+        inputNode: tankLevel, // the variable that will be monitored for change
+
+        lowLimit: 0.2,
+
+        optionals: [
+            "ConfirmedState",
+            "Confirm" // confirm state and confirm Method
+        ]
+    }) as UAExclusiveLimitAlarmImpl;
+    
+    assert(tankLevelCondition.browseName.toString() === "1:TankLevelCondition");
+
+    assert(tankLevel.findReferences("HasCondition").length === 1);
+    assert(tankLevel.findReferencesAsObject("HasCondition", true).length === 1);
+      
+    const conditionName = tankLevel.findReferencesAsObject("HasCondition", true)[0].browseName.toString();
+    const conditionTypeDefinition =  (tankLevel.findReferencesAsObject("HasCondition", true)[0] as UAObject).typeDefinitionObj.browseName.toString();
+    const conditionJavascriptClass = tankLevel.findReferencesAsObject("HasCondition", true)[0].constructor.name.toString();
+    if (false) {
+        console.log(conditionName, conditionTypeDefinition, conditionJavascriptClass);
+    }
+    assert("1:TankLevelCondition" === conditionName);
+    assert("ExclusiveLimitAlarmType" === conditionTypeDefinition)
+    assert("UAExclusiveLimitAlarmImpl" === conditionJavascriptClass);
+
+    // ----------------------------------------------------------------
+    // tripAlarm that signals that the "Tank lid" is opened
+    const tripAlarmType = addressSpace.findEventType("TripAlarmType");
+
+    const tankTripCondition = null;
+    // to
+    // ---------------------------
+    // create a retain condition
+    // xx tankLevelCondition.currentBranch().setRetain(true);
+    // xx tankLevelCondition.raiseNewCondition({message: "Tank is almost 70% full",
+    //                                          severity: 100, quality: StatusCodes.Good});
+
+    // -------------------------------------------------------------
+    // Let's create a second variable with no Exclusive alarm
+    // -------------------------------------------------------------
+    const tankLevel2 = namespace.addVariable({
+        browseName: "tankLevel2",
+        componentOf: tank,
+        dataType: "Double",
+        description: "Fill level in percentage (0% to 100%) of the water tank",
+        eventSourceOf: tank,
+        value: { dataType: "Double", value: 0.5 }
+    });
+
+    const nonExclusiveLimitAlarmType = addressSpace.findEventType("NonExclusiveLimitAlarmType");
+    if (!nonExclusiveLimitAlarmType) {
+        throw new Error("!!");
+    }
+
+    const tankLevelCondition2 = namespace.instantiateNonExclusiveLimitAlarm(nonExclusiveLimitAlarmType, {
+        browseName: "TankLevelCondition2",
+        componentOf: tank,
+        conditionName: "TankLevel2",
+        conditionSource: tankLevel2,
+
+        highHighLimit: 0.9,
+        highLimit: 0.8,
+
+        inputNode: tankLevel2, // the variable that will be monitored for change
+
+        lowLimit: 0.2,
+
+        optionals: [
+            "ConfirmedState",
+            "Confirm" // confirm state and confirm Method
+        ]
+    });
+    assert(tankLevel2.findReferences("HasCondition").length === 1);
+    assert(tankLevel2.findReferencesAsObject("HasCondition", true).length === 1);
+    test.tankLevel = tankLevel;
+    test.tankLevelCondition = tankLevelCondition;
+
+    test.tankLevel2 = tankLevel2;
+    test.tankLevelCondition2 = tankLevelCondition2;
+
+    test.tankTripCondition = tankTripCondition;
+}

package/test_helpers/assertHasMatchingReference.ts

@@ -0,0 +1,43 @@
+/**
+ * @module node-opcua-address-space
+ */
+import { assert } from "node-opcua-assert";
+import { NodeId, sameNodeId } from "node-opcua-nodeid";
+import { AddReferenceOpts, BaseNode, UAReference } from "..";
+
+/**
+ * asserts that the provided reference exists in the node references
+ *
+ * @method assertHasMatchingReference
+ *
+ * @param node
+ * @param reference (Reference}
+ * @param reference.referenceType {String}
+ * @param reference.nodeId        {NodeId}
+ * @param reference.isForward     {Boolean}
+ *
+ * @example:
+ *
+ *     assertHasMatchingReference(node,{ referenceType: "Organizes",i sForward:true, nodeId: "ns=1,i=12" });
+ *
+ *
+ */
+export function assertHasMatchingReference(node: BaseNode, reference: AddReferenceOpts) {
+    const addressSpace = node.addressSpace;
+
+    const normalizedReference = addressSpace.normalizeReferenceType(reference);
+    assert(normalizedReference.referenceType instanceof NodeId);
+
+    let refs = node.findReferences(normalizedReference.referenceType, normalizedReference.isForward);
+
+    refs = refs.filter((ref: UAReference) => {
+        return sameNodeId(ref.nodeId, normalizedReference.nodeId);
+    });
+
+    const dispOpts = { addressSpace };
+
+    if (refs.length !== 1) {
+        throw new Error(" Cannot find reference " + JSON.stringify(normalizedReference));
+    }
+    assert(refs.length === 1);
+}