node-opcua-address-space 2.51.0

package/src/alarms_and_conditions/deviation_alarm_helper.ts

@@ -0,0 +1,66 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+import { assert } from "node-opcua-assert";
+import { DataValue } from "node-opcua-data-value";
+import { NodeId } from "node-opcua-nodeid";
+import { StatusCodes } from "node-opcua-status-code";
+import { DataType } from "node-opcua-variant";
+import { IAddressSpace, BaseNode, UAVariable, UAVariableT } from "node-opcua-address-space-base";
+
+import { AddressSpacePrivate } from "../address_space_private";
+
+export interface DeviationStuff {
+    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
+    setpointNodeNode: UAVariable;
+    _onSetpointDataValueChange(dataValue: DataValue): void;
+    _setStateBasedOnInputValue(value: any): void;
+    getSetpointNodeNode(): UAVariable;
+    getInputNodeValue(): any;
+    getSetpointValue(): number | null;
+
+    readonly addressSpace: IAddressSpace;
+}
+
+export function DeviationAlarmHelper_getSetpointNodeNode(this: DeviationStuff): UAVariable {
+    assert(this.setpointNode.readValue().value.dataType === DataType.NodeId);
+    const nodeId = this.setpointNode.readValue().value.value;
+    const node = this.addressSpace.findNode(nodeId);
+    assert(node === this.setpointNodeNode);
+    return this.setpointNodeNode;
+}
+export function DeviationAlarmHelper_getSetpointValue(this: DeviationStuff): number | null {
+    assert(Object.prototype.hasOwnProperty.call(this, "setpointNode"));
+    assert(Object.prototype.hasOwnProperty.call(this, "setpointNodeNode"));
+    const setpointDataValue = this.setpointNodeNode.readValue();
+    if (setpointDataValue.statusCode !== StatusCodes.Good) {
+        return null;
+    }
+    return this.getSetpointNodeNode().readValue().value.value;
+}
+
+export function DeviationAlarmHelper_onSetpointDataValueChange(this: DeviationStuff, dataValue: DataValue): void {
+    this._setStateBasedOnInputValue(this.getInputNodeValue());
+}
+
+export interface InstallSetPointOptions {
+    setpointNode: UAVariableT<NodeId, DataType.NodeId>;
+}
+export function DeviationAlarmHelper_install_setpoint(this: DeviationStuff, options: InstallSetPointOptions): void {
+    // must provide a set point property
+    assert(Object.prototype.hasOwnProperty.call(options, "setpointNode"), "must provide a setpointNode");
+
+    const addressSpace = this.addressSpace as AddressSpacePrivate;
+    const setpointNodeNode = addressSpace._coerceNode(options.setpointNode);
+    assert(setpointNodeNode, "Expecting a valid setpoint node");
+
+    assert(this.setpointNode.browseName.toString() === "SetpointNode");
+
+    this.setpointNodeNode = addressSpace._coerceNode(options.setpointNode)! as UAVariable;
+    this.setpointNode.setValueFromSource({ dataType: "NodeId", value: this.setpointNodeNode.nodeId });
+
+    // install inputNode monitoring for change
+    this.setpointNodeNode.on("value_changed", (newDataValue: DataValue) => {
+        this._onSetpointDataValueChange(newDataValue);
+    });
+}

package/src/alarms_and_conditions/extract_event_fields.ts

@@ -0,0 +1,104 @@
+import { IEventData, ISessionContext, UAObject } from "node-opcua-address-space-base";
+import { assert } from "node-opcua-assert";
+import { AttributeIds } from "node-opcua-data-model";
+import { resolveNodeId } from "node-opcua-nodeid";
+import { SimpleAttributeOperand } from "node-opcua-types";
+import { DataType, Variant } from "node-opcua-variant";
+
+
+function assert_valid_event_data(eventData: IEventData) {
+    assert(typeof eventData.resolveSelectClause === "function");
+    assert(typeof eventData.readValue === "function");
+}
+
+/**
+ *
+ * @method extractEventField
+ * extract a eventField from a event node, matching the given selectClause
+ * @param eventData
+ * @param selectClause
+ */
+function extractEventField(sessionContext: ISessionContext, eventData: IEventData, selectClause: SimpleAttributeOperand): Variant {
+    assert_valid_event_data(eventData);
+    assert(selectClause instanceof SimpleAttributeOperand);
+
+    selectClause.browsePath = selectClause.browsePath || [];
+
+    if (selectClause.browsePath.length === 0 && selectClause.attributeId === AttributeIds.NodeId) {
+        const eventSource = eventData.$eventDataSource as UAObject;
+        const addressSpace = eventSource.addressSpace;
+        const conditionTypeNodeId = resolveNodeId("ConditionType");
+        const conditionType = addressSpace.findObjectType(conditionTypeNodeId);
+
+        /* istanbul ignore next */
+        if (!conditionType) {
+            throw new Error("Cannot find ConditionType NodeId  !");
+        }
+
+        // "ns=0;i=2782" => ConditionType
+        // "ns=0;i=2041" => BaseEventType
+        if (selectClause.typeDefinitionId.toString() !== "ns=0;i=2782") {
+            // not a ConditionType
+            // but could be on of its derived type. for instance ns=0;i=2881 => AcknowledgeableConditionType
+            const typeDefinitionObj = addressSpace.findObjectType(selectClause.typeDefinitionId);
+
+            /* istanbul ignore next */
+            if (!typeDefinitionObj) {
+                throw new Error("Cannot find TypeDefinition Type !");
+            }
+            if (!typeDefinitionObj.isSupertypeOf(conditionType)) {
+                // tslint:disable-next-line:no-console
+                console.warn(" ", typeDefinitionObj ? typeDefinitionObj.browseName.toString() : "????");
+                // tslint:disable-next-line:no-console
+                console.warn(
+                    "this case is not handled yet : selectClause.typeDefinitionId = " + selectClause.typeDefinitionId.toString()
+                );
+                const eventSource1 = eventData.$eventDataSource!;
+                return new Variant({ dataType: DataType.NodeId, value: eventSource1.nodeId });
+            }
+        }
+
+        const eventSourceTypeDefinition = eventSource.typeDefinitionObj;
+        if (!eventSourceTypeDefinition) {
+            // eventSource is a EventType class
+            return new Variant();
+        }
+
+        if (!eventSourceTypeDefinition.isSupertypeOf(conditionType)) {
+            return new Variant();
+        }
+        // Yeh : our EventType is a Condition Type !
+        return new Variant({ dataType: DataType.NodeId, value: eventSource.nodeId });
+    }
+
+    const handle = eventData.resolveSelectClause(selectClause);
+
+    if (handle !== null) {
+        const value = eventData.readValue(sessionContext, handle, selectClause);
+        assert(value instanceof Variant);
+        return value;
+    } else {
+        // Part 4 - 7.17.3
+        // A null value is returned in the corresponding event field in the Publish response if the selected
+        // field is not part of the Event or an error was returned in the selectClauseResults of the EventFilterResult.
+        // return new Variant({dataType: DataType.StatusCode, value: browsePathResult.statusCode});
+        return new Variant();
+    }
+}
+
+/**
+ * @method extractEventFields
+ * extract a array of eventFields from a event node, matching the selectClauses
+ * @param selectClauses
+ * @param eventData : a pseudo Node that provides a browse Method and a readValue(nodeId)
+ */
+export function extractEventFields(
+    sessionContext: ISessionContext,
+    selectClauses: SimpleAttributeOperand[],
+    eventData: IEventData
+): Variant[] {
+    assert_valid_event_data(eventData);
+    assert(Array.isArray(selectClauses));
+    assert(selectClauses.length === 0 || selectClauses[0] instanceof SimpleAttributeOperand);
+    return selectClauses.map(extractEventField.bind(null, sessionContext, eventData));
+}

package/src/alarms_and_conditions/index.ts

@@ -0,0 +1,18 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+export * from "./condition_info";
+export * from "./condition_snapshot";
+export * from "./ua_condition_impl";
+export * from "./ua_acknowledgeable_condition_impl";
+export * from "./ua_discrete_alarm_impl";
+export * from "./ua_exclusive_deviation_alarm_impl";
+export * from "./ua_exclusive_level_alarm_impl";
+export * from "./ua_exclusive_limit_alarm_impl";
+export * from "./ua_limit_alarm_impl";
+export * from "./ua_non_exclusive_deviation_alarm_impl";
+export * from "./ua_non_exclusive_limit_alarm_impl";
+export * from "./ua_alarm_condition_impl";
+export * from "./ua_certificate_expiration_alarm_impl";
+export * from "./extract_event_fields";
+export * from "./check_where_clause";

package/src/alarms_and_conditions/ua_acknowledgeable_condition_impl.ts

@@ -0,0 +1,339 @@
+/**
+ * @module node-opcua-address-space.AlarmsAndConditions
+ */
+ import { UAAcknowledgeableCondition_Base,  UAAcknowledgeableCondition, UACondition } from "node-opcua-nodeset-ua";
+ import { assert } from "node-opcua-assert";
+import { LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
+import { NodeId } from "node-opcua-nodeid";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+import { DataType, VariantLike } from "node-opcua-variant";
+import { INamespace, RaiseEventData, ISessionContext, UAEventType, UAMethod } from "node-opcua-address-space-base";
+
+import { UATwoStateVariableEx } from "../../source/ua_two_state_variable_ex";
+import { AddressSpacePrivate } from "../address_space_private";
+import { _install_TwoStateVariable_machinery  } from "../state_machine/ua_two_state_variable";
+import { _setAckedState } from "./condition";
+import { ConditionSnapshot } from "./condition_snapshot";
+import { UAConditionHelper, UAConditionImpl, UAConditionEx } from "./ua_condition_impl";
+
+export interface UAAcknowledgeableConditionHelper extends UAConditionHelper {
+    ///
+    on(eventName: string, eventHandler: (...args: any[]) => void): this;
+
+    on(
+        eventName: "acknowledged" | "confirmed",
+        eventHandler: (eventId: Buffer | null, comment: LocalizedText, branch: ConditionSnapshot) => void
+    ): this;
+}
+export interface UAAcknowledgeableConditionHelper {
+    autoConfirmBranch(branch: ConditionSnapshot, comment: LocalizedTextLike): void;
+    acknowledgeAndAutoConfirmBranch(branch: ConditionSnapshot, comment: string | LocalizedTextLike | LocalizedText): void;
+}
+export interface UAAcknowledgeableConditionEx extends UAAcknowledgeableCondition_Base, UAAcknowledgeableConditionHelper , UAConditionEx {
+    on(eventName: string, eventHandler: any): this;
+
+    enabledState: UATwoStateVariableEx;
+    ackedState: UATwoStateVariableEx;
+    confirmedState?: UATwoStateVariableEx;
+    acknowledge: UAMethod;
+    confirm?: UAMethod;
+}
+
+export declare interface UAAcknowledgeableConditionImpl extends UAAcknowledgeableConditionEx, UAConditionImpl {
+    on(eventName: string, eventHandler: any): this;
+}
+
+export class UAAcknowledgeableConditionImpl extends UAConditionImpl implements UAAcknowledgeableConditionEx {
+    /**
+     */
+    public static instantiate(
+        namespace: INamespace,
+        conditionTypeId: UAEventType | NodeId | string,
+        options: any,
+        data: any
+    ): UAAcknowledgeableConditionImpl {
+        const conditionNode = UAConditionImpl.instantiate(
+            namespace,
+            conditionTypeId,
+            options,
+            data
+        ) as UAAcknowledgeableConditionImpl;
+
+        Object.setPrototypeOf(conditionNode, UAAcknowledgeableConditionImpl.prototype);
+
+        // ----------------------- Install Acknowledge-able Condition stuff
+        // install ackedState - Mandatory
+        /**
+         * @property ackedState
+         * @type TwoStateVariable
+         */
+        _install_TwoStateVariable_machinery(conditionNode.ackedState, {
+            falseState: "Unacknowledged",
+            trueState: "Acknowledged"
+        });
+
+        /**
+         * @property acknowledge
+         * @type UAMethod
+         */
+        conditionNode.acknowledge.bindMethod(_acknowledge_method);
+
+        // install confirmedState - Optional
+        /**
+         * @property confirmedState
+         * @type TwoStateVariable
+         */
+        if (conditionNode.confirmedState) {
+            _install_TwoStateVariable_machinery(conditionNode.confirmedState, {
+                falseState: "Unconfirmed",
+                trueState: "Confirmed"
+            });
+        }
+
+        // install confirm Method - Optional
+        /**
+         * @property confirm
+         * @type UAMethod
+         */
+        if (conditionNode.confirm) {
+            conditionNode.confirm.bindMethod(_confirm_method);
+        }
+        assert(conditionNode instanceof UAAcknowledgeableConditionImpl);
+        return conditionNode;
+    }
+
+    public static install_method_handle_on_type(addressSpace: AddressSpacePrivate): void {
+        const acknowledgeableConditionType = addressSpace.findEventType("AcknowledgeableConditionType");
+        assert(acknowledgeableConditionType !== null);
+        (acknowledgeableConditionType as any).acknowledge.bindMethod(_acknowledge_method);
+        (acknowledgeableConditionType as any).confirm.bindMethod(_confirm_method);
+    }
+
+    public _raiseAuditConditionAcknowledgeEvent(branch: ConditionSnapshot): void {
+        // raise the AuditConditionAcknowledgeEventType
+        const eventData: RaiseEventData = {
+            actionTimeStamp: { dataType: DataType.DateTime, value: new Date() },
+            // xx branchId: branch.branchId.readValue().value,
+
+            // AuditEventType
+            clientAuditEntryId: {
+                dataType: DataType.Null
+            },
+
+            clientUserId: {
+                dataType: DataType.Null
+            },
+
+            // The ConditionEventId field shall contain the id of the event for which the comment was added
+            conditionEventId: { dataType: DataType.ByteString, value: branch.getEventId() },
+
+            // The Comment contains the actual comment that was added
+            comment: { dataType: DataType.LocalizedText, value: branch.getComment() },
+
+            inputArguments: {
+                dataType: DataType.Null
+            },
+            methodId: {
+                dataType: DataType.Null
+            },
+            serverId: {
+                dataType: DataType.Null
+            },
+            status: {
+                dataType: DataType.StatusCode,
+                value: StatusCodes.Good
+            }
+        };
+        this.raiseEvent("AuditConditionAcknowledgeEventType", eventData);
+    }
+
+    public _raiseAuditConditionConfirmEvent(branch: ConditionSnapshot): void {
+        // raise the AuditConditionConfirmEventType
+        const eventData: RaiseEventData = {
+            actionTimeStamp: { dataType: DataType.DateTime, value: new Date() },
+
+            // ConditionEventId The ConditionEventId field shall contain the id of the Event that was confirmed
+            conditionEventId: { dataType: DataType.ByteString, value: branch.getEventId() },
+            // xx branchId: branch.branchId.readValue().value,
+
+            // AuditEventType
+            clientAuditEntryId: {
+                dataType: DataType.Null
+            },
+            clientUserId: {
+                dataType: DataType.Null
+            },
+            comment: { dataType: DataType.LocalizedText, value: branch.getComment() },
+            inputArguments: {
+                dataType: DataType.Null
+            },
+            methodId: {
+                dataType: DataType.Null
+            },
+            serverId: {
+                dataType: DataType.Null
+            },
+            status: {
+                dataType: DataType.StatusCode,
+                value: StatusCodes.Good
+            }
+        };
+        this.raiseEvent("AuditConditionConfirmEventType", eventData);
+    }
+
+    public _acknowledge_branch(
+        conditionEventId: Buffer,
+        comment: string | LocalizedTextLike | LocalizedText,
+        branch: ConditionSnapshot,
+        message: string
+    ): StatusCode {
+        assert(typeof message === "string");
+
+        const statusCode = _setAckedState(branch, true, conditionEventId, comment);
+        if (statusCode !== StatusCodes.Good) {
+            return statusCode;
+        }
+
+        if (this.confirmedState) {
+            // alarm has a confirmed state !
+            // we should be waiting for confirmation now
+            branch.setConfirmedState(false);
+            branch.setRetain(true);
+        } else {
+            branch.setRetain(false);
+        }
+
+        branch.setComment(comment);
+
+        this.raiseNewBranchState(branch);
+
+        this._raiseAuditConditionAcknowledgeEvent(branch);
+
+        /**
+         * @event acknowledged
+         * @param  eventId   {Buffer|null}
+         * @param  comment   {LocalizedText}
+         * @param  branch    {ConditionSnapshot}
+         * raised when the alarm branch has been acknowledged
+         */
+        this.emit("acknowledged", conditionEventId, comment, branch);
+
+        return StatusCodes.Good;
+    }
+
+    /**
+     * @method _confirm_branch
+     * @param conditionEventId The ConditionEventId field shall contain the id of the Event that was conformed
+     * @param comment
+     * @param branch
+     * @param message
+     * @private
+     */
+    public _confirm_branch(
+        conditionEventId: Buffer,
+        comment: string | LocalizedTextLike,
+        branch: ConditionSnapshot,
+        message: string
+    ): void {
+        assert(typeof message === "string");
+        assert(comment instanceof LocalizedText);
+
+        // xx var eventId = branch.getEventId();
+        assert(branch.getEventId().toString("hex") === conditionEventId.toString("hex"));
+        branch.setConfirmedState(true);
+
+        // once confirmed a branch do not need to be retained
+        branch.setRetain(false);
+        branch.setComment(comment);
+
+        this._raiseAuditConditionCommentEvent(message, conditionEventId, comment);
+        this._raiseAuditConditionConfirmEvent(branch);
+
+        this.raiseNewBranchState(branch);
+
+        /**
+         * @event confirmed
+         * @param  eventId
+         * @param  comment
+         * @param  eventId
+         * raised when the alarm branch has been confirmed
+         */
+        this.emit("confirmed", conditionEventId, comment, branch);
+    }
+
+    /**
+     * @method autoConfirmBranch
+     * @param branch
+     * @param comment
+     */
+    public autoConfirmBranch(branch: ConditionSnapshot, comment: LocalizedTextLike): void {
+        assert(branch instanceof ConditionSnapshot);
+        if (!this.confirmedState) {
+            // no confirmedState => ignoring
+            return;
+        }
+        assert(!branch.getConfirmedState(), "already confirmed ?");
+        const conditionEventId = branch.getEventId();
+        // tslint:disable-next-line:no-console
+        console.log("autoConfirmBranch getAckedState ", branch.getAckedState());
+        this._confirm_branch(conditionEventId, comment, branch, "Server/Confirm");
+    }
+
+    /**
+     * @method acknowledgeAndAutoConfirmBranch
+     * @param branch {ConditionSnapshot}
+     * @param comment {String|LocalizedText}
+     */
+    public acknowledgeAndAutoConfirmBranch(branch: ConditionSnapshot, comment: string | LocalizedTextLike | LocalizedText): void {
+        comment = LocalizedText.coerce(comment)!;
+        const conditionEventId = branch.getEventId();
+        branch.setRetain(false);
+        this._acknowledge_branch(conditionEventId, comment, branch, "Server/Acknowledge");
+        this.autoConfirmBranch(branch, comment);
+    }
+}
+
+function _acknowledge_method(inputArguments: VariantLike[], context: ISessionContext, callback: any) {
+    UAConditionImpl.with_condition_method(
+        inputArguments,
+        context,
+        callback,
+        (conditionEventId: Buffer, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UACondition) => {
+            const ackConditionNode = conditionNode as UAAcknowledgeableConditionImpl;
+            // precondition checking
+            assert(!conditionEventId || conditionEventId instanceof Buffer, "must have a valid eventId or  null");
+            assert(comment instanceof LocalizedText, "expecting a comment as LocalizedText");
+            assert(conditionNode instanceof UAAcknowledgeableConditionImpl);
+            ackConditionNode._acknowledge_branch(conditionEventId, comment, branch, "Method/Acknowledged");
+            return StatusCodes.Good;
+        }
+    );
+}
+
+/*
+ *
+ * param inputArguments {Variant[]}
+ * param context        {Object}
+ * param callback       {Function}
+ *
+ * @private
+ */
+function _confirm_method(inputArguments: VariantLike[], context: ISessionContext, callback: any) {
+    UAConditionImpl.with_condition_method(
+        inputArguments,
+        context,
+        callback,
+        (eventId: Buffer, comment: LocalizedText, branch: ConditionSnapshot, conditionNode: UACondition) => {
+            assert(eventId instanceof Buffer);
+            assert(branch.getEventId() instanceof Buffer);
+            assert(branch.getEventId().toString("hex") === eventId.toString("hex"));
+
+            const ackConditionNode = conditionNode as UAAcknowledgeableConditionImpl;
+            if (branch.getConfirmedState()) {
+                return StatusCodes.BadConditionBranchAlreadyConfirmed;
+            }
+            ackConditionNode._confirm_branch(eventId, comment, branch, "Method/Confirm");
+            return StatusCodes.Good;
+        }
+    );
+}