private static void OrderChangedDeal()
{
var keysOrder = Program.委托表Changed.Keys.ToList();
foreach (string UserName in keysOrder)
{
if (Program.委托表Changed[UserName])
{
if (Program.交易员委托DataTable.ContainsKey(UserName))
{
var 交易员委托table = Program.交易员委托DataTable[UserName];
if (AutoOrderService.Instance.DictUserLogin.ContainsKey(UserName))
{
if (AutoOrderService.Instance.DictUserConsignmentChange.ContainsKey(UserName))
{
AutoOrderService.Instance.DictUserConsignmentChange[UserName] = true;
}
else if (!AutoOrderService.Instance.DictUserConsignmentChange.TryAdd(UserName, true))
{
AutoOrderService.Instance.DictUserConsignmentChange[UserName] = true;
}
}
JyDataSet.委托DataTable dtNew = null;
lock (交易员委托table)
{
dtNew = 交易员委托table.Copy() as JyDataSet.委托DataTable;
}
Send委托TableChangedNoticeToTrader(UserName, dtNew);
}
Program.委托表Changed[UserName] = false;
}
}
}
public Dictionary <string, TraderBuySaleEntity> GetShareGroupBuySaleList(string StockID)
{
var dict = new Dictionary <string, TraderBuySaleEntity>();
var users = GroupTraderList.Select(_ => _.TraderAccount).ToList();
var wtList = Program.db.已发委托.Where(r => r.日期 == DateTime.Today && users.Contains(r.交易员) && r.证券代码 == StockID);
JyDataSet.委托DataTable interFaceData = null;
if (Program.帐户委托DataTable.ContainsKey(this.GroupName))
{
interFaceData = Program.帐户委托DataTable[GroupName];
}
foreach (var 已发委托Row1 in wtList)
{
JyDataSet.委托Row interfaceItem = null;
if (interFaceData != null)
{
interFaceData.FirstOrDefault(_ => _.委托编号 == 已发委托Row1.委托编号);
}
if (!dict.ContainsKey(已发委托Row1.交易员))
{
dict.Add(已发委托Row1.交易员, new TraderBuySaleEntity()
{
TraderID = 已发委托Row1.交易员, StockID = StockID
});
}
decimal cancelCount = interfaceItem == null ? 已发委托Row1.撤单数量 : interfaceItem.撤单数量;
if (已发委托Row1.买卖方向 % 2 == 0)
{
if (已发委托Row1.成交数量 > 0 && 已发委托Row1.成交数量 < 已发委托Row1.委托数量 && 已发委托Row1.撤单数量 == 已发委托Row1.成交数量)
{
dict[已发委托Row1.交易员].BuyCount += 已发委托Row1.成交数量;
}
else
{
dict[已发委托Row1.交易员].BuyCount += 已发委托Row1.委托数量 - cancelCount;
}
}
else
{
if (已发委托Row1.成交数量 > 0 && 已发委托Row1.成交数量 < 已发委托Row1.委托数量 && 已发委托Row1.撤单数量 == 已发委托Row1.成交数量)
{
dict[已发委托Row1.交易员].SoldCount += 已发委托Row1.成交数量;
}
else
{
dict[已发委托Row1.交易员].SoldCount += 已发委托Row1.委托数量 - cancelCount;
}
}
}
return(dict);
}
public void GetShareGroupHasBuyCount(string 证券代码, out decimal 已买股数, out decimal 已卖股数)
{
已买股数 = 0;
已卖股数 = 0;
if (GroupTraderList != null && GroupTraderList.Count > 0)
{
var users = GroupTraderList.Select(_ => _.TraderAccount).ToList();
var wtList = Program.db.已发委托.Where(r => r.日期 == DateTime.Today && users.Contains(r.交易员) && r.证券代码 == 证券代码);
JyDataSet.委托DataTable interFaceData = null;
if (Program.帐户委托DataTable.ContainsKey(this.GroupName))
{
interFaceData = Program.帐户委托DataTable[GroupName];
}
foreach (var 已发委托Row1 in wtList)
{
JyDataSet.委托Row interfaceItem = null;
if (interFaceData != null)
{
interfaceItem = interFaceData.FirstOrDefault(_ => _.委托编号 == 已发委托Row1.委托编号);
}
decimal cancelCount = interfaceItem == null ? 已发委托Row1.撤单数量 : interfaceItem.撤单数量;
if (已发委托Row1.买卖方向 % 2 == 0)
{
if (已发委托Row1.成交数量 > 0 && 已发委托Row1.成交数量 < 已发委托Row1.委托数量 && 已发委托Row1.撤单数量 == 已发委托Row1.成交数量)
{
已买股数 += 已发委托Row1.成交数量;
}
else
{
已买股数 += 已发委托Row1.委托数量 - cancelCount;
}
}
else
{
if (已发委托Row1.成交数量 > 0 && 已发委托Row1.成交数量 < 已发委托Row1.委托数量 && 已发委托Row1.撤单数量 == 已发委托Row1.成交数量)
{
已卖股数 += 已发委托Row1.成交数量;
}
else
{
已卖股数 += 已发委托Row1.委托数量 - cancelCount;
}
}
}
}
}
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 GetShareGroupHasBuyCount(string 证券代码, string trader, List <string> lstSendedOrderID, out decimal 已买股数, out decimal 已卖股数, out decimal traderBuy, out decimal traderSale)
{
已买股数 = 0;
已卖股数 = 0;
traderBuy = 0;
traderSale = 0;
if (GroupTraderList != null && GroupTraderList.Count > 0)
{
var stockItem = GroupStockList.Where(_ => _.StockID == 证券代码).First();
var users = GroupTraderList.Select(_ => _.TraderAccount).ToList();
JyDataSet.委托DataTable interFaceData = null;
if (Program.帐户委托DataTable.ContainsKey(stockItem.GroupAccount))
{
interFaceData = Program.帐户委托DataTable[stockItem.GroupAccount];
}
var wtList = Program.db.已发委托.Where(r => r.日期 == DateTime.Today && users.Contains(r.交易员) && r.证券代码 == 证券代码);
foreach (var 已发委托Row1 in wtList)
{
JyDataSet.委托Row interfaceItem = null;
if (interFaceData != null)
{
interfaceItem = interFaceData.FirstOrDefault(_ => _.委托编号 == 已发委托Row1.委托编号);
}
decimal cancelCount = interfaceItem == null ? 已发委托Row1.撤单数量 : interfaceItem.撤单数量;
if (已发委托Row1.买卖方向 % 2 == 0)
{
if (已发委托Row1.成交数量 > 0 && 已发委托Row1.成交数量 < 已发委托Row1.委托数量 && 已发委托Row1.撤单数量 == 已发委托Row1.成交数量)
{
已买股数 += 已发委托Row1.成交数量;
if (已发委托Row1.交易员 == trader)
{
traderBuy += 已发委托Row1.成交数量;
}
}
else
{
已买股数 += 已发委托Row1.委托数量 - cancelCount;
if (已发委托Row1.交易员 == trader)
{
traderBuy += 已发委托Row1.委托数量 - cancelCount;
}
}
}
else
{
if (已发委托Row1.成交数量 > 0 && 已发委托Row1.成交数量 < 已发委托Row1.委托数量 && 已发委托Row1.撤单数量 == 已发委托Row1.成交数量)
{
已卖股数 += 已发委托Row1.成交数量;
if (已发委托Row1.交易员 == trader)
{
traderSale += 已发委托Row1.成交数量;
}
}
else
{
已卖股数 += 已发委托Row1.委托数量 - cancelCount;
if (已发委托Row1.交易员 == trader)
{
traderSale += 已发委托Row1.委托数量 - cancelCount;
}
}
}
lstSendedOrderID.Add(已发委托Row1.委托编号);
}
}
}