node-opcua-address-space 2.51.0

package/src/address_space_change_event_tools.ts

@@ -0,0 +1,177 @@
+/**
+ * @module node-opcua-address-space
+ */
+import * as chalk from "chalk";
+
+import { UAReference, BaseNode, UAObject, UAVariable } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { BrowseDirection, NodeClass } from "node-opcua-data-model";
+import { Enum, EnumItem } from "node-opcua-enum";
+import { NodeId } from "node-opcua-nodeid";
+import { ModelChangeStructureDataType } from "node-opcua-types";
+
+import { AddressSpacePrivate } from "./address_space_private";
+import { BaseNodeImpl } from "./base_node_impl";
+
+const verbFlags = new Enum({
+    //                         NodeAdded        0         Indicates the affected Node has been added.
+    NodeAdded: 0x01,
+
+    //                         NodeDeleted      1         Indicates the affected Node has been deleted.
+    NodeDeleted: 0x02,
+
+    //                         ReferenceAdded   2         Indicates a Reference has been added. The affected Node may
+    ReferenceAdded: 0x04,
+
+    //                                                    be either a SourceNode or TargetNode. Note that an added
+    //                                                    bidirectional Reference is reflected by two ChangeStructures.
+    //                         ReferenceDeleted 3         Indicates a Reference has been deleted. The affected Node may
+    //                                                    be either a SourceNode or TargetNode. Note that a deleted
+    //                                                    bidirectional Reference is reflected by two ChangeStructures.
+    ReferenceDeleted: 0x08,
+
+    //                         DataTypeChanged  4         This verb may be used only for affected Nodes that are
+    //                                                    Variables or VariableTypes. It indicates that the DataType
+    //                                                    Attribute has changed.
+    DataTypeChanged: 0x10
+});
+
+function makeVerb(verbs: any): number {
+    const e: EnumItem = verbFlags.get(verbs)!;
+    assert(e !== null);
+    return e.value;
+}
+
+export function _handle_add_reference_change_event(node1: BaseNode, node2id: NodeId): void {
+    const addressSpace = node1.addressSpace as AddressSpacePrivate;
+
+    const node2 = addressSpace.findNode(node2id)! as BaseNode;
+
+    if (node1.nodeVersion || (node2 && node2.nodeVersion)) {
+        // a event has to be send
+        addressSpace.modelChangeTransaction(() => {
+            function _getTypeDef(node: BaseNode) {
+                if (node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.Variable) {
+                    return (<UAVariable | UAObject>node).typeDefinitionObj.nodeId;
+                }
+                return null;
+            }
+
+            let modelChangeTgt = new ModelChangeStructureDataType({
+                affected: node1.nodeId,
+                affectedType: _getTypeDef(node1),
+                verb: makeVerb("ReferenceAdded")
+            });
+            addressSpace._collectModelChange(null, modelChangeTgt);
+
+            modelChangeTgt = new ModelChangeStructureDataType({
+                affected: node2.nodeId,
+                affectedType: _getTypeDef(node2),
+                verb: makeVerb("ReferenceAdded")
+            });
+            addressSpace._collectModelChange(null, modelChangeTgt);
+        });
+    }
+}
+
+try {
+    (ModelChangeStructureDataType as any).prototype.toString = function (options: any): string {
+        if (!options) {
+            return "";
+        }
+        const addressSpace = options.addressSpace;
+
+        function n(nodeId: NodeId | null) {
+            if (!nodeId || nodeId.isEmpty()) {
+                return "";
+            }
+            const node = addressSpace.findNode(nodeId)!;
+            return '"' + nodeId.toString() + '"' + chalk.yellow(" /* " + (node ? node.browseName.toString() : "???") + " */");
+        }
+
+        let str = "{ verb:" + verbFlags.get(this.verb)!.key + ",";
+        str += " affected: " + n(this.affected) + ",";
+        str += " type: " + n(this.affectedType) + " }";
+        return str;
+    };
+} catch (err) {
+    //
+}
+
+export function _handle_model_change_event(node: BaseNodeImpl): void {
+    const addressSpace = node.addressSpace as AddressSpacePrivate;
+    //
+    const parent = node.parent!;
+
+    if (parent && (parent as BaseNode).nodeVersion) {
+        addressSpace.modelChangeTransaction(() => {
+            let typeDefinitionNodeId = null;
+
+            if (node.nodeClass === NodeClass.Object || node.nodeClass === NodeClass.Variable) {
+                typeDefinitionNodeId = node.typeDefinitionObj.nodeId;
+            }
+
+            const modelChange1 = new ModelChangeStructureDataType({
+                affected: node.nodeId,
+                affectedType: typeDefinitionNodeId,
+                verb: makeVerb("NodeAdded")
+            });
+            addressSpace._collectModelChange(null, modelChange1);
+
+            const modelChangeSrc = new ModelChangeStructureDataType({
+                affected: parent.nodeId,
+                affectedType: null,
+                verb: makeVerb("ReferenceAdded")
+            });
+            addressSpace._collectModelChange(null, modelChangeSrc);
+
+            // bidirectional
+            if ((node as BaseNode).nodeVersion) {
+                const modelChangeTgt = new ModelChangeStructureDataType({
+                    affected: node.nodeId,
+                    affectedType: typeDefinitionNodeId,
+                    verb: makeVerb("ReferenceAdded")
+                });
+                addressSpace._collectModelChange(null, modelChangeTgt);
+            }
+        });
+    }
+}
+
+export function _handle_delete_node_model_change_event(node: BaseNode): void {
+    const addressSpace = node.addressSpace as AddressSpacePrivate;
+
+    // get backward references
+    const references = node.findReferencesEx("HierarchicalReferences", BrowseDirection.Inverse)!;
+
+    const parentNodes = references.map((r: UAReference) => {
+        return addressSpace.findNode(r.nodeId)! as BaseNode;
+    });
+
+    const versionableNodes = parentNodes.filter((n: BaseNode) => !!n?.nodeVersion);
+
+    if (versionableNodes.length >= 1 || !!node.nodeVersion) {
+        addressSpace.modelChangeTransaction(() => {
+            // ...
+            for (const r of references) {
+                const target = addressSpace.findNode(r.nodeId)!;
+
+                const modelChangeSrc_l = new ModelChangeStructureDataType({
+                    affected: target.nodeId,
+                    affectedType: null,
+                    verb: makeVerb("ReferenceDeleted")
+                });
+
+                addressSpace._collectModelChange(null, modelChangeSrc_l);
+            }
+
+            const modelChangeSrc = new ModelChangeStructureDataType({
+                affected: node.nodeId,
+                affectedType: (<UAVariable | UAObject>node).typeDefinition,
+                verb: makeVerb("NodeDeleted")
+            });
+
+            addressSpace._collectModelChange(null, modelChangeSrc);
+        });
+    }
+}

package/src/address_space_private.ts

@@ -0,0 +1,98 @@
+/**
+ * @module node-opcua-address-space.Private
+ */
+import { ExtraDataTypeManager } from "node-opcua-client-dynamic-extension-object";
+import { NodeClass, QualifiedNameLike } from "node-opcua-data-model";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+import { ModelChangeStructureDataType, ReadProcessedDetails, HistoryReadResult } from "node-opcua-types";
+import { NumericRange } from "node-opcua-numeric-range";
+import { CallbackT } from "node-opcua-status-code";
+
+import {
+    IAddressSpace,
+    BaseNode,
+    UADataType,
+    UAView,
+    ISessionContext,
+    AddReferenceOpts,
+    ContinuationPoint,
+    UAVariableType,
+    UAObjectType,
+    UAReference,
+    UAVariable
+} from "node-opcua-address-space-base";
+
+import { UARootFolder } from "../source/ua_root_folder";
+
+import { NamespacePrivate } from "./namespace_private";
+import { ExtensionObjectConstructorFuncWithSchema } from "./ua_data_type_impl";
+import { UANamespace} from "./namespace_impl";
+
+export interface AddressSpacePrivate extends IAddressSpace {
+
+    rootFolder: UARootFolder;
+
+    isFrugal: boolean;
+    suspendBackReference: boolean;
+
+    _condition_refresh_in_progress: boolean;
+
+    _coerceNode(node: string | BaseNode | NodeIdLike): BaseNode | null;
+
+    _coerceFolder(folder: string | BaseNode | NodeId): BaseNode | null;
+
+    _coerce_DataType(dataType: NodeIdLike | BaseNode): NodeId;
+
+    _coerceType(
+        baseType: string | NodeId | BaseNode,
+        topMostBaseType: string,
+        nodeClass: NodeClass
+    ): UAVariableType | UAObjectType;
+    _coerceTypeDefinition(typeDefinition: string | NodeId): NodeId;
+
+    _coerce_VariableTypeIds(dataType: NodeId | string | BaseNode): NodeId;
+
+    getDefaultNamespace(): NamespacePrivate;
+
+    getOwnNamespace(): NamespacePrivate;
+
+    getNamespace(indexOrName: number | string): UANamespace;
+
+    registerNamespace(namespaceUri: string): UANamespace;
+
+    getNamespaceArray(): NamespacePrivate[];
+
+    getExtensionObjectConstructor(dataType: NodeId | UADataType): ExtensionObjectConstructorFuncWithSchema;
+
+    constructExtensionObject(dataType: UADataType | NodeId, options?: any): ExtensionObject;
+
+    normalizeReferenceType(params: AddReferenceOpts | UAReference): UAReference;
+
+    normalizeReferenceTypes(references: AddReferenceOpts[] | UAReference[] | null): UAReference[];
+
+    _register(node: BaseNode): void;
+
+    resolveNodeId(nodeIdLike: NodeIdLike): NodeId;
+
+    modelChangeTransaction(action: () => void): void;
+
+    _collectModelChange(view: UAView | null, data: ModelChangeStructureDataType): void;
+
+    deleteNode(nodeId: NodeId): void;
+
+    getDataTypeManager(): ExtraDataTypeManager;
+
+    ///
+    _readProcessedDetails?: (
+        variable: UAVariable,
+        context: ISessionContext,
+        historyReadDetails: ReadProcessedDetails,
+        indexRange: NumericRange | null,
+        dataEncoding: QualifiedNameLike | null,
+        continuationPoint: ContinuationPoint | null,
+        callback: CallbackT<HistoryReadResult>
+    ) => void;
+
+    isEnumeration(dataType: NodeId): boolean;
+}

package/src/alarms_and_conditions/check_where_clause.ts

@@ -0,0 +1,148 @@
+import {
+    ContentFilter, FilterOperator, LiteralOperand, SimpleAttributeOperand, FilterOperand, ElementOperand
+} from "node-opcua-types";
+import { DataType } from "node-opcua-variant";
+import { NodeClass } from "node-opcua-data-model";
+import { ExtensionObject } from "node-opcua-extension-object";
+import { NodeId, sameNodeId } from "node-opcua-nodeid";
+import { IAddressSpace, IEventData, ISessionContext, UAObject, UAObjectType, UAReferenceType, UAVariableType } from "node-opcua-address-space-base";
+
+import { SessionContext } from "../../source/session_context";
+import { extractEventFields } from "./extract_event_fields";
+
+function checkNot(
+    addressSpace: IAddressSpace,
+    sessionContext: ISessionContext,
+    whereClause: ContentFilter,
+    eventData: IEventData,
+    filteredOperands: FilterOperand[]
+): boolean {
+
+    if (filteredOperands[0] instanceof ElementOperand) {
+        const index = (filteredOperands[0] as ElementOperand).index;
+        return !__checkWhereClause(addressSpace, sessionContext, whereClause, index, eventData);
+    }
+    return false;
+}
+
+function checkOfType(
+    addressSpace: IAddressSpace,
+    ofType: LiteralOperand,
+    eventData: IEventData
+): boolean {
+
+    // istanbul ignore next
+    if (!ofType) {
+        throw new Error("invalid operand");
+    }
+    // istanbul ignore next
+    if (ofType.value.dataType !== DataType.NodeId) {
+        throw new Error("invalid operand type (expecting Nodeid");
+    }
+
+    const ofTypeNode = addressSpace.findNode(ofType.value.value) as UAObjectType | UAReferenceType | UAVariableType;
+
+    // istanbul ignore next
+    if (!ofTypeNode) {
+        return false; // the ofType node is not known, we don't know what to do
+    }
+
+    // istanbul ignore next
+    if (ofTypeNode.nodeClass !== NodeClass.ObjectType) {
+        throw new Error("operand should be a ObjectType " + ofTypeNode.nodeId.toString());
+    }
+    const node = eventData.$eventDataSource! as (UAObjectType | UAObject | UAReferenceType | UAVariableType);
+    if (!node) {
+        throw new Error("cannot find  node " + eventData.$eventDataSource?.toString());
+    }
+    if (node.nodeClass === NodeClass.ObjectType) {
+        return node.isSupertypeOf(ofTypeNode);
+    }
+    if (node.nodeClass === NodeClass.Object && node.typeDefinitionObj) {
+        return node.typeDefinitionObj.isSupertypeOf(ofTypeNode);
+    }
+    return true;
+}
+
+function _extractValue(operand: SimpleAttributeOperand, eventData: IEventData): NodeId | null {
+    // eventData.readValue;
+    const v = extractEventFields(SessionContext.defaultContext, [operand], eventData)[0];
+    return v.value as NodeId;
+}
+
+function checkInList(
+    addressSpace: IAddressSpace,
+    filterOperands: ExtensionObject[],
+    eventData: IEventData
+): boolean {
+
+    const operand0 = filterOperands[0];
+    if (!(operand0 instanceof SimpleAttributeOperand)) {
+        // unsupported case
+        return false;
+    }
+    const nodeId: NodeId | null = _extractValue(operand0, eventData);
+    if (!nodeId) {
+        return false;
+    }
+    function _is(nodeId1: NodeId, operandX: LiteralOperand): boolean {
+
+        const operandNode = addressSpace.findNode(operandX.value.value as NodeId);
+        if (!operandNode) {
+            return false;
+        }
+        return sameNodeId(nodeId1, operandNode.nodeId);
+    }
+    for (let i = 1; i < filterOperands.length; i++) {
+        const filterOperand = filterOperands[i];
+        if ((filterOperand instanceof LiteralOperand) && _is(nodeId, filterOperand)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export function __checkWhereClause(
+    addressSpace: IAddressSpace,
+    sessionContext: ISessionContext,
+    whereClause: ContentFilter,
+    index: number,
+    eventData: IEventData
+): boolean {
+
+    if (!whereClause.elements || whereClause.elements.length === 0) {
+        return true;
+    }
+    const element = whereClause.elements[index];
+    if (!element) {
+        return true;
+    }
+    switch (element.filterOperator) {
+        case FilterOperator.Not:
+            return checkNot(addressSpace, sessionContext, whereClause, eventData, element.filterOperands as FilterOperand[]);
+        case FilterOperator.OfType:
+            return checkOfType(addressSpace, element.filterOperands![0] as LiteralOperand, eventData);
+        case FilterOperator.InList:
+            return checkInList(addressSpace, element.filterOperands as ExtensionObject[], eventData);
+        default:
+            // from Spec  OPC Unified Architecture, Part 4 133 Release 1.04
+            //  Any basic FilterOperator in Table 119 may be used in the whereClause, however, only the
+            //  OfType_14 FilterOperator from Table 120 is permitted.
+            // tslint:disable-next-line: no-console
+            console.log("whereClause = ", whereClause.toString());
+            throw new Error("Only OfType operator are allowed in checkWhereClause")
+    }
+}
+
+export function checkWhereClause(
+    addressSpace: IAddressSpace,
+    sessionContext: ISessionContext,
+    whereClause: ContentFilter,
+    eventData: IEventData
+): boolean {
+
+    if (!whereClause.elements || whereClause.elements.length === 0) {
+        return true;
+    }
+    return __checkWhereClause(addressSpace, sessionContext, whereClause, 0, eventData);
+}

package/src/alarms_and_conditions/condition.ts

@@ -0,0 +1,89 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+// tslint:disable:no-console
+// tslint:disable:no-var-requires
+require("set-prototype-of");
+import { assert } from "node-opcua-assert";
+import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
+import { minDate } from "node-opcua-factory";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+
+import { ConditionSnapshot } from "./condition_snapshot";
+
+export function _setAckedState(
+    self: ConditionSnapshot,
+    requestedAckedState: boolean,
+    conditionEventId?: Buffer,
+    comment?: string | LocalizedText | LocalizedTextLike
+): StatusCode {
+
+    assert(self instanceof ConditionSnapshot);
+
+    const ackedState = self.getAckedState();
+
+    if (ackedState && requestedAckedState) {
+        return StatusCodes.BadConditionBranchAlreadyAcked;
+    }
+    self._set_twoStateVariable("ackedState", requestedAckedState);
+    return StatusCodes.Good;
+}
+
+// tslint:disable:max-classes-per-file
+function prepare_date(sourceTimestamp: { value: Date } | null) {
+    if (!sourceTimestamp || !sourceTimestamp.value) {
+        return minDate;
+    }
+    assert(sourceTimestamp.value instanceof Date);
+    return sourceTimestamp;
+}
+
+/*
+ As per spec OPCUA 1.03 part 9:
+
+ A Condition’s EnabledState effects the generation of Event Notifications and as such results
+ in the following specific behaviour:
+ * When the Condition instance enters the Disabled state, the Retain Property of this
+ Condition shall be set to FALSE by the Server to indicate to the Client that the
+ Condition instance is currently not of interest to Clients.
+ * When the Condition instance enters the enabled state, the Condition shall be
+ evaluated and all of its Properties updated to reflect the current values. If this
+ evaluation causes the Retain Property to transition to TRUE for any ConditionBranch,
+ then an Event Notification shall be generated for that ConditionBranch.
+ * The Server may choose to continue to test for a Condition instance while it is
+ Disabled. However, no Event Notifications will be generated while the Condition
+ instance is disabled.
+ * For any Condition that exists in the Address Space the Attributes and the following
+ Variables will continue to have valid values even in the Disabled state; EventId, Event
+ Type, Source Node, Source Name, Time, and EnabledState.
+ Other properties may no longer provide current valid values.
+ All Variables that are no longer provided shall return a status of BadConditionDisabled.
+ The Event that reports the Disabled state  should report the properties as NULL or with a status
+ of BadConditionDisabled.
+ When enabled, changes to the following components shall cause a ConditionType Event Notification:
+ - Quality
+ - Severity (inherited from BaseEventType)
+ - Comment
+
+ // spec :
+ // The HasCondition ReferenceType is a concrete ReferenceType and can be used directly. It is
+ // a subtype of NonHierarchicalReferences.
+ // The semantic of this ReferenceType is to specify the relationship between a ConditionSource
+ // and its Conditions. Each ConditionSource shall be the target of a HasEventSource Reference
+ // or a sub type of HasEventSource. The Address Space organisation that shall be provided for
+ // Clients to detect Conditions and ConditionSources is defined in Clause 6. Various examples
+ // for the use of this ReferenceType can be found in B.2.
+ // HasCondition References can be used in the Type definition of an Object or a Variable. In this
+ // case, the SourceNode of this ReferenceType shall be an ObjectType or VariableType Node or
+ // one of their InstanceDeclaration Nodes. The TargetNode shall be a Condition instance
+ // declaration or a ConditionType. The following rules for instantiation apply:
+ //  All HasCondition References used in a Type shall exist in instances of these Types as
+ //    well.
+ //  If the TargetNode in the Type definition is a ConditionType, the same TargetNode will
+ //    be referenced on the instance.
+ // HasCondition References may be used solely in the instance space when they are not
+ // available in Type definitions. In this case the SourceNode of this ReferenceType shall be an
+ // Object, Variable or Method Node. The TargetNode shall be a Condition instance or a
+ // ConditionType.
+
+ */

package/src/alarms_and_conditions/condition_info.ts

@@ -0,0 +1,66 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { assert } from "node-opcua-assert";
+import { UInt16 } from "node-opcua-basic-types";
+import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
+import { StatusCode } from "node-opcua-status-code";
+import { ConditionInfoOptions } from "../../source/interfaces/alarms_and_conditions/condition_info_i";
+
+export interface ConditionInfo {
+    message: LocalizedText | null;
+    quality: StatusCode | null;
+    severity: UInt16 | null;
+    retain: boolean | null;
+    isDifferentFrom(otherConditionInfo: ConditionInfo): boolean;
+}
+/**
+ * @class ConditionInfo
+ * @param options  {Object}
+ * @param options.message   {String|LocalizedText} the event message
+ * @param options.severity  {UInt16} severity
+ * @param options.quality   {StatusCode} quality
+ * @param options.retain   {Boolean} retain flag
+ * @constructor
+ */
+export class ConditionInfo {
+    public message: LocalizedText | null = null;
+    public quality: StatusCode | null = null;
+    public severity: UInt16 | null = 0;
+    public retain: boolean | null = false;
+
+    constructor(options: ConditionInfoOptions) {
+        this.severity = null;
+        this.quality = null;
+        this.message = null;
+        this.retain = null;
+
+        if (Object.prototype.hasOwnProperty.call(options, "message") && options.message) {
+            this.message = LocalizedText.coerce(options.message);
+        }
+        if (Object.prototype.hasOwnProperty.call(options, "quality") && options.quality !== null) {
+            this.quality = options.quality!;
+        }
+        if (Object.prototype.hasOwnProperty.call(options, "severity") && options.severity !== null) {
+            assert(typeof options.severity === "number");
+            this.severity = options.severity!;
+        }
+        if (Object.prototype.hasOwnProperty.call(options, "retain") && options.retain !== null) {
+            assert(typeof options.retain === "boolean");
+            this.retain = options.retain!;
+        }
+    }
+
+    /**
+     * @method isDifferentFrom
+     * @param otherConditionInfo {ConditionInfo}
+     * @return {Boolean}
+     */
+    public isDifferentFrom(otherConditionInfo: ConditionInfo): boolean {
+        return (
+            this.severity !== otherConditionInfo.severity ||
+            this.quality !== otherConditionInfo.quality ||
+            this.message !== otherConditionInfo.message
+        );
+    }
+}