Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
// ClientAuditEntryId contains the human-readable AuditEntryId defined in Part 3.
clientAuditEntryId: {dataType: "String", value: ""},
// The ClientUserId identifies the user of the client requesting an action. The ClientUserId can be
// obtained from the UserIdentityToken passed in the ActivateSession call.
clientUserId: {dataType: "String", value: "cc"},
sourceName: {dataType: "String", value: "Session/ActivateSession"},
/* part 5 - 6.4.7 AuditSessionEventType */
sessionId: {dataType: "NodeId", value: session.nodeId},
/* part 5 - 6.4.10 AuditActivateSessionEventType */
clientSoftwareCertificates: {
dataType: "ExtensionObject" /* SignedSoftwareCertificate */,
arrayType: VariantArrayType.Array,
value: []
},
// UserIdentityToken reflects the userIdentityToken parameter of the ActivateSession Service call.
// For Username/Password tokens the password should NOT be included.
userIdentityToken: {
dataType: "ExtensionObject" /* UserIdentityToken */,
value: userIdentityTokenPasswordRemoved(session.userIdentityToken)
},
// SecureChannelId shall uniquely identify the SecureChannel. The application shall use the same identifier
// in all AuditEvents related to the Session Service Set (AuditCreateSessionEventType,
// AuditActivateSessionEventType and their subtypes) and the SecureChannel Service Set
// (AuditChannelEventType and its subtypes).
secureChannelId: {dataType: "String", value: session.channel.secureChannelId.toString()}
});
// -------------------------------------------- install default get/put handler
const server_NamespaceArray_Id = makeNodeId(VariableIds.Server_NamespaceArray); // ns=0;i=2255
bindVariableIfPresent(server_NamespaceArray_Id, {
get: function () {
return new Variant({
dataType: DataType.String,
arrayType: VariantArrayType.Array,
value: engine.addressSpace.getNamespaceArray().map(x=>x.namespaceUri)
});
},
set: null // read only
});
const server_NameUrn_var = new Variant({
dataType: DataType.String,
arrayType: VariantArrayType.Array,
value: [
engine.serverNameUrn // this is us !
]
});
const server_ServerArray_Id = makeNodeId(VariableIds.Server_ServerArray); // ns=0;i=2254
bindVariableIfPresent(server_ServerArray_Id, {
get: function () {
return server_NameUrn_var;
},
set: null // read only
});
function bindStandardScalar(id, dataType, func, setter_func) {
assert(_.isNumber(id), "expecting id to be a number");
const basicType = addressSpace.findCorrespondingBasicDataType(uaVariable.dataType);
if (basicType === DataType.Byte && uaVariable.valueRank === 1) {
if (variant.arrayType === VariantArrayType.Scalar && variant.dataType === DataType.ByteString) {
if ((uaVariable.dataType.value === DataType.Byte.value) && (self.dataType.namespace === 0)) { // Byte
variant.arrayType = VariantArrayType.Array;
variant.dataType = DataType.Byte;
assert(variant.dataType === DataType.Byte);
assert(!variant.value || variant.value instanceof Buffer);
}
}
}
if (basicType === DataType.ByteString && uaVariable.valueRank === -1 /* Scalar*/) {
if (variant.arrayType === VariantArrayType.Array && variant.dataType === DataType.Byte) {
if ((self.dataType.value === DataType.ByteString.value) && (self.dataType.namespace === 0)) { // Byte
variant.arrayType = VariantArrayType.Scalar;
variant.dataType = DataType.ByteString;
assert(variant.dataType === DataType.ByteString);
assert(!variant.value || variant.value instanceof Buffer);
}
}
}
return variant;
}
assert(enumStrings.browseName.toString() === "EnumStrings");
} else {
// construct the definition object
definition = options.enumeration.map(function (enumItem) {
return new EnumValueType({
displayName: coerceLocalizedText(enumItem.displayName),
value: [ 0, enumItem.value ],
description: coerceLocalizedText(enumItem.description)
});
});
let value = new Variant({
dataType: DataType.ExtensionObject,
arrayType: VariantArrayType.Array,
value: definition
});
const enumValues = self.addVariable({
propertyOf: enumType,
browseName: {name: "EnumValues", namespaceIndex:0},
modellingRule: "Mandatory",
description: null,
dataType: "EnumValueType",
valueRank: 1,
value: value
});
assert(enumValues.browseName.toString() === "EnumValues");
}
// now create the string value property
//
finish(this: any) {
this.parent.parent.obj.value = {
arrayType: VariantArrayType.Array,
dataType: (DataType as any)[dataType],
value: this.listData
};
},
endElement(this: any, element: string) {
options.value = {dataType: DataType.UInt32, value: 0};
options.statusCode = StatusCodes.BadAttributeIdInvalid;
}
break;
case AttributeIds.DataType:
assert(this.dataType instanceof NodeId);
options.value = {dataType: DataType.NodeId, value: this.dataType};
options.statusCode = StatusCodes.Good;
break;
case AttributeIds.ValueRank:
options.value = {dataType: DataType.Int32, value: this.valueRank};
options.statusCode = StatusCodes.Good;
break;
case AttributeIds.ArrayDimensions:
assert(_.isArray(this.arrayDimensions) || this.arrayDimensions === null);
options.value = {dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: this.arrayDimensions};
options.statusCode = StatusCodes.Good;
break;
default:
return BaseNode.prototype.readAttribute.call(this, context, attributeId);
}
return new DataValue(options);
};
private _readArrayDimensions(): DataValue {
assert(_.isArray(this.arrayDimensions) || this.arrayDimensions === null);
const options = {
statusCode: StatusCodes.Good,
value: { dataType: DataType.UInt32, arrayType: VariantArrayType.Array, value: this.arrayDimensions }
};
return new DataValue(options);
}
function isOutsideDeadbandVariant(v1: Variant, v2: Variant, absoluteDeadBand: number): boolean {
assert(_.isFinite(absoluteDeadBand));
if (v1.arrayType === VariantArrayType.Array) {
if (v1.dataType !== v2.dataType) {
return true;
}
if (v1.value.length !== v2.value.length) {
return true;
}
const n = v1.value.length;
let i = 0;
for (i = 0; i < n; i++) {
if (_isOutsideDeadbandScalar(v1.value[i], v2.value[i], v1.dataType, absoluteDeadBand)) {
return true;
}
}
return false;
const dataType = addressSpace.findDataType(variableType.dataType);
if (!dataType) {
throw new Error("cannot find Data Type");
}
assert(dataType.isSupertypeOf(structure as any), "expecting a structure (= ExtensionObject) here ");
const inner_options = {
componentOf: parentFolder,
browseName: options.browseName,
dataType: dataType.nodeId,
typeDefinition: complexVariableType.nodeId,
value: { dataType: DataType.ExtensionObject, value: [], arrayType: VariantArrayType.Array },
valueRank: 1
};
const uaArrayVariableNode = namespace.addVariable(inner_options) as UADynamicVariableArray;
bindExtObjArrayNode(
uaArrayVariableNode,
options.variableType,
options.indexPropertyName);
return uaArrayVariableNode;
}
finish: function () {
this.parent.parent.obj.value = {
dataType: DataType[dataType],
arrayType: VariantArrayType.Array,
value: this.listData
};
},
endElement: function (element) {