public ResultLogin Login(Model.DB.User model)
{
ApiResultEnum result = UserDA.Login(ref model, platform);
if (result == ApiResultEnum.Success)
{
string user_token = UserRA.Get(model.id.ToString(), "platform_" + platform);
if (string.IsNullOrWhiteSpace(user_token))
{
user_token = FuncHelper.GetUniqueString();
Dictionary <string, string> dic = new Dictionary <string, string>();
dic.Add("platform_" + platform, user_token);
dic.Add("name", model.name);
dic.Add("status_order", model.status_order.ToString());
dic.Add("role", model.role.ToString());
dic.Add("login_time_" + platform, DateTime.Now.Format());
UserRA.Set(model.id.ToString(), dic);
UserRA.SetExpire(model.id.ToString());
}
return(new ResultLogin(result, model, model.id + "-" + user_token));
}
else
{
return(new ResultLogin(result, null, null));
}
}
public Result UpdateUnits(UserUnits model)
{
ApiResultEnum result = UnitDA.UpdateUserID(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
string[] keys = TradeRA.KeySearch("U_*");
foreach (string key in keys)
{
string _user_id = TradeRA.Get(key, "user_id");
if (model.unit_ids.Contains(int.Parse(key.Substring(2))))
{
if (model.id != _user_id)
{
UnitRA.UpdateUserID(model.id, key);
}
}
else
{
if (model.id == _user_id)
{
UnitRA.UpdateUserID("0", key);
}
}
}
}
return(Result(result));
}
/// <summary>
///
/// </summary>
/// <param name="resultEnum"></param>
/// <param name="resultMsg"></param>
/// <param name="data"></param>
/// <returns></returns>
public static ApiResult Write(ApiResultEnum resultEnum, string resultMsg, object data)
{
return(new ApiResult
{
resultCode = (int)resultEnum,
resultMsg = resultMsg,
data = data
});
}
/// <summary>
///
/// </summary>
/// <param name="resultEnum"></param>
/// <returns></returns>
public static ApiResult Write(ApiResultEnum resultEnum)
{
return(new ApiResult
{
resultCode = (int)resultEnum,
resultMsg = resultEnum.ToString(),
data = new object()
});
}
public Result <int> Add(Model.DB.AccountGroup model)
{
int id = 0;
model.created_by = user_id;
ApiResultEnum result = AccountGroupDA.Add(model, ref id);
return(Result(result, id));
}
public Result <int> Add(Model.DB.User model)
{
int id = 0;
model.created_by = user_id;
ApiResultEnum result = UserDA.Add(model, ref id);
return(Result(result, id));
}
public Result UpdateRatioFreezing(Model.DB.Unit model)
{
ApiResultEnum result = UnitDA.UpdateRatioFreezing(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
UnitRA.UpdateRatioFreezing(model.ratio_freezing, "U_" + model.id);
}
return(Result(result));
}
public Result UpdateStatus(Status model)
{
ApiResultEnum result = UnitDA.UpdateStatus(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
UnitRA.UpdateStatus(model.status, "U_" + model.id);
}
return(Result(result));
}
public Result Update(Model.DB.Unit model)
{
ApiResultEnum result = UnitDA.Update(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
OpenCloseBiz.LoadUnit(model, false);
}
return(Result(result));
}
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));
}
public Result Update(Model.DB.Account model)
{
model.created_by = user_id;
ApiResultEnum result = AccountDA.Update(model);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
OpenCloseBiz.LoadAccount(model, false);
}
return(Result(result));
}
public Result CapitalInOut(LogCapital model)
{
model.@operator = user_id;
decimal delta;
ApiResultEnum result = LogCapitalDA.Add(model, out delta);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
UnitRA.UpdateCapitalInOut(delta, "U_" + model.unit_id);
}
return(Result(result));
}
/// <summary>
///
/// </summary>
/// <param name="resultEnum"></param>
/// <param name="resultMsg"></param>
/// <param name="key"></param>
/// <param name="data"></param>
/// <returns></returns>
public static ApiResult Write(ApiResultEnum resultEnum, string resultMsg, string key, object data)
{
Dictionary <string, object> dict = new Dictionary <string, object>();
dict[key] = data;
return(new ApiResult
{
resultCode = (int)resultEnum,
resultMsg = string.IsNullOrEmpty(resultMsg) ? resultEnum.ToString() : resultMsg,
data = dict
});
}
public Result <int> Add(Model.DB.Account model)
{
int id = 0;
model.created_by = user_id;
ApiResultEnum result = AccountDA.Add(model, ref id);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
model.id = id;
OpenCloseBiz.LoadAccount(model);
}
return(Result(result, id));
}
public Result <int> Add(Model.DB.Unit model)
{
int id = 0;
model.created_by = user_id;
model.status_order_enum = StatusOrderEnum.Allowed;
ApiResultEnum result = UnitDA.Add(model, ref id);
if (result == ApiResultEnum.Success && MonitorRA.GetStatusTrade() != 0)
{
model.id = id;
OpenCloseBiz.LoadUnit(model);
}
return(Result(result, id));
}
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 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 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 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 ResultOrder(ApiResultEnum code) : base(code)
{
}
public ResultLogin(ApiResultEnum code, User data, string token) : base(code, data)
{
Token = token;
}
public Base(ApiResultEnum code = ApiResultEnum.Success)
{
Code = code;
Message = Messages[code.ToString()];
}
public static ApiResultEnum Order(Order order)
{
ApiResultEnum result = LimitBiz.CheckStatus(order);
if (result != ApiResultEnum.Success)
{
return(result);
}
result = LimitBiz.CheckUnit(order);
if (result != ApiResultEnum.Success)
{
return(result);
}
Dictionary <int, int> order_items;
if (order.account_id == 0)
{
order_items = LimitBiz.GetOrderAccount(order);
}
else
{
order_items = new Dictionary <int, int>()
{
{ order.account_id, order.count }
}
};
if (order_items.Count == 0)
{
return(ApiResultEnum.Order_Unit_No_Account);
}
if (order_items.Sum(i => i.Value) == 0)
{
return(ApiResultEnum.Order_Group_Negative_Amount);
}
int order_count = 0;
order.trade_no = FuncHelper.GetUniqueID().ToString();
order.trade_count = order.count;
foreach (var kvp in order_items)
{
if (kvp.Value == 0)
{
continue;
}
order.account_id = kvp.Key;
order.count = kvp.Value;
result = LimitBiz.CheckAccount(order);
if (result != ApiResultEnum.Success)
{
continue;
}
BlockInfo block = StockInfoBiz.GetBlock(order.code);
order.price = Math.Round(order.price, block.@decimal);
jybizs[order.account_id].Order(order);
order_count += order.count;
}
if (order_count == 0)
{
return(result);
}
if (order_count < order.count)
{
return(ApiResultEnum.Success_Portion);
}
return(ApiResultEnum.Success);
}
public static void RunOrderAuto()
{
List <OrderAuto> orders = OrderAutoRA.List4Undone();
foreach (OrderAuto orderAuto in orders)
{
if (orderAuto.status_enum != StatusAutoOrderEnum.Run)
{
continue;
}
if (orderAuto.time_next_dt > DateTime.Now)
{
continue;
}
string key = "S_" + orderAuto.id + "_U_" + orderAuto.unit_id + "_D_0";
Random random = new Random();
Order order = new Order()
{
code = orderAuto.code,
type = orderAuto.type,
unit_id = orderAuto.unit_id,
account_id = orderAuto.account_id,
user_id = orderAuto.user_id,
platform = orderAuto.platform
};
order.count = orderAuto.count_total - orderAuto.order_count;
orderAuto.time_next_dt = DateTime.MinValue;
if (order.count > orderAuto.count_max)
{
order.count = random.Next(orderAuto.count_min / 100, orderAuto.count_max / 100) * 100;
orderAuto.time_next_dt = DateTime.Now.AddSeconds(random.Next(orderAuto.time_min, orderAuto.time_max));
}
if (orderAuto.time_next_dt >= time_pause && orderAuto.time_next_dt <= time_recovery)
{
orderAuto.time_next_dt = orderAuto.time_next_dt.AddMinutes(90);
}
if (orderAuto.time_next_dt >= time_close)
{
OrderAutoRA.UpdateStatus(StatusAutoOrderEnum.Stop, 1, key);
continue;
}
order.price = DataBiz.GetPriceByPriceType(orderAuto.code, orderAuto.price_type_enum);
if (order.price < orderAuto.price_min)
{
order.price = orderAuto.price_min;
}
else if (order.price > orderAuto.price_max)
{
order.price = orderAuto.price_max;
}
ApiResultEnum result = Order(order.Clone() as Order);
orderAuto.result_prev = new Model.Return.Return(result).Message;
orderAuto.order_times++;
orderAuto.order_count += order.count;
orderAuto.time_prev_dt = DateTime.Now;
OrderAutoRA.UpdateExecuted(orderAuto, order, key);
}
}
public Result(ApiResultEnum code, T data) : base(code)
{
Data = data;
}
public Result(ApiResultEnum code) : base(code)
{
}
public ResultLong(ApiResultEnum code, long data) : base(code)
{
Data = data;
}
protected Result <T> Result <T>(ApiResultEnum code, T data)
{
return(new Result <T>(code, data));
}
public ResultVersionFiles(ApiResultEnum code, VersionFiles data) : base(code)
{
Data = data;
}
