public string GetMethodParameterExample(IRpcMethodInfo methodInfo, IRpcParameterInfo parameterInfo)
{
var paramNode = this.xpathNavigator.SelectSingleNode(
$"/doc/members/member[@name='{methodInfo.Name}']/param[@name='{parameterInfo.Name}']");
if (paramNode == null)
{
return(string.Empty);
}
var example = paramNode.GetAttribute("example", "");
return(example);
}
private object ParameterGuidValue(IRpcParameterInfo parameter, string stringValue, Type parameterType)
{
if (Guid.TryParse(stringValue, out var intValue))
{
return(intValue);
}
if (parameter.HasDefaultValue)
{
return(parameter.DefaultValue);
}
if (parameterType == typeof(Guid?))
{
return(null);
}
throw new Exception($"Could not convert parameter {parameter.Name} value {stringValue} to guid");
}
protected virtual object ParameterDoubleValue(IRpcParameterInfo parameter, string stringValue, Type parameterType)
{
if (double.TryParse(stringValue, out var intValue))
{
return(intValue);
}
if (parameter.HasDefaultValue)
{
return(parameter.DefaultValue);
}
if (parameterType == typeof(double?))
{
return(null);
}
throw new Exception($"Could not convert parameter {parameter.Name} value {stringValue} to double");
}
public object ConvertString(IRpcParameterInfo parameter, string stringValue)
{
var parameterType = parameter.ParamType;
if (parameterType == typeof(string))
{
return(stringValue);
}
if (parameterType == typeof(int) ||
parameterType == typeof(int?))
{
return(ParameterIntegerValue(parameter, stringValue, parameterType));
}
if (parameterType == typeof(double) ||
parameterType == typeof(double?))
{
return(ParameterDoubleValue(parameter, stringValue, parameterType));
}
if (parameterType == typeof(decimal) ||
parameterType == typeof(decimal?))
{
return(ParameterDecimalValue(parameter, stringValue, parameterType));
}
if (parameterType == typeof(bool) ||
parameterType == typeof(bool?))
{
return(ParameterBooleanValue(parameter, stringValue, parameterType));
}
if (parameterType == typeof(Guid) ||
parameterType == typeof(Guid?))
{
return(ParameterGuidValue(parameter, stringValue, parameterType));
}
return(Convert.ChangeType(stringValue, parameterType));
}
/// <inheritdoc />
public void BindUrlParameter(RequestExecutionContext context,
EndPointMethodConfiguration configuration,
IRpcParameterInfo parameter,
IRequestParameters parameterContext,
ref int currentIndex,
in ReadOnlySpan <char> pathSpan)
protected virtual void BindQueryStringParameter(RequestExecutionContext context, EndPointMethodConfiguration configuration, IRpcParameterInfo parameter, IRequestParameters parameters)
{
if (context.HttpContext.Request.Query.TryGetValue(parameter.BindName, out var value))
{
var boundValue = _stringValueModelBinder.ConvertString(parameter, value);
context.Parameters[parameter.Position] = boundValue;
}
else if (parameter.HasDefaultValue)
{
context.Parameters[parameter.Position] = parameter.DefaultValue;
}
}
private void BindHeaderParameter(RequestExecutionContext context, EndPointMethodConfiguration configuration, IRpcParameterInfo parameter, IRequestParameters parameters)
{
if (context.HttpContext.Request.Headers.TryGetValue(parameter.BindName, out var value))
{
var boundValue = _stringValueModelBinder.ConvertString(parameter, value);
parameters[parameter.Position] = boundValue;
}
else if (parameter.HasDefaultValue)
{
parameters[parameter.Position] = parameter.DefaultValue;
}
}
protected virtual void BindNewData <TValue>(RequestExecutionContext context, EndPointMethodConfiguration configuration, IRpcParameterInfo parameter, IRequestParameters parameterContext) where TValue : new()
{
parameterContext[parameter.Position] = new TValue();
}
private bool ParametersMatch(RpcRequestSignature requestSignature, IReadOnlyList <IRpcParameterInfo> parameters)
{
if (!requestSignature.HasParameters)
{
return(parameters == null || !parameters.Any(p => !p.IsOptional));
}
int parameterCount = 0;
if (requestSignature.IsDictionary)
{
foreach ((Memory <char> name, RpcParameterType type) in requestSignature.ParametersAsDict)
{
bool found = false;
for (int paramIndex = 0; paramIndex < parameters.Count; paramIndex++)
{
IRpcParameterInfo parameter = parameters[paramIndex];
if (!RpcUtil.NamesMatch(parameter.Name.AsSpan(), name.Span) ||
!RpcParameterUtil.TypesCompatible(parameter.Type, type))
{
continue;
}
found = true;
break;
}
if (!found)
{
return(false);
}
parameterCount++;
}
}
else
{
foreach (RpcParameterType parameterType in requestSignature.ParametersAsList)
{
if (parameters.Count <= parameterCount)
{
return(false);
}
IRpcParameterInfo info = parameters[parameterCount];
if (!RpcParameterUtil.TypesCompatible(info.Type, parameterType))
{
return(false);
}
parameterCount++;
}
for (int i = parameterCount; i < parameters.Count; i++)
{
//Only if the last parameters in the method are optional does the request match
//Will be skipped if they are equal length
if (!parameters[i].IsOptional)
{
return(false);
}
}
}
if (parameterCount != parameters.Count)
{
return(false);
}
return(true);
}
public virtual void BindHttpCancellationTokenParameter(RequestExecutionContext context,
EndPointMethodConfiguration endPointMethodConfiguration, IRpcParameterInfo parameter,
IRequestParameters parameterContext)
{
parameterContext[parameter.Position] = context.HttpContext.RequestAborted;
}
public virtual void BindHttpResponseParameter(RequestExecutionContext context,
EndPointMethodConfiguration endPointMethodConfiguration, IRpcParameterInfo parameter,
IRequestParameters parameterContext)
{
parameterContext[parameter.Position] = context.HttpContext.Response;
}
public virtual void BindRequestServicesParameter(RequestExecutionContext context,
EndPointMethodConfiguration endPointMethodConfiguration, IRpcParameterInfo parameter,
IRequestParameters parameterContext)
{
parameterContext[parameter.Position] = context.HttpContext.RequestServices.GetService(parameter.ParamType);
}
