node-opcua-address-space 2.74.0 → 2.75.0

package/src/alarms_and_conditions/check_where_clause.ts

@@ -1,147 +0,0 @@
-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/extract_event_fields.ts

@@ -1,103 +0,0 @@
-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));
-}