/// <summary>
/// Default constructor
/// </summary>
/// <param name="routeInformation"></param>
/// <param name="activationFunc"></param>
/// <param name="invokeInformation"></param>
/// <param name="returnType"></param>
public EndPointMethodConfiguration(RpcRouteInformation routeInformation,
Func <RequestExecutionContext, object> activationFunc,
IMethodInvokeInformation invokeInformation,
Type returnType)
{
RouteInformation = routeInformation;
ActivationFunc = activationFunc;
ReturnType = returnType;
InvokeInformation = invokeInformation;
Parameters = new List <RpcParameterInfo>();
}
private static EndPointMethodConfiguration CreateEndPointMethodConfiguration(string path)
{
var routeInfo = new RpcRouteInformation
{
HasBody = false,
Method = HttpMethods.Get,
RouteBasePath = path,
RouteTemplate = path,
Tokens = Array.Empty <IRpcRouteToken>()
};
var invokeFunc = new MethodInvokeInformation
{
MethodInvokeDelegate = context => null
};
var configuration = new EndPointMethodConfiguration(routeInfo, context => null, invokeFunc, typeof(void));
return(configuration);
}
private RpcRouteInformation GenerateRouteInformation(string path, string method, bool hasBody, string prefixString, ICurrentApiInformation currentApi, Type type, string name, MethodInfo methodInfo, List <Attribute> attributes)
{
var fullPath = BasePath;
if (!string.IsNullOrEmpty(prefixString))
{
if (fullPath.EndsWith('/') && prefixString.StartsWith('/'))
{
fullPath = fullPath.TrimEnd('/');
}
fullPath += prefixString;
}
if (string.IsNullOrEmpty(path))
{
path = "/";
}
if (fullPath.EndsWith('/') && path.StartsWith('/'))
{
fullPath = fullPath.TrimEnd('/');
}
fullPath += path;
var rpcRouteInformation = new RpcRouteInformation
{
RouteTemplate = fullPath,
HasBody = hasBody,
Method = method
};
CalculateRouteTokens(rpcRouteInformation);
return(rpcRouteInformation);
}
private List <RpcParameterInfo> GenerateMethodParameters(Type instanceType, MethodInfo methodInfo, RpcRouteInformation routeInformation)
{
var parameterList = new List <RpcParameterInfo>();
var bodyParams = 0;
var lastPosition = 0;
foreach (var parameterInfo in methodInfo.GetParameters())
{
var rpcParam = new RpcParameterInfo
{
Position = parameterInfo.Position,
Name = parameterInfo.Name,
HasDefaultValue = parameterInfo.HasDefaultValue,
DefaultValue = parameterInfo.HasDefaultValue ? parameterInfo.DefaultValue : null,
ParamType = parameterInfo.ParameterType
};
lastPosition = parameterInfo.Position;
SetParameterSource(routeInformation, parameterInfo.ParameterType, rpcParam, parameterInfo);
if (rpcParam.ParameterSource == EndPointMethodParameterSource.PostParameter)
{
bodyParams++;
}
parameterList.Add(rpcParam);
}
if (instanceType != null)
{
foreach (var propertyInfo in instanceType.GetProperties())
{
var rpcParam = ProcessProperty(propertyInfo);
if (rpcParam != null)
{
rpcParam.BindingType = EndPointBindingType.InstanceProperty;
rpcParam.Name = propertyInfo.Name;
rpcParam.ParamType = propertyInfo.PropertyType;
parameterList.Add(rpcParam);
rpcParam.Position = parameterList.Count - 1;
}
}
}
foreach (var routeToken in routeInformation.Tokens)
{
if (routeToken.ParameterInfo == null)
{
var rpcParam = new RpcParameterInfo
{
Name = routeToken.Name,
HasDefaultValue = false,
DefaultValue = null,
ParamType = GetParameterTypeFromTokenType(routeToken.ParseType),
ParameterSource = EndPointMethodParameterSource.PathParameter,
BindingType = EndPointBindingType.Other
};
parameterList.Add(rpcParam);
rpcParam.Position = parameterList.Count - 1;
}
}
if (bodyParams == 1 &&
_exposeConfigurations.SingleParameterPostFromBody)
{
var parameter = parameterList.First(rpc =>
rpc.ParameterSource == EndPointMethodParameterSource.PostParameter);
if (!DefaultExposeDelegates.SimpleTypeWrapSelector(parameter.ParamType))
{
parameter.ParameterSource = EndPointMethodParameterSource.PostBody;
}
}
return(parameterList);
}
private void CalculateRouteTokens(RpcRouteInformation rpcRouteInformation)
{
var routeTemplate = rpcRouteInformation.RouteTemplate;
var rpcTokens = new List <RpcRouteToken>();
rpcRouteInformation.Tokens = rpcTokens;
var tokenStartBracket = routeTemplate.IndexOf('{');
if (tokenStartBracket == -1)
{
rpcRouteInformation.RouteBasePath = rpcRouteInformation.RouteTemplate;
return;
}
rpcRouteInformation.RouteBasePath = routeTemplate.Substring(0, tokenStartBracket);
while (tokenStartBracket > 0)
{
var tokenEndBracket = routeTemplate.IndexOf('}', tokenStartBracket);
var colonIndex = routeTemplate.IndexOf(':', tokenStartBracket, tokenEndBracket - tokenStartBracket);
var tokenEnd = tokenEndBracket;
var token = new RpcRouteToken();
if (colonIndex > 0)
{
tokenEnd = colonIndex;
var tokenTypeString = routeTemplate.Substring(colonIndex + 1,
tokenEndBracket - (colonIndex + 1));
if (tokenTypeString.EndsWith('?'))
{
tokenTypeString = tokenTypeString.TrimEnd('?');
token.Optional = true;
}
token.ParseType = GetParseType(tokenTypeString);
}
var tokenName =
routeTemplate.Substring(tokenStartBracket + 1,
tokenEnd - (tokenStartBracket + 1));
if (tokenName.EndsWith('?'))
{
tokenName = tokenName.TrimEnd('?');
token.Optional = true;
}
token.Name = tokenName;
if (tokenEndBracket < routeTemplate.Length - 1)
{
var endCharacter = routeTemplate[tokenEndBracket + 1];
if (endCharacter == '{')
{
throw new Exception("Path is invalid tokens need character separater");
}
token.StopCharacter = endCharacter;
}
rpcTokens.Add(token);
tokenStartBracket = routeTemplate.IndexOf('{', tokenEnd);
}
}
