node-opcua-address-space 2.75.0 → 2.76.0

package/source/loader/register_node_promoter.ts

@@ -1,11 +1,12 @@
 import { NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 import { UAObject, UAVariable } from "node-opcua-address-space-base";
 
-import { g_promotableObject } from "./namespace_post_step";
+import { g_promotableObject, Promoter } from "./namespace_post_step";
 
 export function registerNodePromoter(
-    nodeId: NodeIdLike,
-    promoter: ((node: UAVariable) => void) | ((node: UAObject) => void)
+    standardNodeId: number,
+    promoter: Promoter,
+    applyOnTypes = false
 ): void {
-    g_promotableObject[resolveNodeId(nodeId).toString()] = promoter;
+    g_promotableObject[resolveNodeId(standardNodeId).toString()] = { promoter, onInstanceOnly: applyOnTypes };
 }

package/src/alarms_and_conditions/ua_alarm_condition_impl.ts

@@ -191,6 +191,9 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
     public activateAlarm(): void {
         // will set acknowledgeable to false and retain to true
         const branch = this.currentBranch();
+        if (!branch) {
+            return;
+        }
         branch.setRetain(true);
         branch.setActiveState(true);
         branch.setAckedState(false);
@@ -418,7 +421,7 @@ export class UAAlarmConditionImpl extends UAAcknowledgeableConditionImpl impleme
             });
         } else {
             return new ConditionInfoImpl({
-                message: "Condition value is " + value + " and state is " + stateData,
+                message: "Condition is " + value + " and state is " + stateData,
                 quality: StatusCodes.Good,
                 retain: true,
                 severity: 150

package/src/alarms_and_conditions/ua_certificate_expiration_alarm_impl.ts

@@ -2,10 +2,10 @@
  * @module node-opcua-address-space.AlarmsAndConditions
  */
 import { Certificate, exploreCertificate, makeSHA1Thumbprint } from "node-opcua-crypto";
-import { DateTime, minOPCUADate } from "node-opcua-basic-types";
+import { DateTime, minOPCUADate, StatusCodes } from "node-opcua-basic-types";
 import { make_warningLog } from "node-opcua-debug";
 import { NodeId } from "node-opcua-nodeid";
-import { DataType, VariantOptions } from "node-opcua-variant";
+import { DataType, Variant, VariantOptions } from "node-opcua-variant";
 import { INamespace, UAObject, UAProperty } from "node-opcua-address-space-base";
 import { ObjectTypeIds } from "node-opcua-constants";
 import { makeAccessLevelExFlag } from "node-opcua-data-model";
@@ -16,97 +16,136 @@ import { UASystemOffNormalAlarmImpl } from "./ua_system_off_normal_alarm_impl";
 
 const warningLog = make_warningLog("AlarmsAndConditions");
 
+const ellipsis = (arg0: string, arg1 = 4) => {
+    arg1 = Math.max(arg1, 4);
+    return arg0.length <= arg1 ? arg0 : arg0.slice(0, arg1 / 2) + "..." + arg0.slice(arg0.length - arg1 / 2);
+};
+const d = (d: Date) => {
+    return d.toISOString();
+};
 export function instantiateCertificateExpirationAlarm(
     namespace: INamespace,
     alarmType: "CertificateExpirationAlarmType",
-    options: InstantiateOffNormalAlarmOptions,
-    data?: Record<string, VariantOptions>
-
+    options: InstantiateOffNormalAlarmOptions
 ): UACertificateExpirationAlarmEx {
-    return UACertificateExpirationAlarmImpl.instantiate(namespace,alarmType, options, data);
+    return UACertificateExpirationAlarmImpl.instantiate(namespace, alarmType, options);
 }
 
-
 interface UACertificateExpirationAlarmImpl {
-    expirationDate: UAProperty<Date, /*z*/DataType.DateTime>;
-    expirationLimit?: UAProperty<number, /*z*/DataType.Double>;
-    certificateType: UAProperty<NodeId, /*z*/DataType.NodeId>;
-    certificate: UAProperty<Buffer, /*z*/DataType.ByteString>;
+    expirationDate: UAProperty<Date, /*z*/ DataType.DateTime>;
+    expirationLimit?: UAProperty<number, /*z*/ DataType.Double>;
+    certificateType: UAProperty<NodeId, /*z*/ DataType.NodeId>;
+    certificate: UAProperty<Buffer, /*z*/ DataType.ByteString>;
 }
+
+// This Simple DataType is a Double that defines an interval of time in milliseconds (fractions can be used to define sub-millisecond values).
+// Negative values are generally invalid but may have special meanings where the Duration is used.
+export const OneDayDuration = 1000 * 60 * 60 * 24;
+export const TwoWeeksDuration = OneDayDuration * 2 * 7;
+
 /**
  * This UACertificateExpirationAlarm (SystemOffNormalAlarmType) is raised by the Server when the Server’s
  * Certificate is within the ExpirationLimit
  * of expiration. This alarm automatically returns to normal when the certificate is updated.
  */
 class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implements UACertificateExpirationAlarmEx {
-
+    private timer: any;
 
     public static instantiate(
         namespace: INamespace,
         alarmType: "CertificateExpirationAlarmType",
-        options: InstantiateOffNormalAlarmOptions,
-        data?: Record<string, VariantOptions>
+        options: InstantiateOffNormalAlarmOptions
+        // data?: Record<string, VariantOptions>
     ): UACertificateExpirationAlarmImpl {
         const alarm = UASystemOffNormalAlarmImpl.instantiate(
             namespace,
             alarmType || "CertificateExpirationAlarmType",
-            options,
-            data
+            options
+            // data
         ) as UACertificateExpirationAlarmImpl;
-        Object.setPrototypeOf(alarm, UACertificateExpirationAlarmImpl.prototype);
-        alarm._post_initialize();
+        promoteToCertificateExpirationAlarm(alarm);
         return alarm;
     }
 
-    public getExpirationDate(): DateTime {
+    public getExpirationDate(): DateTime | null {
         return this.expirationDate.readValue().value.value;
     }
 
-    public setExpirationDate(expirationDate: Date): void {
-        this.expirationDate.setValueFromSource({
-            dataType: DataType.DateTime,
-            value: expirationDate
+    public updateAlarmState2(isActive: boolean, severity: number, message: string) {
+        //xx console.log(`${message} ${severity} ${d(new Date())}`);
+        isActive ? this.activateAlarm() : this.deactivateAlarm();
+
+        this.raiseNewCondition({
+            message,
+            quality: StatusCodes.Good,
+            retain: isActive ? true : false,
+            severity
         });
+    }
+
+    public update() {
+        this._updateAlarm();
+    }
+
+    private _updateAlarm() {
+        const expirationDate = this.getExpirationDate();
+
         const now = new Date();
+
         const expirationLimit = this.getExpirationLimit();
 
         const checkDate = new Date(now.getTime() + +expirationLimit);
 
-        const thumbprint = makeSHA1Thumbprint(this.getCertificate() || Buffer.alloc(0)).toString("hex");
+        const certificate = this.getCertificate();
 
-        if (expirationDate.getTime() <= checkDate.getTime()) {
-            if (!this.currentBranch().getActiveState()) {
-                warningLog(
-                    `CertificateExpirationAlarm:  becomes active, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()} expirationLimit=${expirationLimit}`
-                );
+        if (!expirationDate || (expirationDate === minOPCUADate && !certificate)) {
+            if (!this.currentBranch() || this.currentBranch().getActiveState()) {
+                this.updateAlarmState2(true, 255, "certificate is missing");
             }
+            return;
+        }
+
+        const thumbprint = ellipsis(makeSHA1Thumbprint(this.getCertificate() || Buffer.alloc(0)).toString("hex"), 10);
+        const info = `| end date: ${d(expirationDate)} | expirationLimit=${expirationLimit}|`;
+        //
+
+        if (expirationDate.getTime() <= checkDate.getTime()) {
             // also raise the event
             if (expirationDate.getTime() <= now.getTime()) {
-                this.updateAlarmState(
-                    true,
-                    `certificate ${thumbprint} has expired : end date is ${expirationDate.toUTCString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
-                );
+                this.updateAlarmState2(true, 250, `certificate ${thumbprint} has expired ${info}`);
             } else {
-                this.updateAlarmState(
-                    true,
-                    `certificate ${thumbprint} is about to expire : end date is ${expirationDate.toString()} checkDate=${checkDate.toUTCString()}  expirationLimit=${expirationLimit}`
-                );
+                //             check--------------------+
+                //       expiry---------------+         |
+                //       today-----+          |         |
+                //                 v          v         v
+                // ----------------+----------+---------+----------+
+                const t1 = checkDate.getTime() - now.getTime();
+                const t2 = checkDate.getTime() - expirationDate.getTime();
+                const severity = t1 === 0 ? 255 : Math.floor((t2 / t1) * 100) + 100;
+                this.updateAlarmState2(true, severity, `certificate ${thumbprint} is about to expire ${info}`);
             }
         } else {
-            if (this.currentBranch().getActiveState()) {
-                warningLog(
-                    `CertificateExpirationAlarm:  becomes desactivated, certificate ${thumbprint} endDate ${expirationDate.toUTCString()} expirationLimit=${expirationLimit}`
-                );
-            }
-            // also raise the event
-            this.updateAlarmState(
-                false,
-                `certificate ${thumbprint} end date is OK: ${expirationDate.toString()} , expirationLimit=${expirationLimit}`
-            );
+            this.updateAlarmState2(false, 0, `certificate ${thumbprint} is OK! ${info}`);
         }
     }
 
+    public setExpirationDate(expirationDate: Date): void {
+        this.expirationDate.setValueFromSource({
+            dataType: DataType.DateTime,
+            value: expirationDate
+        });
+        this._updateAlarm();
+    }
+
     public getExpirationLimit(): number {
+        // This shall be a positive number. If the property is not provided, a default of 2 weeks shall be used.
+        if (!this.expirationLimit) {
+            return TwoWeeksDuration;
+        }
+        const dataValue = this.expirationLimit!.readValue();
+        if ((dataValue as any).dataType === DataType.Null) {
+            return TwoWeeksDuration;
+        }
         return (this.expirationLimit?.readValue().value.value as number) || 0;
     }
 
@@ -115,13 +154,14 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
             dataType: DataType.Double,
             value
         });
+        this._updateAlarm();
     }
 
     public getCertificate(): Certificate | null {
         return (this.certificate.readValue().value.value as Certificate | null) || null;
     }
 
-    public setCertificate(certificate: Certificate | null): void {
+    private _extractAndSetExpiryDate(certificate: Certificate | null): void {
         if (certificate && certificate.length > 0) {
             const info = exploreCertificate(certificate);
             if (info.tbsCertificate.validity.notAfter instanceof Date) {
@@ -132,12 +172,22 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
         } else {
             this.setExpirationDate(minOPCUADate);
         }
+    }
+
+    public setCertificate(certificate: Certificate | null): void {
         this.certificate.setValueFromSource({
             dataType: DataType.ByteString,
             value: certificate
         });
+        this._extractAndSetExpiryDate(certificate);
     }
 
+    stopTimer() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
     _post_initialize() {
         if (this.expirationLimit) {
             this.expirationLimit.accessLevel = makeAccessLevelExFlag("CurrentRead | CurrentWrite");
@@ -148,6 +198,13 @@ class UACertificateExpirationAlarmImpl extends UASystemOffNormalAlarmImpl implem
                 this.setCertificate(certificate);
             });
         }
+        const certificate = this.getCertificate();
+        this._extractAndSetExpiryDate(certificate);
+
+        this.addressSpace.registerShutdownTask(() => {
+            this.stopTimer();
+        });
+        this.timer = setInterval(() => this.update(), OneDayDuration / 48);
     }
 }
 
@@ -160,4 +217,4 @@ export function promoteToCertificateExpirationAlarm(node: UAObject): UACertifica
     _node._post_initialize();
     return _node;
 }
-registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm);
+registerNodePromoter(ObjectTypeIds.CertificateExpirationAlarmType, promoteToCertificateExpirationAlarm, true);

package/src/alarms_and_conditions/ua_condition_impl.ts

@@ -18,7 +18,7 @@ import {
     QualifiedName
 } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
-import { checkDebugFlag, make_debugLog, make_errorLog } from "node-opcua-debug";
+import { checkDebugFlag, make_debugLog, make_errorLog, make_warningLog } from "node-opcua-debug";
 import { minDate } from "node-opcua-basic-types";
 import { coerceNodeId, makeNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
 import { CallbackT, StatusCode, StatusCodes } from "node-opcua-status-code";
@@ -52,6 +52,7 @@ import { ConditionSnapshotImpl } from "./condition_snapshot_impl";
 const debugLog = make_debugLog(__filename);
 const errorLog = make_errorLog(__filename);
 const doDebug = checkDebugFlag(__filename);
+const warningLog = make_warningLog(__filename);
 
 export declare interface UAConditionImpl extends UAConditionEx, UABaseEventImpl {
     on(eventName: string, eventHandler: any): this;
@@ -450,6 +451,8 @@ export class UAConditionImpl extends UABaseEventImpl implements UAConditionEx {
                     node._bubble_up_event(eventData);
                 }
             }
+        } else {
+            warningLog("Condition ", this.nodeId.toString(), "is not linked to a Object with a IsConditionOf(reversed(HasCondition))");
         }
         // xx console.log("MMMMMMMM%%%%%%%%%%%%%%%%%%%%% branch  " +
         // branch.getBranchId().toString() + " eventId = " + branch.getEventId().toString("hex"));

package/src/alarms_and_conditions/ua_exclusive_limit_alarm_impl.ts

@@ -104,7 +104,7 @@ export class UAExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UAExc
         }
 
         if (state !== oldState) {
-            this._signalNewCondition(state, isActive, value.toString());
+            this._signalNewCondition(state, isActive, value.toFixed(3));
         }
     }
 }

package/src/alarms_and_conditions/ua_non_exclusive_limit_alarm_impl.ts

@@ -106,7 +106,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
     }
 
     public _calculateConditionInfo(
-        states: string | null,
+        state: string | null,
         isActive: boolean,
         value: string,
         oldConditionInfo: ConditionInfo
@@ -120,7 +120,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
             });
         } else {
             return new ConditionInfoImpl({
-                message: "Condition value is " + value + " and state is " + states,
+                message: "Condition is " + value + " and state is " + state,
                 quality: StatusCodes.Good,
                 retain: true,
                 severity: 150
@@ -196,7 +196,7 @@ export class UANonExclusiveLimitAlarmImpl extends UALimitAlarmImpl implements UA
         });
 
         if (count > 0) {
-            this._signalNewCondition2(states, isActive, value.toString());
+            this._signalNewCondition2(states, isActive, value.toFixed(3));
         }
     }
 }

package/src/alarms_and_conditions/ua_off_normal_alarm_impl.ts

@@ -1,11 +1,13 @@
 /**
  * @module node-opcua-address-space.AlarmsAndConditions
  */
-import { INamespace, UAVariable } from "node-opcua-address-space-base";
+import { INamespace, UAVariable, UAVariableT } from "node-opcua-address-space-base";
 import { assert } from "node-opcua-assert";
 import { DataValue } from "node-opcua-data-value";
 import { NodeId, NodeIdLike } from "node-opcua-nodeid";
+
 import { UAOffNormalAlarm_Base } from "node-opcua-nodeset-ua";
+import { NumericalRangeInvalid } from "node-opcua-numeric-range";
 import { StatusCodes } from "node-opcua-status-code";
 import * as utils from "node-opcua-utils";
 import { DataType, VariantOptions } from "node-opcua-variant";
@@ -32,11 +34,11 @@ export declare interface UAOffNormalAlarmEx
             | "suppressedState"
         >,
         UADiscreteAlarmEx {
-    getNormalStateNode(): UAVariable | null;
+    getNormalStateNode(): UAVariableT<NodeId, DataType.NodeId> | null;
 
-    getNormalStateValue(): any;
+    getNormalStateValue(): NodeId | null;
 
-    setNormalStateValue(value: any): void;
+    setNormalStateValue(value: NodeIdLike): void;
 }
 
 export declare interface UAOffNormalAlarmImpl extends UAOffNormalAlarmEx, UADiscreteAlarmImpl {
@@ -53,7 +55,7 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
      * When the value of inputNode doesn't match the normalState node value, then the alarm is raised.
      *
      */
-    public static instantiate(
+    public static instantiate<T, DT extends DataType>(
         namespace: INamespace,
         limitAlarmTypeId: string | NodeId,
         options: InstantiateOffNormalAlarmOptions,
@@ -136,9 +138,9 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     // Property the Alarm is Active. If this Variable is not in the AddressSpace, a Null NodeId shall
     // be provided.
 
-    public getNormalStateNode(): UAVariable | null {
+    public getNormalStateNode(): UAVariableT<NodeId, DataType.NodeId> | null {
         const nodeId = this.normalState.readValue().value.value;
-        const node = this.addressSpace.findNode(nodeId) as UAVariable;
+        const node = this.addressSpace.findNode(nodeId) as UAVariableT<NodeId, DataType.NodeId>;
         if (!node) {
             return null;
         }
@@ -148,19 +150,19 @@ export class UAOffNormalAlarmImpl extends UADiscreteAlarmImpl implements UAOffNo
     /**
      * @method getNormalStateValue
      */
-    public getNormalStateValue(): any | null {
+    public getNormalStateValue(): NodeId | null {
         const normalStateNode = this.getNormalStateNode();
         if (!normalStateNode) {
             return null;
         }
-        return normalStateNode.readValue().value.value;
+        return normalStateNode.readValue().value.value as NodeId;
     }
 
     /**
      * @method setNormalStateValue
      * @param value
      */
-    public setNormalStateValue(value: any): void {
+    public setNormalStateValue(value: NodeIdLike): void {
         const normalStateNode = this.getNormalStateNode();
         throw new Error("Not Implemented yet");
     }

package/src/alarms_and_conditions/ua_system_off_normal_alarm_impl.ts

@@ -3,7 +3,7 @@
  */
 import { INamespace } from "node-opcua-address-space-base";
 import { NodeId } from "node-opcua-nodeid";
-import { VariantOptions } from "node-opcua-variant";
+import { DataType, VariantOptions } from "node-opcua-variant";
 import { InstantiateOffNormalAlarmOptions } from "../../source/interfaces/alarms_and_conditions/instantiate_off_normal_alarm_options";
 import { UAOffNormalAlarmImpl } from "./ua_off_normal_alarm_impl";
 

package/src/state_machine/ua_two_state_variable.ts

@@ -5,14 +5,13 @@ import { assert } from "node-opcua-assert";
 
 import { VariableTypeIds } from "node-opcua-constants";
 import { BrowseDirection, coerceLocalizedText, LocalizedText, LocalizedTextLike } from "node-opcua-data-model";
-import { DataValueT, DataValueOptionsT } from "node-opcua-data-value";
+import { DataValueT } from "node-opcua-data-value";
 import { NodeId, resolveNodeId } from "node-opcua-nodeid";
 import { sameNodeId } from "node-opcua-nodeid";
 import { StatusCodes, StatusCode, StatusCodeCallback } from "node-opcua-status-code";
 import { Variant, VariantLike, VariantT } from "node-opcua-variant";
 import { DataType } from "node-opcua-variant";
 import { BaseNode, BindVariableOptions, INamespace, UAReference, UAVariable, ISessionContext } from "node-opcua-address-space-base";
-import { UATwoStateVariable } from "node-opcua-nodeset-ua";
 import { NumericRange } from "node-opcua-numeric-range";
 import { QualifiedNameLike } from "node-opcua-data-model";
 

package/test_helpers/add_event_generator_object.ts

@@ -62,7 +62,6 @@ export function add_eventGeneratorObject(namespace: INamespace, parentFolder: UA
                 value: severity
             }
         });
-        // console.log(require("util").inspect(context).toString());
         const callMethodResult = {
             outputArguments: [],
             statusCode: StatusCodes.Good

package/dist/source/helpers/check_event_clause.d.ts

@@ -1,17 +0,0 @@
-import { SimpleAttributeOperand } from "node-opcua-service-filter";
-import { StatusCode } from "node-opcua-status-code";
-import { BaseNode, UAObjectType } from "node-opcua-address-space-base";
-/**
- * @method checkSelectClause
- * @param parentNode
- * @param selectClause
- * @return {Array<StatusCode>}
- */
-export declare function checkSelectClause(parentNode: BaseNode, selectClause: SimpleAttributeOperand): StatusCode;
-/**
- * @method checkSelectClauses
- * @param eventTypeNode
- * @param selectClauses
- * @return an array of StatusCode
- */
-export declare function checkSelectClauses(eventTypeNode: UAObjectType, selectClauses: SimpleAttributeOperand[]): StatusCode[];

package/dist/source/helpers/check_event_clause.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkSelectClauses = exports.checkSelectClause = void 0;
-/**
- * @module node-opcua-address-space
- */
-// tslint:disable:no-console
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_service_translate_browse_path_1 = require("node-opcua-service-translate-browse-path");
-const node_opcua_status_code_1 = require("node-opcua-status-code");
-/**
- * @method checkSelectClause
- * @param parentNode
- * @param selectClause
- * @return {Array<StatusCode>}
- */
-function checkSelectClause(parentNode, selectClause) {
-    //
-    const addressSpace = parentNode.addressSpace;
-    // istanbul ignore next
-    if (selectClause.typeDefinitionId.isEmpty()) {
-        return node_opcua_status_code_1.StatusCodes.Good;
-    }
-    const eventTypeNode = addressSpace.findEventType(selectClause.typeDefinitionId);
-    if (!eventTypeNode || !(eventTypeNode.nodeClass === node_opcua_data_model_1.NodeClass.ObjectType)) {
-        // xx console.log("eventTypeNode = ",selectClause.typeDefinitionId.toString());
-        // xx console.log("eventTypeNode = ",eventTypeNode);
-        // istanbul ignore next
-        if (eventTypeNode) {
-            console.log(eventTypeNode.toString());
-        }
-    }
-    // istanbul ignore next
-    if (eventTypeNode.nodeClass !== node_opcua_data_model_1.NodeClass.ObjectType) {
-        throw new Error("Expecting a ObjectType");
-    }
-    // navigate to the innerNode specified by the browsePath [ QualifiedName]
-    const browsePath = (0, node_opcua_service_translate_browse_path_1.constructBrowsePathFromQualifiedName)(eventTypeNode, selectClause.browsePath);
-    const browsePathResult = addressSpace.browsePath(browsePath);
-    return browsePathResult.statusCode;
-}
-exports.checkSelectClause = checkSelectClause;
-/**
- * @method checkSelectClauses
- * @param eventTypeNode
- * @param selectClauses
- * @return an array of StatusCode
- */
-function checkSelectClauses(eventTypeNode, selectClauses) {
-    return selectClauses.map(checkSelectClause.bind(null, eventTypeNode));
-}
-exports.checkSelectClauses = checkSelectClauses;
-//# sourceMappingURL=check_event_clause.js.map

package/dist/source/helpers/check_event_clause.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"check_event_clause.js","sourceRoot":"","sources":["../../../source/helpers/check_event_clause.ts"],"names":[],"mappings":";;;AAAA;;GAEG;AACH,4BAA4B;AAC5B,iEAAkD;AAElD,uGAAgG;AAChG,mEAAiE;AAGjE;;;;;GAKG;AACH,SAAgB,iBAAiB,CAAC,UAAoB,EAAE,YAAoC;IACxF,EAAE;IACF,MAAM,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;IAE7C,uBAAuB;IACvB,IAAI,YAAY,CAAC,gBAAgB,CAAC,OAAO,EAAE,EAAE;QACzC,OAAO,oCAAW,CAAC,IAAI,CAAC;KAC3B;IACD,MAAM,aAAa,GAAG,YAAY,CAAC,aAAa,CAAC,YAAY,CAAC,gBAAgB,CAAE,CAAC;IAEjF,IAAI,CAAC,aAAa,IAAI,CAAC,CAAC,aAAa,CAAC,SAAS,KAAK,iCAAS,CAAC,UAAU,CAAC,EAAE;QACvE,+EAA+E;QAC/E,oDAAoD;QACpD,uBAAuB;QACvB,IAAI,aAAa,EAAE;YACf,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC,CAAC;SACzC;KACJ;IAED,uBAAuB;IACvB,IAAI,aAAa,CAAC,SAAS,KAAK,iCAAS,CAAC,UAAU,EAAE;QAClD,MAAM,IAAI,KAAK,CAAC,wBAAwB,CAAC,CAAC;KAC7C;IAED,yEAAyE;IACzE,MAAM,UAAU,GAAG,IAAA,+EAAoC,EAAC,aAAa,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IAChG,MAAM,gBAAgB,GAAG,YAAY,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;IAC7D,OAAO,gBAAgB,CAAC,UAAU,CAAC;AACvC,CAAC;AA5BD,8CA4BC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,aAA2B,EAAE,aAAuC;IACnG,OAAO,aAAa,CAAC,GAAG,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC;AAC1E,CAAC;AAFD,gDAEC"}

package/dist/src/alarms_and_conditions/check_where_clause.d.ts

@@ -1,4 +0,0 @@
-import { ContentFilter } from "node-opcua-types";
-import { IAddressSpace, IEventData, ISessionContext } from "node-opcua-address-space-base";
-export declare function __checkWhereClause(addressSpace: IAddressSpace, sessionContext: ISessionContext, whereClause: ContentFilter, index: number, eventData: IEventData): boolean;
-export declare function checkWhereClause(addressSpace: IAddressSpace, sessionContext: ISessionContext, whereClause: ContentFilter, eventData: IEventData): boolean;

package/dist/src/alarms_and_conditions/check_where_clause.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkWhereClause = exports.__checkWhereClause = void 0;
-const node_opcua_types_1 = require("node-opcua-types");
-const node_opcua_variant_1 = require("node-opcua-variant");
-const node_opcua_data_model_1 = require("node-opcua-data-model");
-const node_opcua_nodeid_1 = require("node-opcua-nodeid");
-const session_context_1 = require("../../source/session_context");
-const extract_event_fields_1 = require("./extract_event_fields");
-function checkNot(addressSpace, sessionContext, whereClause, eventData, filteredOperands) {
-    if (filteredOperands[0] instanceof node_opcua_types_1.ElementOperand) {
-        const index = filteredOperands[0].index;
-        return !__checkWhereClause(addressSpace, sessionContext, whereClause, index, eventData);
-    }
-    return false;
-}
-function checkOfType(addressSpace, ofType, eventData) {
-    var _a;
-    // istanbul ignore next
-    if (!ofType) {
-        throw new Error("invalid operand");
-    }
-    // istanbul ignore next
-    if (ofType.value.dataType !== node_opcua_variant_1.DataType.NodeId) {
-        throw new Error("invalid operand type (expecting Nodeid");
-    }
-    const ofTypeNode = addressSpace.findNode(ofType.value.value);
-    // 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 !== node_opcua_data_model_1.NodeClass.ObjectType) {
-        throw new Error("operand should be a ObjectType " + ofTypeNode.nodeId.toString());
-    }
-    const node = eventData.$eventDataSource;
-    if (!node) {
-        throw new Error("cannot find  node " + ((_a = eventData.$eventDataSource) === null || _a === void 0 ? void 0 : _a.toString()));
-    }
-    if (node.nodeClass === node_opcua_data_model_1.NodeClass.ObjectType) {
-        return node.isSupertypeOf(ofTypeNode);
-    }
-    if (node.nodeClass === node_opcua_data_model_1.NodeClass.Object && node.typeDefinitionObj) {
-        return node.typeDefinitionObj.isSupertypeOf(ofTypeNode);
-    }
-    return true;
-}
-function _extractValue(operand, eventData) {
-    // eventData.readValue;
-    const v = (0, extract_event_fields_1.extractEventFields)(session_context_1.SessionContext.defaultContext, [operand], eventData)[0];
-    return v.value;
-}
-function checkInList(addressSpace, filterOperands, eventData) {
-    const operand0 = filterOperands[0];
-    if (!(operand0 instanceof node_opcua_types_1.SimpleAttributeOperand)) {
-        // unsupported case
-        return false;
-    }
-    const nodeId = _extractValue(operand0, eventData);
-    if (!nodeId) {
-        return false;
-    }
-    function _is(nodeId1, operandX) {
-        const operandNode = addressSpace.findNode(operandX.value.value);
-        if (!operandNode) {
-            return false;
-        }
-        return (0, node_opcua_nodeid_1.sameNodeId)(nodeId1, operandNode.nodeId);
-    }
-    for (let i = 1; i < filterOperands.length; i++) {
-        const filterOperand = filterOperands[i];
-        if (filterOperand instanceof node_opcua_types_1.LiteralOperand && _is(nodeId, filterOperand)) {
-            return true;
-        }
-    }
-    return false;
-}
-function __checkWhereClause(addressSpace, sessionContext, whereClause, index, eventData) {
-    if (!whereClause.elements || whereClause.elements.length === 0) {
-        return true;
-    }
-    const element = whereClause.elements[index];
-    if (!element) {
-        return true;
-    }
-    switch (element.filterOperator) {
-        case node_opcua_types_1.FilterOperator.Not:
-            return checkNot(addressSpace, sessionContext, whereClause, eventData, element.filterOperands);
-        case node_opcua_types_1.FilterOperator.OfType:
-            return checkOfType(addressSpace, element.filterOperands[0], eventData);
-        case node_opcua_types_1.FilterOperator.InList:
-            return checkInList(addressSpace, element.filterOperands, 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");
-    }
-}
-exports.__checkWhereClause = __checkWhereClause;
-function checkWhereClause(addressSpace, sessionContext, whereClause, eventData) {
-    if (!whereClause.elements || whereClause.elements.length === 0) {
-        return true;
-    }
-    return __checkWhereClause(addressSpace, sessionContext, whereClause, 0, eventData);
-}
-exports.checkWhereClause = checkWhereClause;
-//# sourceMappingURL=check_where_clause.js.map