public static void SaveAccountCapital()
{
string[] keys = TradeRA.KeySearch("A_*");
foreach (string key in keys)
{
Account account = AccountRA.Get(key);
AccountDA.UpdateCapital(account);
}
}
//获取主账户最大可下单数量
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 Result UpdateStatusOrder(StatusOrder model)
{
ApiResultEnum result = AccountDA.UpdateStatusOrder(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
AccountRA.UpdateStatusOrder(model.status, "A_" + model.id);
}
return(Result(result));
}
private void JY_QueryCapital_Done(object sender, Capital e)
{
string key = "A_" + account_id;
Account account = new Account()
{
capital_available = decimal.Parse(e.available),
capital_stock_value = decimal.Parse(e.value),
capital_total = decimal.Parse(e.assets),
capital_profit = decimal.Parse(e.profit),
synchronized_time = DateTime.Now.Format()
};
AccountRA.UpdateCapital(account, key);
}
public Result <long> OrderAutoAdd(OrderAutoAdd model)
{
if (model.count_min > model.count_max || model.price_min > model.price_max || model.time_min > model.time_max)
{
return(Result(ApiResultEnum.Parameter_Error, 0L));
}
HQItem hq = HQService.Get(model.code);
Order order = new Order()
{
user_id = user_id,
unit_id = model.unit_id,
code = model.code,
price = hq.Last,
count = model.count_total,
type = model.type,
platform = platform
};
ApiResultEnum result = LimitBiz.CheckStatus(order);
if (result != ApiResultEnum.Success)
{
return(Result(result, 0L));
}
result = LimitBiz.CheckUnit(order);
if (result != ApiResultEnum.Success)
{
return(Result(result, 0L));
}
model.name = StockInfoBiz.GetStock(model.code).name;
model.id = FuncHelper.GetUniqueID();
model.user_id = user_id;
model.platform = platform;
if (model.account_id > 0)
{
model.account_name = AccountRA.GetName(model.account_id);
}
else
{
model.account_name = "";
}
string key = "S_" + model.id + "_U_" + model.unit_id + "_D_0";
OrderAutoRA.Add(model, key);
return(Result(ApiResultEnum.Success, model.id));
}
public static void RunAccountCapitalMonitor()
{
string[] keys = TradeRA.KeySearch("A_*");
foreach (string key in keys)
{
Account account = AccountRA.Get(key);
if (account.ratio_capital_warning > 0 && account.capital_total > 0 && account.capital_total < account.ratio_capital_warning * account.capital_initial)
{
UserDA.ListParents(account.created_by).ForEach(user_id =>
{
MessageBiz.Send(user_id.ToString(), MessageTypeEnum.Account_Warning, "主账户[" + account.code + "]资产已低于预警线");
});
NLog.Info(string.Format("主账户[{0}]资产已低于预警线。总资产：{1}", account.code, account.capital_total));
}
}
}
public Result Delete(Model.DB.Account model)
{
var account_groups = AccountGroupDA.List4Account(model.id);
if (account_groups.Count > 0)
{
return(Result(ApiResultEnum.Cited, string.Join(",", account_groups.Select(u => u.code))));
}
model.created_by = user_id;
ApiResultEnum result = AccountDA.Delete(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
TradeBiz.RemoveAccount(model.id);
AccountRA.Delete("A_" + model.id);
}
return(Result(result));
}
public static void LoadAccount(Account account, bool add = true)
{
TradeBiz.LoadAccount(account);
string key = "A_" + account.id;
if (add && TradeRA.KeyExists(key))
{
return;
}
if (add)
{
AccountRA.Add(account, key);
}
else
{
AccountRA.Update(account, key);
}
}
public Result <List <AccountPosition> > ListAccountPosition(int account_id)
{
List <AccountPosition> list = new List <AccountPosition>();
List <Position> list_in = (account_id == 0) ? PositionRA.List() : PositionRA.List4Account(account_id);
list_in.ForEach(p =>
{
list.Add(new AccountPosition()
{
account_id = p.account_id,
account_name = p.account_name,
code = p.code,
name = p.name,
count = 0,
count_in = p.count
});
});
List <Tuple <int, JY.PositionItem> > list_sys = new List <Tuple <int, JY.PositionItem> >();
if (account_id > 0)
{
TradeBiz.QueryPosition(account_id).ForEach(p =>
{
list_sys.Add(new Tuple <int, JY.PositionItem>(account_id, p));
});
}
else
{
string[] keys = TradeRA.KeySearch("A_*");
foreach (var key in keys)
{
int id = int.Parse(key.Substring(2));
TradeBiz.QueryPosition(id).ForEach(p =>
{
list_sys.Add(new Tuple <int, JY.PositionItem>(id, p));
});
}
}
foreach (var t in list_sys)
{
AccountPosition ap = list.Find(p => p.account_id == t.Item1 && p.code == t.Item2.code);
if (ap == null)
{
list.Add(new AccountPosition()
{
account_id = t.Item1,
account_name = AccountRA.GetName(t.Item1),
code = t.Item2.code,
name = t.Item2.name,
count = (int)decimal.Parse(t.Item2.count),
count_in = 0
});
}
else
{
ap.count = (int)decimal.Parse(t.Item2.count);
}
}
return(Result(list));
}
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);
}
