private async Task <IActionResult> FileResponseHelper(string fileId, string fileType)
{
var _asbestosActions = new AsbestosActions(_asbestosService, _loggerActions);
try
{
if (!IdValidator.ValidateId(fileId))
{
var developerMessage = $"Invalid parameter - file id";
var userMessage = "Please provide a valid file id";
return(new ErrorResponseBuilder().BuildErrorResponse(
userMessage, developerMessage, (int)HttpStatusCode.BadRequest));
}
var response = await _asbestosActions.GetFile(fileId, fileType);
return(File(response.Data, response.ContentType));
}
catch (MissingFileException ex)
{
var developerMessage = ex.Message;
var userMessage = "Cannot find file";
return(new ErrorResponseBuilder().BuildErrorResponse(
userMessage, developerMessage, (int)HttpStatusCode.NotFound));
}
catch (Exception ex)
{
var userMessage = "We had some problems processing your request";
return(new ErrorResponseBuilder().BuildErrorResponseFromException(
ex, userMessage));
}
}
public async Task get_room_throws_expected_custom_exeption()
{
Room fakeEmptyResponse = null;
fakeAsbestosService
.Setup(m => m.GetRoom(It.IsAny <string>()))
.Returns(Task.FromResult(fakeEmptyResponse));
var asbestosAction = new AsbestosActions(fakeAsbestosService.Object, fakeLogger.Object);
await Assert.ThrowsAsync <MissingRoomException>(
async() => await asbestosAction.GetRoom(fakeId));
}
public async Task get_inspection_throws_expected_custom_exeption()
{
var fakeEmptyResponse = new List <Inspection>();
fakeAsbestosService
.Setup(m => m.GetInspection(It.IsAny <string>()))
.Returns(Task.FromResult <IEnumerable <Inspection> >(fakeEmptyResponse));
var asbestosAction = new AsbestosActions(fakeAsbestosService.Object, fakeLogger.Object);
await Assert.ThrowsAsync <MissingInspectionException>(
async() => await asbestosAction.GetInspection(fakeId));
}
public async Task get_file_throws_expected_custom_exeption()
{
var fakeEmptyResponse = new FileContainer();
fakeAsbestosService
.Setup(m => m.GetFile(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(fakeEmptyResponse));
var asbestosAction = new AsbestosActions(fakeAsbestosService.Object, fakeLogger.Object);
await Assert.ThrowsAsync <MissingFileException>(
async() => await asbestosAction.GetFile(fakeId, null));
}
public async Task return_type_should_be_floor()
{
var fakeResponse = new Floor();
fakeAsbestosService
.Setup(m => m.GetFloor(It.IsAny <string>()))
.Returns(Task.FromResult(fakeResponse));
var asbestosAction = new AsbestosActions(fakeAsbestosService.Object, fakeLogger.Object);
var response = await asbestosAction.GetFloor(fakeId);
Assert.True(response is Floor);
}
public async Task return_type_should_be_file_container()
{
var fakeResponse = Fake.GenerateFakeFile(null);
fakeAsbestosService
.Setup(m => m.GetFile(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(fakeResponse));
var asbestosAction = new AsbestosActions(fakeAsbestosService.Object, fakeLogger.Object);
var response = await asbestosAction.GetFile(fakeId, null);
Assert.True(response is FileContainer);
}
public async Task return_type_should_be_list_of_documents()
{
var fakeResponse = Fake.GenerateDocument(123, null);
fakeAsbestosService
.Setup(m => m.GetDocument(It.IsAny <string>(), It.IsAny <string>()))
.Returns(Task.FromResult(fakeResponse));
var asbestosAction = new AsbestosActions(fakeAsbestosService.Object, fakeLogger.Object);
var response = await asbestosAction.GetDocument(fakeId, null);
Assert.True(response is List <Document>);
}
public async Task return_type_should_be_list_of_inspections()
{
var fakeResponse = new List <Inspection>()
{
new Inspection()
};
fakeAsbestosService
.Setup(m => m.GetInspection(It.IsAny <string>()))
.Returns(Task.FromResult <IEnumerable <Inspection> >(fakeResponse));
var asbestosAction = new AsbestosActions(fakeAsbestosService.Object, fakeLogger.Object);
var response = await asbestosAction.GetInspection(fakeId);
Assert.True(response is List <Inspection>);
}
private async Task <JsonResult> DocumentResponseHelper(string propertyId, string fileType)
{
var _asbestosActions = new AsbestosActions(_asbestosService, _loggerActions);
try
{
if (propertyId == null)
{
var developerMessage = $"Missing parameter - propertyId or file id";
var userMessage = "Please provide a valid property id or file id";
return(new ErrorResponseBuilder().BuildErrorResponse(
userMessage, developerMessage, (int)HttpStatusCode.BadRequest));
}
if (!IdValidator.ValidatePropertyId(propertyId))
{
var developerMessage = $"Invalid parameter - propertyId";
var userMessage = "Please provide a valid property id";
return(new ErrorResponseBuilder().BuildErrorResponse(
userMessage, developerMessage, (int)HttpStatusCode.BadRequest));
}
var response = await _asbestosActions.GetDocument(propertyId, fileType);
return(new DocumentResponseBuilder().BuildSuccessResponse(response));
}
catch (MissingDocumentException ex)
{
var developerMessage = ex.Message;
var userMessage = "Cannot find document";
return(new ErrorResponseBuilder().BuildErrorResponse(
userMessage, developerMessage, (int)HttpStatusCode.NotFound));
}
catch (Exception ex)
{
var userMessage = "We had some problems processing your request";
return(new ErrorResponseBuilder().BuildErrorResponseFromException(
ex, userMessage));
}
}
public async Task <JsonResult> GetRoom(string roomId)
{
var responseBuilder = new RoomResponseBuilder();
try
{
_logger.LogInformation($"Calling ValidateId() with {roomId}");
if (!IdValidator.ValidateId(roomId))
{
_logger.LogError("roomId has not passed validation");
var developerMessage = "Invalid parameter - roomId";
var userMessage = "Please provide a valid room id";
return(responseBuilder.BuildErrorResponse(
userMessage, developerMessage, 400));
}
var _asbestosActions = new AsbestosActions(_asbestosService, _loggerActions);
var response = await _asbestosActions.GetRoom(roomId);
return(responseBuilder.BuildSuccessResponse(response));
}
catch (MissingRoomException ex)
{
_logger.LogError("No room returned for roomId");
var developerMessage = ex.Message;
var userMessage = "Cannot find room";
return(responseBuilder.BuildErrorResponse(
userMessage, developerMessage, 404));
}
catch (Exception ex)
{
var userMessage = "We had some problems processing your request";
return(responseBuilder.BuildErrorResponseFromException(ex, userMessage));
}
}
public async Task <JsonResult> GetElement(string elementId)
{
try
{
var responseBuilder = new ElementResponseBuilder();
_logger.LogInformation($"Calling ValidateId() with {elementId}");
if (!IdValidator.ValidateId(elementId))
{
_logger.LogError("elementId has not passed validation");
var developerMessage = "Invalid parameter - elementId";
var userMessage = "Please provide a valid element id";
return(responseBuilder.BuildErrorResponse(
userMessage, developerMessage, 400));
}
var _asbestosActions = new AsbestosActions(_asbestosService, _loggerActions);
var response = await _asbestosActions.GetElement(elementId);
return(responseBuilder.BuildSuccessResponse(response));
}
catch (MissingElementException ex)
{
_logger.LogError("No element returned for elementId");
var developerMessage = ex.Message;
var userMessage = "Cannot find element";
var responseBuilder = new ElementResponseBuilder();
return(responseBuilder.BuildErrorResponse(
userMessage, developerMessage, 404));
}
catch (Exception ex)
{
return(BuildErrorResponseFromException(ex));
}
}
