/// <summary>
/// Response for missing/Invalid headers.
/// </summary>
/// <param name="ignoreMissingAuth">Whether or not errors due to missing <see cref="HeaderNames.Authorization"/> should be thrown.</param>
/// <returns>The appropriate <see cref="IActionResult"/>.</returns>
protected IActionResult HeadersIssue(bool ignoreMissingAuth)
{
HeadersException headersException;
try
{
var _ = new ApiHeaders(Request.GetTypedHeaders(), ignoreMissingAuth);
throw new InvalidOperationException("Expected a header parse exception!");
}
catch (HeadersException ex)
{
headersException = ex;
}
var errorMessage = new ErrorMessageResponse(ErrorCode.BadHeaders)
{
AdditionalData = headersException.Message
};
if (headersException.MissingOrMalformedHeaders.HasFlag(HeaderTypes.Accept))
{
return(StatusCode(HttpStatusCode.NotAcceptable, errorMessage));
}
return(BadRequest(errorMessage));
}
public void OnException(ExceptionContext context)
{
logger.LogError(new EventId(context.Exception.HResult), context.Exception, context.Exception.Message);
if (context.Exception is CartException)
{
var errorResponse = new ErrorMessageResponse
{
Message = context.Exception.Message,
StatusCode = (int)HttpStatusCode.BadRequest
};
context.Result = new BadRequestObjectResult(errorResponse);
context.HttpContext.Response.StatusCode = errorResponse.StatusCode;
}
else
{
var errorResponse = new ErrorMessageResponse
{
Message = "An unexpected error has occured. Please try again later.",
};
if (env.IsDevelopment())
{
errorResponse.Exception = context.Exception;
}
errorResponse.StatusCode = (int)HttpStatusCode.InternalServerError;
context.Result = new ObjectResult(errorResponse);
context.HttpContext.Response.StatusCode = errorResponse.StatusCode;
}
context.ExceptionHandled = true;
}
private static Task HandleInternalExceptionAsync(HttpContext context, Exception ex)
{
var error = new ErrorMessageResponse
{
Error = ex.Message,
Status = HttpStatusCode.InternalServerError
};
var result = JsonConvert.SerializeObject(error);
context.Response.ContentType = "application/json";
context.Response.StatusCode = (int)error.Status;
return(context.Response.WriteAsync(result));
}
public async Task Invoke(HttpContext context)
{
ErrorMessageResponse errorMessageResponse = null;
try
{
string authHeader = context.Request.Headers["Authorization"];
var apiKey = authSettings.Value.ApiKey;
if (authHeader != null && apiKey != null && authHeader.Equals(apiKey))
{
await next.Invoke(context);
}
else
{
context.Response.StatusCode = 401;
throw new UnauthorizedAccessException();
}
}
catch (Exception ex)
{
logger.LogError(new EventId(ex.HResult), ex, ex.Message);
errorMessageResponse = new ErrorMessageResponse
{
Message = ex.Message,
Exception = ex,
StatusCode = 401
};
context.Response.StatusCode = 401;
}
if (!context.Response.HasStarted)
{
context.Response.ContentType = "application/json";
var response = JsonConvert.SerializeObject(errorMessageResponse, new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
});
await context.Response.WriteAsync(response);
}
}
/// <inheritdoc />
public void SetErrorMessage(ErrorMessageResponse errorMessage)
{
if (errorMessage == null)
#pragma warning disable IDE0016 // Use 'throw' expression
{
throw new ArgumentNullException(nameof(errorMessage));
}
#pragma warning restore IDE0016 // Use 'throw' expression
if (this.errorMessage != null)
{
throw new InvalidOperationException("ErrorMessage already set!");
}
this.errorMessage = errorMessage;
completionTcs.TrySetResult(null);
}
public async Task <IActionResult> UploadFile(IFormFile file)
{
string extension = "." + file.FileName.Split(".")[file.FileName.Split(".").Length - 1];
if (extension != ".csv" && extension != ".xml")
{
ErrorMessageResponse response = new ErrorMessageResponse();
response.StatusCode = "Error";
response.Message = "Unknown format";
return(NotFound(response));
}
List <FileModel> files = extension == ".csv" ? readCSVfile(file) : readXMLfile(file);
if (!_ValidateData(files, extension))
{
return(BadRequest(_invalidtrasactionResponse));
}
else
{
bool result = await CreateTransaction(files, extension);
UploadResponse response = new UploadResponse();
if (result)
{
response.StatusCode = "200";
response.Message = "Upload Success";
return(Ok(response));
}
else
{
response.StatusCode = "400";
response.Message = "Upload Fail";
return(BadRequest(response));
}
}
}
internal void OnError(ErrorMessageResponse message)
{
Logger.Info("ErrorInfo message: " + message.Error);
Error?.Invoke(this, new EventArgs<string>(message.Error));
}
private static async void ProcessReceive(TcpTransport serverTransport, FrameData frameData,
IMessageProcessor messageProcessor)
{
ResponseBase response = null;
if (frameData.TitleBytes == null || frameData.TitleBytes.Length == 0)
{
response = new ErrorMessageResponse((byte)ResponseCode.SERVICE_TITLE_ERROR, "service title is null or empty");
}
if (messageProcessor == null)
{
response = new ErrorMessageResponse((byte)ResponseCode.MESSAGE_PROCESSOR_EMPTY, "message processor is null");
}
try
{
if (response == null)
{
if (NetworkSettings.ServerProcessMode == CommunicationMode.Sync)
{
var responseTask = messageProcessor.Process(frameData);
responseTask.Wait();
response = responseTask.Result;
}
else
{
response = await messageProcessor.Process(frameData);
}
}
}
catch
{
response = new ErrorMessageResponse((byte)ResponseCode.SERVER_INTERNAL_ERROR, "server internal error");
}
var responseExtention = response.HeaderExtentionBytes ?? FrameFormat.EmptyBytes;
var responseContent = response.ContentBytes ?? FrameFormat.EmptyBytes;
var responseCode = response.Code;
try
{
var messageByteCount = FrameFormat.ComputeFrameByteCount(responseExtention, FrameFormat.EmptyBytes, responseContent);
var sendBuffer = serverTransport.SendBufferCache.Get(messageByteCount);
FrameFormat.FillFrame(sendBuffer, responseExtention, FrameFormat.EmptyBytes, responseContent, responseCode, frameData.MessageId);
//if (NetworkSettings.ServerTcpSendMode == TcpSendMode.Async)
//{
// serverTransport.SendAsync(sendBuffer, messageByteCount);
//}
//else
//{
serverTransport.Send(sendBuffer, messageByteCount);
//}
serverTransport.SendBufferCache.Cache(sendBuffer);
}
catch
{
serverTransport.Close();
}
}
