public override void OnException(HttpActionExecutedContext context)
{
HttpStatusCode status = HttpStatusCode.InternalServerError;
var exType = context.Exception.GetType();
if (exType == typeof(UnauthorizedAccessException))
{
status = HttpStatusCode.Unauthorized;
}
else if (exType == typeof(ArgumentException))
{
status = HttpStatusCode.NotFound;
}
var apiError = new ApiErrorMessage()
{
RequestUri = context.Request.RequestUri.ToString(),
Method = context.Request.Method.ToString(),
PostData = JsonConvert.SerializeObject(context.ActionContext.ActionArguments.Values),
Exception = context.Exception.Message
};
// create a new response and attach our ApiError object
// which now gets returned on ANY exception result
var errorResponse = context.Request.CreateResponse(status, apiError);
context.Response = errorResponse;
base.OnException(context);
}
public ValidationResult ValidateAddressesLPIKey(string lpikey)
{
List <ApiErrorMessage> myErrors = new List <ApiErrorMessage>();
bool hasError = false;
lpikey = lpikey.Replace(" ", "");
if (lpikey.Length < 10)
{
var error = new ApiErrorMessage
{
developerMessage = "LPIKey is invalid, length should be > 10.",
userMessage = "LPIKey is invalid, length should be > 10."
};
myErrors.Add(error);
}
ValidationResult validationObject = new ValidationResult();
validationObject.ErrorOccurred = hasError;
validationObject.ErrorMessages = myErrors;
return(validationObject);
}
public ApiErrorMessage ValidateStreetName(string streetName)
{
if (streetName.Length > 100 || streetName.Length < 3)
{
var error = new ApiErrorMessage
{
developerMessage = "Street Name is invalid, length should be < 100 Char and > 3 Char.",
userMessage = "Street Name is invalid, length should be < 100 Char and > 3 Char."
};
return(error);
}
return(null);
}
private ObjectContent <ApiErrorMessage> CreateApiResponse(HttpActionExecutedContext context)
{
var apiErrorMessage = new ApiErrorMessage
{
ErrorMessage = context.Exception.Message,
ErrorType = context.Exception.GetType().ToString()
};
if (context.Exception is AggregateException)
{
apiErrorMessage = new ApiErrorMessage
{
ErrorMessage = context.Exception.InnerException.Message,
ErrorType = string.Format("{0}, {1}", context.Exception.GetType(), context.Exception.InnerException.GetType())
};
}
return(new ObjectContent <ApiErrorMessage>(apiErrorMessage, new JsonMediaTypeFormatter()));
}
public async Task <JsonResult> Post(string workOrderReference, [FromBody] ScheduleAppointmentRequest request)
{
try
{
var validationResult = _scheduleBookingRequestValidator.Validate(workOrderReference, request);
if (validationResult.Valid)
{
var appointmentsActions = new AppointmentActions(_loggerAdapter, _appointmentsService,
_serviceRequestBuilder, _repairsService, _repairsServiceRequestBuilder);
var result = await appointmentsActions.BookAppointment(workOrderReference,
DateTime.Parse(request.BeginDate),
DateTime.Parse(request.EndDate));
var json = Json(result);
json.StatusCode = 200;
json.ContentType = "application/json";
return(json);
}
else
{
var errors = validationResult.ErrorMessages.Select(error => new ApiErrorMessage
{
developerMessage = error,
userMessage = error
}).ToList();
var jsonResponse = Json(errors);
jsonResponse.StatusCode = 400;
return(jsonResponse);
}
}
catch (Exception e)
{
var errorMessage = new ApiErrorMessage
{
developerMessage = e.Message,
userMessage = "We had some problems processing your request"
};
var jsonResponse = Json(errorMessage);
jsonResponse.StatusCode = 500;
return(jsonResponse);
}
}
public void Test_ApiErrorResult_Instance(string key, string message)
{
// Arrange
var serviceProviderMock = new Mock <IServiceProvider>();
serviceProviderMock.Setup(serviceProvider =>
serviceProvider.GetService(typeof(ILogger <ValidateModelAttribute>)))
.Returns(Mock.Of <ILogger <ValidateModelAttribute> >());
var httpContext = new DefaultHttpContext {
RequestServices = serviceProviderMock.Object
};
// Act
var err = new ApiErrorResult(new Exception(message), key);
var servErr = new InternalServerErrorResult(new Exception(message));
var res = httpContext.Response;
var req = httpContext.Request;
var apiError = new ApiErrorMessage("", "");
apiError = new ApiErrorMessage(null, "");
apiError = new ApiErrorMessage("test", "");
// Assert
err.Message.Should().Be(key);
err.Errors.Count.Should().Be(1);
err.Errors[0].Message.Should().Be(message);
servErr.StatusCode.Should().Be(500);
Assert.IsType <ApiErrorResult>(servErr.Value);
res.Headers.Add(key, message);
res.StatusCode = 200;
res.Body = new MemoryStream(Encoding.ASCII.GetBytes(message));
res.ToFormattedString().Length.Should().BeGreaterThan(0);
req.Headers.Add(key, message);
req.Body = new MemoryStream(Encoding.ASCII.GetBytes(message));
req.ToFormattedString().Length.Should().BeGreaterThan(0);
}
private void ConfigJwtAuthentication(IServiceCollection services)
{
var symmetricKey = Convert.FromBase64String(EncryptionUtil.ToBase64Encode("123456abcdefqwer"));
services.AddAuthentication(x =>
{
x.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(symmetricKey),
ValidateIssuer = false,
ValidateAudience = false,
ValidateLifetime = true,
ClockSkew = TimeSpan.Zero
};
x.Events = new JwtBearerEvents()
{
OnAuthenticationFailed = async context =>
{
Console.WriteLine("ABCDDDDDDDDDDDDDDDDDDD");
var apiErrorMessage = new ApiErrorMessage();
var statusCode = HttpStatusCode.Unauthorized;
if (context.Exception is SecurityTokenExpiredException)
{
apiErrorMessage.ErrorCode = (int)ErrorCodeEnum.ACCESS_TOKEN_IS_EXPIRED;
apiErrorMessage.ErrorMessage = ErrorMessageConstant.ACCESS_TOKEN_IS_EXPIRED;
}
else
{
apiErrorMessage.ErrorCode = (int)ErrorCodeEnum.ACCESS_TOKEN_IS_INVALID;
apiErrorMessage.ErrorMessage = ErrorMessageConstant.ACCESS_TOKEN_IS_INVALID;
statusCode = (HttpStatusCode.Forbidden);
}
var apiResponseException = new ApiResponseException()
{
ErrorMessages = new List <ApiErrorMessage>
{
apiErrorMessage
},
StatusCode = statusCode
};
var apiResponse = new ApiSingleResponse <string>()
{
Data = null,
Errors = apiResponseException.ErrorMessages
};
context.Response.StatusCode = (int)statusCode;
context.Response.ContentType = "application/json";
await context.Response.WriteAsync(JsonSerializer.Serialize(apiResponse, new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
}));
}
};
});
}
