private static bool ParseBody <TCommunicatorRequest>(ControllerBase controllerBase, out TCommunicatorRequest request, out IActionResult actionResult) where TCommunicatorRequest : class, ICommunicatorRequest { try { request = JsonConvert.DeserializeObject <TCommunicatorRequest>( new StreamReader(controllerBase.Request.Body).ReadToEndAsync().Result); } catch (JsonException) { request = default; { actionResult = controllerBase.BadRequest("Given request can't be parsed correctly"); return(false); } } if (request == null) { actionResult = controllerBase.BadRequest("Given request can't be parsed correctly"); return(false); } actionResult = null; return(true); }
/// <summary> /// This is used to return the ServiceGetResultCode for the /// associated ServiceGetResult.ResultCode. /// </summary> /// <typeparam name="T">This is the ServiceGetResult type</typeparam> /// <typeparam name="U">This is the response object that is held by this</typeparam> /// <param name="result">This is ServiceResultCode corresponding to the /// result code</param> /// <param name="controllerBase">The Web API controller</param> /// <returns>This is the IActionResult that corresponds to the result code</returns> public static IActionResult ToApiGetResponse <T, U>(this T result, ControllerBase controllerBase) where T : ServiceGetResult <U> where U : class { IActionResult response = null; switch (result.ResultCode) { case ServiceGetResultCode.Success: response = controllerBase.Ok(result.Resource); break; case ServiceGetResultCode.NotFound: response = controllerBase.NotFound(); break; case ServiceGetResultCode.ValidationErrors: response = controllerBase.BadRequest(result.ValidationErrors); break; case ServiceGetResultCode.NotAuthorized: response = controllerBase.Unauthorized(); break; default: response = controllerBase.BadRequest("Unknown error occurred"); break; } return(response); }
public static IActionResult getErrors(ControllerBase c, Exception ex) { if (ex.GetType() == typeof(DbUpdateException)) { if (ex.InnerException is SqlException sqlException) { switch (sqlException.Number) { case 2627: return(c.BadRequest(new { errors = new { UniqueConstraint = sqlException.Message } })); // Unique constraint error case 547: return(c.BadRequest(new { errors = new { constraintViolation = sqlException.Message } })); // Constraint check violation case 2601: return(c.BadRequest(new { errors = new { duplicatedkey = "Cannot insert duplicate key row in object" } })); // Duplicated key row error // Constraint violation exception // A custom exception of yours for concurrency issues default: return(c.StatusCode(500, new { errors = new { unhandleException = sqlException.Message } })); // A custom exception of yours for other DB issues } } } return(c.StatusCode(500, new { errors = new { unhandleException = ex.Message } })); }
/// <summary> /// Creates an ActionResult from a service Result /// </summary> /// <returns>The action result.</returns> /// <param name="result">Service Result.</param> /// <typeparam name="T">The data type of the Result.</typeparam> public static ActionResult FromResult <T>(this ControllerBase controller, Result <T> result) { switch (result.ResultType) { case ResultType.Ok: if (result.Data == null) { return(controller.NoContent()); } else { return(controller.Ok(result.Data)); } case ResultType.NotFound: return(controller.NotFound(result.Errors)); case ResultType.Invalid: return(controller.BadRequest(result.Errors)); case ResultType.Unexpected: return(controller.BadRequest(result.Errors)); case ResultType.Unauthorized: return(controller.Unauthorized()); default: throw new Exception("An unhandled result has occurred as a result of a service call."); } }
public async Task <IActionResult> DeleteItem(ControllerBase controller, IDbResourceRepository <T, O> repo, int id) { try { string desc = GetControllerDescription(controller); _logger.LogInfo(desc); if (id < 1) { _logger.LogWarn($"{desc}: Empty request submitted"); return(controller.BadRequest()); } var user = await _userService.GetCurrentUser(); if (user == null) { _logger.LogWarn($"{desc}: Invalid request submitted - Not a valid user"); return(controller.BadRequest()); } var exists = await repo.Exists(id, user?.Id); if (!exists) { _logger.LogWarn($"{desc}: Item with id {id} was not found or does not belong to {user?.Email}"); return(controller.NotFound()); } if (!controller.ModelState.IsValid) { _logger.LogWarn($"{desc}: Invalid request submitted"); return(controller.BadRequest(controller.ModelState)); } var item = await repo.GetById(id, new BaseQueryOptions() { UserId = user != null ? user.Id : "" }); if (item == null) { _logger.LogWarn($"{desc}: Item with id {id} was not found or does not belong to {user?.Email}"); return(controller.NotFound()); } var isSuccess = await repo.Delete(item); if (!isSuccess) { return(InternalError(controller, "{desc}: Item delete failed")); } _logger.LogInfo($"{desc}: Item deleted"); return(controller.Ok(id)); } catch (Exception e) { return(InternalError(controller, e)); } }
public async Task <IActionResult> Create <D>(ControllerBase controller, IDbResourceRepository <T> repo, D itemDTO) { string desc = GetControllerDescription(controller); try { _logger.LogInfo(desc); if (itemDTO == null) { _logger.LogWarn($"{desc}: Empty request submitted"); return(controller.BadRequest()); } if (!controller.ModelState.IsValid) { _logger.LogWarn($"{desc}: Invalid request submitted"); return(controller.BadRequest(controller.ModelState)); } var item = _mapper.Map <T>(itemDTO); var isSuccess = await repo.Create(item); if (!isSuccess) { return(InternalError(controller, $"{desc}: Item creation failed")); } _logger.LogInfo($"{desc}: Item created"); return(controller.Created("", new { item })); } catch (Exception e) { return(InternalError(controller, e)); } }
public async Task <IActionResult> UpdateItem <D>(ControllerBase controller, IDbResourceRepository <T, O> repo, int id, D itemDTO) { try { string desc = GetControllerDescription(controller); _logger.LogInfo(desc); if (id < 1 || itemDTO == null) { _logger.LogWarn($"{desc}: Empty request submitted"); return(controller.BadRequest()); } var user = await _userService.GetCurrentUser(); if (user == null) { _logger.LogWarn($"{desc}: Invalid request submitted - Not a valid user"); return(controller.BadRequest()); } var exists = await repo.Exists(id, user?.Id); if (!exists) { _logger.LogWarn($"{desc}: Item with id {id} was not found or does not belong to {user?.Email}"); return(controller.NotFound()); } if (!controller.ModelState.IsValid) { _logger.LogWarn($"{desc}: Invalid request submitted"); return(controller.BadRequest(controller.ModelState)); } // map data to DTO var item = _mapper.Map <T>(itemDTO); // force item.Id to be id passed in and userId to currently authenticated user item.Id = id; // set the userId to the currently authenticated user item.UserId = user?.Id; var isSuccess = await repo.Update(item); if (!isSuccess) { return(InternalError(controller, $"{desc}: Update failed")); } _logger.LogInfo($"{desc}: Update Successful"); item.UserId = null; return(controller.Ok(new { item })); } catch (Exception e) { return(InternalError(controller, $"Server Error: {e.Message} - {e.InnerException}")); } }
/// <summary> /// Adds an error to model state and returns the whole model state as /// BadRequest result. /// </summary> /// <param name="controller">Instance of the /// <see cref="ControllerBase"/>.</param> /// <param name="fieldName">Field name causing the problem.</param> /// <param name="errorMessage">Error message describing the problem. /// </param> /// <returns>Instance of <see cref="IActionResult"/></returns> public static IActionResult BadRequest( this ControllerBase controller, string fieldName, string errorMessage) { if (controller.ModelState .TryAddModelError(fieldName, errorMessage)) { return(controller.BadRequest(controller.ModelState)); } return(controller.BadRequest(errorMessage)); }
/// <summary> /// Extend try catch /// </summary> /// <typeparam name="T"></typeparam> /// <param name="ctrl"></param> /// <param name="func"></param> /// <returns></returns> public static ActionResult <T> TryCatchWithModelState <T>(this ControllerBase ctrl, Func <T> func) { if (!ctrl.ModelState.IsValid) { return(ctrl.BadRequest(ctrl.ModelState)); } try { return(ctrl.Ok(func())); } catch (Exception ex) { return(ctrl.BadRequest(ex.Message)); } }
public static BadRequestObjectResult BadRequestWithErrors(this ControllerBase controller) { return(controller.BadRequest( controller.ModelState.Values .SelectMany(e => e.Errors) .Select(e => e.ErrorMessage))); }
public static ActionResult ToActionResult(this ControllerBase controllerBase, IResult result) { switch (result.Status) { case ResultStatus.Ok: return(controllerBase.Ok(new { success = true, data = result.GetValue() })); case ResultStatus.NotFound: return(controllerBase.NotFound()); case ResultStatus.Invalid: return(controllerBase.BadRequest(new { success = false, errors = result.ValidationErrors })); case ResultStatus.Error: return(controllerBase.StatusCode(500)); default: throw new NotSupportedException($"Result {result.Status} translation is not supported"); } }
public async Task <IActionResult> Delete(ControllerBase controller, IDbResourceRepository <T> repo, int id) { try { string desc = GetControllerDescription(controller); _logger.LogInfo(desc); if (id < 1) { _logger.LogWarn($"{desc}: Empty request submitted"); return(controller.BadRequest()); } var item = await repo.FindById(id); if (item == null) { _logger.LogWarn($"{desc}: Item with id ${id} was not found"); return(controller.NotFound()); } var isSuccess = await repo.Delete(item); if (!isSuccess) { return(InternalError(controller, "{desc}: Item delete failed")); } _logger.LogInfo("{desc}: Item deleted"); return(controller.Ok(id)); } catch (Exception e) { return(InternalError(controller, e)); } }
/// <summary> /// This is used to return the ServiceCreateResultCode for the /// associated ServiceCreateResult.ResultCode. /// </summary> /// <typeparam name="T">This is the ServiceCreateResult type</typeparam> /// <typeparam name="U">This is the response object that is held by this</typeparam> /// <param name="result">This is ServiceResultCode corresponding to the /// result code</param> /// <param name="controllerBase">The Web API controller</param> /// <returns>This is the IActionResult that corresponds to the result code</returns> public static IActionResult ToApiCreateResponse <T, U>(this T result, ControllerBase controllerBase) where T : ServiceCreateResult <U> where U : class { IActionResult response; switch (result.ResultCode) { case ServiceCreateResultCode.Success: response = controllerBase.Created(string.Empty, result.Identifier); break; case ServiceCreateResultCode.ResourceAlreadyExists: response = controllerBase.StatusCode((int)HttpStatusCode.PreconditionFailed, result.Identifier); break; case ServiceCreateResultCode.ValidationErrors: response = controllerBase.BadRequest(result.ValidationErrors); break; default: throw new InvalidCastException($"Unexpected {typeof(T).Name} value of {result.ResultCode} received."); } return(response); }
/// <summary> /// This is used to retrieve the response for a service change result. /// </summary> /// <typeparam name="T">This is the service result type</typeparam> /// <param name="result">This is the result</param> /// <param name="controllerBase">Controller base</param> /// <returns>The corresponding action</returns> public static IActionResult ToApiChangeResponse <T>(this T result, ControllerBase controllerBase) where T : ServiceChangeResult { IActionResult response; switch (result.ResultCode) { case ServiceChangeResultCode.Success: response = controllerBase.NoContent(); break; case ServiceChangeResultCode.NotFound: response = controllerBase.NotFound(); break; case ServiceChangeResultCode.ValidationErrors: response = controllerBase.BadRequest(result.ValidationErrors); break; case ServiceChangeResultCode.VersionConflict: response = controllerBase.Conflict(); break; default: throw new InvalidCastException($"Unexpected {typeof(T).Name} value of {result.ResultCode} received."); } return(response); }
/// <summary> /// Get Item by Id /// </summary> /// <typeparam name="D">Data Transfer Object class</typeparam> /// <param name="controller"></param> /// <param name="repo"></param> /// <param name="id"></param> /// <param name="options"></param> /// <returns></returns> public async Task <IActionResult> GetItem <D>(ControllerBase controller, IDbResourceRepository <T, O> repo, int id, IBaseQueryOptions options) { try { string desc = GetControllerDescription(controller); _logger.LogInfo($"{desc}: {id}"); // set options.UserId for the current authenticated user var user = await _userService.GetCurrentUser(); if (user == null) { _logger.LogWarn($"{desc}: Invalid request submitted - Not a valid user"); return(controller.BadRequest()); } options.UserId = user?.Id; var item = await repo.GetById(id, options); if (item == null) { _logger.LogWarn($"{desc}: Item {id} was not found or does not belong to {user?.Email} "); return(controller.NotFound()); } var response = _mapper.Map <D>(item); _logger.LogInfo($"{desc} - Successful"); return(controller.Ok(response)); } catch (Exception e) { return(InternalError(controller, $"Server Error: {e.Message} - {e.InnerException}")); } }
public static async Task <IActionResult> BulkDeleteAsync(this ControllerBase controller, IDeletableMembershipBoundedService service, string membershipId, string[] ids) { var utilizer = controller.GetUtilizer(); if (ids != null) { var isDeleted = await service.BulkDeleteAsync(utilizer, membershipId, ids); if (isDeleted != null) { if (isDeleted.Value) { return(controller.NoContent()); } else { return(controller.BulkDeleteFailed(ids)); } } else { return(controller.BulkDeletePartial()); } } else { return(controller.BadRequest()); } }
public static ActionResult FromServiceOperationResult( this ControllerBase controllerBase, ServiceOperationResult result ) { switch (result.StatusCode) { case HttpStatusCode.OK: return(controllerBase.Ok()); case HttpStatusCode.Accepted: return(controllerBase.Accepted()); case HttpStatusCode.Unauthorized: return(controllerBase.Unauthorized()); case HttpStatusCode.NotFound: return(controllerBase.NotFound(result.Errors)); case HttpStatusCode.Conflict: return(controllerBase.Conflict(result.Errors)); case HttpStatusCode.UnprocessableEntity: return(controllerBase.UnprocessableEntity(result.Errors)); case HttpStatusCode.NotImplemented: return(controllerBase.StatusCode((int)result.StatusCode, result.Errors)); default: return(controllerBase.BadRequest(result.Errors)); } }
public static BadRequestObjectResult Error(this ControllerBase controller, string message) { return(controller.BadRequest(new { Message = message })); }
public static IActionResult GetActionResultFromServiceResult(this ControllerBase controller, ServiceResult result) { switch (result.StatusCode) { case StatusCodes.Status200OK: { return(controller.Ok(result.ContentResult)); } case StatusCodes.Status201Created: { return(controller.StatusCode(StatusCodes.Status201Created, result.ContentResult)); } case StatusCodes.Status400BadRequest: { return(controller.BadRequest(result.ContentResult)); } case StatusCodes.Status404NotFound: { return(controller.NotFound(result.ContentResult)); } case StatusCodes.Status500InternalServerError: { return(controller.StatusCode(StatusCodes.Status500InternalServerError, result.ContentResult)); } default: { return(controller.StatusCode(result.StatusCode, "Unhandled Status Code")); } } }
public static IActionResult CreateResponse <T>(this ControllerBase controller, HttpStatusCode statusCode, SwaggerResponse <T> result) { switch (statusCode) { case HttpStatusCode.OK: return(controller.Ok(result.Result)); case HttpStatusCode.Created: if (result.Result is Ronny createRonny) { return(controller.Created(new Uri($"{controller.BasePath()}/ronnies/{createRonny.Id}"), createRonny)); } else { return(controller.Created("", result.Result)); } case HttpStatusCode.Accepted: if (result.Result is Ronny updateRonny) { return(controller.Accepted(new Uri($"{controller.BasePath()}/ronnies/{updateRonny.Id}"), updateRonny)); } else { return(controller.Accepted("", result.Result)); } case HttpStatusCode.BadRequest: return(controller.BadRequest(result.Error)); default: return(controller.StatusCode((int)statusCode)); } }
public static IActionResult ValidationError(this ControllerBase controller, ValidationException validationException) { controller.Response.Headers.Add(DtoHelper.PayloadTypeHeaderName, DtoHelper.ValidationErrorPayloadType); var error = WebApiHostHelper.CreateValidationErrorDto(validationException); return(controller.BadRequest(error)); }
/// <summary> /// Returns a Bad request with data specific for this current system /// </summary> /// <param name="message">Message to send with the request</param> /// <returns></returns> public static IActionResult FixedBadRequest(this ControllerBase _base, string message = null) { return(_base.BadRequest(new HttpSingleResponse <object> { IsSuccess = false, Message = message })); }
public static ActionResult <GenericApiResponse <object> > HandleBadRequest(this ControllerBase controller, string title, string error) { var response = new GenericApiResponse <object>(); response.Error.title = title; response.Error.error = error; return(controller.BadRequest(response)); }
public static BadRequestObjectResult BadRequestResource(this ControllerBase controller, MediaType resource) { var result = controller.BadRequest(resource); result.ContentTypes.Add(resource.GetMediaType("restfulbank")); return(result); }
internal static IActionResult ProcessRequest <TCommunicatorRequest>( [NotNull] this ControllerBase controllerBase, [CanBeNull] out TCommunicatorRequest request, out Guid apiKey) where TCommunicatorRequest : class, ICommunicatorRequest { if (controllerBase == null) { throw new ArgumentNullException(nameof(controllerBase)); } Program.Logger.LogDebug("Processing request"); request = null; apiKey = Guid.Empty; if (!HeadersValid(controllerBase.Request.Headers)) { return(controllerBase.BadRequest( $"The request has invalid encoding (not {Encoding.UTF8.WebName}) or invalid content type " + $"(not {MediaTypeNames.Application.Json})")); } Program.Logger.LogDebug("Headers are valid"); if (!ParseBody(controllerBase, out request, out var actionResult)) { return(actionResult); } Program.Logger.LogDebug("JSON is valid"); var guidString = request.ApiKey; var guidNullable = request.ApiKey.ToGuidOrNull(); if (!guidNullable.HasValue) { return(controllerBase.BadRequest($"String {guidString} can't be parsed as GUID")); } Program.Logger.LogDebug("GUID is valid"); apiKey = guidNullable.Value; Program.Logger.LogDebug($"Matching user by key. Inputted: {apiKey}. All users: "); Program.DataStorage.Users.ForEach(it => Program.Logger.LogDebug(it.ToString())); return(Program.HasUserWithApiKey(apiKey) ? null : controllerBase.StatusCode(403)); }
private IActionResult GenerateBadRequest(ServiceException e) { ErrorDto errorMessage = new ErrorDto() { ErrorMessage = e.Message }; return(sender.BadRequest(errorMessage)); }
public static IActionResult GenerateResponse(this ControllerBase controllerBase, Response response) { if (response.Success) { return(controllerBase.Ok(response)); } return(controllerBase.BadRequest(response)); }
private IActionResult GetCommandResponse <T>(T response, ControllerBase controller) where T : SimpleCommandResponseData { if (!response.IsValid) { return(controller.BadRequest(response)); } return(controller.Ok(response)); }
private static ActionResult BadRequest(ControllerBase controller, IApiResponse response) { foreach (var error in response.ValidationErrors) { controller.ModelState.AddModelError(error.Identifier, error.ErrorMessage); } return(controller.BadRequest(controller.ModelState)); }
public static ActionResult Error( this ControllerBase controller, string error) { var dict = new Microsoft.AspNetCore.Mvc.ModelBinding.ModelStateDictionary(); dict.AddModelError("error", error); return(controller.BadRequest(dict)); }