private static void TradeChangedDeal()
{
var keysTrades = Program.成交表Changed.Keys.ToList();
foreach (string UserName in keysTrades)
{
if (Program.成交表Changed[UserName])
{
if (Program.交易员成交DataTable.ContainsKey(UserName))
{
var dtOrders = Program.交易员成交DataTable[UserName];
JyDataSet.成交DataTable dtSuccessOrder = null;
lock (dtOrders)
{
dtSuccessOrder = dtOrders.Copy() as JyDataSet.成交DataTable;
}
Send成交TableChangedNoticeToTrader(UserName, dtSuccessOrder);
}
Program.成交表Changed[UserName] = false;
}
}
}
public void Deal()
{
AASServer.DbDataSet.已发委托Row 已发委托Row1 = Program.db.已发委托.Get已发委托(DateTime.Today, this.组合号, this.委托编号);
if (已发委托Row1 == null)
{
return;
}
if (this.状态说明 == "废单")
{
bool needUpdate = false;
if (已发委托Row1.状态说明 != "废单")
{
Program.db.已发委托.Update(已发委托Row1.日期, 已发委托Row1.组合号, 已发委托Row1.委托编号, "废单");
needUpdate = true;
}
if (needUpdate)
{
Program.废单通知.Enqueue(this);
}
}
if (this.状态说明.Contains("未通知废单"))
{
if (Regex.IsMatch(this.状态说明, "Please Input Valid Value For Quantity [(]Lot Size [0-9]+"))
{
this.状态说明 = string.Format("废单，请按一手股数{0}的整数倍交易!", Regex.Match(this.状态说明, "[0-9]+").Value);
}
else
{
this.状态说明 = this.状态说明.Replace("未通知废单", "废单");
}
Program.db.已发委托.Update(已发委托Row1.日期, 已发委托Row1.组合号, 已发委托Row1.委托编号, this.状态说明);
Program.废单通知.Enqueue(this);
}
if (this.撤单数量 > 已发委托Row1.撤单数量)
{
Program.db.已发委托.Update(已发委托Row1.日期, 已发委托Row1.组合号, 已发委托Row1.委托编号, this.撤单数量);
}
if (this.成交数量 > 已发委托Row1.成交数量)
{
decimal 未处理成交数量 = this.成交数量 - 已发委托Row1.成交数量;
if (this.成交价格 == 0)
{
this.成交价格 = this.委托价格;
}
decimal 未处理成交金额 = this.成交价格 * this.成交数量 - 已发委托Row1.成交价格 * 已发委托Row1.成交数量;
decimal 未处理成交价格 = Math.Round(未处理成交金额 / 未处理成交数量, 3, MidpointRounding.AwayFromZero);
AASServer.JyDataSet.成交DataTable 成交DataTable1 = new JyDataSet.成交DataTable();
JyDataSet.成交Row 成交Row1 = 成交DataTable1.New成交Row();
成交Row1.交易员 = this.交易员;
成交Row1.组合号 = this.组合号;
成交Row1.成交时间 = DateTime.Now.ToString("HH:mm:ss");
成交Row1.证券代码 = this.证券代码;
成交Row1.证券名称 = this.证券名称;
成交Row1.成交价格 = 未处理成交价格;
成交Row1.成交数量 = 未处理成交数量;
成交Row1.成交金额 = 未处理成交金额;
成交Row1.成交编号 = this.委托编号;
成交Row1.委托编号 = this.委托编号;
成交Row1.买卖方向 = this.买卖方向;
成交Row1.市场代码 = this.市场代码;
if (!Program.db.订单.Exists(成交Row1))
{
Program.db.订单.Add(成交Row1);
}
else
{
Program.db.订单.Update(成交Row1);
}
Program.db.已发委托.Update(DateTime.Today, this.组合号, this.委托编号, this.成交价格, this.成交数量);
Program.db.交易日志.Add(成交Row1);
Program.成交通知.Enqueue(成交Row1);
}
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
Program.logger.LogInfo("启动服务中...");
Program.db.Load();
foreach (var item in Program.db.平台用户)
{
if (item.角色 == (int)角色.交易员 && !Program.SendOrderObjDict.ContainsKey(item.用户名))
{
Program.SendOrderObjDict[item.用户名] = new object();
}
}
//AyersMessageAdapter.Instance.Load();
//AyersMessageAdapter.Instance.Start();
LimitManageService.Instance.Start();
if (!Program.db.平台用户.ExistsRole(角色.超级管理员))
{
this.backgroundWorker1.ReportProgress(0);
}
#region 初始化服务
ServiceHost TradeServiceHost = RunService();
ServiceHost GroupServiceHost = InitGroupService();
#endregion
while (!this.backgroundWorker1.CancellationPending)
{
this.backgroundWorker1.ReportProgress(1);
try
{
Program.db.券商帐户.Start();
Program.db.恒生帐户.Start();
Program.IsServiceUpdating = true;
#region 由 帐户DataTable 转为 交易员DataTable
Dictionary <string, JyDataSet.成交DataTable> 交易员成交DataTable = new Dictionary <string, JyDataSet.成交DataTable>();
Dictionary <string, JyDataSet.委托DataTable> 交易员委托DataTable = new Dictionary <string, JyDataSet.委托DataTable>();
#region 成交
foreach (JyDataSet.成交DataTable 帐户成交DataTable in Program.帐户成交DataTable.Values)
{
foreach (JyDataSet.成交Row 成交Row1 in 帐户成交DataTable)
{
if (!交易员成交DataTable.ContainsKey(成交Row1.交易员))
{
交易员成交DataTable[成交Row1.交易员] = new JyDataSet.成交DataTable();
}
交易员成交DataTable[成交Row1.交易员].ImportRow(成交Row1);
}
}
#endregion
#region 委托
foreach (JyDataSet.委托DataTable 帐户委托DataTable in Program.帐户委托DataTable.Values)
{
foreach (JyDataSet.委托Row 委托Row1 in 帐户委托DataTable)
{
if (!交易员委托DataTable.ContainsKey(委托Row1.交易员))
{
交易员委托DataTable[委托Row1.交易员] = new JyDataSet.委托DataTable();
}
交易员委托DataTable[委托Row1.交易员].ImportRow(委托Row1);
}
}
#endregion
#region 风控平仓
JyDataSet.委托DataTable 风控平仓委托DataTable = Program.db.已发委托.Get风控平仓委托DataTable();
foreach (JyDataSet.委托Row 委托Row1 in 风控平仓委托DataTable)
{
if (!交易员委托DataTable.ContainsKey(委托Row1.交易员))
{
交易员委托DataTable[委托Row1.交易员] = new JyDataSet.委托DataTable();
}
交易员委托DataTable[委托Row1.交易员].ImportRow(委托Row1);
}
#endregion
#endregion
#region 比较Key是否一致
foreach (string 交易员 in 交易员成交DataTable.Keys)
{
if (!Program.交易员成交DataTable.ContainsKey(交易员))
{
Program.交易员成交DataTable[交易员] = new JyDataSet.成交DataTable();
}
}
foreach (string 交易员 in Program.交易员成交DataTable.Keys)
{
if (!交易员成交DataTable.ContainsKey(交易员))
{
交易员成交DataTable[交易员] = new JyDataSet.成交DataTable();
}
}
foreach (string 交易员 in 交易员委托DataTable.Keys)
{
if (!Program.交易员委托DataTable.ContainsKey(交易员))
{
Program.交易员委托DataTable[交易员] = new JyDataSet.委托DataTable();
}
}
foreach (string 交易员 in Program.交易员委托DataTable.Keys)
{
if (!交易员委托DataTable.ContainsKey(交易员))
{
交易员委托DataTable[交易员] = new JyDataSet.委托DataTable();
}
}
#endregion
#region 刷新交易员数据表
foreach (string 交易员 in 交易员成交DataTable.Keys)
{
bool bool1 = Tool.RefreshDrcjDataTable(Program.交易员成交DataTable[交易员], 交易员成交DataTable[交易员], new string[] { "组合号", "委托编号", "成交编号" });
if (bool1)
{
Program.成交表Changed[交易员] = true;
}
}
foreach (string 交易员 in 交易员委托DataTable.Keys)
{
try
{
bool bool1 = Tool.RefreshDrcjDataTable(Program.交易员委托DataTable[交易员], 交易员委托DataTable[交易员], new string[] { "组合号", "委托编号" });
if (bool1)
{
Program.委托表Changed[交易员] = true;
}
}
catch (Exception ex)
{
Program.logger.LogInfo("刷新交易员数据异常：{0},交易员：{1}", ex.Message, 交易员);
}
}
#endregion
AddNewestConsignment();
Tool.SendNotifyToClient(); //通知交易客户端和风控客户端
RemoveAddedConsignment();
Program.IsServiceUpdating = false;
Thread.Sleep(100);
}
catch (Exception ex)
{
Program.logger.LogInfo("服务器线程异常:{0} {1}", ex.Message, ex.StackTrace);
Thread.Sleep(1000);
}
}
Program.db.券商帐户.Stop();
Program.db.恒生帐户.Stop();
AyersMessageAdapter.Instance.Stop();
//TdxHqApi.Instance.Stop();
LimitManageService.Instance.Stop();
if (GroupServiceHost != null)
{
GroupServiceHost.Close();
}
TradeServiceHost.Close();
Program.logger.LogInfo("服务已关闭");
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
Program.logger.LogInfo("启动服务中...");
Program.db.Load();
if (AutoOrderService.Instance != null)
{
AutoOrderService.Instance.Start();
}
if (!Program.db.平台用户.ExistsRole(角色.超级管理员))
{
this.backgroundWorker1.ReportProgress(0);
}
#region 初始化服务
ServiceHost ServiceHost1 = RunService();
Program.logger.LogInfo("服务已启动");
#endregion
while (!this.backgroundWorker1.CancellationPending)
{
this.backgroundWorker1.ReportProgress(1);
try
{
Program.db.电子币帐户.Start();
Program.IsServiceUpdating = true;
#region 由 帐户DataTable 转为 交易员DataTable
Dictionary <string, JyDataSet.成交DataTable> 交易员成交DataTable = new Dictionary <string, JyDataSet.成交DataTable>();
Dictionary <string, JyDataSet.委托DataTable> 交易员委托DataTable = new Dictionary <string, JyDataSet.委托DataTable>();
#region 成交
foreach (JyDataSet.成交DataTable 帐户成交DataTable in Program.帐户成交DataTable.Values)
{
foreach (JyDataSet.成交Row 成交Row1 in 帐户成交DataTable)
{
if (!交易员成交DataTable.ContainsKey(成交Row1.交易员))
{
交易员成交DataTable[成交Row1.交易员] = new JyDataSet.成交DataTable();
}
交易员成交DataTable[成交Row1.交易员].ImportRow(成交Row1);
}
}
#endregion
#region 委托
foreach (JyDataSet.委托DataTable 帐户委托DataTable in Program.帐户委托DataTable.Values)
{
foreach (JyDataSet.委托Row 委托Row1 in 帐户委托DataTable)
{
if (!交易员委托DataTable.ContainsKey(委托Row1.交易员))
{
交易员委托DataTable[委托Row1.交易员] = new JyDataSet.委托DataTable();
}
交易员委托DataTable[委托Row1.交易员].ImportRow(委托Row1);
}
}
#endregion
#region 风控平仓
JyDataSet.委托DataTable 风控平仓委托DataTable = Program.db.已发委托.Get风控平仓委托DataTable();
foreach (JyDataSet.委托Row 委托Row1 in 风控平仓委托DataTable)
{
if (!交易员委托DataTable.ContainsKey(委托Row1.交易员))
{
交易员委托DataTable[委托Row1.交易员] = new JyDataSet.委托DataTable();
}
交易员委托DataTable[委托Row1.交易员].ImportRow(委托Row1);
}
#endregion
#endregion
#region 比较Key是否一致
foreach (string 交易员 in 交易员成交DataTable.Keys)
{
if (!Program.交易员成交DataTable.ContainsKey(交易员))
{
Program.交易员成交DataTable[交易员] = new JyDataSet.成交DataTable();
}
}
foreach (string 交易员 in Program.交易员成交DataTable.Keys)
{
if (!交易员成交DataTable.ContainsKey(交易员))
{
交易员成交DataTable[交易员] = new JyDataSet.成交DataTable();
}
}
foreach (string 交易员 in 交易员委托DataTable.Keys)
{
if (!Program.交易员委托DataTable.ContainsKey(交易员))
{
Program.交易员委托DataTable[交易员] = new JyDataSet.委托DataTable();
}
}
foreach (string 交易员 in Program.交易员委托DataTable.Keys)
{
if (!交易员委托DataTable.ContainsKey(交易员))
{
交易员委托DataTable[交易员] = new JyDataSet.委托DataTable();
}
}
#endregion
#region 刷新交易员数据表
foreach (string 交易员 in 交易员成交DataTable.Keys)
{
bool bool1 = Tool.RefreshDrcjDataTable(Program.交易员成交DataTable[交易员], 交易员成交DataTable[交易员], new string[] { "组合号", "委托编号", "成交编号" });
if (bool1)
{
Program.成交表Changed[交易员] = true;
}
}
foreach (string 交易员 in 交易员委托DataTable.Keys)
{
try
{
bool bool1 = Tool.RefreshDrcjDataTable(Program.交易员委托DataTable[交易员], 交易员委托DataTable[交易员], new string[] { "组合号", "委托编号" });
if (bool1)
{
Program.委托表Changed[交易员] = true;
}
}
catch (Exception ex)
{
Program.logger.LogInfo("刷新交易员数据异常：{0} 交易员：{1}", ex.Message, 交易员);
}
}
#endregion
Tool.SendNotifyToClient(); //通知交易客户端和风控客户端
Program.IsServiceUpdating = false;
Thread.Sleep(100);
}
catch (Exception ex)
{
Program.logger.LogInfo("服务器线程异常:{0} {1}", ex.Message, ex.StackTrace);
Thread.Sleep(1000);
}
}
Program.db.电子币帐户.Stop();
if (ServiceHost1 != null && ServiceHost1.State != CommunicationState.Faulted)
{
ServiceHost1.Close();
}
Program.logger.LogInfo("服务已关闭");
}
public void QueryData(out JyDataSet.委托DataTable dtWt, out JyDataSet.成交DataTable dtCJ)
{
dtWt = new JyDataSet.委托DataTable();
dtCJ = new JyDataSet.成交DataTable();
foreach (var order in queueOrder)
{
var trader = GetOrderTrader(order.Orderid);
if (!string.IsNullOrEmpty(trader))
{
var row = dtWt.New委托Row();
row.买卖方向 = order.Side.Contains("BUY") ? 0 : 1;
row.交易员 = trader;
row.委托价格 = order.Price;
row.委托数量 = order.OriginalQuantity;
row.委托时间 = StartTime.AddMilliseconds(order.EventTime).ToString("yyyy-MM-dd HH:mm:ss");
row.委托编号 = order.Orderid + "";
row.市场代码 = 0;
row.撤单数量 = 0;
row.成交价格 = 0;
row.成交数量 = Math.Max(order.FilledTradesAccumulatedQuantity, order.LastFilledTradeQuantity);
row.状态说明 = GetStatusDescription(order.Status);
row.组合号 = AccountName;
row.证券代码 = order.Symbol;
row.证券名称 = order.Symbol;
InitOrderTradeInfo(order.Orderid, row);
if (order.Status == "CANCELED")
{
row.撤单数量 = row.委托数量 - row.成交数量;
}
dtWt.Add委托Row(row);
}
}
foreach (var item in queueTrade)
{
var trader = GetOrderTrader(item.Orderid);
if (!string.IsNullOrEmpty(trader))
{
var row = dtCJ.New成交Row();
row.买卖方向 = item.Side == "BUY" ? 0 : 1;
row.交易员 = trader;
row.委托编号 = item.Orderid.ToString();
row.市场代码 = 0;
row.成交价格 = item.LastFilledTradePrice;
row.成交数量 = item.LastFilledTradeQuantity;
row.成交时间 = StartTime.AddMilliseconds(item.TradeTime).ToString("yyyy-MM-dd hh:mm:ss");
row.成交编号 = item.TradeId.ToString();
row.成交金额 = item.LastFilledTradePrice * item.LastFilledTradeQuantity;
row.组合号 = this.AccountName;
row.证券名称 = item.Symbol;
row.证券代码 = item.Symbol;
dtCJ.Add成交Row(row);
}
}
if (dtWt.FirstOrDefault(_ => _.委托数量 > (_.成交数量 + _.撤单数量)) != null && DateTime.Now > AutoBanTime)
{
List <int> lstOrderID = new List <int>();
foreach (var item in dtWt.Where(_ => _.委托数量 > (_.成交数量 + _.撤单数量)))
{
var cacheItem = queueOrderTraderRelation.FirstOrDefault(_ => _.OrderID.ToString() == item.委托编号);
if (cacheItem != null && (cacheItem.LastQueryTime == cacheItem.SendTime || (DateTime.Now - StartTime).TotalMilliseconds - cacheItem.LastQueryTime >= 3000))
{
lstOrderID.Add(cacheItem.OrderID);
cacheItem.LastQueryTime = (long)(DateTime.Now - StartTime).TotalMilliseconds;
}
}
if (lstOrderID.Count > 0)
{
var orders = queueOrder.Where(_ => !string.IsNullOrEmpty(_.Symbol) && lstOrderID.Contains(_.Orderid));
var orderIdMin = lstOrderID.Min();
var symbols = orders.Select(_ => _.Symbol).Distinct().ToList();
Program.logger.LogInfo("{0} query orders {1}, orderID {2}", this.AccountName, string.Join(",", symbols), string.Join(",", orders.Select(_ => _.Orderid)));
foreach (var symbol in symbols)
{
QueryOrders(symbol, orders);
Thread.Sleep(500);
}
Thread.Sleep(500);
}
}
if (dtWt.FirstOrDefault(_ => _.成交数量 > 0 && (_.成交价格 == 0 || (_.委托数量 > _.成交数量 + _.撤单数量))) != null && DateTime.Now > AutoBanTime)
{
var lstNeedTradeID = dtWt.Where(_ => _.成交数量 > 0 && (_.成交价格 == 0 || (_.委托数量 > _.成交数量 + _.撤单数量))).Select(_ => _.委托编号).ToList();
var symbols = queueOrder.Where(_ => lstNeedTradeID.Contains(_.Orderid + "")).Select(_ => _.Symbol).Distinct();
Program.logger.LogInfo("{0} query trades {1}, orderID {2}", this.AccountName, string.Join(",", symbols), string.Join(",", lstNeedTradeID));
//var needMax = lstNeedTradeID.Max(_ => int.Parse(_));
//if (queueTrade.Count > 0 && queueTrade.Min(_=> _.Orderid) > needMax)
//{
// var minTradeID = queueTrade.Min(_ => _.TradeId) -1;
// var minTradeTime = queueTrade.Min(_ => _.TradeTime) - 1000;
// var lstNeedEqueu = historyOrder.Where(_ => lstNeedTradeID.Contains(_.委托编号)).ToList();
// lstNeedEqueu.ForEach(_ =>
// queueTrade.Enqueue(new OrderOrTradeUpdatedMessage() {
// FilledTradesAccumulatedQuantity = _.成交数量,
// LastFilledTradeQuantity = _.成交数量,
// LastFilledTradePrice = _.成交价格,
// Price = _.成交价格,
// Orderid =int.Parse(_.委托编号),
// Side = _.买卖方向 == 0 ? "BUY" : "SELL",
// Symbol = _.证券代码,
// TradeId = minTradeID--,
// TradeTime = minTradeTime,
// })
// );
//}
foreach (string symbol in symbols)
{
QueryTraders(symbol);
Thread.Sleep(500);
}
Thread.Sleep(500);
}
if ((DateTime.Now - lastRequesTime).TotalMinutes >= 1)
{
try
{
binanceClient.TestConnectivity();
lastRequesTime = DateTime.Now;
//Program.logger.LogInfoDetail("{0} TestConnectivity OK, Time {1}.", this.AccountName, DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss fff"));
}
catch (Exception ex)
{
Program.logger.LogInfoDetail("{0} TestConnectivity Exception, StackTrace {1}.", this.AccountName, ex.ToString());
Thread.Sleep(30000);
}
}
}
