public override void OnException(HttpActionExecutedContext context)
{
if (context.Exception != null)
{
var jsonFieldsSerializer = EngineContext.Current.Resolve <IJsonFieldsSerializer>();
var errors = new Dictionary <string, List <string> >()
{
{
"server_error",
new List <string>()
{
"Please contact the store owner!"
}
}
};
var logger = EngineContext.Current.Resolve <ILogger>();
logger.Error(context.Exception.Message, context.Exception);
var errorsRootObject = new ErrorsRootObject()
{
Errors = errors
};
var errorsJson = jsonFieldsSerializer.Serialize(errorsRootObject, null);
var errorResult = new ErrorActionResult(errorsJson, HttpStatusCode.InternalServerError);
context.Response = errorResult.ExecuteAsync(new CancellationToken()).Result;
}
}
private async Task <IRootObject> Query(string url)
{
if (!string.IsNullOrEmpty(_sortingAttribute) && _endpoint != Endpoint.Status.ToString())
{
if (!url.Contains("?"))
{
url += "?";
}
url += "sort=";
if (!_sortingOrder)
{
url += "-";
}
url += _sortingAttribute;
}
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(_apiUrl);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Authorization", _apiKey);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/vnd.api+json"));
HttpResponseMessage response = await client.GetAsync(url);
_status = (int)response.StatusCode;
_statusText = response.StatusCode.ToString();
string jsonString = await response.Content.ReadAsStringAsync();
ResponseRootObject returnObject = null;
if (_isSuccessStatusCode = response.IsSuccessStatusCode)
{
ResponseRootObject responseData = (ResponseRootObject)JsonConvert.DeserializeObject(jsonString);
returnObject = Helpers.ConvertToEndpointType(responseData, (Endpoint)Enum.Parse(typeof(Endpoint), _endpoint));
_rootObject = returnObject;
_nextUrl = returnObject.Links.Next.Replace(_apiUrl, "");
_previousUrl = returnObject.Links.Previous.Replace(_apiUrl, "");
_firstUrl = returnObject.Links.First.Replace(_apiUrl, "");
return(responseData);
}
else
{
ErrorsRootObject responseError = (ErrorsRootObject)JsonConvert.DeserializeObject(jsonString);
//TODO: Error handling including throttling (errorcode 4XX)
return(responseError);
}
}
}
private void SetError(ActionExecutedContext actionExecutedContext, KeyValuePair <string, List <string> > error)
{
var bindingError = new Dictionary <string, List <string> > {
{ error.Key, error.Value }
};
var errorsRootObject = new ErrorsRootObject
{
Errors = bindingError
};
var errorJson = _jsonFieldsSerializer.Serialize(errorsRootObject, null);
actionExecutedContext.Result = new ErrorActionResult(errorJson, HttpStatusCode.BadRequest);
}
protected IHttpActionResult Error(HttpStatusCode statusCode = (HttpStatusCode)422, string propertyKey = "", string errorMessage = "")
{
var errors = new Dictionary <string, List <string> >();
if (!string.IsNullOrEmpty(errorMessage) && !string.IsNullOrEmpty(propertyKey))
{
var errorsList = new List <string>()
{
errorMessage
};
errors.Add(propertyKey, errorsList);
}
foreach (var item in ModelState)
{
var errorMessages = item.Value.Errors.Select(x => x.ErrorMessage);
List <string> validErrorMessages = new List <string>();
if (errorMessages != null)
{
validErrorMessages.AddRange(errorMessages.Where(message => !string.IsNullOrEmpty(message)));
}
if (validErrorMessages.Count > 0)
{
if (errors.ContainsKey(item.Key))
{
errors[item.Key].AddRange(validErrorMessages);
}
else
{
errors.Add(item.Key, validErrorMessages.ToList());
}
}
}
var errorsRootObject = new ErrorsRootObject()
{
Errors = errors
};
var errorsJson = _jsonFieldsSerializer.Serialize(errorsRootObject, null);
return(new ErrorActionResult(errorsJson, statusCode));
}
static void Main(string[] args)
{
PUBGApiClient client = new PUBGApiClient(Shards.PcAsia, Endpoint.Matches);
var taskObj = client.CallEndpointAsync();
if (taskObj.Result.GetType() == typeof(ErrorsRootObject))
{
ErrorsRootObject result = null;
result = (ErrorsRootObject)taskObj.Result;
Console.WriteLine(result.Errors.FirstOrDefault().Title);
}
else if (taskObj.Result.GetType() == typeof(ResponseRootObject))
{
//do something
}
Console.ReadKey();
}
protected async Task <IActionResult> Error(
HttpStatusCode statusCode = (HttpStatusCode)422,
string propertyKey = "",
string errorMessage = "")
{
var errors = new Dictionary <string, List <string> >();
if (!string.IsNullOrEmpty(errorMessage) && !string.IsNullOrEmpty(propertyKey))
{
var errorsList = new List <string>()
{
errorMessage
};
errors.Add(propertyKey, errorsList);
}
foreach (var model in ModelState)
{
var errorMessages = model.Value.Errors.Select(m => m.ErrorMessage);
var validErrorMessages = new List <string>();
validErrorMessages.AddRange(errorMessages.Where(message => !string.IsNullOrEmpty(message)));
if (validErrorMessages.Count > 0)
{
if (errors.ContainsKey(model.Key))
{
errors[model.Key].AddRange(validErrorMessages);
}
else
{
errors.Add(model.Key, validErrorMessages.ToList());
}
}
}
var errorsRootObject = new ErrorsRootObject {
Errors = errors
};
var errorsJson = JsonFieldsSerializer.Serialize(errorsRootObject, null);
return(await Task.FromResult <IActionResult>(new ErrorActionResult(errorsJson, statusCode)));
}
private void SetError(ActionExecutedContext actionExecutedContext, KeyValuePair <string, List <string> > error)
{
var bindingError = new Dictionary <string, List <string> >
{
{
error.Key, error.Value
}
};
var errorsRootObject = new ErrorsRootObject
{
Errors = bindingError
};
var errorJson = _jsonFieldsSerializer.Serialize(errorsRootObject, null);
var response = new ContentResult();
response.Content = errorJson;
response.ContentType = "application/json";
response.StatusCode = (int)HttpStatusCode.InternalServerError;
actionExecutedContext.Result = response;
}
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
{
if (actionExecutedContext.Response != null && actionExecutedContext.Response.StatusCode != HttpStatusCode.OK)
{
var content = actionExecutedContext.Response.Content.ReadAsStringAsync().Result;
DefaultWeApiErrorsModel defaultWebApiErrorsModel = JsonConvert.DeserializeObject <DefaultWeApiErrorsModel>(content);
// If both are null this means that it is not the default web api error format,
// which means that it the error is formatted by our standard and we don't need to do anything.
if (!string.IsNullOrEmpty(defaultWebApiErrorsModel.Message) &&
!string.IsNullOrEmpty(defaultWebApiErrorsModel.MessageDetail))
{
Dictionary <string, List <string> > bindingError = new Dictionary <string, List <string> >()
{
{
"lookup_error",
new List <string>()
{
"not found"
}
}
};
var errorsRootObject = new ErrorsRootObject()
{
Errors = bindingError
};
var errorJson = _jsonFieldsSerializer.Serialize(errorsRootObject, null);
actionExecutedContext.Response = actionExecutedContext.Request.CreateResponse(
HttpStatusCode.BadRequest, errorJson);
}
}
base.OnActionExecuted(actionExecutedContext);
}
