node-opcua-address-space 2.51.0

package/src/data_access/ua_two_state_discrete.ts

@@ -0,0 +1,185 @@
+import assert from "node-opcua-assert";
+import { coerceLocalizedText, LocalizedText, LocalizedTextLike, QualifiedNameLike } from "node-opcua-data-model";
+import { DataType, Variant, VariantLike } from "node-opcua-variant";
+import { VariableTypeIds } from "node-opcua-constants";
+import { INamespace, UAVariable, BindVariableOptions, UAProperty, ISessionContext } from "node-opcua-address-space-base";
+import { DataValueT } from "node-opcua-data-value";
+import { NumericRange } from "node-opcua-numeric-range";
+
+import { UAVariableImpl } from "../ua_variable_impl";
+import { registerNodePromoter } from "../../source/loader/register_node_promoter";
+import { AddTwoStateDiscreteOptions } from "../../source/address_space_ts";
+import { UATwoStateDiscreteEx } from "../../source/interfaces/data_access/ua_two_state_discrete_ex";
+
+import { add_dataItem_stuff } from "./add_dataItem_stuff";
+
+export interface UATwoStateDiscreteImpl {
+    falseState: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
+    trueState: UAProperty<LocalizedText, /*c*/ DataType.LocalizedText>;
+
+    readValue(
+        context?: ISessionContext | null,
+        indexRange?: NumericRange,
+        dataEncoding?: QualifiedNameLike | null
+    ): DataValueT<boolean, DataType.Boolean>;
+
+    readValueAsync(context: ISessionContext | null, callback?: any): any;
+}
+export class UATwoStateDiscreteImpl extends UAVariableImpl implements UATwoStateDiscreteEx {
+    /*
+     * @private
+     */
+    _post_initialize(): void {
+        // The StatusCode SemanticsChanged bit shall be set if any of the FalseState or TrueState
+        // (changes can cause misinterpretation by users or (scripting) programs) Properties are changed
+        // (see section 5.2 for additional information).
+        const handler = this.handle_semantic_changed.bind(this);
+
+        const falseState = this.getPropertyByName("FalseState");
+        /* istanbul ignore else */
+        if (falseState) {
+            falseState.on("value_changed", handler);
+        } else {
+            console.warn(
+                "warning: UATwoStateDiscrete -> a FalseState property is mandatory ",
+                this.browseName.toString(),
+                this.nodeId.toString()
+            );
+        }
+        const trueState = this.getPropertyByName("TrueState");
+        /* istanbul ignore else */
+        if (trueState) {
+            trueState.on("value_changed", handler);
+        } else {
+            console.warn(
+                "waring: UATwoStateDiscrete -> a TrueState property is mandatory",
+                this.browseName.toString(),
+                this.nodeId.toString()
+            );
+        }
+    }
+    setValue(value: boolean | LocalizedTextLike): void {
+        if (typeof value === "boolean") {
+            this.setValueFromSource({ dataType: DataType.Boolean, value });
+        } else {
+            const text: string = (typeof value === "string" ? value : value.text) || "";
+            if (text === this.getTrueStateAsString()) {
+                this.setValue(true);
+            } else if (text === this.getFalseStateAsString()) {
+                this.setValue(false);
+            } else {
+                throw new Error("setValue invalid value " + value);
+            }
+        }
+    }
+    getValue(): boolean {
+        return this.readValue().value.value as boolean;
+    }
+    getValueAsString(): string {
+        if (this.getValue()) {
+            return this.getTrueStateAsString();
+        } else {
+            return this.getFalseStateAsString();
+        }
+    }
+    getTrueStateAsString(): string {
+        return (this.trueState.readValue().value.value as LocalizedText).text || "";
+    }
+    getFalseStateAsString(): string {
+        return (this.falseState.readValue().value.value as LocalizedText).text || "";
+    }
+
+    public clone(options1: any, optionalFilter: any, extraInfo: any): UAVariable {
+        const variable1 = UAVariableImpl.prototype.clone.call(this, options1, optionalFilter, extraInfo);
+        promoteToTwoStateDiscrete(variable1);
+        return variable1;
+    }
+}
+
+export function promoteToTwoStateDiscrete(node: UAVariable): UATwoStateDiscreteEx {
+    if (node instanceof UATwoStateDiscreteImpl) {
+        return node as unknown as UATwoStateDiscreteEx; // already promoted
+    }
+    Object.setPrototypeOf(node, UATwoStateDiscreteImpl.prototype);
+    assert(node instanceof UATwoStateDiscreteImpl, "should now  be a UATwoStateDiscrete");
+    const _node = node as UATwoStateDiscreteImpl;
+    _node._post_initialize();
+    return _node as unknown as UATwoStateDiscreteEx;
+}
+registerNodePromoter(VariableTypeIds.TwoStateDiscreteType, promoteToTwoStateDiscrete);
+
+export function _addTwoStateDiscrete(namespace: INamespace, options: AddTwoStateDiscreteOptions): UATwoStateDiscreteEx {
+    const addressSpace = namespace.addressSpace;
+
+    assert(!Object.prototype.hasOwnProperty.call(options, "ValuePrecision"));
+
+    const twoStateDiscreteType = addressSpace.findVariableType("TwoStateDiscreteType");
+    if (!twoStateDiscreteType) {
+        throw new Error("expecting TwoStateDiscreteType to be defined , check nodeset xml file");
+    }
+
+    let value: undefined | BindVariableOptions;
+    if (typeof options.value === "boolean") {
+        value = new Variant({ dataType: DataType.Boolean, value: !!options.value });
+    } else {
+        value = options.value;
+    }
+    // todo : if options.typeDefinition is specified,
+    // todo : refactor to use twoStateDiscreteType.instantiate
+
+    const variable = namespace.addVariable({
+        accessLevel: options.accessLevel,
+        browseName: options.browseName,
+        componentOf: options.componentOf,
+        dataType: DataType.Boolean,
+        nodeId: options.nodeId,
+        typeDefinition: twoStateDiscreteType.nodeId,
+        userAccessLevel: options.userAccessLevel,
+        modellingRule: options.modellingRule,
+        minimumSamplingInterval: options.minimumSamplingInterval,
+        value
+    }) as UAVariable;
+
+    /*
+    const dataValueVerif = variable.readValue();
+    assert(dataValueVerif.value.dataType === DataType.Boolean);
+    */
+    const handler = (variable as UAVariableImpl).handle_semantic_changed.bind(variable);
+
+    add_dataItem_stuff(variable, options);
+
+    const trueStateNode = namespace.addVariable({
+        browseName: { name: "TrueState", namespaceIndex: 0 },
+        dataType: "LocalizedText",
+        minimumSamplingInterval: 0,
+        propertyOf: variable,
+        typeDefinition: "PropertyType",
+        modellingRule: options.modellingRule ? "Mandatory" : undefined,
+        value: new Variant({
+            dataType: DataType.LocalizedText,
+            value: coerceLocalizedText(options.trueState || "ON")
+        })
+    });
+
+    trueStateNode.on("value_changed", handler);
+
+    const falseStateNode = namespace.addVariable({
+        browseName: { name: "FalseState", namespaceIndex: 0 },
+        dataType: "LocalizedText",
+        minimumSamplingInterval: 0,
+        propertyOf: variable,
+        typeDefinition: "PropertyType",
+        modellingRule: options.modellingRule ? "Mandatory" : undefined,
+
+        value: new Variant({
+            dataType: DataType.LocalizedText,
+            value: coerceLocalizedText(options.falseState || "OFF")
+        })
+    });
+
+    falseStateNode.on("value_changed", handler);
+
+    variable.install_extra_properties();
+
+    return promoteToTwoStateDiscrete(variable);
+}

package/src/event_data.ts

@@ -0,0 +1,117 @@
+/**
+ * @module node-opcua-address-space.Private
+ */
+import { assert } from "node-opcua-assert";
+import { AttributeIds, NodeClass } from "node-opcua-data-model";
+import { DataValue } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { constructBrowsePathFromQualifiedName } from "node-opcua-service-translate-browse-path";
+import { StatusCodes } from "node-opcua-status-code";
+import { SimpleAttributeOperand } from "node-opcua-types";
+import { DataType, Variant, VariantLike } from "node-opcua-variant";
+
+import {
+    ISessionContext,
+    BaseNode,
+    IEventData,
+    UAVariable
+} from "node-opcua-address-space-base";
+
+/**
+ * @class EventData
+ * @param eventTypeNode {BaseNode}
+ * @constructor
+ */
+export class EventData implements IEventData {
+
+    public eventId: NodeId;
+    public $eventDataSource: BaseNode;
+
+    private __nodes: { [key: string]: Variant };
+
+    constructor(eventTypeNode: BaseNode) {
+        this.__nodes = {};
+        this.eventId = NodeId.nullNodeId;
+        this.$eventDataSource = eventTypeNode;
+    }
+
+    /**
+     * @method resolveSelectClause
+     * @param selectClause {SimpleAttributeOperand}
+     * @return {NodeId|null}
+     */
+    public resolveSelectClause(selectClause: SimpleAttributeOperand): NodeId | null {
+        assert(selectClause instanceof SimpleAttributeOperand);
+        const addressSpace = this.$eventDataSource.addressSpace;
+
+        if (selectClause.browsePath!.length === 0 && selectClause.attributeId === AttributeIds.NodeId) {
+            assert(!"Cannot use resolveSelectClause on this selectClause as it has no browsePath");
+        }
+        // navigate to the innerNode specified by the browsePath [ QualifiedName]
+        const browsePath = constructBrowsePathFromQualifiedName(this.$eventDataSource, selectClause.browsePath);
+
+        // xx console.log(self.$eventDataSource.browseName.toString());
+        // xx console.log("xx browse Path", browsePath.toString());
+
+        const browsePathResult = addressSpace.browsePath(browsePath);
+
+        // xx console.log(" br",
+        //    self.$eventDataSource.nodeId.toString(),
+        //    selectClause.browsePath.toString(),
+        //    browsePathResult.targets[0] ? browsePathResult.targets[0].targetId.toString() : "!!!NOT FOUND!!!"é)
+
+        if (browsePathResult.statusCode !== StatusCodes.Good) {
+            return null;
+        }
+        if (!browsePathResult.targets) {
+            return null;
+        }
+        // istanbul ignore next
+        if (browsePathResult.targets.length !== 1) {
+            // xx console.log("selectClause ",selectClause.toString());
+            // xx console.log("browsePathResult ",browsePathResult.toString());
+            // xx throw new Error("browsePathResult.targets.length !== 1"  + browsePathResult.targets.length);
+        }
+        return browsePathResult.targets[0].targetId;
+    }
+
+    public setValue(lowerName: string, node: BaseNode, variant: VariantLike): void {
+        const eventData = this as any;
+        eventData[lowerName] = Variant.coerce(variant); /// _coerceVariant(variant);
+        eventData.__nodes[node.nodeId.toString()] = eventData[lowerName];
+    }
+    /**
+     * @method readValue
+     * @param nodeId {NodeId}
+     * @param selectClause {SimpleAttributeOperand}
+     * @return {Variant}
+     */
+    public readValue(sessionContext: ISessionContext, nodeId: NodeId, selectClause: SimpleAttributeOperand): Variant {
+        assert(nodeId instanceof NodeId);
+        assert(selectClause instanceof SimpleAttributeOperand);
+        assert(nodeId instanceof NodeId);
+        const addressSpace = this.$eventDataSource.addressSpace;
+
+        const node = addressSpace.findNode(nodeId)!;
+        const key = node.nodeId.toString();
+
+        // if the value exists in cache ... we read it from cache...
+        const cached_value = this.__nodes[key];
+        if (cached_value) {
+            return cached_value;
+        }
+
+        if (node.nodeClass === NodeClass.Variable && selectClause.attributeId === AttributeIds.Value) {
+            const nodeVariable = node as UAVariable;
+            return prepare(nodeVariable.readValue(sessionContext, selectClause.indexRange));
+        }
+        return prepare(node.readAttribute(sessionContext, selectClause.attributeId));
+    }
+}
+
+function prepare(dataValue: DataValue): Variant {
+    if (dataValue.statusCode === StatusCodes.Good) {
+        return dataValue.value;
+    }
+    return new Variant({ dataType: DataType.StatusCode, value: dataValue.statusCode });
+}

package/src/extension_object_array_node.ts

@@ -0,0 +1,325 @@
+/**
+ * @module node-opcua-address-space.Private
+ */
+import { assert } from "node-opcua-assert";
+
+import { BrowseDirection, NodeClass } from "node-opcua-data-model";
+import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
+import { NodeId } from "node-opcua-nodeid";
+import { Variant } from "node-opcua-variant";
+import { DataType } from "node-opcua-variant";
+import { VariantArrayType } from "node-opcua-variant";
+
+import { ExtensionObject } from "node-opcua-extension-object";
+import {
+    UADataType,
+    UADynamicVariableArray,
+    UAObject,
+    UAReferenceType,
+    UAVariable
+} from "node-opcua-address-space-base"
+import { UAVariableImpl } from "./ua_variable_impl";
+
+const doDebug = checkDebugFlag(__filename);
+const debugLog = make_debugLog(__filename);
+/*
+ * define a complex Variable containing a array of extension objects
+ * each element of the array is also accessible as a component variable.
+ *
+ */
+
+function getExtObjArrayNodeValue(this: any) {
+    return new Variant({
+        arrayType: VariantArrayType.Array,
+        dataType: DataType.ExtensionObject,
+        value: this.$$extensionObjectArray
+    });
+}
+
+function removeElementByIndex<T extends ExtensionObject>(uaArrayVariableNode: UADynamicVariableArray<T>, elementIndex: number) {
+    const _array = uaArrayVariableNode.$$extensionObjectArray;
+
+    assert(typeof elementIndex === "number");
+
+    const addressSpace = uaArrayVariableNode.addressSpace;
+    const extObj = _array[elementIndex];
+    const browseName = uaArrayVariableNode.$$getElementBrowseName(extObj);
+
+    // remove element from global array (inefficient)
+    uaArrayVariableNode.$$extensionObjectArray.splice(elementIndex, 1);
+
+    // remove matching component
+    const node = uaArrayVariableNode.getComponentByName(browseName);
+    if (!node) {
+        throw new Error(" cannot find component ");
+    }
+
+    const hasComponent = uaArrayVariableNode.addressSpace.findReferenceType("HasComponent")! as UAReferenceType;
+
+    // remove the hasComponent reference toward node
+    uaArrayVariableNode.removeReference({
+        isForward: true,
+        nodeId: node.nodeId,
+        referenceType: hasComponent.nodeId
+    });
+
+    // now check if node has still some parent
+    const parents = node.findReferencesEx("HasChild", BrowseDirection.Inverse);
+    if (parents.length === 0) {
+        addressSpace.deleteNode(node.nodeId);
+    }
+}
+
+/**
+ *
+ * create a node Variable that contains a array of ExtensionObject of a given type
+ * @method createExtObjArrayNode
+ * @param parentFolder
+ * @param options
+ * @param options.browseName
+ * @param options.complexVariableType
+ * @param options.variableType        the type of Extension objects stored in the array.
+ * @param options.indexPropertyName
+ * @return {Object|UAVariable}
+ */
+export function createExtObjArrayNode<T extends ExtensionObject>(parentFolder: UAObject, options: any): UADynamicVariableArray<T> {
+    assert(typeof options.variableType === "string");
+    assert(typeof options.indexPropertyName === "string");
+
+    const addressSpace = parentFolder.addressSpace;
+    const namespace = parentFolder.namespace;
+
+    const complexVariableType = addressSpace.findVariableType(options.complexVariableType);
+    if (!complexVariableType) {
+        throw new Error("cannot find complex variable type");
+    }
+    assert(!complexVariableType.nodeId.isEmpty());
+
+    const variableType = addressSpace.findVariableType(options.variableType);
+    if (!variableType) {
+        throw new Error("cannot find variable Type");
+    }
+    assert(!variableType.nodeId.isEmpty());
+
+    const structure = addressSpace.findDataType("Structure");
+    assert(structure, "Structure Type not found: please check your nodeset file");
+
+    const dataType = addressSpace.findDataType(variableType.dataType);
+    if (!dataType) {
+        throw new Error("cannot find Data Type");
+    }
+
+    assert(dataType.isSupertypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
+
+    const inner_options = {
+        componentOf: parentFolder,
+
+        browseName: options.browseName,
+        dataType: dataType.nodeId,
+        typeDefinition: complexVariableType.nodeId,
+        value: { dataType: DataType.ExtensionObject, value: [], arrayType: VariantArrayType.Array },
+        valueRank: 1
+    };
+
+    const uaArrayVariableNode = namespace.addVariable(inner_options) as UADynamicVariableArray<T>;
+
+    bindExtObjArrayNode(uaArrayVariableNode, options.variableType, options.indexPropertyName);
+
+    return uaArrayVariableNode;
+}
+
+/**
+ * @method bindExtObjArrayNode
+ * @param uaArrayVariableNode
+ * @param variableTypeNodeId
+ * @param indexPropertyName
+ * @return
+ */
+export function bindExtObjArrayNode<T extends ExtensionObject>(
+    uaArrayVariableNode: UADynamicVariableArray<T>,
+    variableTypeNodeId: string | NodeId,
+    indexPropertyName: string
+): UAVariable {
+    const addressSpace = uaArrayVariableNode.addressSpace;
+
+    const variableType = addressSpace.findVariableType(variableTypeNodeId);
+    if (!variableType) {
+        throw new Error("Cannot find VariableType " + variableTypeNodeId.toString());
+    }
+    assert(!variableType.nodeId.isEmpty());
+
+    let structure = addressSpace.findDataType("Structure");
+    assert(structure, "Structure Type not found: please check your nodeset file");
+
+    let dataType = addressSpace.findDataType(variableType.dataType);
+    if (!dataType) {
+        throw new Error("Cannot find DataType " + variableType.dataType.toString());
+    }
+    assert(dataType.isSupertypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
+
+    assert(!uaArrayVariableNode.$$variableType, "uaArrayVariableNode has already been bound !");
+
+    uaArrayVariableNode.$$variableType = variableType;
+
+    structure = addressSpace.findDataType("Structure");
+    assert(structure, "Structure Type not found: please check your nodeset file");
+
+    // verify that an object with same doesn't already exist
+    dataType = addressSpace.findDataType(variableType.dataType)! as UADataType;
+    assert(dataType!.isSupertypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
+
+    uaArrayVariableNode.$$dataType = dataType;
+    uaArrayVariableNode.$$extensionObjectArray = [];
+    uaArrayVariableNode.$$indexPropertyName = indexPropertyName;
+
+    uaArrayVariableNode.$$getElementBrowseName = function (this: any, extObj: ExtensionObject) {
+        const indexPropertyName1 = this.$$indexPropertyName;
+
+        if (!Object.prototype.hasOwnProperty.call(extObj,indexPropertyName1)) {
+            console.log(" extension object do not have ", indexPropertyName1, extObj);
+        }
+        // assert(extObj.constructor === addressSpace.constructExtensionObject(dataType));
+        assert(Object.prototype.hasOwnProperty.call(extObj,indexPropertyName1));
+        const browseName = (extObj as any)[indexPropertyName1].toString();
+        return browseName;
+    };
+
+    const options = {
+        get: getExtObjArrayNodeValue,
+        set: undefined // readonly
+    };
+
+    // bind the readonly
+    uaArrayVariableNode.bindVariable(options, true);
+
+    return uaArrayVariableNode;
+}
+
+/**
+ * @method addElement
+ * add a new element in a ExtensionObject Array variable
+ * @param options {Object}   data used to construct the underlying ExtensionObject
+ * @param uaArrayVariableNode {UAVariable}
+ * @return {UAVariable}
+ *
+ * @method addElement
+ * add a new element in a ExtensionObject Array variable
+ * @param nodeVariable a variable already exposing an extension objects
+ * @param uaArrayVariableNode {UAVariable}
+ * @return {UAVariable}
+ *
+ * @method addElement
+ * add a new element in a ExtensionObject Array variable
+ * @param constructor  constructor of the extension object to create
+ * @param uaArrayVariableNode {UAVariable}
+ * @return {UAVariable}
+ */
+export function addElement<T extends ExtensionObject>(
+    options: any /* ExtensionObjectConstructor | ExtensionObject | UAVariable*/,
+    uaArrayVariableNode: UADynamicVariableArray<T>
+): UAVariable {
+    assert(uaArrayVariableNode, " must provide an UAVariable containing the array");
+    // verify that arr has been created correctly
+    assert(
+        !!uaArrayVariableNode.$$variableType && !!uaArrayVariableNode.$$dataType,
+        "did you create the array Node with createExtObjArrayNode ?"
+    );
+    assert(uaArrayVariableNode.$$dataType.nodeClass === NodeClass.DataType);
+
+    const addressSpace = uaArrayVariableNode.addressSpace;
+    const Constructor = addressSpace.getExtensionObjectConstructor(uaArrayVariableNode.$$dataType);
+    assert(Constructor instanceof Function);
+
+    let extensionObject: T;
+    let elVar = null;
+    let browseName;
+
+    if (options instanceof UAVariableImpl) {
+        elVar = options;
+        extensionObject = elVar.$extensionObject; // get shared extension object
+
+        assert(
+            extensionObject instanceof Constructor,
+            "the provided variable must expose a Extension Object of the expected type "
+        );
+        // add a reference
+        uaArrayVariableNode.addReference({
+            isForward: true,
+            nodeId: elVar.nodeId,
+            referenceType: "HasComponent"
+        });
+        // xx elVar.bindExtensionObject();
+    } else {
+        if (options instanceof Constructor) {
+            // extension object has already been created
+            extensionObject = options as T;
+        } else {
+            extensionObject = addressSpace.constructExtensionObject(uaArrayVariableNode.$$dataType, options) as T;
+        }
+        browseName = uaArrayVariableNode.$$getElementBrowseName(extensionObject);
+        elVar = uaArrayVariableNode.$$variableType.instantiate({
+            browseName,
+            componentOf: uaArrayVariableNode.nodeId,
+            value: { dataType: DataType.ExtensionObject, value: extensionObject }
+        }) as UAVariableImpl;
+        elVar.bindExtensionObject();
+        elVar.$extensionObject = extensionObject;
+    }
+
+    // also add the value inside
+    uaArrayVariableNode.$$extensionObjectArray.push(extensionObject);
+
+    return elVar;
+}
+
+/**
+ *
+ * @method removeElement
+ * @param uaArrayVariableNode {UAVariable}
+ * @param element {number}   index of element to remove in array
+ *
+ *
+ * @method removeElement
+ * @param uaArrayVariableNode {UAVariable}
+ * @param element {UAVariable}   node of element to remove in array
+ *
+ * @method removeElement
+ * @param uaArrayVariableNode {UAVariable}
+ * @param element {ExtensionObject}   extension object of the node of element to remove in array
+ *
+ */
+export function removeElement<T extends ExtensionObject>(
+    uaArrayVariableNode: UADynamicVariableArray<T>,
+    element: any /* number | UAVariable | (a any) => boolean | ExtensionObject */
+): void {
+    assert(element, "element must exist");
+    const _array = uaArrayVariableNode.$$extensionObjectArray;
+    if (_array.length === 0) {
+        throw new Error(" cannot remove an element from an empty array ");
+    }
+    let elementIndex = -1;
+
+    if (typeof element === "number") {
+        // find element by index
+        elementIndex = element;
+        assert(elementIndex >= 0 && elementIndex < _array.length);
+    } else if (element && element.nodeClass) {
+        // find element by name
+        const browseNameToFind = element.browseName.name!.toString();
+        elementIndex = _array.findIndex((obj: any, i: number) => {
+            const browseName = uaArrayVariableNode.$$getElementBrowseName(obj).toString();
+            return browseName === browseNameToFind;
+        });
+    } else if (typeof element === "function") {
+        // find element by functor
+        elementIndex = _array.findIndex(element);
+    } else {
+        // find element by inner extension object
+        assert(_array[0].constructor.name === (element as any).constructor.name, "element must match");
+        elementIndex = _array.findIndex((x: any) => x === element);
+    }
+    if (elementIndex < 0) {
+        throw new Error(" cannot find element matching " + element.toString());
+    }
+    return removeElementByIndex(uaArrayVariableNode, elementIndex);
+}