public async Task <ActionResult <TheatreDomainModel> > DeleteAsync(int id)
{
TheatreDomainModel deletedTheatre;
try
{
deletedTheatre = await _theatreService.Delete(id);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (deletedTheatre == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.THEATRE_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Accepted("theatres//" + deletedTheatre.Id, deletedTheatre));
}
public ActionResult <ReservationResultModel> MakeReservation([FromBody] CreateReservationModel model)
{
ReservationResultModel res;
try
{
res = _reservationService.CreateReservation(model);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (!res.IsSuccessful)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = res.ErrorMessage,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Created("reservations//" + res.Reservation.Id, res));
}
public void MovieTagsController_DeleteByMovieIdTagId_ServiceReturnsNull()
{
//Arrange
MovieTagsDomainModel movieTags = null;
Task <MovieTagsDomainModel> responseTask = Task.FromResult(movieTags);
string expectedMessage = Messages.MOVIETAG_DOES_NOT_EXIST;
int expectedStatusCode = 500;
ErrorResponseModel errorResponseModel = new ErrorResponseModel();
errorResponseModel.ErrorMessage = expectedMessage;
errorResponseModel.StatusCode = System.Net.HttpStatusCode.InternalServerError;
MovieTagsController movieTagsController = new MovieTagsController(_mockMovieTagService.Object);
_mockMovieTagService.Setup(x => x.DeleteByMovieIdTagId(It.IsAny <Guid>(), It.IsAny <int>())).Returns(responseTask);
//Act
var result = movieTagsController.DeleteByMovieIdTagId(_movieTagDomainModel.MovieId, _movieTagDomainModel.TagId).ConfigureAwait(false).GetAwaiter().GetResult();
ObjectResult viewResult = (ObjectResult)result;
//Assert
Assert.IsNotNull(result);
Assert.AreEqual(viewResult.Value.ToString(), errorResponseModel.ToString());
Assert.AreEqual(viewResult.StatusCode, expectedStatusCode);
}
public async Task <ActionResult <ShowDomainModel> > DeleteShow(int id)
{
ShowDomainModel deletedPiece;
try
{
deletedPiece = await _showService.DeleteShow(id);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (deletedPiece == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.CANNOT_DELETE_SHOW,
StatusCode = System.Net.HttpStatusCode.InternalServerError
};
return(BadRequest(errorResponse));
}
return(Accepted("pieces//" + deletedPiece.Id, deletedPiece));
}
public async Task <ActionResult> Delete(int id)
{
DeleteAuditoriumResultModel deleteAudit;
try
{
deleteAudit = await _auditoriumService.DeleteAuditorium(id);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (deleteAudit.IsSuccessful.Equals(false))
{
ErrorResponseModel errorResponse = new ErrorResponseModel()
{
ErrorMessage = deleteAudit.ErrorMessage,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Accepted("auditorium//" + deleteAudit.Auditorium.Id, deleteAudit.Auditorium));
}
public async Task <ActionResult> Delete(int id)
{
CinemaDomainModel deletedCinema;
try
{
deletedCinema = await _cinemaService.DeleteCinema(id);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (deletedCinema == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.MOVIE_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.InternalServerError
};
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, errorResponse));
}
return(Accepted("cinemas//" + deletedCinema.Id, deletedCinema));
}
public async Task <ActionResult> PutCurrent(Guid id)
{
MovieDomainModel movieToUpdate;
movieToUpdate = await _movieService.GetMovieByIdAsync(id);
var movieWithProjections = await _projectionsService.GetProjectionByMovieId(id);
if (movieToUpdate == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.MOVIE_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (movieWithProjections != null && movieWithProjections.Count() != 0)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.MOVIE_DOES_NOT_EXIST_OR_HAVE_PROJECTIONS,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
movieToUpdate.Title = movieToUpdate.Title;
if (movieToUpdate.Current == true)
{
movieToUpdate.Current = false;
}
else
{
movieToUpdate.Current = true;
}
movieToUpdate.Year = movieToUpdate.Year;
movieToUpdate.Rating = movieToUpdate.Rating;
MovieDomainModel movieDomainModel;
try
{
movieDomainModel = await _movieService.UpdateMovie(movieToUpdate);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Accepted("movies//" + movieDomainModel.Id, movieDomainModel));
}
public override string Execute(string jsonStr)
{
string returnJsonStr = string.Empty;
DBRepository dBRepository = new DBRepository();
try
{
UserLogoutModel model = JsonSerializer.Deserialize <UserLogoutModel>(jsonStr);
UserInfo userInfo = WebSocketManager.UserInfoDict[model.Token];
dBRepository.UserLogoutSP(userInfo.UserName);
BaseResponseModel responseModel = new BaseResponseModel();
responseModel.StatusCode = 1;
returnJsonStr = JsonSerializer.Serialize(responseModel);
WebSocketManager.RemoveUserInfoAndWebSocket(model.Token);
}
catch (Exception ex)
{
ErrorResponseModel responseModel = new ErrorResponseModel();
responseModel.StatusCode = 0;
responseModel.ErrorCode = "500";
responseModel.Message = ex.Message;
returnJsonStr = JsonSerializer.Serialize(responseModel);
}
return(returnJsonStr);
}
protected HttpResponseMessage CreateResponse <T>(HttpStatusCode statusCode, ErrorResponseModel error, MessageDataModel messageData,
T data, int?pageNumber = null, int?pageSize = null, int?totalRecordCount = null)
{
var response = new ResponseModel <T>
{
Error = error,
MessageDetails = messageData,
Result = new ResultResponseModel <T>
{
Data = data,
Paging = null
}
};
if (pageNumber.HasValue && pageSize.HasValue && totalRecordCount.HasValue)
{
response.Result.Paging = new PagingInfo()
{
PageNumber = pageNumber.Value,
PageSize = pageSize.Value,
TotalRecordCount = totalRecordCount.Value,
TotalPageCount = totalRecordCount.Value > 0
? (int)Math.Ceiling(totalRecordCount.Value / (double)pageSize.Value)
: 0
};
}
return(CreateResponse(statusCode, response));
}
public async Task <ActionResult> Delete(Guid id)
{
ProjectionDomainModel deletedProjection;
try
{
deletedProjection = await _projectionService.DeleteProjection(id);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (deletedProjection == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.PROJECTION_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.InternalServerError
};
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, errorResponse));
}
return(Accepted("movies//" + deletedProjection.Id, deletedProjection));
}
public async Task <ActionResult <ActorDomainModel> > AddActor([FromBody] ActorModel actorModel)
{
ActorDomainModel domainModel = new ActorDomainModel
{
FirstName = actorModel.FirstName,
LastName = actorModel.LastName
};
ActorDomainModel createActor;
try
{
createActor = await _actorService.AddActor(domainModel);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (createActor == null)
{
return(BadRequest(Messages.ACTOR_CREATION_ERROR));
}
return(CreatedAtAction(nameof(GetActorById), new { Id = createActor.Id }, createActor));
}
public async Task <ActionResult> Delete(int id)
{
PieceDomainModel deletedPiece;
try
{
deletedPiece = await _pieceService.DeletePiece(id);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (deletedPiece == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.PIECE_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.InternalServerError
};
return(BadRequest(errorResponse));
}
return(Accepted("pieces//" + deletedPiece.Id, deletedPiece));
}
public async Task <ActionResult <IEnumerable <ReservationDomainModel> > > DeleteByProjectionId(Guid projectionId)
{
IEnumerable <ReservationDomainModel> deletedReservations;
try
{
deletedReservations = await _reservationService.DeleteByProjectionId(projectionId);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (deletedReservations == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.RESERVATION_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.InternalServerError
};
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, errorResponse));
}
return(Accepted(deletedReservations));
}
/// <summary>
/// Action executing.
/// </summary>
/// <param name="context">Executing context.</param>
/// <param name="next">Executing delegate.</param>
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (!context.ModelState.IsValid)
{
var errorsInModelState = context.ModelState
.Where(x => x.Value.Errors.Count > 0)
.ToDictionary(pair => pair.Key, pair => pair.Value.Errors.Select(x => x.ErrorMessage))
.ToArray();
var errorResponse = new ErrorResponseModel();
foreach (var error in errorsInModelState)
{
foreach (var subError in error.Value)
{
errorResponse.Errors.Add(new ValidationResponseModel
{
FieldName = error.Key,
Message = subError
});
}
}
context.Result = ResponseResult
.InitializeFactories()
.ExecuteCreation(ResponseTypeEnum.Error, HttpStatusCode.BadRequest)
.Build(errorResponse);
return;
}
await next();
}
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
if (!context.ModelState.IsValid)
{
var errorsInModelState = context.ModelState
.Where(x => x.Value.Errors.Count > 0)
.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Errors.Select(x => x.ErrorMessage)).ToArray();
var errorResponse = new ErrorResponseModel();
foreach (var error in errorsInModelState)
{
foreach (var subError in error.Value)
{
var errorModel = new ErrorModel
{
FieldName = error.Key,
Message = subError
};
errorResponse.Errors.Add(errorModel);
}
}
context.Result = new BadRequestObjectResult(errorResponse);
return;
}
await next();
}
public override async Task <IActionResult> HandleAsync(HttpRequest req, ILogger log)
{
try
{
AllRecordsResponseModel records = await _recordService.GetRecordsAsync();
var result = records
.Records
.GroupBy(r => r.Artist)
.Select(
gr => new
{
Artist = gr.Key,
Titles = gr.ToList()
.Select(
t => new
{
song = t.Song,
timestamp = t.Timestamp
})
});
return(new ObjectResult(result)
{
StatusCode = 200
});
}
catch (Exception e)
{
return(new ObjectResult(ErrorResponseModel.FromInternal(e.Message)));
}
}
public async Task OnExceptionAsync(ExceptionContext context)
{
//if (!hostingEnvironment.IsDevelopment()) { return; }
var response = new ErrorResponseModel
{
Message = "An unexpected error occurred.",
StatusCode = HttpStatusCode.InternalServerError
};
memoryCache.Set($"error-uid:{response.UId}", response.ToJsonString());
var accept = context.HttpContext.Request.Headers["Accept"];
var contentType = context.HttpContext.Request.Headers["Content-Type"];
if (contentType.Any(a => a == "application/json") || !accept.Any(a => a.Contains("text/html")))
{
context.HttpContext.Response.ContentType = "application/json";
context.HttpContext.Response.StatusCode = (int)response.StatusCode;
await context.HttpContext.Response.WriteAsync(response.ToJsonString());
return;
}
context.Result = new RedirectToActionResult("Error", "Home", new { uid = response.UId });
}
public async Task <ActionResult <ActorDomainModel> > DeleteActor(int id)
{
ActorDomainModel deletedActor;
try
{
deletedActor = await _actorService.DeleteActor(id);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (deletedActor == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.ACTOR_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.InternalServerError
};
return(BadRequest(errorResponse));
}
return(Accepted("actors//" + deletedActor.Id, deletedActor));
}
public override void OnException(ExceptionContext context)
{
var errorModel = new ErrorResponseModel {
Message = "An error has occured."
};
var exception = context.Exception;
if (exception == null)
{
// Should never happen.
return;
}
var badRequestException = exception as BadRequestException;
if (badRequestException != null)
{
context.HttpContext.Response.StatusCode = 400;
if (badRequestException.ModelState != null)
{
errorModel = new ErrorResponseModel(badRequestException.ModelState);
}
else
{
errorModel.Message = badRequestException.Message;
}
}
else if (exception is ApplicationException)
{
context.HttpContext.Response.StatusCode = 402;
}
else if (exception is NotFoundException)
{
errorModel.Message = "Resource not found.";
context.HttpContext.Response.StatusCode = 404;
}
else
{
var logger = context.HttpContext.RequestServices.GetRequiredService <ILogger <ExceptionHandlerFilterAttribute> >();
logger.LogError(0, exception, exception.Message);
logger.LogError(0, exception, exception.Message);
errorModel.Message = "An unhandled server error has occured.";
context.HttpContext.Response.StatusCode = 500;
}
var env = context.HttpContext.RequestServices.GetRequiredService <IHostingEnvironment>();
if (env.IsDevelopment())
{
errorModel.ExceptionMessage = exception.Message;
errorModel.ExceptionStackTrace = exception.StackTrace;
errorModel.InnerExceptionMessage = exception?.InnerException?.Message;
}
context.Result = new ObjectResult(errorModel);
}
private async Task HandleExceptionAsync(HttpContext httpContext, Exception ex)
{
// get all the information you want to log and use Serilog or Nlog to log exceptions to text/json files.
_logger.LogError("Starting Logging for Exception");
ClaimsPrincipal principal = httpContext.User;
var claimItems = new List <string>();
foreach (Claim claim in principal.Claims)
{
claimItems.Add(claim.Value);
}
var errorModel = new ErrorResponseModel
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
InnerExceptionMessage = ex.InnerException?.Message,
// fill up remaining info , email, ...etch found in ErrorResponseModel
FullName = claimItems[0] + " " + claimItems[1],
UserId = claimItems[2],
Email = claimItems[3],
ExceptionDateTime = DateTime.UtcNow
};
switch (ex)
{
case ConflictException conflictException:
httpContext.Response.StatusCode = (int)HttpStatusCode.Conflict;
break;
case NotFoundException notFoundException:
httpContext.Response.StatusCode = (int)HttpStatusCode.NotFound;
break;
case UnauthorizedAccessException unauthorized:
httpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
break;
case Exception exception:
httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
break;
}
// Serilog to log errorModel along with exception model.
// redirect to error page
// send email as well.
var message =
$"Exception Code: {httpContext.Response.StatusCode}, {errorModel.ExceptionMessage}, {errorModel.ExceptionStackTrace},{errorModel.InnerExceptionMessage}, {errorModel.FullName}, {errorModel.ExceptionDateTime.ToLongDateString()}";
_logger.LogInformation(message);
_logger.LogCritical(message);
httpContext.Response.Redirect("/Home/Error");
await Task.CompletedTask;
}
public void ConstructorTest1()
{
var r = new ErrorResponseModel();
Assert.Equal(200, r.Status);
Assert.Null(r.Title);
Assert.NotNull(r.Errors);
Assert.Empty(r.Errors);
}
private async Task HandleExceptionAsync(HttpContext httpContext, Exception ex)
{
// get the exception details from ex, such as exception date, stacktrace, inner exception, error message etc
// return exception information in a friendly JSON message so that Angular can use that message to display
// proper Error message in the Browser
// by default set the HttpStatusCode to 500 as its a internal server error
httpContext.Response.ContentType = "application/json";
httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
var env = httpContext.RequestServices.GetRequiredService <IWebHostEnvironment>();
string result;
if (env.IsDevelopment())
{
// contrsuct a error object so that we can send that error object as Json to Angular or client
var errorDetails = new ErrorResponseModel
{
ErrorMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
InnerException = ex.InnerException?.Message
};
// convert C# errordetails object to JSON using NewtonSoft.Json library so that Angular will recieve Json object
result = JsonConvert.SerializeObject(new { erros = errorDetails });
}
else
{
result = JsonConvert.SerializeObject(new { erros = ex.Message });
}
// we can catch for specific exception and handle them and add our custom messages
switch (ex)
{
case UnauthorizedAccessException _:
httpContext.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
break;
case DivideByZeroException _:
httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
break;
case Exception _:
httpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
break;
default:
break;
}
// write the json object to the http response
await httpContext.Response.WriteAsync(result);
}
public async Task <ActionResult> Post([FromBody] CinemaModel cinemaModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CinemaDomainModel cinemaWithoutAuditorium = new CinemaDomainModel()
{
Name = cinemaModel.Name
};
CreateCinemaWithAuditoriumModel cinemaWithAuditoriumModel = new CreateCinemaWithAuditoriumModel
{
AuditoriumName = cinemaModel.auditName,
CinemaName = cinemaModel.Name,
NumberOfRows = cinemaModel.seatRows,
NumberOfColumns = cinemaModel.numberOfSeats
};
CreateCinemaResultModel createCinema;
try
{
if (cinemaModel.auditName != null && cinemaModel.numberOfSeats > 0 && cinemaModel.seatRows > 0)
{
createCinema = await _cinemaService.AddCinemaWithAuditorium(cinemaWithAuditoriumModel);
}
else
{
createCinema = await _cinemaService.AddCinema(cinemaWithoutAuditorium);
}
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (createCinema.IsSuccessful != true)
{
ErrorResponseModel errorResponse = new ErrorResponseModel()
{
ErrorMessage = createCinema.ErrorMessage,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Created("cinemas//" + createCinema.Cinema.Id, createCinema.Cinema));
}
public async Task <ActionResult> UpdateMovie(Guid id, [FromBody] UpdateMovieModel movieModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
MovieDomainModel movieToUpdate;
movieToUpdate = await _movieService.GetMovieByIdAsync(id);
if (movieToUpdate == null)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = Messages.MOVIE_DOES_NOT_EXIST,
StatusCode = System.Net.HttpStatusCode.NotFound
};
return(NotFound(errorResponse));
}
movieToUpdate.Title = movieModel.Title;
movieToUpdate.Current = movieModel.Current;
movieToUpdate.Year = movieModel.Year;
movieToUpdate.Rating = movieModel.Rating;
CreateMovieResultModel movieDomainModel;
try
{
movieDomainModel = await _movieService.UpdateMovie(movieToUpdate);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (!movieDomainModel.IsSuccessful)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = movieDomainModel.ErrorMessage,
StatusCode = System.Net.HttpStatusCode.InternalServerError
};
return(StatusCode((int)System.Net.HttpStatusCode.InternalServerError, errorResponse));
}
return(Accepted("movies//" + movieDomainModel.Movie.Id, movieDomainModel));
}
/// <summary>
/// Creates a 404 Not Found response for a request.
/// </summary>
/// <param name="req">The request.</param>
/// <param name="message">The response content.</param>
/// <returns>The 404 Not Found response.</returns>
public HttpResponseMessage CreateNotFoundResponse(HttpRequestMessage req, string message)
{
var errorResponse = new ErrorResponseModel
{
StatusCode = (int)HttpStatusCode.NotFound,
Message = message
};
return(CreateNotFoundResponse(req, errorResponse));
}
/// <summary>
/// Generate a user friendly error message if exception is referring to a duplicate constraint.
/// </summary>
/// <param name="ex"></param>
/// <param name="message"></param>
/// <returns>User friendly error message if exception is caused by duplicate. Otherwise null.</returns>
public static ErrorResponseModel CheckErrorMessageForDuplicate(this Exception ex, string message)
{
if (ex.InnerException?.Message.Contains("duplicate") ?? false)
{
ErrorResponseModel error = new ErrorResponseModel(message,
"Ensure that you have not entered a duplicate name into the system.");
return(error);
}
return(null);
}
/// <summary>
/// Creates a 400 Bad Request response for a request.
/// </summary>
/// <param name="req">The request.</param>
/// <param name="message">The response content.</param>
/// <returns>The 400 Bad Request response.</returns>
protected HttpResponseMessage CreateBadRequestResponse(HttpRequestMessage req, string message)
{
var errorResponse = new ErrorResponseModel
{
StatusCode = (int)HttpStatusCode.BadRequest,
Message = message
};
return(this.CreateBadRequestResponse(req, errorResponse));
}
/// <summary>
/// Creates a 415 Unsupported Media Type response for a request.
/// </summary>
/// <param name="req">The request.</param>
/// <param name="message">The response content.</param>
/// <returns>The 415 Unsupported Media Type response.</returns>
protected HttpResponseMessage CreateUnsupportedMediaTypeResponse(HttpRequestMessage req, string message)
{
var errorResponse = new ErrorResponseModel
{
StatusCode = (int)HttpStatusCode.UnsupportedMediaType,
Message = message
};
return(this.CreateNotFoundResponse(req, errorResponse));
}
public static async Task ExecuteAPI(HttpContext context, System.Net.WebSockets.WebSocket webSocket)
{
var buffer = new byte[1024 * 20];
WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
while (!result.CloseStatus.HasValue)
{
string strRequest = Encoding.UTF8.GetString(buffer);
string str = strRequest.Replace("\0", string.Empty);
string jsonStr = string.Empty;
try
{
//Method
APIModel apiModel = JsonSerializer.Deserialize <APIModel>(str);
string apiName = apiModel.Method;
BaseCommand command = Activator.CreateInstance(CommandsDict[apiName]) as BaseCommand;
command.WebSocket = webSocket;
jsonStr = command.Execute(str);
buffer = Encoding.UTF8.GetBytes(jsonStr);
BaseRequestModel requestModel = JsonSerializer.Deserialize <BaseRequestModel>(str);
if (!string.IsNullOrEmpty(requestModel.Token))
{
if (command is UserLogoutCommand)
{
//do nothing
}
else
{
UserInfo userInfo = UserInfoDict[requestModel.Token];
userInfo.ActionTime = DateTime.Now;
}
}
else if (command is UserLoginCommand)
{
//do nothing
}
}
catch (Exception ex)
{
ErrorResponseModel responseModel = new ErrorResponseModel();
responseModel.StatusCode = 0;
responseModel.ErrorCode = "500";
responseModel.Message = ex.Message;
jsonStr = JsonSerializer.Serialize(responseModel);
buffer = Encoding.UTF8.GetBytes(jsonStr);
}
await webSocket.SendAsync(new ArraySegment <byte>(buffer, 0, jsonStr.Length), result.MessageType, result.EndOfMessage, CancellationToken.None);
buffer = new byte[1024 * 20];
result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
}
await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
}
public async Task ErrorHandling_StatusCodePages_AddsErrorResponseModelTo500InternalServerErrorResponseWithNoBody()
{
// Act
HttpResponseMessage httpResponseMessage = await _httpClient.GetAsync("ErrorHandlingTest/InternalServerError");
// Assert
ErrorResponseModel body = JsonConvert.DeserializeObject <ErrorResponseModel>(await httpResponseMessage.Content.ReadAsStringAsync());
Assert.Equal(_internalServerError, httpResponseMessage.StatusCode.ToString());
Assert.Equal(Strings.ErrorMessage_UnexpectedError, body.ErrorMessage);
}
