private async Task <string> ProcessGetOrderRequest(GetOrderRequest request)
{
try
{
OrderDto orderDto = await _orderService.GetOrder(request.Order);
string result;
if (orderDto == null)
{
WebMessageBase response = new WebMessageBase("get_order");
response.Status = MessageStatus.FAIL;
response.Message = "Order with ID: " + request.Order + " not found";
result = JsonConvert.SerializeObject(response, Formatting.Indented);
return(result);
}
OrderRequestResponse orderResponse = new OrderRequestResponse("get_order", orderDto.FromDto());
result = JsonConvert.SerializeObject(orderResponse, Formatting.Indented);
return(result);
}
catch (Exception e)
{
WebMessageBase response = new WebMessageBase();
response.Status = MessageStatus.FAIL;
response.Message = "Could not get order !";
string result = JsonConvert.SerializeObject(response, Formatting.Indented);
_log("During processing get_order request an error occured: " + e.Message);
return(result);
}
}
private async Task <string> ProcessMakeOrderRequest(OrderRequestResponse request)
{
try
{
string clientID = request.Order.ClientInfo.Id;
if (string.IsNullOrEmpty(clientID) || string.IsNullOrWhiteSpace(clientID))
{
clientID = await _orderService.CustomerService.SaveCustomer(request.Order.ClientInfo.ToDto());
}
CustomerDto clientDto = await _orderService.CustomerService.GetCustomer(clientID);
string result;
if (clientDto == null)
{
WebMessageBase response = new WebMessageBase("make_order");
response.Status = MessageStatus.FAIL;
response.Message = "Client with ID: " + clientID + " not found";
result = JsonConvert.SerializeObject(response, Formatting.Indented);
return(result);
}
request.Order.ClientInfo.Id = clientID;
string orderId = await _orderService.SaveOrder(request.Order.ToDto());
OrderDto orderDto = await _orderService.GetOrder(orderId);
if (orderDto == null)
{
WebMessageBase response = new WebMessageBase("make_order");
response.Status = MessageStatus.FAIL;
response.Message = "Order with ID: " + request.Order.Id + " not found";
result = JsonConvert.SerializeObject(response, Formatting.Indented);
return(result);
}
OrderRequestResponse orderResponse = new OrderRequestResponse("make_order", orderDto.FromDto());
result = JsonConvert.SerializeObject(orderResponse, Formatting.Indented);
return(result);
}
catch (Exception e)
{
WebMessageBase response = new WebMessageBase();
response.Status = MessageStatus.FAIL;
response.Message = "Make order request error.";
string result = JsonConvert.SerializeObject(response, Formatting.Indented);
_log("During processing save_order request an error occured: " + e.Message);
return(result);
}
}
public async Task <string> MakeOrderRequest(Order order)
{
byte[] buffer = new byte[20000];
ArraySegment <byte> segment = new ArraySegment <byte>(buffer);
OrderModel orderModel = order.ToCommModel();
OrderRequestResponse request = new OrderRequestResponse("make_order", orderModel);
string requestJson = JsonConvert.SerializeObject(request, Formatting.Indented);
await _clientWebSocket.SendAsync(requestJson);
bool gotCorrectResponse = false;
string message = "";
while (!gotCorrectResponse)
{
WebSocketReceiveResult result = _clientWebSocket.ClientWebSocket.ReceiveAsync(segment, _timeOut).Result;
if (result.MessageType == WebSocketMessageType.Close)
{
_clientWebSocket.Disconnect();
throw new Exception("Disconnected. Close message");
}
int count = result.Count;
while (!result.EndOfMessage)
{
if (count >= buffer.Length)
{
_clientWebSocket.Disconnect();
throw new Exception("Disconnected. Buffer overloaded");
}
segment = new ArraySegment <byte>(buffer, count, buffer.Length - count);
result = _clientWebSocket.ClientWebSocket.ReceiveAsync(segment, _timeOut).Result;
count += result.Count;
}
message = Encoding.UTF8.GetString(buffer, 0, count);
WebMessageBase baseResponse = JsonConvert.DeserializeObject <WebMessageBase>(message);
if (baseResponse.Tag == "make_order")
{
gotCorrectResponse = true;
if (baseResponse.Status != MessageStatus.SUCCESS)
{
throw new Exception(baseResponse.Message);
}
}
}
OrderRequestResponse response = JsonConvert.DeserializeObject <OrderRequestResponse>(message);
string clientId = response.Order.ClientInfo.Id;
string orderId = response.Order.Id;
return("make_order:" + clientId + ":" + orderId);
}
private string OrderContext(string merchantId, OrderRequestResponse order)
{
var obj = new
{
MerchantId = merchantId,
order.Timestamp,
order.Address,
order.OrderId,
order.Currency,
order.Amount,
order.RecommendedFee,
order.TotalAmount,
order.ExchangeRate,
order.OrderRequestId,
order.TransactionWaitingTime,
order.MerchantPayRequestStatus
};
return(obj.ToJson());
}
public async Task <string> Resolve(string message, WebSocketConnection ws)
{
WebMessageBase request = JsonConvert.DeserializeObject <WebMessageBase>(message);
Console.WriteLine("[{0}] Resolving request: \"{1}\", status: {2}", DateTime.Now.ToString("HH:mm:ss.fff"), request.Tag, request.Status);
string output = String.Empty;
switch (request.Tag)
{
case "get_customer":
{
GetCustomerRequest customerRequest = JsonConvert.DeserializeObject <GetCustomerRequest>(message);
output = await ProcessGetCustomerRequest(customerRequest);
break;
}
case "get_merchandises":
{
GetMerchandisesRequest merchandiseRequest = JsonConvert.DeserializeObject <GetMerchandisesRequest>(message);
output = await ProcessGetMerchandisesRequest(merchandiseRequest);
break;
}
case "get_order":
{
GetOrderRequest ordeRequest = JsonConvert.DeserializeObject <GetOrderRequest>(message);
output = await ProcessGetOrderRequest(ordeRequest);
break;
}
case "make_order":
{
OrderRequestResponse orderRequest = JsonConvert.DeserializeObject <OrderRequestResponse>(message);
output = await ProcessMakeOrderRequest(orderRequest);
break;
}
case "subscription":
{
WebMessageBase subRequest = JsonConvert.DeserializeObject <WebMessageBase>(message);
output = await ProcessSubscriptionRequest(subRequest, ws);
break;
}
case "unsubscription":
{
WebMessageBase unSubRequest = JsonConvert.DeserializeObject <WebMessageBase>(message);
output = await ProcessUnsubscriptionRequest(unSubRequest, ws);
break;
}
}
return(output);
}
