node-opcua-client/source/tools/read_history_server_capabilities.ts

pure nodejs OPCUA SDK - module client

/**
 * @module node-opcua-client
 */
import { assert } from "node-opcua-assert";
import { ObjectIds } from "node-opcua-constants";
import { AttributeIds } from "node-opcua-data-model";
import type { DataValue } from "node-opcua-data-value";
import { NodeId } from "node-opcua-nodeid";
import type { ReadValueIdOptions } from "node-opcua-service-read";
import { type BrowsePath, type BrowsePathResult, makeBrowsePath } from "node-opcua-service-translate-browse-path";
import { StatusCodes } from "node-opcua-status-code";
import { lowerFirstLetter } from "node-opcua-utils";
import type { Variant } from "node-opcua-variant";

import type { ClientSession } from "../client_session";

export interface HistoryServerCapabilities {
    [key: string]: any;
}

export function readHistoryServerCapabilities(session: ClientSession): Promise<HistoryServerCapabilities>;
export function readHistoryServerCapabilities(
    session: ClientSession,
    callback: (err: Error | null, capabilities?: HistoryServerCapabilities) => void
): void;
export function readHistoryServerCapabilities(
    session: ClientSession,
    callback?: (err: Error | null, capabilities?: HistoryServerCapabilities) => void
): any {
    if (!callback) {
        return new Promise<HistoryServerCapabilities>((resolve, reject) => {
            readHistoryServerCapabilities(session, (err, capabilities) => {
                if (err) {
                    return reject(err);
                }
                resolve(capabilities!);
            });
        });
    }
    // display HistoryCapabilities of server
    const browsePath: BrowsePath = makeBrowsePath(ObjectIds.ObjectsFolder, "/Server/ServerCapabilities.HistoryServerCapabilities");

    session.translateBrowsePath(browsePath, (err: Error | null, result?: BrowsePathResult) => {
        if (err) {
            return callback(err);
        }
        /* c8 ignore next */
        if (!result) {
            return callback(new Error("Internal Error"));
        }
        if (result.statusCode.isNotGood()) {
            return callback(new Error("StatusCode = " + result.statusCode.toString()));
        }

        result.targets = result.targets || [];

        const historyServerCapabilitiesNodeId = result.targets[0].targetId;
        // (should be ns=0;i=11192)
        assert(historyServerCapabilitiesNodeId.toString() === "ns=0;i=11192");

        // -------------------------
        const properties = [
            "AccessHistoryDataCapability",
            "AccessHistoryEventsCapability",

            "DeleteAtTimeCapability",
            "DeleteRawCapability",
            "DeleteEventCapability",

            "InsertAnnotationCapability",
            "InsertDataCapability",
            "InsertEventCapability",

            "ReplaceDataCapability",
            "ReplaceEventCapability",

            "UpdateDataCapability",
            "UpdateEventCapability",

            "MaxReturnDataValues",
            "MaxReturnEventValues",

            "AggregateFunctions/AnnotationCount",
            "AggregateFunctions/Average",
            "AggregateFunctions/Count",
            "AggregateFunctions/Delta",
            "AggregateFunctions/DeltaBounds",
            "AggregateFunctions/DurationBad",
            "AggregateFunctions/DurationGood",
            "AggregateFunctions/DurationStateNonZero"
            // etc....
        ];
        const browsePaths = properties.map((prop: string) => makeBrowsePath(historyServerCapabilitiesNodeId, "." + prop));

        session.translateBrowsePath(browsePaths, (innerErr: Error | null, results?: BrowsePathResult[]) => {
            if (innerErr) {
                return callback(innerErr);
            }
            /* c8 ignore next */
            if (!results) {
                return callback(new Error("Internal Error"));
            }

            const nodeIds = results.map((innerResult: BrowsePathResult) =>
                innerResult.statusCode.isGood() && innerResult.targets ? innerResult.targets[0].targetId : new NodeId()
            );

            const nodesToRead: ReadValueIdOptions[] = nodeIds.map((nodeId: NodeId) => ({
                attributeId: AttributeIds.Value,
                nodeId /*: coerceNodeId(nodeId)*/
            }));

            const data: HistoryServerCapabilities = {};

            session.read(nodesToRead, (err2: Error | null, dataValues?: DataValue[]) => {
                if (err2) {
                    return callback(err2);
                }
                /* c8 ignore next */
                if (!dataValues) {
                    return callback(new Error("Internal Error"));
                }

                for (let i = 0; i < dataValues.length; i++) {
                    const propName = lowerFirstLetter(properties[i]);
                    data[propName] = dataValues[i].value as Variant;
                }
                callback(null, data);
            });
        });
    });
}