public void Test_ParseNull_ChecksBindingStyle(BindingStyle bindingStyle, Type expectedType) { var result = paramsParserMock.Object.ParseNull(bindingStyle); result.Should().BeOfType(expectedType); paramsParserMock.Verify(x => x.ParseNull(bindingStyle)); paramsParserMock.VerifyNoOtherCalls(); }
public ParameterMetadata(JsonName name, Type type, int index, BindingStyle bindingStyle, bool isOptional) { Name = name ?? throw new ArgumentNullException(nameof(name)); Type = type; Index = index; BindingStyle = bindingStyle; IsOptional = isOptional; }
public IDiBinding AsSingleton(Type to) { // configure ToType = to; Style = BindingStyle.BySingleton; // return return(this); }
public void Test_ParseObject_ReturnsResult(JObject jObject, string property, BindingStyle style, IParseResult expected) { var result = paramsParserMock.Object.ParseObject(jObject, property, style); result.Should().BeOfType(expected.GetType()); result.Should().BeEquivalentTo(expected, options => options.Excluding(x => x.Type == typeof(ErrorParseResult) && x.Name == nameof(ErrorParseResult.Message)) ); paramsParserMock.Verify(x => x.ParseObject(jObject, property, style)); paramsParserMock.VerifyNoOtherCalls(); }
public IDiBinding AsConversion <TO>(Func <object, object> converter) { // Conversion is reversed, from becomes the type. ConversionFrom = typeof(TO); Style = BindingStyle.ByConversion; Conversion = converter; ConversionTo = FromType; //return return(this); }
public void Test_ParseArray_ReturnsResult(JArray jArray, int index, BindingStyle style, IParseResult expected) { var result = paramsParserMock.Object.ParseArray(jArray, index, style); result.Should().BeOfType(expected.GetType()); result.Should().BeEquivalentTo(expected, options => options.Excluding(x => x.RuntimeType == typeof(ErrorParseResult) && x.SelectedMemberInfo.Name == nameof(ErrorParseResult.Message)) ); paramsParserMock.Verify(x => x.ParseArray(jArray, index, style)); paramsParserMock.VerifyNoOtherCalls(); }
internal static MethodObjectParamStructure ToParamStructure(this BindingStyle bindingStyle) { switch (bindingStyle) { case BindingStyle.Default: return(MethodObjectParamStructure.Either); case BindingStyle.Object: return(MethodObjectParamStructure.ByName); case BindingStyle.Array: return(MethodObjectParamStructure.ByPosition); default: throw new ArgumentOutOfRangeException(nameof(bindingStyle), bindingStyle, null); } }
public void Test_GetRpcParameterInfo_UsesAttributes(BindingStyle bindingStyle) { var attribute = new FromParamsAttribute(bindingStyle); var serializerType = typeof(SnakeCaseJsonRpcSerializer); var controllerModel = new Mock <ControllerModel>(typeof(JsonRpcTestController).GetTypeInfo(), new List <object>()).Object; var actionModel = new Mock <ActionModel>(typeof(JsonRpcTestController).GetMethod(nameof(JsonRpcTestController.VoidAction)), new List <object>()).Object; var model = new Mock <ParameterModel>(typeof(JsonRpcTestController).GetMethod(nameof(JsonRpcTestController.VoidAction)).GetParameters()[0], new List <object> { attribute }).Object; actionModel.Controller = controllerModel; model.Action = actionModel; var parameterConvention = testEnvironment.ServiceProvider.GetRequiredService <ParameterConvention>(); var result = parameterConvention.GetParameterMetadata(model, serializerType); result.BindingStyle.Should().Be(bindingStyle); }
protected internal virtual IParseResult ParseNull(BindingStyle bindingStyle) { switch (bindingStyle) { case BindingStyle.Default: log.LogWarning($"Binding null to regular parameter failed"); return(new ErrorParseResult("Can not bind method arguments from [null] json params", string.Empty)); case BindingStyle.Object: case BindingStyle.Array: // this is fine log.LogTrace($"Binding null to object or array parameter"); return(new NullParseResult(string.Empty)); default: log.LogWarning($"Binding null failed"); return(new ErrorParseResult($"Unknown {nameof(bindingStyle)} [{bindingStyle}]", string.Empty)); } }
protected internal virtual IParseResult ParseArray(JArray jArray, int index, BindingStyle bindingStyle) { var indexString = index.ToString(); switch (bindingStyle) { case BindingStyle.Default: // map array items to args by indices if (index < jArray.Count) { var value = jArray[index]; if (value.Type == JTokenType.Null) { log.LogTrace($"Json value for binding by index [{indexString}] is null"); return(new NullParseResult(indexString)); } log.LogTrace($"Json value for binding by index [{indexString}] found"); return(new SuccessParseResult(value, indexString)); } else { log.LogTrace($"Json value for binding by index [{indexString}] not found"); return(new NoParseResult(indexString)); } case BindingStyle.Object: log.LogWarning($"Can not bind json array to object for [{indexString}]"); return(new ErrorParseResult("Can not bind array to object parameter", indexString)); case BindingStyle.Array: // map 1:1 to collection log.LogTrace($"Binding whole json array to [{indexString}]"); return(new SuccessParseResult(jArray, indexString)); default: log.LogWarning($"Binding failed for index [{indexString}]"); return(new ErrorParseResult($"Unknown {nameof(bindingStyle)} [{bindingStyle}]", indexString)); } }
internal void ValidateParameter(ParameterModel parameterModel, BindingStyle bindingStyle) { var isCollection = Common.Utils.IsCollection(parameterModel.ParameterType); switch (bindingStyle) { case BindingStyle.Default: return; case BindingStyle.Object: // meh, dont want to check if complex type return; case BindingStyle.Array: if (!isCollection) { throw new ArgumentOutOfRangeException(parameterModel.Name, parameterModel.ParameterType.Name, $"[{nameof(BindingStyle)}.{nameof(BindingStyle.Array)}] only works with collections. Change signature of [{parameterModel.Action.Controller.ControllerName}.{parameterModel.Action.ActionName}]"); } return; default: throw new ArgumentOutOfRangeException(nameof(bindingStyle), bindingStyle, null); } }
public FromParamsAttribute(BindingStyle bindingStyle) { BindingStyle = bindingStyle; }
/// <summary> /// For a given wsdl service operation, generate an Rpc or document style wrapped data contract /// and data contract serializer. /// </summary> /// <param name="BindingStyle">A flag indicating the binding style.</param> /// <param name="operationMessage">A OperationMessage type containing an OperationInput or OperationOutput type.</param> /// <param name="messageParts">A collection of message parts used by the operation.</param> /// <param name="messageTypes">An arraylist of message elements and or types used by the operation.</param> private void GenerateWrappedContracts(BindingStyle bindingStyle, OperationMessage operationMessage, MessagePartCollection messageParts, ArrayList messageTypes) { if (messageTypes.Count == 0) return; // Rules: Rpc/Literal support only. WS-I basic profile Rpc/Literal rules apply. // Create a temporary wrapper element type that will be used to wrap the message parts. // As per rpc/literal spec the name of the type is the name of the operation // If the message is a response the name = the operation name + "Response". // The temporary wrapper element is stored in a new schema that will be added to the existing // ServiceDescription schema set and recompiled to resolve all type references. XmlSchema schema = operationMessage.Operation.PortType.ServiceDescription.Types.Schemas[0]; XmlSchemaSet schemaSet = new XmlSchemaSet(); XmlSchemaElement wrapperElement = new XmlSchemaElement(); schema.Items.Add(wrapperElement); string elementName = operationMessage.Operation.Name; elementName = operationMessage is OperationOutput ? elementName + "Response" : elementName + "Request"; wrapperElement.Name = elementName; // The element namespace is the target namespace by default else it is // defined by the binding/operation/soap12Body/namespace attribute schema.TargetNamespace = CodeGenUtils.GetOperationNamespace(operationMessage); // Add a new complex type to the element XmlSchemaComplexType complexType = new XmlSchemaComplexType(); wrapperElement.SchemaType = complexType; // Add a sequence particles to the complex type XmlSchemaSequence sequence = new XmlSchemaSequence(); complexType.Particle = sequence; // Loop through the list of parts and add thier definitions to the sequence for (int i = 0; i < messageTypes.Count; ++i) { if (bindingStyle == BindingStyle.Rpc) { XmlSchemaElement typeElement = new XmlSchemaElement(); typeElement.Name = messageParts[i].Name; typeElement.SchemaTypeName = new XmlQualifiedName(messageParts[i].Type.Name, messageParts[i].Type.Namespace); sequence.Items.Add(typeElement); schema.Items.Add((XmlSchemaType)messageTypes[i]); } else sequence.Items.Add((XmlSchemaElement)messageTypes[i]); } // Add the new schema containing the new element to a set and compile schemaSet.Add(schema); schemaSet.Compile(); // Build the new element and serializer CodeTypeDeclaration codeType = new CodeTypeDeclaration(); CodeNamespace codeNs = CodeGenUtils.GetDotNetNamespace(m_codeNamespaces, wrapperElement.QualifiedName.Namespace); BuildElementType(wrapperElement, codeType); if (!CodeGenUtils.TypeExists(codeNs, codeType.Name)) { codeNs.Types.Add(codeType); m_dcsCodeGen.BuildDataContractSerializer(m_encodingType, codeType, codeNs); } // Swap the existing message parts with a new replacement part. All subsequent processing // will use the new single message part foreach (Message message in operationMessage.Operation.PortType.ServiceDescription.Messages) { if (message.Name == operationMessage.Message.Name) { MessagePart replacementPart = new MessagePart(); replacementPart.Element = new XmlQualifiedName(elementName); replacementPart.Type = wrapperElement.QualifiedName; replacementPart.Name = operationMessage.Name; replacementPart.Namespaces = operationMessage.Namespaces; message.Parts.Clear(); message.Parts.Add(replacementPart); break; } } }
protected internal virtual IParseResult ParseObject(JObject jObject, string jsonProperty, BindingStyle bindingStyle) { switch (bindingStyle) { case BindingStyle.Default: // map keys to args by names if (jObject.ContainsKey(jsonProperty)) { var value = jObject[jsonProperty]; if (value.Type == JTokenType.Null) { log.LogTrace($"Json value for binding [{jsonProperty}] is null"); return(new NullParseResult(jsonProperty)); } log.LogTrace($"Json value for binding [{jsonProperty}] found"); return(new SuccessParseResult(value, jsonProperty)); } else { log.LogTrace($"Json value for binding [{jsonProperty}] not found"); return(new NoParseResult(jsonProperty)); } case BindingStyle.Object: // map 1:1 to object log.LogTrace($"Binding whole json object to [{jsonProperty}]"); return(new SuccessParseResult(jObject, jsonProperty)); case BindingStyle.Array: log.LogTrace($"Can not bind json object to array for [{jsonProperty}]"); return(new ErrorParseResult("Can not bind object to collection parameter", jsonProperty)); default: log.LogWarning($"Binding failed for [{jsonProperty}]"); return(new ErrorParseResult($"Unknown {nameof(bindingStyle)} [{bindingStyle}]", jsonProperty)); } }