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