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); }