public async Task Consume(ReceiveContext <ReceivableBooked> messageContext)
{
var @event = messageContext.Message;
var orderStatusRequest = new GetOrderStatus(@event.OrderStatus);
var orderStatus = await this.requestBus.Request <GetOrderStatus, OrderStatus>(orderStatusRequest);
this.uow.Update <OrderReview>()
.SetValue(o => o.OrderStatusDescription, orderStatus.Description)
.Where(o => o.Id, @event.OrderId);
await this.uow.Save();
var response = new OrderStatusResponse(orderStatus.LongDescription);
await messageContext.Respond(response);
}
/// <summary>
/// update order data
/// обновить данные по ордерам
/// </summary>
private void GetOrders()
{
for (int i = 0; i < _osEngineOrders.Count; i++)
{
Thread.Sleep(300);
Order order = _osEngineOrders[i];
OrderStatusResponse response = GetOrderStatus(order.NumberMarket);
if (response.transactions != null &&
response.transactions.Length != 0)
{
MyTrade trade = new MyTrade();
trade.NumberOrderParent = order.NumberMarket;
trade.NumberTrade = response.transactions[0].tid;
trade.Volume = order.Volume;
trade.Price =
response.transactions[0].price.ToDecimal();
_osEngineOrders.RemoveAt(i);
i--;
if (MyTradeEvent != null)
{
MyTradeEvent(trade);
}
}
else if (response.status == "Finished" || response.status == null)
{
Order newOrder = new Order();
newOrder.SecurityNameCode = order.SecurityNameCode;
newOrder.NumberUser = order.NumberUser;
newOrder.NumberMarket = order.NumberMarket;
newOrder.PortfolioNumber = order.PortfolioNumber;
newOrder.Side = order.Side;
newOrder.State = OrderStateType.Cancel;
if (MyOrderEvent != null)
{
MyOrderEvent(newOrder);
}
_osEngineOrders.RemoveAt(i);
i--;
}
}
}
public static async Task <HttpResponseMessage> SetOrderStatus([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
// Get request body
var body = await req.Content.ReadAsStringAsync();
var request = JsonConvert.DeserializeObject <OrderStatusRequest>(body);
if (request == null)
{
return(req.CreateResponse(HttpStatusCode.BadRequest, "No Valid Data submitted."));
}
var result = await CosmosClient.Instance.UpdateOrderStatus(request.OrderId, request.Status);
var response = new OrderStatusResponse();
return(req.CreateResponse(HttpStatusCode.OK, response));
}
private void GetOrderStatus(Guid orderId)
{
var fail = new Fail();
var orderStatusResponse = new OrderStatusResponse();
var orderService = new FsiOrderServiceV5();
var orderStatusServiceResponse = orderService.GetOrderStatus(orderId);
if (orderStatusServiceResponse.ResponseMessage.IsSuccessStatusCode)
{
//do success stuff
string xml = orderStatusServiceResponse.Content;
var serializer = new XmlSerializer(typeof(OrderStatusResponse));
var sr = new StringReader(orderStatusServiceResponse.Content);
//save xml file
//serialize the successful response if needed in objects
orderStatusResponse = (OrderStatusResponse)serializer.Deserialize(sr);
//write to log file
}
else
{
if (!string.IsNullOrWhiteSpace(orderStatusServiceResponse.Content))
{
//do fail stuff
var serializer = new XmlSerializer(typeof(Fail));
var sr = new StringReader(orderStatusServiceResponse.Content);
//serialize the failed response
//fail = (Fail) serializer.Deserialize(sr);
sr.Close();
//write to error log
}
}
}
public async Task <BaseResponse <OrderStatusResponse> > Get(int OrderStatusId)
{
OrderStatusResponse OrderStatus = _mapper.Map <OrderStatusResponse>(await _db.OrderStatuses.Where(x => x.Id == OrderStatusId)
.FirstOrDefaultAsync());
if (OrderStatus != null)
{
return(new BaseResponse <OrderStatusResponse>
{
Code = RsponseCode.Success,
Message = "",
Data = OrderStatus
});
}
return(new BaseResponse <OrderStatusResponse>
{
Code = RsponseCode.NotFound,
Message = "لا يوجد بيانات ",
Data = null
});
}
public virtual async Task Consume(ReceiveContext <OrderCreated> messageContext)
{
var message = messageContext.Message;
var customerRequest = new GetCustomer(message.CustomerId);
var customer = await this.requestBus.Request <GetCustomer, Customer>(customerRequest);
var orderStatus = await this.GetOrderStatus(message.OrderStatus);
var orderReview = new OrderReview(
message.OrderId,
customer.Name,
message.OrderTotal,
orderStatus.Description);
this.uow.Add(orderReview);
foreach (var eventItem in message.Items)
{
var productRequest = new GetProduct(eventItem.ProductId);
var product = await this.requestBus.Request <GetProduct, Product>(productRequest);
var item = new OrderItem(
message.OrderId,
eventItem.LineNumber,
product.Name,
eventItem.Quantity,
eventItem.Price);
this.uow.Add(item);
}
await this.uow.Save();
if (message.OrderStatus == OrderStatusEnum.OrderSuspended)
{
var response = new OrderStatusResponse(orderStatus.LongDescription);
await messageContext.Respond(response);
}
}
private IncomingRequest GetOrderStatus(IncomingRequest request, string orderOptionNumber, ChatRecord userlastRecordDb, string incomingMessage)
{
try
{
var url = "/getAllOrders";
// var orders = WebGETSync<IList<OrderResponse>>(url);
var orders = new List <OrderResponse>()
{
new OrderResponse {
Name = "Order1", Id = 111111, ValidatedOn = DateTime.Now
},
new OrderResponse {
Name = "Order2", Id = 222222, ValidatedOn = DateTime.Now
},
new OrderResponse {
Name = "Order3", Id = 333333, ValidatedOn = DateTime.Now
},
new OrderResponse {
Name = "Order4", Id = 444444, ValidatedOn = DateTime.Now
},
new OrderResponse {
Name = "Order5", Id = 555555, ValidatedOn = DateTime.Now
},
};
string orderStatusUrl = "";
string orderName = "";
string orderId = "";
if (orderOptionNumber == "1")
{
orderStatusUrl = $"/getOrderStatusById?orderId={orders[0].Id}";
orderName = orders[0].Name;
orderId = orders[0].Id.ToString();
}
if (orderOptionNumber == "2")
{
orderStatusUrl = $"/getOrderStatusById?orderId={orders[1].Id}";
orderName = orders[1].Name;
orderId = orders[1].Id.ToString();
}
if (orderOptionNumber == "3")
{
orderStatusUrl = $"/getOrderStatusById?orderId={orders[2].Id}";
orderName = orders[2].Name;
orderId = orders[2].Id.ToString();
}
if (orderOptionNumber == "4")
{
orderStatusUrl = $"/getOrderStatusById?orderId={orders[3].Id}";
orderName = orders[3].Name;
orderId = orders[3].Id.ToString();
}
if (orderOptionNumber == "5")
{
orderStatusUrl = $"/getOrderStatusById?orderId={orders[4].Id}";
orderName = orders[4].Name;
orderId = orders[4].Id.ToString();
}
// var response = WebGETSync<OrderStatusResponse>(orderStatusUrl);
var response = new OrderStatusResponse {
Status = "LO"
};
if (response.Status == "LO")
{
string orderStatus = $"Order {orderName} (Order id :{orderId}) has been locked." +
$"\n Locked : Your order has been confirmed by the laboratory";
request.body = orderStatus;
SaveSentResponse(request, userlastRecordDb, incomingMessage, Constants.OrderStatusMessage);
return(request);
}
if (response.Status == "OI")
{
string orderStatus = $"Order {orderName} (Order id :{orderId}) has been imported by lab." +
$"\n Imported : Your order has successfully reached laboratory";
request.body = orderStatus;
SaveSentResponse(request, userlastRecordDb, incomingMessage, Constants.OrderStatusMessage);
return(request);
}
if (response.Status == "CV")
{
string orderStatus = $"Order {orderName} (Order id :{orderId}) has been validated." +
$"\n Validated: Your order is confirmed and yet to be received by laboratory.";
request.body = orderStatus;
SaveSentResponse(request, userlastRecordDb, incomingMessage, Constants.OrderStatusMessage);
return(request);
}
else
{
string orderStatus = $"Order {orderName} (Order id :{orderId}) is pending order." +
$"\n Pending Order: Your order is not yet submitted and it is still in pending state.";
request.body = orderStatus;
SaveSentResponse(request, userlastRecordDb, incomingMessage, Constants.OrderStatusMessage);
request.body = orderStatus;
SaveSentResponse(request, userlastRecordDb, incomingMessage, Constants.ReOrderSuceessMessage);
}
return(request);
}
catch
{
request.body = Constants.ApiExceptionMessage;
SaveSentResponse(request, userlastRecordDb, incomingMessage, Constants.ApiExceptionMessage);
return(request);
}
}
public decimal Long()
{
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
string baseCurrency = Properties.Settings.Default.BaseCurrency;
string market = Properties.Settings.Default.Market;
decimal price = 0;
try
{
decimal balance = this.GetBalance(baseCurrency);
//-------------------------------
string pair = (market + baseCurrency).ToLower();
price = this.GetCurrentPrice(baseCurrency, market);
decimal ammount;
if (Properties.Settings.Default.UsingFixedAmount)
{
ammount = decimal.Parse(Properties.Settings.Default.FixedAmmount.ToString());
}
else
{
ammount = Properties.Settings.Default.CapitalPercentageInEachOrder * (balance / price);
}
decimal limitBuyPrice = price * ((100 + Properties.Settings.Default.LimitSpreadPercentage) / 100);
//------------------------------------------------------
string decimalString = ammount.ToString();
if (decimalString.Contains(","))
{
decimalString = decimalString.Replace(",", ".");
ammount = Convert.ToDecimal(decimalString);
}
//------------------------------------------------------
//CancelAllOrdersResponse cancelOrdersResponse = api.CancelAllOrders();
ActivePositionsResponse activePositionsResponse = api.GetActivePositions();
foreach (var pos in activePositionsResponse.positions)
{
decimal posAmmount = decimal.Parse(pos.amount);
if (pos.symbol == pair && posAmmount < 0)
{
ammount -= posAmmount;
}
}
//------------------------------------------------------
NewOrderResponse buyResponse = api.ExecuteBuyOrder(pair.ToUpper(), ammount, limitBuyPrice, OrderExchange.Bitfinex, OrderType.MarginMarket);
string orderId = buyResponse.order_id;
OrderStatusResponse buyStatus = api.GetOrderStatus(Int64.Parse(buyResponse.order_id));
if (bool.Parse(buyStatus.is_cancelled))
{
//Console.ForegroundColor = ConsoleColor.Magenta;
//Console.WriteLine("Order was canceled...");
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("-----------------------------------------------------------------------------------");
Console.WriteLine("Market LONG order executed on " + buyResponse.symbol + " id = " + orderId);
Console.WriteLine("Price: " + buyStatus.price);
Console.WriteLine("Average Execution Price: " + buyStatus.avg_execution_price);
Console.WriteLine("Executed ammount: " + buyStatus.executed_amount);
Console.WriteLine("Remaining ammount : " + buyStatus.remaining_amount);
//update price, to return real price per unit
price = Convert.ToDecimal(buyStatus.avg_execution_price);
Console.ForegroundColor = ConsoleColor.White;
//-------------------------------------------------------------
// logger.Log("------" + DateTime.Now.ToShortDateString() + "--------------------------------------------------------------------");
// logger.Log("Market LONG order executed on " + buyResponse.symbol + " id = " + orderId);
// logger.Log("Price: " + buyStatus.price);
// logger.Log("Average Execution Price: " + buyStatus.avg_execution_price);
// logger.Log("Executed ammount: " + buyStatus.executed_amount);
// logger.Log("Remaining ammount : " + buyStatus.remaining_amount);
}
return(price);
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Error on Long Order: ");
Console.WriteLine("ex.Message");
Console.WriteLine(ex.InnerException);
Console.WriteLine(ex.StackTrace);
Console.ForegroundColor = ConsoleColor.White;
}
return(price);
}
