node-opcua-aggregates 2.54.0 → 2.57.0

package/source/average.ts

@@ -1,74 +1,71 @@
-import { UAVariable } from "node-opcua-address-space";
-import { DataValue } from "node-opcua-data-value";
-import { Variant, DataType } from "node-opcua-variant";
-import { getAggregateData } from "./common";
-import { Interval, AggregateConfigurationOptions, isGood } from "./interval";
-import { StatusCode, StatusCodes } from "node-opcua-status-code";
-
-function calculateIntervalAverageValue(
-    interval: Interval,
-    options: AggregateConfigurationOptions
-): DataValue {
-
-    const indexStart = interval.index;
-    let statusCode: StatusCode;
-    let isPartial = interval.isPartial;
-
-    let isRaw = false;
-    let hasBad = false;
-
-    const values: number[] = [];
-
-    for (let i = indexStart; i < indexStart + interval.count; i++) {
-
-        const dataValue = interval.dataValues[i];
-
-        if (dataValue.statusCode === StatusCodes.BadNoData) {
-            isPartial = true;
-            continue;
-        }
-
-        if (!isGood(dataValue.statusCode)) {
-            hasBad = true;
-            continue;
-        }
-        values.push(dataValue.value.value);
-    }
-
-    if (isRaw) {
-        if (hasBad) {
-            statusCode = StatusCodes.UncertainDataSubNormal;
-        } else {
-            statusCode = StatusCodes.Good;
-        }
-    } else if (hasBad) {
-        statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, "HistorianCalculated");
-    } else {
-        statusCode = StatusCode.makeStatusCode(StatusCodes.Good, "HistorianCalculated");
-    }
-    if (values.length === 0) {
-        return new DataValue({
-            sourceTimestamp: interval.startTime,
-            statusCode: StatusCodes.BadNoData,
-        });
-    }
-    const mean = values.reduce((p, c) => p + c, 0) / values.length;
-
-    return new DataValue({
-        sourceTimestamp: interval.startTime,
-        statusCode: statusCode as StatusCode,
-        value: {
-            dataType: DataType.Double, value: mean
-        }
-    });
-}
-
-export function getAverageData(
-    node: UAVariable,
-    processingInterval: number,
-    startDate: Date,
-    endDate: Date,
-    callback: (err: Error | null, dataValues?: DataValue[]) => void
-) {
-    return getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalAverageValue, callback);
-}
+import { UAVariable } from "node-opcua-address-space";
+import { DataValue } from "node-opcua-data-value";
+import { Variant, DataType } from "node-opcua-variant";
+import { StatusCode, StatusCodes } from "node-opcua-status-code";
+
+import { getAggregateData } from "./common";
+import { Interval, AggregateConfigurationOptions, isGood } from "./interval";
+
+function calculateIntervalAverageValue(interval: Interval, options: AggregateConfigurationOptions): DataValue {
+    const indexStart = interval.index;
+    let statusCode: StatusCode;
+    let isPartial = interval.isPartial;
+
+    const isRaw = false;
+    let hasBad = false;
+
+    const values: number[] = [];
+
+    for (let i = indexStart; i < indexStart + interval.count; i++) {
+        const dataValue = interval.dataValues[i];
+
+        if (dataValue.statusCode === StatusCodes.BadNoData) {
+            isPartial = true;
+            continue;
+        }
+
+        if (!isGood(dataValue.statusCode)) {
+            hasBad = true;
+            continue;
+        }
+        values.push(dataValue.value.value);
+    }
+
+    if (isRaw) {
+        if (hasBad) {
+            statusCode = StatusCodes.UncertainDataSubNormal;
+        } else {
+            statusCode = StatusCodes.Good;
+        }
+    } else if (hasBad) {
+        statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, "HistorianCalculated");
+    } else {
+        statusCode = StatusCode.makeStatusCode(StatusCodes.Good, "HistorianCalculated");
+    }
+    if (values.length === 0) {
+        return new DataValue({
+            sourceTimestamp: interval.startTime,
+            statusCode: StatusCodes.BadNoData
+        });
+    }
+    const mean = values.reduce((p, c) => p + c, 0) / values.length;
+
+    return new DataValue({
+        sourceTimestamp: interval.startTime,
+        statusCode: statusCode as StatusCode,
+        value: {
+            dataType: DataType.Double,
+            value: mean
+        }
+    });
+}
+
+export function getAverageData(
+    node: UAVariable,
+    processingInterval: number,
+    startDate: Date,
+    endDate: Date,
+    callback: (err: Error | null, dataValues?: DataValue[]) => void
+): void {
+    getAggregateData(node, processingInterval, startDate, endDate, calculateIntervalAverageValue, callback);
+}

package/source/common.ts

@@ -1,11 +1,12 @@
 /**
  * @module node-opca-aggregates
  */
-import { SessionContext, UAVariable } from "node-opcua-address-space";
+import { SessionContext, UAVariable, ContinuationPointManager, ContinuationPoint } from "node-opcua-address-space";
 import { NodeClass } from "node-opcua-data-model";
 import { DataValue } from "node-opcua-data-value";
 import { HistoryData, HistoryReadResult, ReadRawModifiedDetails } from "node-opcua-service-history";
 import { StatusCode } from "node-opcua-status-code";
+import { coerceNodeId } from "node-opcua-nodeid";
 
 import { getAggregateConfiguration } from "./aggregates";
 import { getInterval, Interval, AggregateConfigurationOptionsEx } from "./interval";
@@ -56,7 +57,6 @@ function processAggregateData(
     setImmediate(() => {
         callback(null, results);
     });
-
 }
 
 export function getAggregateData(
@@ -66,8 +66,7 @@ export function getAggregateData(
     endDate: Date,
     lambda: (interval: Interval, aggregateConfiguration: AggregateConfigurationOptionsEx) => DataValue,
     callback: (err: Error | null, dataValues?: DataValue[]) => void
-) {
-
+): void {
     /* istanbul ignore next */
     if (node.nodeClass !== NodeClass.Variable) {
         throw new Error("node must be UAVariable");
@@ -78,17 +77,30 @@ export function getAggregateData(
         throw new Error("Invalid processing interval, shall be greater than 0");
     }
 
-    const context = new SessionContext();
+    const continuationPointManager = new ContinuationPointManager();
+    const context = new SessionContext({
+        session: {
+            continuationPointManager,
+            getSessionId: () => coerceNodeId("i=0")
+        }
+    });
     const historyReadDetails = new ReadRawModifiedDetails({
         endTime: endDate,
         startTime: startDate,
+        isReadModified: false,
+        numValuesPerNode: 0
+        // returnBounds: true,
     });
     const indexRange = null;
     const dataEncoding = null;
-    const continuationPoint = null;
-    node.historyRead(context, historyReadDetails, indexRange, dataEncoding, continuationPoint,
+    const continuationPoint: ContinuationPoint | null = null;
+    node.historyRead(
+        context,
+        historyReadDetails,
+        indexRange,
+        dataEncoding,
+        { continuationPoint },
         (err: Error | null, result?: HistoryReadResult) => {
-
             /* istanbul ignore next */
             if (err) {
                 return callback(err);
@@ -98,10 +110,11 @@ export function getAggregateData(
             const dataValues = historyData.dataValues || [];
 
             processAggregateData(node, processingInterval, startDate, endDate, dataValues, lambda, callback);
-        });
+        }
+    );
 }
 
-export function interpolateValue(dataValue1: DataValue, dataValue2: DataValue, date: Date) {
+export function interpolateValue(dataValue1: DataValue, dataValue2: DataValue, date: Date): DataValue {
     const t0 = dataValue1.sourceTimestamp!.getTime();
     const t = date.getTime();
     const t1 = dataValue2.sourceTimestamp!.getTime();

package/source/index.ts

@@ -1,17 +1,11 @@
-/**
- * @module node-opca-aggregates
- */
-export {
-    addAggregateSupport,
-    installAggregateConfigurationOptions,
-    getAggregateConfiguration,
-} from "./aggregates";
-export * from "./interpolate";
-export * from "./minmax";
-export * from "./interval";
-export * from "./common";
-export * from "./average";
-export * from "./read_processed_details";
-export {
-    AggregateFunction
-} from "node-opcua-constants";
+/**
+ * @module node-opca-aggregates
+ */
+export { addAggregateSupport, installAggregateConfigurationOptions, getAggregateConfiguration } from "./aggregates";
+export * from "./interpolate";
+export * from "./minmax";
+export * from "./interval";
+export * from "./common";
+export * from "./average";
+export * from "./read_processed_details";
+export { AggregateFunction } from "node-opcua-constants";

package/source/interpolate.ts

@@ -1,5 +1,5 @@
 /**
- * @module node-opca-aggregates
+ * @module node-opcua-aggregates
  */
 //  excerpt from OPC Unified Architecture, Part 13 21 Release 1.04
 //
@@ -47,7 +47,8 @@ import {
     _findGoodDataValueBefore,
     adjustProcessingOptions,
     AggregateConfigurationOptionsEx,
-    Interval, isBad,
+    Interval,
+    isBad,
     isGood
 } from "./interval";
 
@@ -62,11 +63,10 @@ import {
  If for an interval neither ratio applies then that interval is Uncertain_DataSubNormal.
   */
 export function interpolatedValue(interval: Interval, options: AggregateConfigurationOptionsEx): DataValue {
-
     options = adjustProcessingOptions(options);
 
-    assert(Object.prototype.hasOwnProperty.call(options,"useSlopedExtrapolation"));
-    assert(Object.prototype.hasOwnProperty.call(options,"treatUncertainAsBad"));
+    assert(Object.prototype.hasOwnProperty.call(options, "useSlopedExtrapolation"));
+    assert(Object.prototype.hasOwnProperty.call(options, "treatUncertainAsBad"));
 
     const bTreatUncertainAsBad = options.treatUncertainAsBad!;
 
@@ -77,10 +77,9 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
         const interpValue = new DataValue({
             sourceTimestamp: interval.startTime,
             statusCode: StatusCodes.Bad,
-            value: previousDataValue.value,
+            value: previousDataValue.value
         });
-        interpValue.statusCode =
-            StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, "HistorianInterpolated");
+        interpValue.statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, "HistorianInterpolated");
         return interpValue;
     };
 
@@ -93,7 +92,7 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
             return new DataValue({
                 sourceTimestamp: interval.startTime,
                 statusCode: StatusCodes.BadNoData,
-                value: undefined,
+                value: undefined
             });
         }
         if (!options.useSlopedExtrapolation) {
@@ -111,13 +110,12 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
         // tslint:disable:no-bitwise
         if (prev2.index + 1 < prev1.index || prev1.index < interval.dataValues.length - 1) {
             // some bad data exist in between = change status code
-            const mask = 0x0000FFFFFF;
+            const mask = 0x0000ffffff;
             const extraBits = interpVal.statusCode.value & mask;
             interpVal.statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, extraBits);
         }
 
         return interpVal;
-
     }
 
     /* istanbul ignore next */
@@ -166,16 +164,12 @@ export function interpolatedValue(interval: Interval, options: AggregateConfigur
     //   x is a value at ‘x’ and Tx is the timestamp associated with Vx.
     const interpolatedDataValue = interpolateValue(before.dataValue, next.dataValue, interval.startTime);
 
-    if (before.index + 1 < next.index
-        || !isGood(next.dataValue.statusCode)
-        || !isGood(before.dataValue.statusCode)
-    ) {
+    if (before.index + 1 < next.index || !isGood(next.dataValue.statusCode) || !isGood(before.dataValue.statusCode)) {
         // tslint:disable:no-bitwise
         // some bad data exist in between = change status code
-        const mask = 0x0000FFFFFF;
+        const mask = 0x0000ffffff;
         const extraBits = interpolatedDataValue.statusCode.value & mask;
-        interpolatedDataValue.statusCode =
-            StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, extraBits);
+        interpolatedDataValue.statusCode = StatusCode.makeStatusCode(StatusCodes.UncertainDataSubNormal, extraBits);
     }
     // check if uncertain or bad value exist between before/next
     // todo
@@ -196,6 +190,6 @@ export function getInterpolatedData(
     startDate: Date,
     endDate: Date,
     callback: (err: Error | null, dataValues?: DataValue[]) => void
-) {
-    return getAggregateData(node, processingInterval, startDate, endDate, interpolatedValue, callback);
+): void {
+    getAggregateData(node, processingInterval, startDate, endDate, interpolatedValue, callback);
 }

package/source/interval.ts

@@ -117,7 +117,7 @@ export class Interval {
     /**
      * returns true if a raw data exists at start
      */
-    public hasRawDataAsStart() {
+    public hasRawDataAsStart(): boolean {
         const index = this.index;
         if (index < 0) {
             return false;
@@ -131,11 +131,11 @@ export class Interval {
      * just preceding this interval
      * @returns {*}
      */
-    public beforeStartDataValue(bTreatUncertainAsBad: boolean) {
+    public beforeStartDataValue(bTreatUncertainAsBad: boolean): DataValueWithIndex {
         return _findGoodDataValueBefore(this.dataValues, this.index, bTreatUncertainAsBad);
     }
 
-    public nextStartDataValue(bTreatUncertainAsBad: boolean) {
+    public nextStartDataValue(bTreatUncertainAsBad: boolean): DataValueWithIndex {
         return _findGoodDataValueAfter(this.dataValues, this.index, bTreatUncertainAsBad);
     }