private static HttpRequestMessage CreateHttpRequestMessage(GoRequest request)
{
var requestUrl = BuildUrl(request);
var httpRequest = new HttpRequestMessage(GetHttpMethod(request.Method, HttpMethod.Get), requestUrl);
if (request.Body != null)
{
httpRequest.Content = new StreamContent(request.Body);
}
foreach (var header in request.Headers)
{
var name = header.Key;
var value = header.Value.ToString();
if (httpRequest.Headers.TryAddWithoutValidation(name, value))
{
continue;
}
if (httpRequest.Content == null)
{
httpRequest.Content = new StringContent(string.Empty);
}
httpRequest.Content.Headers.Add(name, value);
}
return(httpRequest);
}
private static void BuildQueryAndHeaders(GoRequest request, IDictionary <ParameterTarget, IDictionary <string, StringValues> > parameters)
{
if (parameters == null || !parameters.Any())
{
return;
}
foreach (var item in parameters)
{
var target = item.Value;
if (!target.Any())
{
continue;
}
Func <string, StringValues, GoRequest> set;
switch (item.Key)
{
case ParameterTarget.Query:
set = request.AddQuery;
break;
case ParameterTarget.Header:
set = request.AddHeader;
break;
default:
continue;
}
foreach (var t in target)
{
set(t.Key, t.Value);
}
}
}
public Task EncodeAsync(object instance, Type type, GoRequest request)
{
if (!(instance is DingTalkMessage dingTalkMessage))
{
return(Task.CompletedTask);
}
var messageType = dingTalkMessage.Type.ToString();
messageType = messageType[0].ToString().ToLower() + messageType.Substring(1);
var propertyName = messageType;
var dictionary = new
Dictionary <string, object>
{
{ "msgtype", messageType },
{ propertyName, instance }
};
if (instance is IAtMessage atMessage)
{
dictionary["at"] = new
{
atMobiles = atMessage.AtMobiles,
isAtAll = atMessage.IsAtAll
};
}
var json = JsonConvert.SerializeObject(dictionary, SerializerSettings);
request.Body(json, "application/json");
return(Task.CompletedTask);
}
public Task EncodeAsync(object instance, Type type, GoRequest request)
{
if (instance is UserModel user && !string.IsNullOrEmpty(user.Password))
{
user.Password = Convert.ToBase64String(Encoding.UTF8.GetBytes(user.Password));
request.Body(JsonConvert.SerializeObject(user));
}
return(Task.CompletedTask);
}
public void Go()
{
if (state != Tcp_State.HostWithinLobby)
{
throw new System.Exception("Must be host to start the lobby");
}
var request = new GoRequest();
var outerRequest = new HostWithinLobbyRequest();
outerRequest.GoRequest = request;
outerRequest.WriteDelimitedTo(stream);
}
public Task EncodeAsync(object instance, Type type, GoRequest request)
{
if (instance == null)
{
return(Task.CompletedTask);
}
using (var sw = new StringWriter())
{
_jsonSerializer.Serialize(sw, instance, type);
request.Body(sw.ToString(), "application/json");
}
return(Task.CompletedTask);
}
private static string BuildUrl(GoRequest request)
{
var url = $"{request.Scheme}://{request.Host}";
if (request.Port.HasValue)
{
url += ":" + request.Port.Value;
}
url += $"{request.Path}";
if (request.Query.Any())
{
url = QueryHelpers.AddQueryString(url, request.Query.ToDictionary(i => i.Key, i => i.Value.ToString()));
}
return(url);
}
private static async Task BuildBodyAsync(GoRequest request, IEncoder encoder, IReadOnlyList <ParameterDescriptor> parameterDescriptors, IReadOnlyList <object> arguments)
{
if (encoder == null || parameterDescriptors == null || !parameterDescriptors.Any() || arguments == null || !arguments.Any())
{
return;
}
object bodyArgument = null;
Type bodyType = null;
for (var i = 0; i < parameterDescriptors.Count; i++)
{
var parameterDescriptor = parameterDescriptors[i];
if (parameterDescriptor.FormattingInfo.Target != ParameterTarget.Body)
{
continue;
}
bodyArgument = arguments[i];
bodyType = parameterDescriptor.ParameterType;
break;
}
if (bodyArgument == null || bodyType == null)
{
return;
}
try
{
await encoder.EncodeAsync(bodyArgument, bodyType, request);
}
catch (EncodeException)
{
throw;
}
catch (Exception e)
{
throw new EncodeException(e.Message, e);
}
}
protected override async Task InitializeRequestAsync(GoRequest request, IReadOnlyList <object> arguments)
{
var methodDescriptor = RequestContext.MethodDescriptor;
var formatResult = await FormatAsync(methodDescriptor.Parameters, _keyValueFormatterFactory, arguments);
var urlTemplate = _entry.UrlTemplate;
request.Method = methodDescriptor.Method;
request.Scheme = urlTemplate.Scheme;
request.Host = urlTemplate.Host;
request.Port = urlTemplate.Port;
var path = urlTemplate.Path;
// render path
if (path.Contains("{") && path.Contains("}"))
{
path = _templateParser.Parse(path, formatResult[ParameterTarget.Path].ToDictionary(i => i.Key, i => i.Value.ToString()));
}
request.Path = path;
if (urlTemplate.HasQuery())
{
var queryString = urlTemplate.QueryString;
var query = QueryHelpers.ParseNullableQuery(queryString);
if (query != null && query.Any())
{
foreach (var item in query)
{
request.AddQuery(item.Key, item.Value);
}
}
}
await BuildBodyAsync(request, _codec.Encoder, methodDescriptor.Parameters, arguments);
BuildQueryAndHeaders(request, formatResult);
}
protected abstract Task InitializeRequestAsync(GoRequest request, IReadOnlyList <object> arguments);
