TypeScript node-opcua-data-model.coerceLocalizedText函数代码示例

        return coerceEnumValues(_.map(enumValues, (value: Int64, key)  => {

            return new EnumValueType({
                description: coerceLocalizedText(key),
                displayName: coerceLocalizedText(key),
                value,
            });
        }));

        it("should add a YArrayItem", () => {

            const yArrayItem = namespace.addYArrayItem({

                organizedBy: objectsFolder,

                browseName: "MyYArrayItem",

                title: "My Little YArray Item",

                engineeringUnits: standardUnits.degree_celsius,
                engineeringUnitsRange: { low: 100, high: 200 },

                axisScaleType: "Log",

                xAxisDefinition: {
                    axisScaleType: AxisScaleEnumeration.Linear,
                    axisSteps: [0, 25, 50, 75, 100],
                    engineeringUnits: standardUnits.second,
                    euRange: { low: -10, high: 100 },
                    title: coerceLocalizedText("the X axis legend"),
                },

                value: new Variant({
                    arrayType: VariantArrayType.Array,
                    dataType: DataType.Float,
                    value: [1, 2, 3, 2]
                })
            });

            yArrayItem.browseName.toString().should.eql("1:MyYArrayItem");

            yArrayItem.dataType.should.eql(resolveNodeId("Float"));

            yArrayItem.readValue().value.value.length.should.eql(4);
            yArrayItem.readValue().value.value[0].should.eql(1);
            yArrayItem.readValue().value.value[1].should.eql(2);
            yArrayItem.readValue().value.value[2].should.eql(3);
            yArrayItem.readValue().value.value[3].should.eql(2);

            yArrayItem.hasOwnProperty("instrumentRange").should.eql(false, "optional instrument Range not expected");

            yArrayItem.euRange.readValue().value.value.low.should.eql(100);
            yArrayItem.euRange.readValue().value.value.high.should.eql(200);

            yArrayItem.title.readValue().value.value.text.should.eql("My Little YArray Item");

            // access xAxisDefinition from extension object
            const x = yArrayItem.xAxisDefinition.readValue().value.value as AxisInformation;

            x.engineeringUnits.should.eql(standardUnits.second);
            x.title!.text!.should.eql("the X axis legend");
            x.euRange.low.should.eql(-10);
            x.euRange.high.should.eql(100);

            // xx console.log("xxxx ",yArrayItem.xAxisDefinition.toString())
            // xx yArrayItem.xAxisDefinition.euRange.readValue().value.value.should.eql(standardUnits.second);
            // xx yArrayItem.xAxisDefinition.engineeringUnits.readValue().value.value.should.eql(standardUnits.second);

        });

                function step8_condition_confirmed(callback) {
                    //    branchId  |  Active  | Acked | Confirmed | Retain |
                    //    null      |  false   | true  | true      | false   |

                    const context = new SessionContext({ object: condition });
                    const param = [
                        // the eventId
                        { dataType: DataType.ByteString, value: condition.eventId.readValue().value.value },
                        //
                        { dataType: DataType.LocalizedText, value: coerceLocalizedText("Some message") }
                    ];
                    condition.confirm!.execute(param, context,
                      (err: Error|null, callMethodResult: CallMethodResultOptions) => {
                        callMethodResult.statusCode!.should.equal(StatusCodes.Good);
                    });

                    should(condition.branchId.readValue().value.value).eql(NodeId.nullNodeId);
                    should(condition.ackedState.readValue().value.value.text).eql("Acknowledged");
                    should(condition.confirmedState!.readValue().value.value.text).eql("Confirmed");
                    should(condition.retain!.readValue().value.value).eql(false);

                    condition.currentBranch().getBranchId().should.eql(NodeId.nullNodeId);
                    condition.currentBranch().getActiveState().should.eql(false);
                    condition.currentBranch().getAckedState().should.eql(true);
                    condition.currentBranch().getConfirmedState().should.eql(true);
                    condition.currentBranch().getRetain().should.eql(false);

                    callback();
                }

            it("should be possible to set the comment of a condition using the addComment method of the conditionType", async () => {
                const namespace = addressSpace.getOwnNamespace();

                const condition = namespace.instantiateCondition(myCustomConditionType, {
                    browseName: "MyCustomCondition12",
                    conditionSource: null,
                    organizedBy: addressSpace.rootFolder.objects
                });

                condition.raiseNewCondition(new ConditionInfo({ severity: 100 }));

                const context = new SessionContext({ object: condition });
                const eventId = condition.eventId.readValue().value.value;
                should(eventId).be.instanceOf(Buffer);

                const param = [
                    // the eventId
                    new Variant({ dataType: DataType.ByteString, value: eventId }),
                    //
                    new Variant({ dataType: DataType.LocalizedText, value: coerceLocalizedText("Some message") })
                ];

                const conditionType = addressSpace.findObjectType("ConditionType")! as ConditionType;

                conditionType.addComment.execute(param, context,
                  (err: Error | null, callMethodResult: CallMethodResultOptions) => {
                      callMethodResult.statusCode!.should.equal(StatusCodes.Good);
                  });

                condition.currentBranch().getComment().text!.should.eql("Some message");

            });

 return _.map(enumValues, (en: any) => {
     assert(en.hasOwnProperty("value"));
     assert(en.hasOwnProperty("displayName"));
     return new EnumValueType({
         displayName: coerceLocalizedText(en.displayName),
         value: en.value,
     });
 });

                function step2_condition_acknowledged(callback) {
                    // Step 2 : Condition acknowledged :=> Confirmed required
                    //    branchId  |  Active  | Acked | Confirmed | Retain |
                    // 1) null      |  true    | true  | false      | true   |

                    const context = new SessionContext({ object: condition });
                    const param = [
                        // the eventId
                        { dataType: DataType.ByteString, value: condition.eventId.readValue().value.value },
                        //
                        { dataType: DataType.LocalizedText, value: coerceLocalizedText("Some message") }
                    ];
                    condition.acknowledge.execute(param, context,
                      (err: Error| null, callMethodResult: CallMethodResultOptions) => {
                        callMethodResult.statusCode!.should.equal(StatusCodes.Good);
                    });

                    should(condition.branchId.readValue().value.value).eql(NodeId.nullNodeId);
                    should(condition.activeState.readValue().value.value.text).eql("Active");
                    should(condition.ackedState.readValue().value.value.text).eql("Acknowledged");
                    should(condition.confirmedState!.readValue().value.value.text).eql("Unconfirmed");
                    should(condition.retain!.readValue().value.value).eql(true);

                    condition.currentBranch().getBranchId().should.eql(NodeId.nullNodeId);
                    condition.currentBranch().getActiveState().should.eql(true);
                    condition.currentBranch().getAckedState().should.eql(true);
                    condition.currentBranch().getConfirmedState().should.eql(false);
                    condition.currentBranch().getRetain().should.eql(true);

                    // --------------------- the 'acknowledge' event must have been raised
                    acknowledged_spy.callCount.should.eql(1);
                    acknowledged_spy.getCall(0).args.length.should.eql(3);
                    should.not.exist(acknowledged_spy.getCall(0).args[0], "eventId is null");
                    acknowledged_spy.getCall(0).args[1].should.be.instanceOf(LocalizedText);
                    // acknowledged_spy.getCall(0).args[2].should.be.instanceOf(ConditionSnapshot);
                    acknowledged_spy.thisValues[0].should.eql(condition);
                    callback();

                },

    /**
     * @method setState
     */
    public setState(toStateNode: string | State | null): void {

        if (!toStateNode) {
            this.currentStateNode = null;
            this.currentState.setValueFromSource({ dataType: DataType.Null }, StatusCodes.BadStateNotActive);
            return;
        }

        if (_.isString(toStateNode)) {
            const state = this.getStateByName(toStateNode);
            // istanbul ignore next
            if (!state) {
                throw new Error("Cannot find state with name " + toStateNode);
            }
            assert(state.browseName.toString() === toStateNode);
            toStateNode = state;
        }
        const fromStateNode = this.currentStateNode;

        toStateNode = this._coerceNode(toStateNode) as any as State;
        assert(toStateNode.nodeClass === NodeClass.Object);

        this.currentState.setValueFromSource({
            dataType: DataType.LocalizedText,
            value: coerceLocalizedText(toStateNode.browseName.toString())
        }, StatusCodes.Good);

        this.currentStateNode = toStateNode;

        const transitionNode = this.findTransitionNode(fromStateNode, toStateNode);

        if (transitionNode) {

            // xx console.log("transitionNode ",transitionNode.toString());
            // The inherited Property SourceNode shall be filled with the NodeId of the StateMachine instance where the
            // Transition occurs. If the Transition occurs in a SubStateMachine, then the NodeId of the SubStateMachine
            // has to be used. If the Transition occurs between a StateMachine and a SubStateMachine, then the NodeId of
            // the StateMachine has to be used, independent of the direction of the Transition.
            // Transition identifies the Transition that triggered the Event.
            // FromState identifies the State before the Transition.
            // ToState identifies the State after the Transition.
            this.raiseEvent("TransitionEventType", {

                // Base EventType
                // xx nodeId:      this.nodeId,
                // TransitionEventType
                // TransitionVariableType
                "transition": {
                    dataType: "LocalizedText",
                    value: transitionNode.displayName[0]
                },

                "transition.id": transitionNode.transitionNumber.readValue().value,

                "fromState": {
                    dataType: "LocalizedText",
                    value: fromStateNode ? fromStateNode.displayName[0] : ""
                },   // StateVariableType

                "fromState.id": fromStateNode ? fromStateNode.stateNumber.readValue().value : {
                    dataType: "Null"
                },

                "toState": {
                    dataType: "LocalizedText",
                    value: toStateNode.displayName[0]
                },    // StateVariableType

                "toState.id": toStateNode.stateNumber.readValue().value
            });

        } else {
            if (fromStateNode && fromStateNode !== toStateNode) {
                if (doDebug) {
                    const f = fromStateNode.browseName.toString();
                    const t = toStateNode.browseName.toString();
                    console.log(chalk.red("Warning"),
                      " cannot raise event :  transition " + f + " to " + t + " is missing");
                }
            }
        }

        // also update executable flags on methods
        for (const method of this.getMethods()) {
            (method as any)._notifyAttributeChange(AttributeIds.Executable);
        }
    }

//.........这里部分代码省略.........
                        this.parent.argument.valueRank = parseInt(this.text.trim(), 10);
                    }
                },

                ArrayDimensions: {

                    finish(this: any) {
                        // xx  this.parent.argument.arrayDimensions =[];
                    }
                },
                Description: {
                    init(this: any) {
                        this._text = "";
                        this.locale = null;
                        this.text = null;
                    },
                    parser: {
                        Locale: {
                            init(this: any) {
                                this.text = "";
                            },
                            finish(this: any) {
                                this.parent.locale = this.text.trim();
                            }
                        },
                        Text: {
                            finish(this: any) {
                                this.text = this.text || "";
                                this.parent._text = this.text.trim();
                            }
                        }
                    },
                    finish(this: any) {
                        this.parent.argument.description = coerceLocalizedText(this._text);
                    }
                }
            },
            finish(this: any) {
                // xx this.argument = new Argument(this.argument);
            }
        }
    };

    const Range_parser = {
        Range: {
            init(this: any) {
                this.range = new Range({});
            },
            parser: {
                Low: {
                    finish(this: any) {
                        this.parent.range.low = parseFloat(this.text);
                    }
                },

                High: {
                    finish(this: any) {
                        this.parent.range.high = parseFloat(this.text);
                    }
                }
            }
        }
    };

    const EUInformation_parser = {
        EUInformation: {