internal void ParseFromNonMarketBuyOrderForeignCommission(OrderUpdate.OrderTypes type)
{
var order = new OrderUpdate(
orderId: 0,
tradeId: 0,
orderType: type,
orderStatus: Filled,
createdTimestamp: 0,
setPrice: 0.2M,
side: OrderSide.Buy,
pair: TradingPair.Parse("EOSETH"),
setQuantity: 100M)
{
FilledQuantity = 100M,
AverageFilledPrice = 0.15M,
LastFillIncrement = 100M,
LastFillPrice = 0.15M,
Commission = 96.42M,
CommissionAsset = new Currency("BNB"),
};
var exec = TradeExecution.FromOrder(order);
Assert.Equal(0M, exec.From.Free);
Assert.Equal(100M * 0.2M, exec.From.Locked);
Assert.Equal(100M, exec.To.Free);
Assert.Equal(0M, exec.To.Locked);
}
internal void ParseFromMarketSellOrderNewHappyFlow()
{
var order = new OrderUpdate(
orderId: 0,
tradeId: 0,
orderType: Market,
orderStatus: New,
createdTimestamp: 0,
setPrice: 0.4M,
side: OrderSide.Sell,
pair: TradingPair.Parse("EOSETH"),
setQuantity: 40M)
{
FilledQuantity = 40M,
AverageFilledPrice = 0.401M,
};
var exec = TradeExecution.FromOrder(order);
Assert.Equal(order.Pair.Left, exec.From.Symbol);
Assert.Equal(order.Pair.Right, exec.To.Symbol);
Assert.Equal(40M, exec.From.Free);
Assert.Equal(0, exec.From.Locked);
Assert.Equal(40M * 0.401M, exec.To.Free);
Assert.Equal(0, exec.To.Locked);
}
internal void ParseFromMarketOrderPriceZero(OrderSide side)
{
var order = new OrderUpdate(
orderId: 0,
tradeId: 0,
orderType: Market,
orderStatus: New,
createdTimestamp: 0,
setPrice: 0.4M,
side: side,
pair: TradingPair.Parse("EOSETH"),
setQuantity: 40M)
{
AverageFilledPrice = 0M,
FilledQuantity = 10M,
};
var exec = TradeExecution.FromOrder(order);
Assert.Equal(exec.From.Locked, decimal.Zero);
if (side == OrderSide.Sell)
{
Assert.Equal(10M, exec.From.Free);
Assert.Equal(decimal.Zero, exec.To.Free);
}
else
{
Assert.Equal(decimal.Zero, exec.From.Free);
Assert.Equal(10M, exec.To.Free);
}
Assert.Equal(exec.To.Locked, decimal.Zero);
}
internal void ParseFromNonMarketSellOrderCancelledHappyFlow(OrderUpdate.OrderTypes orderType)
{
var order = new OrderUpdate(
orderId: 0,
tradeId: 0,
orderType: orderType,
orderStatus: Cancelled,
createdTimestamp: 0,
setPrice: 0.2M,
side: OrderSide.Sell,
pair: TradingPair.Parse("EOSETH"),
setQuantity: 100M);
var exec = TradeExecution.FromOrder(order);
Assert.NotNull(exec);
var symbol = new Currency("EOS");
Assert.Equal(symbol, exec.From.Symbol);
Assert.Equal(symbol, exec.To.Symbol);
Assert.Equal(0M, exec.From.Free);
Assert.Equal(100M, exec.From.Locked);
Assert.Equal(100M, exec.To.Free);
Assert.Equal(0M, exec.To.Locked);
}
public async Task <AttrResultModel> UpdateOrder([FromBody] CreateOrderDto orderDto)
{
//这里如果不指定主键的话，默认会按照实体的第一个带有ID的字段为主键,建议手动指定
var result = await client.UpdateHasValueFieldAsync <CreateOrderDto, R01_Order>(orderDto, "更新出错", "R01_OrderId");
result = await client.UpdateAsync <CreateOrderDto, R01_Order>(orderDto, "更新出错", "R01_OrderId");
result = await client.ExecUpdateSql <R01_Order>(null, "Update R01_Order set R01_OrderNo = 'test' where R01_OrderId = 1", "更新出错");
OrderUpdate orderUpdate = new OrderUpdate()
{
C02_CustomerId = 1,
P01_ProductId = 1,
P02_ProductFlowId = 1,
R01_OrderNo = "11"
};
//生成的sql
/*
* Update tableName
* set DbfieldName2 = @C02_CustomerId,
* DbfieldName3 = @P01_ProductId,
* DbfieldName4 = @P02_ProductFlowId
* Where DbfieldName1 = @R01_OrderNo
*/
result = await client.UpdateAsync(orderUpdate);
return(result);
}
protected override State <Config> Run(TradingProvider trading, DataProvider data)
{
// If the Filter and CrossoverSMA signal the trade, we buy at market.
OrderUpdate buyOrder = trading.ExecuteFullMarketOrderBuy(FirstPair);
return(new InTradeState(buyOrder));
}
private OrderUpdate xx()
{
HttpWebPage openWeb = new HttpWebPage();
string activeUrl = "http://www.mysdic.com/join/invite.html";
string tempHtml = openWeb.DoGet(activeUrl);
string count1 = tempHtml.Abstract("fnt_24", "详细内容");
if (count1.Contains("招聘"))
{
List <string> ss = RegexHelper.GetMatchsList(@"\d{4}年\d{2}月\d{2}日", count1);
if (ss.Count > 0)
{
DateTime start = this.dateTimePicker1.Value;
DateTime end = new DateTime(
int.Parse(ss[0].Abstract("", "年")),
int.Parse(ss[0].Abstract("年", "月")),
int.Parse(ss[0].Abstract("月", "日")));
TimeSpan ts = end - start;
if (ts.TotalSeconds > 0)
{
this.dateTimePicker1.Value = end;
OrderUpdate record = new OrderUpdate();
record.Price = ss[0];
record.Quantity = count1.Abstract("blank\">", "</a>");
return(record);
}
}
}
return(null);
}
public void onOrder(Order order)
{
OrderUpdate update = new OrderUpdate();
update.orderId = StringUtils.trim(order.orderId);
update.orderSide = (int)order.orderSide;
update.orderType = (int)order.orderType;
update.ordStatus = (int)order.ordStatus;
update.price = order.price;
update.quantity = order.quantity;
update.symbol = StringUtils.trim(order.symbol);
update.timeInForce = (int)order.timeInForce;
update.exchangeOrderId = StringUtils.trim(order.exchangeOrderId);
update.avgPx = order.avgPx;
update.clOrderId = StringUtils.trim(order.clOrderId);
update.created = StringUtils.trim(order.created);
update.cumQty = order.cumQty;
update.exchangeAccount = order.exchangeAccount;
update.execType = (int)order.execType;
update.account = order.account;
_manager.Publish(update);
logger.Info("Send OrderUpdate: " + order.ToString());
}
private void OnOrderUpdate(OrderUpdate update)
{
//TODO： 显示update到_dgvOrderbook
//用invoke和委托来解决线程安全的问题
if (this._dgvOrderbook.InvokeRequired)
{
this.Invoke(new updateDelegate(OnOrderUpdate), new object[] { update });
}
else
{
DataRow dr = dtTemp.NewRow();
dr[0] = update.OrderID;
dr[1] = update.Side;
dr[2] = update.Price;
dr[3] = update.Quantity;
dr[4] = update.Status;
if (isPalse)
{
//处于暂停状态时，当前行存入dtShow，直到按钮点击继续时，处理dtTemp中的行
dtTemp.Rows.Add(dr);
}
else
{ //处于进行状态时，直接处理当前行
ProcessRow(dr);
}
}
}
private static void MarketDataSource_OrderUpdateEvent(OrderUpdate orderDetail)
{
if (orderDetail.OrderStatus != "ACCEPTED")
{
Console.WriteLine(orderDetail.OrderStatus + " for Client Id " + orderDetail.ClientId + " Product Type " + orderDetail.Product + " Order Type " + orderDetail.OrderType + " Price " + orderDetail.Price + " Avg Price " + orderDetail.AverageTradePrice + " Trigger Price " + orderDetail.TriggerPrice + " Qty " + orderDetail.Quantity + " Disc Qty " + orderDetail.DisclosedQuantity);
}
}
public void GetFilledBuyStoplossOrderUnMutated()
{
var order = new OrderUpdate(
orderId: 9,
tradeId: 8,
orderStatus: OrderUpdate.OrderStatus.New,
orderType: OrderTypes.StopLoss,
createdTimestamp: 302,
setPrice: 2.1M,
side: OrderSide.Buy,
pair: TradingPair.Parse("TRXETH"),
setQuantity: 18.6M)
{
StopPrice = 1.9M,
};
var candle = new BacktestingCandle(0, 1, 1, 2, 1, 0, "EOSETH");
GetFilledOrder(order, candle, 434424233);
Assert.Equal(OrderStatus.Filled, order.Status);
Assert.Equal(OrderTypes.StopLoss, order.OrderType);
Assert.Equal(1.9M, order.AverageFilledPrice);
Assert.Equal(1.9M, order.LastFillPrice);
Assert.Equal(18.6M, order.FilledQuantity);
Assert.Equal(18.6M, order.LastFillIncrement);
Assert.Equal(434424233, order.FilledTimestamp);
}
public CallResult <BinancePlacedOrder> PlaceOrder(string symbol, OrderSide side, OrderType type,
decimal quantity, string newClientOrderId = null,
decimal?price = null, TimeInForce?timeInForce = null, decimal?stopPrice = null,
decimal?icebergQty = null,
OrderResponseType?orderResponseType = null, int?receiveWindow = null)
{
var order = _implementation.PlaceTestOrder(symbol, side, type, quantity, newClientOrderId, price, timeInForce,
stopPrice, icebergQty, orderResponseType, receiveWindow);
if (order.Success)
{
var data = order.Data;
data.OrderId = _orderIdGenerator.Next();
// PlaceTestOrder does not propagate this data, set it manually.
data.Type = type;
data.Side = side;
var ev = new OrderUpdate(
orderId: data.OrderId,
tradeId: 0,
orderStatus: data.Type == OrderType.Market ? OrderUpdate.OrderStatus.Filled : OrderUpdate.OrderStatus.New,
orderType: BinanceUtilities.ToInternal(data.Type),
createdTimestamp: 0,
setPrice: data.Price,
side: BinanceUtilities.ToInternal(data.Side),
pair: TradingPair.Parse(symbol),
setQuantity: data.OriginalQuantity);
_parent.ScheduleObserverEvent(ev);
}
return(order);
}
public async Task<IActionResult> PutOrderItem([FromBody]OrderUpdate orderUpdate)
{
try
{
if (orderUpdate.OrderID <= 0)
throw new Exception("One or more validation errors occurred");
var orderExists = await DbAccessClass.OrderIDExists(orderUpdate.OrderID, _context);
if (!orderExists)
throw new Exception("Order not found");
var order = await DbAccessClass.GetOrder(orderUpdate.OrderID, _context);
await DbAccessClass.UpdateOrder(orderUpdate, order, _context);
return Ok("Order updated successfully");
}
catch (Exception ex)
{
return ex.Message switch
{
"Order not found" => NotFound(new JsonResult(ex.Message)),
"One or more validation errors occurred" => UnprocessableEntity(new JsonResult(ex.Message)),
_ => BadRequest(new JsonResult(ex.Message)),
};
}
}
/// <inheritdoc />
public override ResponseObject <OrderUpdate> PlaceStoplossOrder(TradingPair pair, OrderSide side, decimal quantity, decimal price, long tradeId)
{
// Add the order to the watchlist
OrderUpdate order = new OrderUpdate(
orderId: _mockOrderCounter++,
tradeId: tradeId,
orderStatus: OrderUpdate.OrderStatus.New,
orderType: OrderUpdate.OrderTypes.StopLoss,
createdTimestamp: Timer.CurrentTime.ToUnixTimeMilliseconds(),
setPrice: 0,
side: side,
pair: pair,
setQuantity: quantity)
{
StopPrice = price,
};
// Add to order cache to confirm placement.
_orderCache.Enqueue(order);
// Add to watchlist to check if filled
WatchList.Add(order.OrderId, order);
return(new ResponseObject <OrderUpdate>(ResponseCode.Success, order));
}
/// <inheritdoc />
public override ResponseObject <OrderUpdate> ExecuteMarketOrder(TradingPair pair, OrderSide side, decimal quantity, long tradeId)
{
decimal priceEstimate = _dataProvider.GetCurrentPriceTopBid(pair).Data;
var order = new OrderUpdate(
_mockOrderCounter++,
tradeId,
OrderUpdate.OrderStatus.Filled,
OrderUpdate.OrderTypes.Market,
Timer.CurrentTime.ToUnixTimeMilliseconds(),
priceEstimate,
side,
pair,
quantity)
{
AverageFilledPrice = priceEstimate,
FilledQuantity = quantity,
FilledTimestamp = Timer.CurrentTime.ToUnixTimeMilliseconds(),
};
// Add to order cache to confirm filled
_orderCache.Enqueue(order);
// Write the trade to the logger
LogOrder(order);
return(new ResponseObject <OrderUpdate>(
ResponseCode.Success,
order));
}
protected override State <Config> Run(TradingProvider trading, DataProvider data)
{
decimal stopPrice = data.GetLowestLow(FirstPair, AlgorithmConfiguration.Loss);
stopLoss = trading.PlaceFullStoplossSell(FirstPair, stopPrice);
return(new InTradeState(_buyOrder, stopLoss));
}
private DataRow OrderObjToDataRow(OrderUpdate order)
{
DataRow row = sourceData.NewRow();
row["Price"] = order.Price;
row["Quantity"] = order.Quantity;
return(row);
}
public override State <Config> OnOrderUpdate(OrderUpdate order)
{
if (_stoploss != null && order.OrderId == _stoploss.OrderId && order.Status == OrderUpdate.OrderStatus.Filled)
{
return(new EntryState());
}
return(new NothingState <Config>());
}
protected override State <Config> Run(TradingProvider trading, DataProvider data)
{
// Get the lowest low from the last y hours.
decimal shortTermTimePrice = data.GetLowestLow(FirstPair, AlgorithmConfiguration.ShortTermTime);
// Set first stop loss order at DCMin.
_stoploss = trading.PlaceFullStoplossSell(FirstPair, shortTermTimePrice);
return(new CheckState(_stoploss));
}
protected override State <Config> Run(TradingProvider trading, DataProvider data)
{
var pair = AlgorithmConfiguration.TradingPairs.First();
var price = data.GetCurrentPriceTopBid(pair);
_stoploss = trading.PlaceFullStoplossSell(pair, price * AlgorithmConfiguration.StopTrail);
SetTimer(TimeSpan.FromHours(AlgorithmConfiguration.WaitTime));
return(new NothingState <KeiraNightlyConfiguration>());
}
public override State <Config> OnOrderUpdate(OrderUpdate order)
{
if (order.Status == OrderUpdate.OrderStatus.Filled && order.OrderId == _limitSell.OrderId)
{
return(new WaitState());
}
return(new NothingState <Config>());
}
public override State <KeiraNightlyConfiguration> OnOrderUpdate(OrderUpdate order)
{
if (_sell != null && order.OrderId == _sell.OrderId && order.Status == OrderUpdate.OrderStatus.Filled)
{
return(new CoolDownState());
}
return(new NothingState <KeiraNightlyConfiguration>());
}
protected override State <Config> Run(TradingProvider trading, DataProvider data)
{
var pair = AlgorithmConfiguration.TradingPairs.First();
var price = data.GetCurrentPriceTopBid(pair);
_sell = trading.PlaceFullLimitOrderSell(pair, price * AlgorithmConfiguration.TakeProfit);
SetTimer(TimeSpan.FromHours(AlgorithmConfiguration.WaitTime));
return(new NothingState <Config>());
}
public Mail Translate(OrderUpdate orderUpdate)
{
var mail = Mail.GetInstance();
mail.AddTo(orderUpdate.ReminderTo);
mail.AddCc(orderUpdate.CopyReminderTo);
mail.Subject = string.Format("Task Reminder! Task {0} is due on {1}", orderUpdate.OrderReference, orderUpdate.DueDate);
return(mail);
}
private void OnNext(OrderUpdate order)
{
var item = new OrderEvent(Session, DateTimeOffset.Now.ToUnixTimeMilliseconds(), order);
lock (Lock)
{
_database.OrderEvents.Add(item);
_database.SaveChanges();
}
}
public IActionResult UpdateOrderPut(OrderUpdate orderUpdate) //полное обновление заказа
{
if (_repository.Orders.IsOrderExists(orderUpdate.Number))
{
OrderStore orderFromStore = _repository.Orders.GetOrder(orderUpdate.Number);
_mapper.Map(orderUpdate, orderFromStore);
_repository.Orders.UpdateOrder(orderFromStore);
return(NoContent());
}
return(NotFound());
}
public void OrderNew_Creates_A_Copy_Of_Provided_Source()
{
var copy = OrderUpdate.From(Source);
Assert.True(copy != Source);
Assert.Equal(copy.RowVersion, Source.RowVersion);
Assert.Equal(copy.HouseNumber, Source.HouseNumber);
Assert.Equal(copy.PostCode, Source.PostCode);
Assert.Equal(copy.Price, Source.Price);
Assert.Equal(copy.CustomerName, Source.CustomerName);
}
public OrderUpdateTests()
{
Source = new OrderUpdate()
{
CustomerName = "Test Name",
HouseNumber = 1,
RowVersion = new byte[] { 1, 1, 1, 1 },
PostCode = "1541UT",
Price = 20m
};
}
private void m_Sim_OnFillUpdate(OrderUpdate f)
{
Debug.WriteLine(f.FFT);
String BS = "B";
if (f.FillType == Request.RequestType.SELL)
{
BS = "S";
}
OnFill(this, Convert.ToDouble(f.Qty), BS, Convert.ToString(f.Price), Convert.ToString(f.FFT));
}
public IActionResult Update([FromBody] OrderUpdate order)
{
try
{
var result = _orderService.Update(order);
return(Ok(result));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
