Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
const inputArguments: Variant[] = inputArgsDef.map((arg: any) => {
const dataType = convertNodeIdToDataType(arg.dataType);
const arrayType = (arg.valueRank === 1) ? VariantArrayType.Array : VariantArrayType.Scalar;
// xx console.log("xxx ",arg.toString());
const propName = lowerFirstLetter(arg.name);
const value = inputArgs[propName];
if (value === undefined) {
throw new Error("expecting input argument " + propName);
}
if (arrayType === VariantArrayType.Array) {
if (!_.isArray(value)) {
throw new Error("expecting value to be an Array or a TypedArray");
}
}
return new Variant({arrayType, dataType, value});
});
function adjustVariant(uaVariable, variant) {
const self = uaVariable;
// convert Variant( Scalar|ByteString) => Variant(Array|ByteArray)
const addressSpace = self.addressSpace;
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);
function makeVariant(dataTypeName, isArray, current_value) {
isArray = (isArray === null) ? false : isArray;
let arrayType = VariantArrayType.Scalar;
if (isArray) {
arrayType = VariantArrayType.Array;
}
const dataType = _findDataType(dataTypeName);
assert(!dataType.isAbstract);
const validatorFunc = getValidatorFuncForType(dataType);
validate_value_or_array(isArray, current_value, validatorFunc);
const variant = new Variant({
dataType: dataType,
arrayType: arrayType,
value: current_value
});
return variant;
export async function resolveDynamicExtensionObject(
variant: Variant,
extraDataType: ExtraDataTypeManager
): Promise {
if (variant.dataType !== DataType.ExtensionObject) {
return;
}
if (variant.arrayType !== VariantArrayType.Scalar) {
if (variant.value instanceof Array) {
variant.value = (variant.value as any[]).map((v: any) => {
if (!(v instanceof OpaqueStructure)) {
return v;
}
const obj = resolveDynamicExtensionObjectV(v as OpaqueStructure, extraDataType);
return obj;
});
}
return;
}
if (!(variant.value instanceof OpaqueStructure)) {
return;
async function _createSigningRequest(
this: UAMethod,
inputArguments: Variant[],
context: SessionContext
): Promise {
const certificateGroupIdVariant = inputArguments[0];
const certificateTypeIdVariant = inputArguments[1];
const subjectNameVariant = inputArguments[2];
const regeneratePrivateKeyVariant = inputArguments[3];
const nonceVariant = inputArguments[4];
if (!expected(certificateGroupIdVariant, DataType.NodeId, VariantArrayType.Scalar)) {
return { statusCode: StatusCodes.BadInvalidArgument };
}
if (!expected(certificateTypeIdVariant, DataType.NodeId, VariantArrayType.Scalar)) {
return { statusCode: StatusCodes.BadInvalidArgument };
}
if (!expected(subjectNameVariant, DataType.String, VariantArrayType.Scalar)) {
return { statusCode: StatusCodes.BadInvalidArgument };
}
if (!expected(regeneratePrivateKeyVariant, DataType.Boolean, VariantArrayType.Scalar)) {
return { statusCode: StatusCodes.BadInvalidArgument };
}
if (!expected(regeneratePrivateKeyVariant, DataType.Boolean, VariantArrayType.Scalar)) {
return { statusCode: StatusCodes.BadInvalidArgument };
}
if (!hasEncryptedChannel(context)) {
public async write(data: Buffer): Promise {
await this.ensureInitialized();
if (!this.fileHandle) {
throw new Error("File has node been opened yet");
}
const result = await this.session.call({
inputArguments: [
{ dataType: DataType.UInt32, value: this.fileHandle },
{
arrayType: VariantArrayType.Scalar,
dataType: DataType.ByteString,
value: data
}
],
methodId: this.writeNodeId,
objectId: this.fileNodeId
});
if (result.statusCode !== StatusCodes.Good) {
throw new Error("Error " + result.statusCode.toString());
}
return;
}
finish: function () {
const base64text = this.text;
const byteString = Buffer.from(base64text, "base64");
this.parent.parent.obj.value = {
dataType: DataType.ByteString,
arrayType: VariantArrayType.Scalar,
value: byteString
};
}
},
function canRange(dataValue) {
return dataValue.value && ((dataValue.value.arrayType !== VariantArrayType.Scalar) ||
((dataValue.value.arrayType === VariantArrayType.Scalar) && (dataValue.value.dataType === DataType.ByteString)) ||
((dataValue.value.arrayType === VariantArrayType.Scalar) && (dataValue.value.dataType === DataType.String)));
}
function canRange(dataValue: DataValue): boolean {
return dataValue.value && ((dataValue.value.arrayType !== VariantArrayType.Scalar) ||
((dataValue.value.arrayType === VariantArrayType.Scalar) && (dataValue.value.dataType === DataType.ByteString))
||
((dataValue.value.arrayType === VariantArrayType.Scalar) && (dataValue.value.dataType === DataType.String)));
}