node-opcua-address-space 2.97.0 → 2.98.1

package/test_helpers/add_event_generator_object.ts

@@ -1,71 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-import { CallbackT, StatusCodes } from "node-opcua-status-code";
-import { DataType, Variant } from "node-opcua-variant";
-import { INamespace, UAObject, ISessionContext } from "node-opcua-address-space-base";
-import { UAFolder } from "node-opcua-nodeset-ua";
-import { CallMethodResultOptions } from "node-opcua-types";
-
-export function add_eventGeneratorObject(namespace: INamespace, parentFolder: UAFolder | string): void {
-    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: CallbackT<CallMethodResultOptions>) => {
-        // 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
-            }
-        });
-        const callMethodResult = {
-            outputArguments: [],
-            statusCode: StatusCodes.Good
-        };
-        callback(null, callMethodResult);
-    });
-}

package/test_helpers/alarms_and_conditions_demo.ts

@@ -1,151 +0,0 @@
-/**
- * @module node-opcua-address-space
- */
-import { assert } from "node-opcua-assert";
-import { AddressSpace,UANonExclusiveLimitAlarmEx, UAExclusiveLimitAlarmEx, UAObject, UAVariable } 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): void {
-    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
-        ],
-
-        setpointNode: null,
-
-    }) as UAExclusiveLimitAlarmEx;
-
-    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

@@ -1,43 +0,0 @@
-/**
- * @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): void {
-    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);
-}