/// <summary>
/// 检测结果的正确性
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override async Task SetResultAsync(ApiResponseContext context)
{
if (context.ResultStatus == ResultStatus.None)
{
var response = context.HttpContext.ResponseMessage;
if (response != null && response.IsSuccessStatusCode == false)
{
var error = await context.JsonDeserializeAsync(typeof(InfuxdbError));
if (error is InfuxdbError infuxdbError)
{
throw new InfluxdbException(infuxdbError);
}
}
}
}
/// <summary>
/// 设置结果值
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override Task SetResultAsync(ApiResponseContext context)
{
if (context.ActionDescriptor.Return.DataType.IsRawType == true)
{
return(Task.CompletedTask);
}
var response = context.HttpContext.ResponseMessage;
if (response != null && IsNoContent(response))
{
context.Result = context.ActionDescriptor.Return.DataType.Type.DefaultValue();
}
return(Task.CompletedTask);
}
public async Task ByteArrayResultTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("ByteArrayAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
context.HttpContext.ResponseMessage.Content = new StringContent("laojiu", Encoding.UTF8);
var attr = new RawReturnAttribute();
await attr.OnResponseAsync(responseContext);
var text = Encoding.UTF8.GetString((byte[])responseContext.Result);
Assert.True(text == "laojiu");
}
/// <summary>
/// 读取响应内容
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private async Task <string?> ReadResponseContentAsync(ApiResponseContext context)
{
var content = context.HttpContext.ResponseMessage?.Content;
if (content == null)
{
return(null);
}
if (content.IsBuffered() == true || context.GetCompletionOption() == HttpCompletionOption.ResponseContentRead)
{
return(await content.ReadAsStringAsync().ConfigureAwait(false));
}
return("...");
}
/// <summary>
/// 设置强类型模型结果值
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task SetResultAsync(ApiResponseContext context)
{
if (context.ApiAction.Return.DataType.IsModelType == false)
{
return;
}
try
{
var resultType = context.ApiAction.Return.DataType.Type;
context.Result = await context.XmlDeserializeAsync(resultType).ConfigureAwait(false);
}
catch (Exception ex)
{
context.Exception = ex;
}
}
/// <summary>
/// 响应后
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public sealed async override Task OnResponseAsync(ApiResponseContext context)
{
var response = context.HttpContext.ResponseMessage;
var logMessage = context.UserDatas.Get <LogMessage>(typeof(LoggingFilterAttribute));
logMessage.ResponseTime = DateTime.Now;
logMessage.Exception = context.Exception;
if (this.LogResponse && response != null)
{
logMessage.HasResponse = true;
logMessage.ResponseHeaders = response.GetHeadersString();
logMessage.ResponseContent = await this.ReadResponseContentAsync(response.Content).ConfigureAwait(false);
}
await this.WriteLogAsync(context, logMessage).ConfigureAwait(false);
}
public async Task EnsureSuccessStatusCodeTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("JsonXmlAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
context.HttpContext.ResponseMessage.StatusCode = System.Net.HttpStatusCode.InternalServerError;
var attr = new JsonReturnAttribute()
{
EnsureSuccessStatusCode = true
};
await attr.OnResponseAsync(responseContext, () => Task.CompletedTask);
Assert.IsType <HttpStatusFailureException>(responseContext.Exception);
}
/// <summary>
/// 设置强类型模型结果值
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task SetResultAsync(ApiResponseContext context)
{
var content = context.HttpContext.ResponseMessage?.Content;
if (content == null)
{
return;
}
var json = await content.ReadAsStringAsync().ConfigureAwait(false);
var resultType = context.ActionDescriptor.Return.DataType.Type;
var name = context.HttpContext.OptionsName;
var options = context.HttpContext.ServiceProvider.GetService <IOptionsMonitor <JsonNetSerializerOptions> >().Get(name);
context.Result = JsonConvert.DeserializeObject(json, resultType, options.JsonDeserializeOptions);
}
/// <summary>
/// 响应后
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public async Task OnResponseAsync(ApiResponseContext context)
{
if (context.ActionDescriptor.Return.DataType.IsRawType == true)
{
return;
}
var contenType = context.HttpContext.ResponseMessage?.Content.Headers.ContentType;
if (this.EnsureMatchAcceptContentType && this.IsMatchAcceptContentType(contenType) == false)
{
return;
}
await this.ValidateResponseAsync(context).ConfigureAwait(false);
await this.SetResultAsync(context).ConfigureAwait(false);
}
/// <summary>
/// 处理响应上下文
/// </summary>
/// <returns></returns>
private static async Task HandleResponseAsync(ApiResponseContext context)
{
// Return特性请求后执行
var returns = context.ActionDescriptor.Return.Attributes.GetEnumerator();
while (context.ResultStatus == ResultStatus.None && returns.MoveNext())
{
try
{
await returns.Current.OnResponseAsync(context).ConfigureAwait(false);
}
catch (Exception ex)
{
context.Exception = ex;
}
}
// 结果验证
if (context.ResultStatus == ResultStatus.HasResult &&
context.ActionDescriptor.Return.DataType.IsRawType == false &&
context.HttpContext.HttpApiOptions.UseReturnValuePropertyValidate)
{
try
{
DataValidator.ValidateReturnValue(context.Result);
}
catch (Exception ex)
{
context.Exception = ex;
}
}
// GlobalFilter请求后执行
foreach (var filter in context.HttpContext.HttpApiOptions.GlobalFilters)
{
await filter.OnResponseAsync(context).ConfigureAwait(false);
}
// Filter请求后执行
foreach (var filter in context.ActionDescriptor.FilterAttributes)
{
await filter.OnResponseAsync(context).ConfigureAwait(false);
}
}
public async Task EnsureSuccessStatusCodeTest()
{
var apiAction = new DefaultApiActionDescriptor(typeof(ITestApi).GetMethod("JsonXmlAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
context.HttpContext.ResponseMessage.Content = new JsonContent();
context.HttpContext.ResponseMessage.StatusCode = System.Net.HttpStatusCode.InternalServerError;
await Assert.ThrowsAsync <ApiResponseStatusException>(async() =>
{
var attr = new JsonReturnAttribute()
{
EnsureSuccessStatusCode = true
};
await attr.OnResponseAsync(responseContext);
});
}
protected override Task WriteLogAsync(ApiResponseContext context, LogMessage logMessage)
{
ILoggerFactory service = context.HttpContext.ServiceProvider.GetService <ILoggerFactory>();
if (service == null)
{
return(Task.CompletedTask);
}
MethodInfo member = context.ApiAction.Member;
string[] strArray = new string[5];
Type declaringType1 = member.DeclaringType;
strArray[0] = (object)declaringType1 != null ? declaringType1.Namespace : (string)null;
strArray[1] = ".";
Type declaringType2 = member.DeclaringType;
strArray[2] = (object)declaringType2 != null ? declaringType2.Name : (string)null;
strArray[3] = ".";
strArray[4] = member.Name;
string categoryName = string.Concat(strArray);
ILogger logger = service.CreateLogger(categoryName);
if (logMessage.Exception == null)
{
logger.LogDebug(logMessage.ToString());//修改为Debug等级
}
else
{
if (_logError)
{
logger.LogError(logMessage.ToString());
}
else
{
logger.LogDebug(logMessage.ToString());
}
}
return(Task.CompletedTask);
}
/// <summary>
/// 设置强类型模型结果值
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task SetResultAsync(ApiResponseContext context)
{
var response = context.HttpContext.ResponseMessage;
if (response == null || response.Content == null)
{
return;
}
if (context.ApiAction.Return.DataType.IsRawType == false)
{
var json = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var resultType = context.ApiAction.Return.DataType.Type;
var name = context.ApiAction.InterfaceType.FullName;
var options = context.HttpContext.ServiceProvider.GetService <IOptionsMonitor <JsonNetSerializerOptions> >().Get(name);
context.Result = JsonConvert.DeserializeObject(json, resultType, options.JsonDeserializeOptions);
}
}
public async Task JsonResultTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("JsonXmlAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var model = new TestModel();
var json = context.HttpContext.Services.GetRequiredService <IJsonFormatter>().Serialize(model, null);
context.HttpContext.ResponseMessage.Content = new JsonContent(json);
var attr = new JsonReturnAttribute();
await attr.OnResponseAsync(responseContext);
var result = responseContext.Result as TestModel;
Assert.True(model.Name == result.Name && model.Age == result.Age);
}
/// <summary>
/// 写日志到LoggerFactory
/// </summary>
/// <param name="context">上下文</param>
/// <param name="logMessage">日志消息</param>
/// <returns></returns>
protected virtual Task WriteLogAsync(ApiResponseContext context, LogMessage logMessage)
{
var logger = context.GetLogger();
if (logger == null)
{
return(Task.CompletedTask);
}
if (logMessage.Exception == null)
{
logger.LogInformation(logMessage.ToString());
}
else
{
logger.LogError(logMessage.ToString());
}
return(Task.CompletedTask);
}
public async Task XmlResultTest()
{
var apiAction = new ApiActionDescriptor(typeof(ITestApi).GetMethod("JsonXmlAsync"));
var context = new TestRequestContext(apiAction, "laojiu");
var responseContext = new ApiResponseContext(context);
context.HttpContext.RequestMessage.Method = HttpMethod.Post;
var model = new TestModel();
var xml = context.HttpContext.Services.GetRequiredService <IXmlFormatter>().Serialize(model, Encoding.UTF8);
context.HttpContext.ResponseMessage.Content = new XmlContent(xml, Encoding.UTF8);
var attr = new XmlReturnAttribute();
await attr.OnResponseAsync(responseContext, () => Task.CompletedTask);
var result = responseContext.Result as TestModel;
Assert.True(model.Name == result.Name && model.Age == result.Age);
}
/// <summary>
/// 设置结果值
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task SetResultAsync(ApiResponseContext context)
{
var response = context.HttpContext.ResponseMessage;
var dataType = context.ApiAction.Return.DataType;
if (dataType.IsHttpResponseMessage == true)
{
context.Result = response;
}
else if (dataType.IsString == true)
{
context.Result = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
}
else if (dataType.IsByteArray == true)
{
context.Result = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
}
else if (dataType.IsStream == true)
{
context.Result = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
}
}
/// <summary>
/// 写日志到LoggerFactory
/// </summary>
/// <param name="context">上下文</param>
/// <param name="logMessage">日志消息</param>
/// <returns></returns>
protected virtual Task WriteLogAsync(ApiResponseContext context, LogMessage logMessage)
{
var method = context.ApiAction.Member;
var categoryName = $"{method.DeclaringType.Namespace}.{method.DeclaringType.Name}.{method.Name}";
var loggerFactory = context.HttpContext.Services.GetService <ILoggerFactory>();
if (loggerFactory == null)
{
return(Task.CompletedTask);
}
var logger = loggerFactory.CreateLogger(categoryName);
logger.LogInformation(logMessage.ToExcludeException().ToString());
if (logMessage.Exception != null)
{
logger.LogError(logMessage.Exception, logMessage.Exception.Message);
}
return(Task.CompletedTask);
}
/// <summary>
/// 指示是否可以设置结果
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
protected override bool CanSetResult(ApiResponseContext context)
{
return(context.ActionDescriptor.Return.DataType.IsRawType);
}
/// <summary> /// 设置结果值 /// </summary> /// <param name="context">上下文</param> /// <returns></returns> public abstract Task SetResultAsync(ApiResponseContext context);
/// <summary>
/// Http失败状态码异常
/// </summary>
/// <param name="context"></param>
/// <exception cref="ArgumentNullException"></exception>
public HttpStatusFailureException(ApiResponseContext context)
{
this.context = context;
}
/// <summary>
/// 指示是否可以设置结果
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
protected virtual bool CanSetResult(ApiResponseContext context)
{
return(true);
}
/// <summary>
/// 响应后
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public Task OnResponseAsync(ApiResponseContext context)
{
return(this.CanSetResult(context)
? this.SetResultAsync(context)
: Task.CompletedTask);
}
/// <summary>
/// Filter响应后
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
Task IApiFilter.OnResponseAsync(ApiResponseContext context)
{
return(Task.CompletedTask);
}
/// <summary>
/// 设置强类型模型结果值
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task SetResultAsync(ApiResponseContext context)
{
var resultType = context.ApiAction.Return.DataType.Type;
context.Result = await context.JsonDeserializeAsync(resultType).ConfigureAwait(false);
}
/// <summary>
/// 返回响应是否为未授权状态
/// 反回true则强制清除token以支持下次获取到新的token
/// </summary>
/// <param name="context"></param>
protected virtual bool IsUnauthorized(ApiResponseContext context)
{
var response = context.HttpContext.ResponseMessage;
return(response != null && response.StatusCode == HttpStatusCode.Unauthorized);
}
/// <summary>
/// 响应后
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public Task OnResponseAsync(ApiResponseContext context)
{
return(this.SetResultAsync(context));
}
/// <summary>
/// 接口不支持处理响应消息的异常
/// </summary>
/// <param name="context"></param>
/// <exception cref="ArgumentNullException"></exception>
public ApiReturnNotSupportedExteption(ApiResponseContext context)
{
this.Context = context ?? throw new ArgumentNullException(nameof(context));
}
public override Task OnResponseAsync(ApiResponseContext context)
{
//不处理响应的信息
return(Task.CompletedTask);
}
/// <summary> /// 响应后 /// </summary> /// <param name="context">上下文</param> /// <returns></returns> public abstract Task OnResponseAsync(ApiResponseContext context);
