//获取主账户最大可下单数量
public static int GetAccountCount(Order order)
{
Account account = AccountRA.Get("A_" + order.account_id);
if (order.type_enum == OrderTypeEnum.Buy && !string.IsNullOrWhiteSpace(account.limit_no_buying) && account.limit_no_buying.Contains(order.code))
{
return(0);
}
if (account.status_enum == StatusEnum.Forbidden)
{
return(0);
}
if (account.status_order_enum == StatusOrderEnum.Forbidden)
{
return(0);
}
if (order.type_enum == OrderTypeEnum.Buy && account.status_order_enum == StatusOrderEnum.NoBuying)
{
return(0);
}
if (order.type_enum == OrderTypeEnum.Buy)
{
decimal count = account.capital_initial / order.price;
if (account.limit_ratio_single > 0)
{
count = Math.Min(count, account.capital_initial * account.limit_ratio_single / order.price);
}
BlockInfo block = StockInfoBiz.GetBlock(order.code);
if (block.block_type_enum == BlockEnum.gem)
{
if (account.limit_ratio_gem_single > 0)
{
count = Math.Min(count, account.capital_initial * account.limit_ratio_gem_single / order.price);
}
if (account.limit_ratio_gem_total > 0)
{
count = Math.Min(count, (account.capital_initial * account.limit_ratio_gem_total - account.capital_stock_value_gem) / order.price);
}
}
string[] keys = TradeRA.KeySearch("G_*_U_" + order.unit_id + "_A_" + order.account_id);
AccountGroupItem item = AccountGroupRA.Get(keys[0]);
if (item.capital_available > 0)
{
count = Math.Min(count, (item.capital_available - item.capital_stock_value) / order.price);
}
return((int)Math.Ceiling(count / 100) * 100);
}
else
{
return(PositionRA.GetSellable(order.unit_id, order.code, order.account_id));
}
}
public static void LoadAccountGroupItem(AccountGroupItem item)
{
string key = "G_" + item.account_group_id + "_U_" + item.unit_id + "_A_" + item.account_id;
if (TradeRA.KeyExists(key))
{
return;
}
AccountGroupRA.Add(item, key);
}
//将单元的下单数量分配到主账户
public static Dictionary <int, int> GetOrderAccount(Order order)
{
Dictionary <int, int> order_items = new Dictionary <int, int>();
Unit unit = UnitRA.Get("U_" + order.unit_id);
List <AccountGroupItem> items = AccountGroupRA.List4Unit(order.unit_id);
int total = 0;
if (order.type_enum == OrderTypeEnum.Buy)
{
if (unit.priority_strategy_enum == PriorityStrategyEnum.Natural)
{
items = items.OrderBy(i => i.sort_buy).ToList();
}
else
{
items = items.OrderByDescending(i => i.capital_available).ToList();
}
foreach (AccountGroupItem item in items)
{
int buyable = (item.capital_available == decimal.MaxValue) ? (order.count - total) : (int)(item.capital_available / 100 / order.price) * 100;
int ct = Math.Min(buyable, (order.count - total));
order_items.Add(item.account_id, ct);
total += ct;
if (ct == order.count)
{
break;
}
}
}
else
{
items = items.OrderBy(i => i.sort_sell).ToList();
foreach (AccountGroupItem item in items)
{
int sellable = PositionRA.GetSellable(order.unit_id, order.code, item.account_id);
int ct = Math.Min(sellable, (order.count - total));
order_items.Add(item.account_id, ct);
total += ct;
if (ct == order.count)
{
break;
}
}
}
return(order_items);
}
public Result Delete(Model.DB.AccountGroup model)
{
var units = UnitDA.List4AccountGroup(model.id);
if (units.Count > 0)
{
return(Result(ApiResultEnum.Cited, string.Join(",", units.Select(u => u.code))));
}
model.created_by = user_id;
ApiResultEnum result = AccountGroupDA.Delete(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
AccountGroupRA.Delete4AccountGroup(model.id);
}
return(Result(result, string.Empty));
}
public Result UpdateItems(Model.DB.AccountGroup model)
{
model.items = model.items.OrderBy(i => i.sort_buy).AsEnumerable().DistinctBy(i => i.account_id).ToList();
ApiResultEnum result = AccountGroupDA.UpdateItems(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
var units = UnitDA.List4AccountGroup(model.id);
foreach (var kvp in units)
{
UnitRA.UpdatePriorityStrategy(model.priority_strategy, "U_" + kvp.id);
}
AccountGroupRA.Delete4AccountGroup(model.id);
List <Model.DB.AccountGroupItem> items = AccountGroupDA.ListItems4AccountGroup(model.id);
foreach (Model.DB.AccountGroupItem item in items)
{
OpenCloseBiz.LoadAccountGroupItem(item);
}
TradeBiz.RunCalculateValue();
}
return(Result(result));
}
public Result <int> Count(Order model)
{
model.user_id = user_id;
ApiResultEnum result = LimitBiz.CheckStatus(model);
if (result != ApiResultEnum.Success && result != ApiResultEnum.Order_Count_Error && (result != ApiResultEnum.Order_Price_Error || model.type_enum == OrderTypeEnum.Buy))
{
return(Result(ApiResultEnum.Success, 0));
}
int unit_count = LimitBiz.GetUnitCount(model);
if (unit_count == 0)
{
return(Result(ApiResultEnum.Success, 0));
}
List <int> order_items;
int account_count = 0;
if (model.account_id == 0)
{
order_items = AccountGroupRA.List4Unit(model.unit_id).Select(g => g.account_id).ToList();
}
else
{
order_items = new List <int> {
model.account_id
}
};
foreach (int account_id in order_items)
{
model.account_id = account_id;
account_count += LimitBiz.GetAccountCount(model);
}
return(Result(ApiResultEnum.Success, Math.Min(unit_count, account_count)));
}
public static void RunCalculateValue()
{
//单元的市值
Dictionary <int, decimal[]> dic_unit = new Dictionary <int, decimal[]>();
//主账户的市值
Dictionary <int, decimal> dic_account = new Dictionary <int, decimal>();
//单元下主账户组中的主账户市值
Dictionary <string, decimal> dic_account_group = new Dictionary <string, decimal>();
string[] keys = TradeRA.KeySearch("P_*");
foreach (string key in keys)
{
Position position = PositionRA.Get(key);
HQItem hq = HQService.Get(position.code);
decimal price = hq == null ? position.price_latest : hq.Last;
decimal value = price * position.count;
decimal profit = (price - position.price_cost) * position.count;
if (dic_unit.ContainsKey(position.unit_id))
{
dic_unit[position.unit_id][position.block] += value;
dic_unit[position.unit_id][4] += value;
dic_unit[position.unit_id][5] += profit;
}
else
{
decimal[] values = new decimal[6] {
0, 0, 0, 0, value, profit
};
values[position.block] = value;
dic_unit.Add(position.unit_id, values);
}
//主账户市值暂只计算创业板
if (position.block_enum == BlockEnum.gem)
{
if (dic_account.ContainsKey(position.account_id))
{
dic_account[position.account_id] += value;
}
else
{
dic_account.Add(position.account_id, value);
}
}
string ua = "U_" + position.unit_id + "_A_" + position.account_id;
if (dic_account_group.ContainsKey(ua))
{
dic_account_group[ua] += value;
}
else
{
dic_account_group.Add(ua, value);
}
}
foreach (var kvp in dic_unit)
{
UnitRA.UpdateCapitalStockValue(kvp.Value, "U_" + kvp.Key);
}
foreach (var kvp in dic_account)
{
AccountRA.UpdateCapitalStockValue(kvp.Value, "A_" + kvp.Key);
}
foreach (var kvp in dic_account_group)
{
AccountGroupRA.UpdateCapitalStockValue(kvp.Key, kvp.Value);
}
}
//检查主账户是否满足下单条件
public static ApiResultEnum CheckAccount(Order order)
{
Account account = AccountRA.Get("A_" + order.account_id);
if (order.type_enum == OrderTypeEnum.Buy && !string.IsNullOrWhiteSpace(account.limit_no_buying) && account.limit_no_buying.Contains(order.code))
{
return(ApiResultEnum.Order_Account_NoBuying_Code);
}
if (account.status_enum == StatusEnum.Forbidden)
{
return(ApiResultEnum.Order_Account_Forbidden);
}
if (account.status_order_enum == StatusOrderEnum.Forbidden)
{
return(ApiResultEnum.Order_Account_Forbidden_Order);
}
if (order.type_enum == OrderTypeEnum.Buy && account.status_order_enum == StatusOrderEnum.NoBuying)
{
return(ApiResultEnum.Order_Account_NoBuying_Order);
}
if (order.type_enum == OrderTypeEnum.Buy)
{
if (account.limit_ratio_single > 0 && order.price * order.count > account.capital_initial * account.limit_ratio_single)
{
return(ApiResultEnum.Order_Account_Limit_Single);
}
BlockInfo block = StockInfoBiz.GetBlock(order.code);
if (block.block_type_enum == BlockEnum.gem)
{
if (account.limit_ratio_gem_single > 0 && order.price * order.count > account.capital_initial * account.limit_ratio_gem_single)
{
return(ApiResultEnum.Order_Account_Limit_GEM_Single);
}
if (account.limit_ratio_gem_total > 0 && order.price * order.count + account.capital_stock_value_gem > account.capital_initial * account.limit_ratio_gem_total)
{
return(ApiResultEnum.Order_Account_Limit_GEM_Total);
}
}
string[] keys = TradeRA.KeySearch("G_*_U_" + order.unit_id + "_A_" + order.account_id);
AccountGroupItem item = AccountGroupRA.Get(keys[0]);
if (item.capital_available > 0 && item.capital_available < order.price * order.count + item.capital_stock_value)
{
return(ApiResultEnum.Order_Account_Negative_Amount);
}
}
else
{
if (PositionRA.GetSellable(order.unit_id, order.code, order.account_id) < order.count)
{
return(ApiResultEnum.Order_Account_Negative_Position);
}
}
//风控通过进行冻结
if (order.type_enum == OrderTypeEnum.Buy)
{
string key_unit = "U_" + order.unit_id;
UnitRA.UpdateCapitalOrderBuy(order.price * order.count, key_unit);
}
else if (order.type_enum == OrderTypeEnum.Sell)
{
string key_position = "P_" + order.code + "_A_" + order.account_id + "_U_" + order.unit_id;
PositionRA.UpdateSellableOrderSell(-order.count, key_position);
}
return(ApiResultEnum.Success);
}
