node-opcua-service-filter 2.74.0 → 2.76.2

package/source/resolve_operand.ts

@@ -0,0 +1,45 @@
+import { NodeClass } from "node-opcua-data-model";
+import { make_warningLog } from "node-opcua-debug";
+import { NodeId } from "node-opcua-nodeid";
+import { constructBrowsePathFromQualifiedName, makeBrowsePath } from "node-opcua-service-translate-browse-path";
+import { StatusCodes } from "node-opcua-status-code";
+import { SimpleAttributeOperand, AttributeOperand, VariableAttributes } from "node-opcua-types";
+import { DataType, Variant } from "node-opcua-variant";
+import { FilterContext } from "./filter_context";
+
+const warningLog = make_warningLog("FILTER");
+
+// export function readOperand(context: FilterContext, operand: SimpleAttributeOperand): Variant {
+//     // navigate to the innerNode specified by the browsePath [ QualifiedName]
+//     const browsePath = constructBrowsePathFromQualifiedName({ nodeId: context.eventSource }, operand.browsePath);
+//     const targetNode = context.browsePath(browsePath);
+//     if (!targetNode) {
+//         return new Variant({ dataType: DataType.Null });
+//     }
+//     return context.readNodeValue(targetNode);
+// }
+
+export function resolveOperand(context: FilterContext, operand: SimpleAttributeOperand | AttributeOperand): Variant {
+    if (operand instanceof SimpleAttributeOperand) {
+        const browsePath = constructBrowsePathFromQualifiedName({ nodeId: context.eventSource }, operand.browsePath);
+
+        const target: NodeId | null = context.browsePath(browsePath);
+        if (!target) {
+            return new Variant({ dataType: DataType.Null });
+            // return new Variant({ dataType: DataType.StatusCode, value: StatusCodes.BadNodeIdUnknown });
+        }
+        const nodeClass = context.getNodeClass(target);
+        if (nodeClass !== NodeClass.Variable) {
+            warningLog("resolveOperand: cannot find variable here but got nodeClass", NodeClass[nodeClass], browsePath.toString());
+            return new Variant({ dataType: DataType.StatusCode, value: StatusCodes.BadNodeClassInvalid });
+        }
+        const value = context.readNodeValue(target);
+        return value;
+    } else {
+        if (!(operand instanceof AttributeOperand)) {
+            throw new Error("expecting an AttributeOperand");
+        }
+        warningLog("AttributeOperand is not yet implemented");
+        return new Variant({ dataType: DataType.Null });
+    }
+}

package/source/tools_event_filter.ts

@@ -1,168 +1,100 @@
 /**
  * @module node-opcua-service-filter
  */
-// tslint:disable:object-literal-shorthand
-// tslint:disable:only-arrow-functions
-// tslint:disable:max-line-length
-
-import { assert } from "node-opcua-assert";
 import { ObjectTypeIds } from "node-opcua-constants";
-import { AttributeIds, stringToQualifiedName } from "node-opcua-data-model";
-import { checkDebugFlag, make_debugLog } from "node-opcua-debug";
-import { makeNodeId, NodeId, resolveNodeId, sameNodeId } from "node-opcua-nodeid";
-import { DataType, Variant } from "node-opcua-variant";
+import { AttributeIds, QualifiedName, stringToQualifiedName } from "node-opcua-data-model";
+import { NodeIdLike, resolveNodeId } from "node-opcua-nodeid";
 
-import { EventFilter, SimpleAttributeOperand } from "./imports";
+import { ContentFilter, ContentFilterElement, ContentFilterOptions, EventFilter, FilterOperator, SimpleAttributeOperand } from "./imports";
 
-const debugLog = make_debugLog(__filename);
-const doDebug = checkDebugFlag(__filename);
+import { ofType } from "./make_content_filter";
 
-/**
- * helper to construct event filters:
- * construct a simple event filter
- *
- *
- * @example
- *
- *     constructEventFilter(["SourceName","Message","ReceiveTime"]);
- *
- *     constructEventFilter(["SourceName",{namespaceIndex:2 , "MyData"}]);
- *     constructEventFilter(["SourceName","2:MyData" ]);
- *
- *     constructEventFilter(["SourceName" ,["EnabledState","EffectiveDisplayName"] ]);
- *     constructEventFilter(["SourceName" ,"EnabledState.EffectiveDisplayName" ]);
- *
- */
-export function constructEventFilter(arrayOfNames: string[] | string, conditionTypes?: NodeId[] | NodeId): EventFilter {
+export function constructSelectClause(arrayOfNames: string | string[]): SimpleAttributeOperand[] {
     if (!Array.isArray(arrayOfNames)) {
-        return constructEventFilter([arrayOfNames], conditionTypes);
-    }
-    if (conditionTypes && !Array.isArray(conditionTypes)) {
-        return constructEventFilter(arrayOfNames, [conditionTypes]);
-    }
-    // istanbul ignore next
-    if (!(arrayOfNames instanceof Array)) {
-        throw new Error("internal error");
+        return constructSelectClause([arrayOfNames]);
     }
+
     // replace "string" element in the form A.B.C into [ "A","B","C"]
-    const arrayOfNames2 = arrayOfNames.map((path) => {
-        if (typeof path !== "string") {
-            return path;
-        }
-        return path.split(".");
-    });
+    const arrayOfNames2 = arrayOfNames.map((path) => (typeof path !== "string" ? path : path.split(".")));
+
+    const arrayOfNames3 = arrayOfNames2.map((path) => (Array.isArray(path) ? path.map(stringToQualifiedName) : path));
 
-    const arrayOfNames3 = arrayOfNames2.map((path) => {
-        if (Array.isArray(path)) {
-            return path.map(stringToQualifiedName);
-        }
-        return path;
-    });
     // replace "string" elements in arrayOfName with QualifiedName in namespace 0
-    const arrayOfNames4 = arrayOfNames3.map((s) => {
-        return typeof s === "string" ? stringToQualifiedName(s) : s;
-    });
+    const arrayOfNames4 = arrayOfNames3.map((s) => (typeof s === "string" ? stringToQualifiedName(s) : s));
 
     // construct browse paths array
-    const browsePaths = arrayOfNames4.map((s) => {
-        return Array.isArray(s) ? s : [s];
-    });
+    const browsePaths = arrayOfNames4.map((s) => (Array.isArray(s) ? s : [s]));
 
     // Part 4 page 127:
     // In some cases the same BrowsePath will apply to multiple EventTypes. If the Client specifies the BaseEventType
     // in the SimpleAttributeOperand then the Server shall evaluate the BrowsePath without considering the Type.
 
+    const isBrowsePathForConditionId = (browsePath: QualifiedName[]) =>
+        browsePath.length === 1 && browsePath[0].namespaceIndex === 0 && browsePath[0].name === "ConditionId";
+
     // [..]
     // The SimpleAttributeOperand structure allows the Client to specify any Attribute, however, the Server is only
     // required to support the Value Attribute for Variable Nodes and the NodeId Attribute for Object Nodes.
     // That said, profiles defined in Part 7 may make support for additional Attributes mandatory.
-    let selectClauses = browsePaths.map((browsePath) => {
-        return new SimpleAttributeOperand({
-            attributeId: AttributeIds.Value,
-            browsePath,
-            indexRange: undefined, //  NumericRange
-            typeDefinitionId: makeNodeId(ObjectTypeIds.BaseEventType) // i=2041
-        });
-    });
-
-    if (conditionTypes && conditionTypes instanceof Array) {
-        const extraSelectClauses = conditionTypes.map((nodeId) => {
+    const selectClauses = browsePaths.map((browsePath: QualifiedName[]) => {
+        if (isBrowsePathForConditionId(browsePath)) {
+            // special case
+            //
+            // The NodeId of the Condition instance is used as ConditionId. It is not explicitly modelled as a
+            // component of the ConditionType. However, it can be requested with the following
+            // SimpleAttributeOperand (see Table 10) in the SelectClause of the EventFilter:
+            //
+            //  SimpleAttributeOperand
+            //  Name          Type          Description
+            //  typeId        NodeId        NodeId of the ConditionType Node
+            //  browsePath[]  QualifiedName empty
+            //  attributeId   IntegerId     Id of the NodeId Attribute
+            //
             return new SimpleAttributeOperand({
                 attributeId: AttributeIds.NodeId,
-                browsePath: undefined,
+                browsePath: null,
                 indexRange: undefined, //  NumericRange
-                typeDefinitionId: nodeId // conditionType for instance
+                typeDefinitionId: ObjectTypeIds.ConditionType // i=2782
+            });
+        } else
+            return new SimpleAttributeOperand({
+                attributeId: AttributeIds.Value,
+                browsePath,
+                indexRange: undefined, //  NumericRange
+                typeDefinitionId: ObjectTypeIds.BaseEventType // i=2041
             });
-        });
-        selectClauses = selectClauses.concat(extraSelectClauses);
-    }
-
-    const filter = new EventFilter({
-        selectClauses,
-        whereClause: {
-            // ContentFilter
-            elements: [
-                // ContentFilterElement
-                // {
-                //    filterOperator: FilterOperator.IsNull,
-                //    filterOperands: [ //
-                //        new ElementOperand({
-                //            index: 123
-                //        }),
-                //        new AttributeOperand({
-                //            nodeId: "i=10",
-                //            alias: "someText",
-                //            browsePath: { //RelativePath
-                //
-                //            },
-                //            attributeId: AttributeIds.Value
-                //        })
-                //    ]
-                // }
-            ]
-        }
     });
-    return filter;
+    return selectClauses;
 }
-
 /**
- * @class SimpleAttributeOperand
- * @method toPath
- * @return {String}
+ * helper to construct event filters:
+ * construct a simple event filter
  *
- * @example:
+ *  "ConditionId" in the arrayOfNames has a special meaning
  *
+ * @example
  *
- */
-function simpleAttributeOperandToPath(self: SimpleAttributeOperand): string {
-    if (!self.browsePath) {
-        return "";
-    }
-    return self.browsePath
-        .map((a) => {
-            return a.name;
-        })
-        .join("/");
-}
-
-/**
- * @class SimpleAttributeOperand
- * @method toShortString
- * @return {String}
+ *     constructEventFilter(["SourceName","Message","ReceiveTime"]);
  *
- * @example:
+ *     constructEventFilter(["SourceName",{namespaceIndex:2 , "MyData"}]);
+ *     constructEventFilter(["SourceName","2:MyData" ]);
  *
+ *     constructEventFilter(["SourceName" ,["EnabledState","EffectiveDisplayName"] ]);
+ *     constructEventFilter(["SourceName" ,"EnabledState.EffectiveDisplayName" ]);
  *
  */
-export function simpleAttributeOperandToShortString(
-    self: SimpleAttributeOperand,
-    addressSpace: any // Address Space
-): string {
-    let str = "";
-    if (addressSpace) {
-        const n = addressSpace.findNode(self.typeDefinitionId)!;
-        str += n.BrowseName.toString();
+export function constructEventFilter(
+    arrayOfNames: string[] | string,
+    whereClause?: ContentFilterOptions | ContentFilterElement
+): EventFilter {
+    const selectClauses = constructSelectClause(arrayOfNames);
+
+    if (whereClause instanceof ContentFilterElement) {
+        whereClause = new ContentFilter({ elements: [whereClause] });
     }
-    str += "[" + self.typeDefinitionId.toString() + "]" + simpleAttributeOperandToPath(self);
-    return str;
+    const filter = new EventFilter({
+        selectClauses,
+        whereClause
+    });
+    return filter;
 }