/// <summary>
///
/// </summary>
/// <param name="context"></param>
public Task OnAuthorizationAsync(AuthorizationFilterContext context)
{
var requestLocalizer = context.HttpContext.RequestServices.GetRequiredService <IStringLocalizer <Request> >();
var ctrl = (ControllerActionDescriptor)context.ActionDescriptor;
//匿名不需要验证
var allowAnonymous = ctrl.MethodInfo.IsDefined(typeof(AllowAnonymousAttribute)) ||
ctrl.ControllerTypeInfo.IsDefined(typeof(AllowAnonymousAttribute));
if (allowAnonymous)
{
return(Task.CompletedTask);
}
// 判断当前登录用户
var user = SetPrincipal(context);
if (!user)
{
var content = new ApiResult <string>
{
Status = 203,
Msg = requestLocalizer["No login or login timeout"]
};
ResponseStatusCode.SetResponseStatusCode(content, context.HttpContext.Response);
// 此处不能直接设置Response，要设置Result，后续过滤器才不会往下执行，下游判断Result不为空，直接执行结果，自动写入响应
// 否则此处设置响应流，请求到达控制器，又会执行控制器的结果，因再次写入Response而抛异常
context.Result = new ObjectResult(content);
}
return(Task.CompletedTask);
}
public ModelContainer(T model, ActionType actionType, ResponseStatusCode responseCode, bool isSuccessful = true, ModelContainerErrorMessages errorMessage = ModelContainerErrorMessages.None)
{
Model = model;
ErrorMessage = errorMessage;
ResponseStatusCode = responseCode;
TransformActionData(actionType);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResponseException" /> class.
/// </summary>
/// <param name="statusCode">The status code returned by the server.</param>
/// <param name="statusAttributes">The status attributes from the gremlin response.</param>
/// <param name="message">The error message string.</param>
public ResponseException(ResponseStatusCode statusCode,
IReadOnlyDictionary <string, object> statusAttributes,
string message) : base(message)
{
StatusCode = statusCode;
StatusAttributes = statusAttributes;
}
protected HttpResponse(ResponseStatusCode statusCode)
{
Validator.CheckIfNull(statusCode, nameof(statusCode));
this.HeaderCollection = new HttpHeaderCollection();
this.CookieCollection = new HttpCookieCollection();
this.StatusCode = statusCode;
}
public HttpResponseHeaders(long contentLength, ResponseStatusCode code, IResponseField[] fields, string version)
{
this.ContentLength = contentLength;
this.Status = code;
this.HttpVersion = version;
this.Fields = fields;
this.Buffer = null;
}
public IdentityResultErrorResponse(
ResponseStatusCode statusCode,
IEnumerable <IdentityError> errors,
string message = null
) : base(statusCode, message)
{
Errors = errors.ToList();
}
public UnexpectedResponseException(
ReaderCommand command,
ResponseStatusCode status
) : base($"Response for command {command} returned unexpected status {status}")
{
Command = command;
Status = status;
}
public CommandExecutionFailedException(
ReaderCommand command,
ResponseStatusCode status
) : base($"Response for command {command} returned non success status {status}")
{
Command = command;
Status = status;
}
public IllegalCommandException(
ReaderCommand command,
ResponseStatusCode status
) : base($"Command {command} is illegal for current reader")
{
Command = command;
Status = status;
}
public ResponseModel(string message, bool status, ResponseStatusCode statusCode)
{
if (message == null)
{
message = string.Empty;
}
Message = message;
status = !string.IsNullOrEmpty(message) ? false : true;
StatusCode = statusCode;
}
/// <summary>无权限请求</summary>
/// <param name="filterContext"></param>
protected void HandleUnauthorizedRequest(AuthorizationFilterContext filterContext)
{
var content = new ApiResult <String>
{
Status = 401,
Msg = "No permission" // 没有权限
};
ResponseStatusCode.SetResponseStatusCode(content, filterContext.HttpContext.Response);
// 此处不能直接设置Response，要设置Result，后续过滤器才不会往下执行，下游判断Result不为空，直接执行结果，自动写入响应
// 否则此处设置响应流，请求到达控制器，又会执行控制器的结果，因再次写入Response而抛异常
filterContext.Result = new ObjectResult(content);
}
public static string GetDefaultMessageForStatusCode(ResponseStatusCode responseStatusCode)
{
switch (responseStatusCode)
{
case ResponseStatusCode.Success:
return("");
case ResponseStatusCode.Error:
return("An unexpected error has occurred. Please contact your administrator.");
default:
return(null);
}
}
/// <summary>
/// Create return json
/// </summary>
/// <typeparam name="TRes"></typeparam>
/// <typeparam name="TData"></typeparam>
/// <param name="statusCode"></param>
/// <param name="msg"></param>
/// <param name="data"></param>
/// <param name="totalCount">记录条数,分页时使用</param>
/// <returns></returns>
protected JsonResult CreateResult <TData>(ResponseStatusCode statusCode, string msg = "", TData data = null, int totalCount = 0)
where TData : class
{
ResponseDefault <TData> res = new ResponseDefault <TData>();
res.result = (int)statusCode;
res.msg = msg;
res.count = totalCount;
if (null != data)
{
res.data = data;
}
return(Json(res));
}
/// <summary>
/// get weather data using zip code
/// </summary>
/// <param name="zipCode">zip code</param>
/// <returns>weather data</returns>
public WeatherData GetWeatherByZipCode(int zipCode, out ResponseStatusCode responseStatusCode)
{
var restClient = new RestClient();
restClient.BaseUrl = new Uri(ApiAccess.OPEN_WEATHER_MAP_BASE_URL);
var request = new RestRequest("weather", Method.GET);
request.AddParameter("appid", ApiAccess.OPEN_WEATHER_MAP_KEY);
request.AddParameter("zip", zipCode);
RestApiClientSync syncRestClient = new RestApiClientSync();
WeatherData weatherData = syncRestClient.ExecuteRequest(restClient, request, out responseStatusCode);
return(weatherData);
}
/// <summary>
/// InvokeAsync
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public async Task InvokeAsync(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception e)
{
//记录系统的异常信息
XTrace.WriteException(e);
// 如果已经开始响应到客户端，直接抛出异常，否则下面写入响应也会抛异常
if (context.Response.HasStarted)
{
throw;
}
var data = new ApiResult <String>();
if (e is ApiException apiexc)
{
data.Status = apiexc.Status;
data.Msg = apiexc.Message;
//data.Status = ResponseStatusCode.GetStatusCode(apiexc.Status);
//context.Response.StatusCode = ResponseStatusCode.SetHttpStatusCode ?
// data.Status : 200;
ResponseStatusCode.SetResponseStatusCode(data, context.Response);
}
else
{
data.Msg = e.Message;
data.Status = ResponseStatusCode.GetStatusCode(500);
//context.Response.StatusCode = ResponseStatusCode.SetHttpStatusCode ?
// data.Status : (Int32)HttpStatusCode.InternalServerError;
ResponseStatusCode.SetResponseStatusCode(data, context.Response);
}
context.Response.Headers.Add(HeaderNames.ContentType, "application/json;charset=utf-8");
await context.Response.WriteAsync(JsonConvert.SerializeObject(data), Encoding.UTF8);
}
}
public void ReturnFailedIfMessageNotPushedToMessageQueue(ResponseStatusCode responseStatusCode)
{
//Arrange
messaginQueueHandlerMoq.Setup(mq => mq.PushMessage <PingVehicleModel>(It.IsAny <PingVehicleModel>(), It.IsAny <IModel>())).Returns(new ResponseDetailsBase(responseStatusCode));
var customerService = new MessageQueueHelper(loggerMoq.Object, messaginQueueHandlerMoq.Object);
//Act
var result = customerService.PushMessageToQueue(new VehicleDto()
{
VehicleId = "Test123"
});
//Assert
Assert.Equal(responseStatusCode, result.StatusCode);
}
public override void HandleMessage(Message msg)
{
progressBar.Visibility = ViewStates.Gone;
ResponseStatusCode responseStatusCode = ResponseStatusCode.FromId(msg.What);
if (responseStatusCode == ResponseStatusCode.StartTunnelSuccess)
{
Log.Info(TAG, "Tunnel started successfully!!!");
Toast.MakeText(Application.Context, Resource.String.MvpnTunnelStarted, ToastLength.Short).Show();
}
else if (responseStatusCode == ResponseStatusCode.TunnelAlreadyRunning)
{
Log.Warn(TAG, "Tunnel is already running.");
Toast.MakeText(Application.Context, Resource.String.MvpnTunnelAlreadyRunning, ToastLength.Short).Show();
}
else if (responseStatusCode == ResponseStatusCode.StartTunnelFailed)
{
Log.Error(TAG, "Failed to start tunnel!!!");
Toast.MakeText(Application.Context, Resource.String.MvpnTunnelFailed, ToastLength.Long).Show();
}
else if (responseStatusCode == ResponseStatusCode.SessionExpired)
{
Log.Info(TAG, "Session Expired!!!");
Toast.MakeText(Application.Context, Resource.String.MvpnSessionExpired, ToastLength.Short).Show();
}
else if (responseStatusCode == ResponseStatusCode.FoundLegacyMode)
{
Log.Error(TAG, "Cannot start tunnel for Legacy ManagementMode!!!");
}
else if (responseStatusCode == ResponseStatusCode.FoundNonManagedApp)
{
Log.Error(TAG, "Could not retrieve policies!!! \n This could be because of the following reasons: \n\t 1. SecureHub is not installed.\n\t 2. SecureHub enrollment is not completed.\n\t 3. App is not managed through CEM.");
Toast.MakeText(Application.Context, Resource.String.MvpnNonManagedApp, ToastLength.Long).Show();
}
else if (responseStatusCode == ResponseStatusCode.FoundNonWebssoMode)
{
Log.Error(TAG, "Cannot start tunnel for NetworkAccess mode other than Tunneled - Web SSO!!!");
Toast.MakeText(Application.Context, Resource.String.MvpnNonWebSsoMode, ToastLength.Long).Show();
}
else if (responseStatusCode == ResponseStatusCode.NoNetworkConnection)
{
Log.Error(TAG, "Failed to start tunnel. No Network!!!");
Toast.MakeText(Application.Context, Resource.String.MvpnNoNetworkConnection, ToastLength.Long).Show();
}
}
/// <summary>
/// Returns generic response model T <see cref="IActionResult"/> acording <see cref="ModelContainer<T>.ResponseStatusCode"/>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="mappedResponseModel"></param>
/// <param name="responseStatusCode"></param>
/// <param name="errorMessage"></param>
/// <returns></returns>
private ActionResult ApiActionResult <T>(T mappedResponseModel, ResponseStatusCode responseStatusCode, ModelContainerErrorMessages errorMessage)
{
if (!ModelState.IsValid)
{
return(BadRequest(JsonConvert.SerializeObject(ModelState.Values.Select(e => e.Errors).ToList())));
}
return(responseStatusCode switch
{
ResponseStatusCode.Ok => Ok((mappedResponseModel)),
ResponseStatusCode.Created => Created("", mappedResponseModel),//todo: uri
ResponseStatusCode.Accepted => Accepted(mappedResponseModel),
ResponseStatusCode.NoContent => NoContent(),
ResponseStatusCode.UnprocessableEntity => UnprocessableEntity(errorMessage),
ResponseStatusCode.NotFound => NotFound(errorMessage),
ResponseStatusCode.BadRequest => BadRequest(errorMessage),
_ => throw new Exception("Not implemented Response status code."),
});
public XElement GetResultXElement(string resXmlString)
{
try
{
XElement xe = XElement.Parse(resXmlString);
ResponseStatusCode code = (ResponseStatusCode)Convert.ToInt32(xe.Element("Status").Element("Code").Value);
if (ResponseStatusCode.OK == code)
{
return(xe.Element("Result"));
}
else
{
switch (code)
{
case ResponseStatusCode.BadRequest:
throw new ErrorResponseExp(UIResources.ERROR_400_BadRequest);
case ResponseStatusCode.Conflict:
throw new ErrorResponseExp(UIResources.ERROR_409_Conflict);
case ResponseStatusCode.IntertalServerError:
throw new ErrorResponseExp(UIResources.ERROR_500_IntertalServerError);
case ResponseStatusCode.NotFound:
throw new ErrorResponseExp(UIResources.ERROR_404_NotFound);
case ResponseStatusCode.Unauthorized:
throw new ErrorResponseExp(UIResources.ERROR_401_Unauthorized);
default:
// Should never go here
throw new Exception();
}
}
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// display user error message base on the response status code
/// </summary>
/// <param name="responseStatusCode">response status code</param>
/// <returns>error message</returns>
static string DisplayResponseStatusErrorMessage(ResponseStatusCode responseStatusCode)
{
string errorMessage = "\t*************************************************************************************\n";
switch (responseStatusCode)
{
case ResponseStatusCode.TRANSPORT_ERROR:
errorMessage += "\t\tAn error occurred in the request: network is down, failed DNS lookup, etc \n";
break;
case ResponseStatusCode.UNAUTHORIZED:
errorMessage += "\t\tAn error occurred in the request: key is unauthorized \n";
break;
case ResponseStatusCode.BAD_REQUEST:
errorMessage += "\t\tAn error occurred in the request: the request was malformed\n";
break;
}
errorMessage += "\t*************************************************************************************\n";
return(errorMessage);
}
public static bool IndicatesError(this ResponseStatusCode statusCode)
{
switch (statusCode)
{
case ResponseStatusCode.Success:
case ResponseStatusCode.NoContent:
case ResponseStatusCode.PartialContent:
case ResponseStatusCode.Authenticate:
return(false);
case ResponseStatusCode.Unauthorized:
case ResponseStatusCode.MalformedRequest:
case ResponseStatusCode.InvalidRequestArguments:
case ResponseStatusCode.ServerError:
case ResponseStatusCode.ScriptEvaluationError:
case ResponseStatusCode.ServerTimeout:
case ResponseStatusCode.ServerSerializationError:
return(true);
default:
throw new ArgumentOutOfRangeException(nameof(statusCode), statusCode, null);
}
}
public ViewResponse(ResponseStatusCode statusCode, IView view) : base(statusCode, view)
{
}
public SmartResponseException(string message, ErrorType errorType, ResponseStatusCode statusCode) : base(message)
{
ErrorType = errorType;
StatusCode = statusCode;
}
public SmartResponseException(string message, ResponseStatusCode statusCode) : this(message, ErrorType.Warning, statusCode)
{
}
/// <summary>
/// execute a rest client request
/// </summary>
/// <param name="restClient">rest api client</param>
/// <param name="request">rest api request</param>
/// <returns>weather data object</returns>
/// <out>response status</out>
public WeatherData ExecuteRequest(RestClient restClient, IRestRequest request, out ResponseStatusCode responseStatusCode)
{
WeatherData weatherData = null;
responseStatusCode = ResponseStatusCode.COMPLETE;
var response = restClient.Execute(request);
var content = response.Content;
weatherData = JsonConvert.DeserializeObject <WeatherData>(content);
//
// convert RestSharp error status to application's response status code
//
if (response.ResponseStatus == ResponseStatus.Error)
{
responseStatusCode = ResponseStatusCode.TRANSPORT_ERROR;
}
else if (response.StatusCode == HttpStatusCode.Unauthorized)
{
responseStatusCode = ResponseStatusCode.UNAUTHORIZED;
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
responseStatusCode = ResponseStatusCode.BAD_REQUEST;
}
return(weatherData);
}
/// <summary>
/// 初始化一个<see cref="DataResult"/>类型的新实例
/// </summary>
public DataResult(ResponseStatusCode code, string msg, object data = null)
{
this.Code = code;
this.Msg = msg;
this.Data = data;
}
public ResponseModel(T data, bool status, ResponseStatusCode statusCode)
{
Data = data;
Status = status;
StatusCode = statusCode;
}
public void SetMessage(ResponseStatusCode code, string message)
{
SetMessage(code.ToInt().ToString(), message);
}
public void SetMessage(ResponseStatusCode code)
{
SetMessage(code, code.ToAlias());
}
public HttpResponse(ResponseStatusCode statusCode)
{
this.StatusCode = statusCode;
this.Header = new Header(HeaderType.HttpResponse);
this.Content = new byte[10];
}
private async Task <RavenJToken> CheckForErrorsAndReturnCachedResultIfAnyAsync(bool readErrorString)
{
if (Response.IsSuccessStatusCode)
{
return(null);
}
if (ResponseStatusCode == HttpStatusCode.Unauthorized ||
ResponseStatusCode == HttpStatusCode.NotFound ||
ResponseStatusCode == HttpStatusCode.Conflict)
{
if (factory.CanLogRequest)
{
factory.OnLogRequest(owner, new RequestResultArgs
{
DurationMilliseconds = CalculateDuration(),
Method = Method,
HttpResult = (int)ResponseStatusCode,
Status = RequestStatus.ErrorOnServer,
Result = ResponseStatusCode.ToString(),
Url = Url,
PostedData = postedData
});
}
throw ErrorResponseException.FromResponseMessage(Response, readErrorString);
}
if (ResponseStatusCode == HttpStatusCode.NotModified &&
CachedRequestDetails != null)
{
factory.UpdateCacheTime(this);
var result = factory.GetCachedResponse(this, ResponseHeaders);
// here we explicitly need to get Response.Headers, and NOT ResponseHeaders because we are
// getting the value _right now_ from the secondary, and don't care about the 304, the force check
// is still valid
HandleReplicationStatusChanges(ResponseHeaders, primaryUrl, operationUrl);
if (factory.CanLogRequest)
{
factory.OnLogRequest(owner, new RequestResultArgs
{
DurationMilliseconds = CalculateDuration(),
Method = Method,
HttpResult = (int)ResponseStatusCode,
Status = RequestStatus.Cached,
Result = result.ToString(),
Url = Url,
PostedData = postedData
});
}
return(result);
}
using (var sr = new StreamReader(await Response.GetResponseStreamWithHttpDecompression().ConfigureAwait(false)))
{
var readToEnd = sr.ReadToEnd();
if (factory.CanLogRequest)
{
factory.OnLogRequest(owner, new RequestResultArgs
{
DurationMilliseconds = CalculateDuration(),
Method = Method,
HttpResult = (int)ResponseStatusCode,
Status = RequestStatus.Cached,
Result = readToEnd,
Url = Url,
PostedData = postedData
});
}
if (string.IsNullOrWhiteSpace(readToEnd))
{
throw ErrorResponseException.FromResponseMessage(Response);
}
RavenJObject ravenJObject;
try
{
ravenJObject = RavenJObject.Parse(readToEnd);
}
catch (Exception e)
{
throw new ErrorResponseException(Response, readToEnd, e);
}
if (ravenJObject.ContainsKey("IndexDefinitionProperty"))
{
throw new IndexCompilationException(ravenJObject.Value <string>("Message"))
{
IndexDefinitionProperty = ravenJObject.Value <string>("IndexDefinitionProperty"),
ProblematicText = ravenJObject.Value <string>("ProblematicText")
};
}
//else if (ravenJObject.ContainsKey())
if (ResponseStatusCode == HttpStatusCode.BadRequest && ravenJObject.ContainsKey("Message"))
{
throw new BadRequestException(ravenJObject.Value <string>("Message"), ErrorResponseException.FromResponseMessage(Response));
}
if (ravenJObject.ContainsKey("Error"))
{
var errorValue = ravenJObject.Value <string>("Error");
if (errorValue != null && errorValue.StartsWith("System.TimeoutException"))
{
throw new TimeoutException(errorValue.Substring("System.TimeoutException: ".Length));
}
var sb = new StringBuilder();
foreach (var prop in ravenJObject)
{
if (prop.Key == "Error")
{
continue;
}
sb.Append(prop.Key).Append(": ").AppendLine(prop.Value.ToString(Formatting.Indented));
}
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.Append(errorValue);
throw new ErrorResponseException(Response, sb.ToString(), readToEnd);
}
throw new ErrorResponseException(Response, readToEnd);
}
}
