public static string CreateSession() { var perculus = Common.CreatePerculusClient(); Models.PostSessionView model = new Models.PostSessionView { name = "test session", lang = "tr-TR", description = "description", duration = 15, start_date = DateTimeOffset.Now }; ApiErrorResponse error = null; SessionView session = null; (session, error) = perculus.Sessions.CreateSession(model); if (error != null) { Common.HandleErrorResponse(error); } if (session != null && !String.IsNullOrEmpty(session.session_id)) { return(session.session_id); } return(null); }
private Task HandleExceptionAsync(HttpContext context, Exception exception) { //context.Response.ContentType = "application/json"; var apiErrorResponce = new ApiErrorResponse(); int code = (int)HttpStatusCode.InternalServerError; if (exception is DbUpdateException) { apiErrorResponce.Message = exception.Message; code = (int)HttpStatusCode.BadRequest; context.Response.StatusCode = code; } //else if else { apiErrorResponce.Message = exception.Message; code = (int)HttpStatusCode.InternalServerError; context.Response.StatusCode = code; } var apiResponce = new ApiDataResponse <ApiErrorResponse>(code, apiErrorResponce); var json = JsonConvert.SerializeObject(apiResponce); logger.LogError($"An exception occured {exception.Message}"); return(context.Response.WriteAsync(json)); }
/// <summary> /// Changes user's password. /// </summary> /// <param name="userId"></param> /// <param name="password"></param> /// <returns></returns> public bool ChangeUserPassword(string userId, string password, out ApiErrorResponse error) { if (String.IsNullOrEmpty(userId)) { throw new ArgumentNullException(nameof(userId)); } if (String.IsNullOrEmpty(password)) { throw new ArgumentNullException(nameof(password)); } var request = HttpWebClient.CreateWebRequest("PUT", BuildRoute($"user/{userId}/password?password={password}")); var response = HttpWebClient.SendWebRequest(request, password); error = null; bool success = false; if (response != null) { success = response.StatusCode == HttpStatusCode.NoContent; if (!success) { error = response.ToErrorResponse(); } } return(success); }
/// <summary> /// Deletes and attendee by session id and email /// </summary> /// <param name="sessionId"></param> /// <param name="email"></param> /// <returns></returns> public bool DeleteByEmail(string sessionId, string email, out ApiErrorResponse error) { if (String.IsNullOrEmpty(sessionId)) { throw new ArgumentNullException(nameof(sessionId)); } if (String.IsNullOrEmpty(email)) { throw new ArgumentNullException(nameof(email)); } var request = HttpWebClient.CreateWebRequest("DELETE", BuildRoute($"session/{sessionId}/attendee/{email}")); var response = HttpWebClient.SendWebRequest(request); error = null; bool success = false; if (response != null) { success = response.StatusCode == HttpStatusCode.NoContent; if (!success) { error = response.ToErrorResponse(); } } return(success); }
/// <summary> /// Get attendee by session id and email /// </summary> /// <param name="sessionId"></param> /// <param name="email"></param> /// <returns></returns> public AttendeeView GetByEmail(string sessionId, string email, out ApiErrorResponse error) { if (String.IsNullOrEmpty(sessionId)) { throw new ArgumentNullException(nameof(sessionId)); } if (String.IsNullOrEmpty(email)) { throw new ArgumentNullException(nameof(email)); } var request = HttpWebClient.CreateWebRequest("GET", BuildRoute($"session/{sessionId}/attendee/{email}")); var response = HttpWebClient.SendWebRequest(request); AttendeeView attendeeView = null; error = null; if (response != null) { string result = HttpWebClient.GetResponseBody(response); if (response.StatusCode == HttpStatusCode.OK) { attendeeView = result.ToObject <AttendeeView>(); } else { error = response.ToErrorResponse(); } } return(attendeeView); }
private void ThrowApiException(HttpWebResponse webResponse, Stream resultStream) { try { resultStream.Position = 0; using (var responseReader = new StreamReader(resultStream)) { var responseData = responseReader.ReadToEnd(); var errorResponse = (ApiErrorResponse)JsonSerializationHelper.Deserialize(responseData, typeof(ApiErrorResponse)); if (errorResponse == null) { errorResponse = new ApiErrorResponse(); errorResponse.Error = new HttpWebException(responseData, CommonStatusCode.Error.Code, webResponse.StatusCode); } throw errorResponse.Error; } } catch (HttpWebException) { throw; } catch (Exception) { throw new HttpWebException(webResponse.StatusDescription, CommonStatusCode.Error.Code, webResponse.StatusCode); } }
public ApiErrorResponse Error() { ApiErrorResponse response = new ApiErrorResponse(); var context = HttpContext.Features.Get <IExceptionHandlerFeature>(); var exception = context?.Error; var code = 500; if (exception is UnauthorizedException) { code = 401; response.Status = 401; } if (exception?.InnerException is ServiceException serviceException) { code = 400; response.Status = code; response.Errors = serviceException.Errors; } Response.StatusCode = code; return(response); }
/// <summary> /// Deletes a user by user id /// </summary> /// <param name="userId"></param> /// <returns></returns> public bool DeleteByUserId(string userId, out ApiErrorResponse error) { if (String.IsNullOrEmpty(userId)) { throw new ArgumentNullException(nameof(userId)); } var request = HttpWebClient.CreateWebRequest("DELETE", BuildRoute($"user/{userId}")); var response = HttpWebClient.SendWebRequest(request); error = null; bool success = false; if (response != null) { success = response.StatusCode == HttpStatusCode.NoContent; if (!success) { error = response.ToErrorResponse(); } } return(success); }
private Task HandleNotSuccessValidationAsync(HttpContext context, int statusCode, ModelStateDictionary modelState) { var errorListModel = modelState .Where(x => x.Value.Errors.Count > 0) .ToDictionary(er => er.Key, er => er.Value.Errors.Select(x => x.ErrorMessage)) .ToList(); var apiErrorResponce = new ApiErrorResponse(); foreach (var error in errorListModel) { foreach (var erValue in error.Value) { var errorModel = new ValidationError() { Name = error.Key, Message = erValue }; apiErrorResponce.ValidationErrors.Add(errorModel); } } var apiResponce = new ApiDataResponse <ApiErrorResponse>(statusCode, apiErrorResponce); context.Response.StatusCode = statusCode; var json = JsonConvert.SerializeObject(apiResponce); return(context.Response.WriteAsync(json)); }
private async Task HandleExceptionAsync(HttpContext context, Exception exception, ILogger <ErrorHandlingMiddleware> logger) { var code = HttpStatusCode.InternalServerError; var result = new ApiErrorResponse(); switch (exception) { //TODO: all exceptions caused by the user case NotSupportedException _: case AlreadyExistsException _: case ValidationException _: case NotFoundException _: code = HttpStatusCode.BadRequest; result = new ApiErrorResponse(exception.Message); break; case Exception e: logger.LogError(exception, "SERVER ERROR"); code = HttpStatusCode.InternalServerError; result = string.IsNullOrWhiteSpace(e.Message) ? new ApiErrorResponse("Error") : new ApiErrorResponse(e.Message); break; } context.Response.ContentType = "application/json"; context.Response.StatusCode = (int)code; string jsonResponse = JsonSerializer.Serialize(result); await context.Response.WriteAsync(jsonResponse); }
public static ApiErrorResponse MapErrorResponse(ApiErrorResponse errorResponse) { var errorMappingFile = ConfigManager.GetAppSetting("ErrorMapping"); var filePath = Utility.GetFullpath(errorMappingFile); if (File.Exists(filePath)) { var json = File.ReadAllText(filePath); var operationErrorMaps = JsonConvert.DeserializeObject <List <OperationErrorMapInfo> >(json); if (operationErrorMaps != null) { foreach (var operation in operationErrorMaps) { if (string.Equals(operation.EventType, errorResponse.EventType, StringComparison.OrdinalIgnoreCase)) { foreach (var map in operation.Maps) { if (string.Equals(map.ExternalResponseCode, errorResponse.ExternalResponseCode)) { errorResponse.ErrorCode = (ErrorCodeEnum)map.ErrorCode; errorResponse.ErrorName = map.ErrorName; break; } } break; } } return(errorResponse); } } return(errorResponse); }
private static Task HandleExceptionAsync(HttpContext context, Exception exception) { HttpStatusCode code; ApiErrorResponse apiResponse = new ApiErrorResponse(); if (exception is ApiException apiException) { code = (HttpStatusCode)apiException.HttpStatusCode; apiResponse.Message = apiException.Message; } else { code = HttpStatusCode.InternalServerError; apiResponse.Message = exception.Message; } var jsonSerializerSettings = new JsonSerializerSettings { Converters = new List <JsonConverter> { new Newtonsoft.Json.Converters.StringEnumConverter(true) }, ContractResolver = new CamelCasePropertyNamesContractResolver() }; string result = JsonConvert.SerializeObject(apiResponse, jsonSerializerSettings); context.Response.ContentType = "application/json"; context.Response.StatusCode = (int)code; return(context.Response.WriteAsync(result)); }
private Task HandleExceptionAsync(HttpContext context, Exception exception) { ApiErrorResponse errorResponse = new ApiErrorResponse(); HttpStatusCode responseCode = HttpStatusCode.InternalServerError; switch (exception) { case AppException appException: responseCode = appException.StatusCode; errorResponse.ResponseCode = appException.StatusCode.ToString(); errorResponse.EntityId = appException.EntityId; errorResponse.Message = appException.GetFormattedMessage(); errorResponse.Details = new[] { appException.Details }; break; default: errorResponse.ResponseCode = responseCode.ToString(); errorResponse.Message = exception.Message; break; } var result = JsonConvert.SerializeObject(errorResponse, Formatting.Indented, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore }); context.Response.ContentType = "application/json"; context.Response.StatusCode = (int)responseCode; return(context.Response.WriteAsync(result)); }
/// <summary> /// Creates a session /// </summary> /// <param name="session">A session view object which holds session data</param> /// <returns>The created session object is returned. If an error occurs, error information is returned as well.</returns> public SessionView CreateSession(PostSessionView session, out ApiErrorResponse error) { if (session is null) { throw new ArgumentNullException(nameof(session)); } var request = HttpWebClient.CreateWebRequest("POST", BuildRoute("session")); var response = HttpWebClient.SendWebRequest(request, session); SessionView sessionView = null; error = null; if (response != null) { string result = HttpWebClient.GetResponseBody(response); if (response.StatusCode == HttpStatusCode.Created) { sessionView = result.ToObject <SessionView>(); } else { error = response.ToErrorResponse(); } } return(sessionView); }
/// <summary> /// Add one attendee to a session /// </summary> /// <param name="sessionId"></param> /// <param name="attendee"></param> /// <returns></returns> public AttendeeView AddAttendee(string sessionId, PostAttendeeView attendee, out ApiErrorResponse responseView) { if (String.IsNullOrEmpty(sessionId)) { throw new ArgumentNullException(nameof(sessionId)); } if (attendee is null) { throw new ArgumentNullException(nameof(attendee)); } AttendeesPostResult result = AddMultiple(sessionId, new PostAttendeeView[] { attendee }, out ApiErrorResponse response); AttendeeView attendeeView = null; responseView = response; if (result != null) { attendeeView = result.approved != null && result.approved.Count > 0 ? result.approved.FirstOrDefault() : null; responseView = result.rejected != null && result.rejected.Count > 0 ? result.rejected.FirstOrDefault().State : null; } return(attendeeView); }
private async Task HandleExceptionAsync(HttpContext context, Exception ex, IWebHostEnvironment env) { var code = HttpStatusCode.InternalServerError; var error = new ApiErrorResponse { StatusCode = (int)code }; if (_env.IsDevelopment()) { error.Details = ex.StackTrace; } else { error.Details = ex.Message; } switch (ex) { case ApplicationValidationException e: error.Message = e.Message; error.StatusCode = (int)HttpStatusCode.UnprocessableEntity; break; default: error.Message = "Something Went Wrong"; break; } var result = JsonConvert.SerializeObject(error); context.Response.ContentType = "application/json"; context.Response.StatusCode = error.StatusCode; await context.Response.WriteAsync(result); }
/// <summary> /// Gets a user by username /// </summary> /// <param name="username"></param> /// <returns></returns> public UserView GetUserByUsername(string username, out ApiErrorResponse error) { if (String.IsNullOrEmpty(username)) { throw new ArgumentNullException(nameof(username)); } var request = HttpWebClient.CreateWebRequest("GET", BuildRoute($"user/{username}")); var response = HttpWebClient.SendWebRequest(request); UserView userView = null; error = null; if (response != null) { string result = HttpWebClient.GetResponseBody(response); if (response.StatusCode == HttpStatusCode.OK) { userView = result.ToObject <UserView>(); } else { error = response.ToErrorResponse(); } } return(userView); }
/// <summary> /// Handle Exception /// </summary> /// <param name="httpContext">Http Context</param> /// <param name="exception">Exception</param> /// <returns>Task</returns> private async Task HandleExceptionAsync(HttpContext httpContext, Exception exception) { ApiErrorResponse errorResponse; switch (exception) { case ApiException: ApiException apiException = (ApiException)exception; httpContext.Response.StatusCode = (int)(apiException.StatusCode); errorResponse = new ApiErrorResponse { Message = exception.Message, ErrorCode = apiException.Code }; break; default: httpContext.Response.StatusCode = StatusCodes.Status500InternalServerError; // Do not return an internal Error Message unless it is clear that it might be shown to the user. errorResponse = new ApiErrorResponse { ErrorCode = ErrorCode.Unknown }; break; } httpContext.Response.ContentType = MediaTypeNames.Application.Json; JsonSerializerOptions options = new JsonSerializerOptions { Converters = { new JsonStringEnumConverter() } }; await httpContext.Response.WriteAsync(JsonSerializer.Serialize(errorResponse, options)).ConfigureAwait(false); }
/// <summary> /// Updates a user /// </summary> /// <param name="user"></param> /// <returns></returns> public UserView UpdateUser(string user_id, PostUserView user, out ApiErrorResponse error) { if (user is null) { throw new ArgumentNullException(nameof(user)); } var request = HttpWebClient.CreateWebRequest("PUT", BuildRoute($"user/{user_id}")); var response = HttpWebClient.SendWebRequest(request, user); UserView userView = null; error = null; if (response != null) { string result = HttpWebClient.GetResponseBody(response); if (response.StatusCode == HttpStatusCode.OK) { userView = result.ToObject <UserView>(); } else { error = response.ToErrorResponse(); } } return(userView); }
public IActionResult SendMessage(SendMessageReq pReq) { try { if (!ModelState.IsValid) { StringBuilder wStr = new StringBuilder(); wStr.AppendLine("Some data is invalid"); if (string.IsNullOrEmpty(pReq.PhoneNumberTo)) { wStr.AppendLine("PhoneNumberTo in url param required"); } if (string.IsNullOrEmpty(pReq.PhoneNumber)) { wStr.AppendLine("PhoneNumber required"); } ApiErrorResponse wResp = new ApiErrorResponse(HttpStatusCode.BadRequest, wStr.ToString()); ObjectResult wObjRes = this.StatusCode(400, wResp); return(wObjRes); } service.TestMessage(pReq); return(Ok()); } catch (Exception ex) { apiLogServices.LogError_asynk(ex); return(BadRequest(ex.Message)); } }
public static ApiErrorResponse ToErrorResponse(this HttpWebResponse response, string content = null) { ApiErrorResponse apiErrorResponse = null; if (response is null) { return(null); } try { if (content is null) { content = HttpWebClient.GetResponseBody(response); } if (response.StatusCode == HttpStatusCode.Unauthorized) { apiErrorResponse = new ApiErrorResponse(ApiErrorCode.Unauthorized); } else { apiErrorResponse = content.ToObject <ApiErrorResponse>(); } } finally { if (apiErrorResponse is null) { apiErrorResponse = new ApiErrorResponse(ApiErrorCode.None); } apiErrorResponse.HttpStatusCode = response.StatusCode; } return(apiErrorResponse); }
/// <summary> /// Verifica a situação do modelo /// </summary> /// <param name="context">Contexto da action</param> private void CheckModelState( ActionExecutingContext context) { try { if (!context.ModelState.IsValid) { ApiErrorResponse apiError = new ApiErrorResponse(); foreach (KeyValuePair <string, ModelStateEntry> item in context.ModelState) { if (item.Value.Errors != null && item.Value.Errors.Count > 0) { foreach (ModelError error in item.Value.Errors) { apiError.Errors.Add(new ApiErrorDetailResponse() { ErrorType = ErrorType.ModelValidation, Message = error.ErrorMessage }); } } } context.Result = new BadRequestObjectResult(apiError); } } catch (Exception ex) { _logger.LogError(ex, ex.Message); } }
public void OnException(ExceptionContext context) { logger.LogError(new EventId(context.Exception.HResult), context.Exception, context.Exception.Message); if (context.Exception is DomainException <object> ) { if (context.Exception is DomainApiResultException <ApiErrorResponse <object> > ) { var exception = context.Exception as DomainApiResultException <ApiErrorResponse <object> >; context.Result = new ObjectResult(exception.ExceptionDetails); context.HttpContext.Response.StatusCode = (int)exception.HttpStatusCode; } else if (context.Exception is DomainApiResultException <object> ) { var exception = context.Exception as DomainApiResultException <object>; context.Result = new ObjectResult(new ApiErrorResponse <object> { Status = ResponseStatusCode.Error, Message = new string[] { exception.Message }, Data = exception.ExceptionDetails }); context.HttpContext.Response.StatusCode = (int)exception.HttpStatusCode; } else { var exception = context.Exception as DomainException <object>; context.Result = new ObjectResult(new ApiErrorResponse <object> { Status = ResponseStatusCode.Error, Message = new string[] { exception.Message }, Data = exception.ExceptionDetails }); context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError; } } else { var errorResponse = new ApiErrorResponse <string> { Status = ResponseStatusCode.Error, Message = new string[] { "Unexpected server error. Please try again later. If the problem persists, please contact support.", $"CorrelationId: {_correlationContext.CorrelationContext.CorrelationId}" } }; if (env.IsDevelopment()) { errorResponse.Data = context.Exception.ToString(); } context.Result = new ObjectResult(errorResponse); context.HttpContext.Response.StatusCode = (int)HttpStatusCode.InternalServerError; } context.ExceptionHandled = true; }
internal static void ParseError(IRestResponse response, RequestType requestType) { ApiErrorResponse apiError = GetApiErrorResponse(response.Content); DracoonApiCode resultCode = Parse((int)response.StatusCode, response, apiError, requestType); DracoonClient.Log.Debug(LogTag, $"Query for '{requestType.ToString()}' failed with '{resultCode.Text}'"); throw new DracoonApiException(resultCode); }
private static void OnClose(bool wasClean, ApiErrorResponse errorResponse) { if (!wasClean) { Console.WriteLine("Connection is forcibly closed."); OnError(errorResponse, null); } Console.WriteLine("Connection is closed."); }
private static void OnError(ApiErrorResponse errorResponse, long?requestId) { StringBuilder sb = new StringBuilder(); foreach (Error error in errorResponse.ErrorList) { sb.AppendLine(error.ToString()); Console.WriteLine(error); } }
public void SetResponseBody(HttpContext context, ApiErrorResponse response) { var json = JsonConvert.SerializeObject(response); using (var streamWriter = new StreamWriter(context.Response.Body)) { streamWriter.Write(json); streamWriter.Flush(); } }
public void OnActionExecuting(ActionExecutingContext context) { if (!context.ModelState.IsValid) { var modelState = context.ModelState.Values.First(x => x.ValidationState == ModelValidationState.Invalid); var errorMessage = string.Join(" ", modelState.Errors.Select(e => e.ErrorMessage)); var response = new ApiErrorResponse("Invalid Request", errorMessage); context.Result = new BadRequestObjectResult(response); } }
public async Task ListDatabasesAsync_ShouldThrow_WhenDatabaseIsNotSystem() { var ex = await Assert.ThrowsAsync <ApiErrorException>(async() => { await _fixture.DatabaseClientOther.GetDatabasesAsync(); }); ApiErrorResponse apiError = ex.ApiError; Assert.Equal(HttpStatusCode.Forbidden, apiError.Code); Assert.Equal(1230, apiError.ErrorNum); }
public async Task GetCurrentDatabaseInfoAsync_ShouldThrow_WhenDatabaseDoesNotExist() { var ex = await Assert.ThrowsAsync <ApiErrorException>(async() => { await _fixture.DatabaseClientNonExistent.GetDatabasesAsync(); }); ApiErrorResponse apiError = ex.ApiError; Assert.Equal(HttpStatusCode.NotFound, apiError.Code); Assert.Equal(1228, apiError.ErrorNum); }