public Task <ObservableCollection <PortfolioVM> > QueryPortfolioAsync(int timeout = 10000)
{
var sst = new StringMap();
var msgId = (uint)BusinessMessageID.MSG_ID_QUERY_PORTFOLIO;
var tcs = new TaskCompletionSource <ObservableCollection <PortfolioVM> >(new CancellationTokenSource(timeout));
var serialId = NextSerialId;
sst.Header = new DataHeader {
SerialId = serialId
};
MessageWrapper.RegisterAction <PBPortfolioList, ExceptionMessage>
(msgId,
(resp) =>
{
if (resp.Header?.SerialId == serialId)
{
OnQueryPortfolioSuccessAction(resp);
tcs.TrySetResult(PortfolioVMCollection);
}
},
(bizErr) =>
{
OnErrorAction(bizErr);
tcs.SetResult(null);
}
);
MessageWrapper.SendMessage(msgId, sst);
return(tcs.Task);
}
public void UpdateStrategyModel(StrategyVM sVM, StrategyVM.Model model)
{
var strategy = new PBStrategy();
strategy.Exchange = sVM.Exchange;
strategy.Contract = sVM.Contract;
strategy.Symbol = sVM.StrategySym;
strategy.BaseContract = sVM.BaseContract;
if (model == StrategyVM.Model.PM)
{
strategy.PricingModel = sVM.PricingModel;
}
if (model == StrategyVM.Model.IVM)
{
strategy.IvModel = sVM.IVModel;
}
if (model == StrategyVM.Model.VM)
{
strategy.VolModel = sVM.VolModel;
}
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_MODIFY_PRICING_CONTRACT, strategy);
}
public Task <ObservableCollection <RiskVM> > QueryRiskAsync(string portfolio, int timeout = 10000)
{
var sst = new StringMap();
var msgId = (uint)BusinessMessageID.MSG_ID_QUERY_RISK;
var tcs = new TaskCompletionSource <ObservableCollection <RiskVM> >(new CancellationTokenSource(timeout));
var serialId = NextSerialId;
sst.Header = new DataHeader {
SerialId = serialId
};
sst.Entry.Add(string.Empty, portfolio);
MessageWrapper.RegisterAction <PBRiskList, ExceptionMessage>
(msgId,
(resp) =>
{
if (resp.Header?.SerialId == serialId)
{
tcs.TrySetResult(OnQueryRiskSuccessAction(resp));
}
},
(bizErr) =>
{
OnErrorAction(bizErr);
tcs.SetResult(null);
}
);
MessageWrapper.SendMessage(msgId, sst);
return(tcs.Task);
}
public void UpdateStrategy(StrategyVM sVM, bool resetCounter = false)
{
var strategy = new PBStrategy();
strategy.Exchange = sVM.Exchange;
strategy.Contract = sVM.Contract;
strategy.Symbol = sVM.StrategySym;
strategy.Depth = sVM.Depth;
strategy.BidQV = sVM.BidQV;
strategy.AskQV = sVM.AskQV;
strategy.Hedging = sVM.Hedging;
strategy.AskEnabled = sVM.AskEnabled;
strategy.BidEnabled = sVM.BidEnabled;
strategy.MaxAutoTrade = sVM.MaxAutoTrade;
strategy.BidNotCross = sVM.BidNotCross;
strategy.CloseMode = sVM.CloseMode;
strategy.Tif = (int)sVM.TIF;
strategy.VolCond = (int)sVM.VolCondition;
strategy.TickSizeMult = sVM.TickSize;
if (resetCounter)
{
strategy.BidCounter = -1;
strategy.AskCounter = -1;
}
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_MODIFY_STRATEGY, strategy);
}
public void QueryAccountInfo()
{
var sst = new StringMap();
sst.Header = new DataHeader();
sst.Header.SerialId = NextSerialId;
MessageWrapper?.SendMessage((uint)BusinessMessageID.MSG_ID_QUERY_ACCOUNT_INFO, sst);
}
public void QueryPositionDiffer()
{
var sst = new StringMap();
sst.Header = new DataHeader();
sst.Header.SerialId = NextSerialId;
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_QUERY_POSITION_DIFFER, sst);
}
public void QueryTrade()
{
var sst = new StringMap();
sst.Header = new DataHeader();
sst.Header.SerialId = NextSerialId;
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_QUERY_TRADE, sst);
}
public void RemoveTempModel(string modelName)
{
var model = new ModelParams();
model.InstanceName = modelName;
MessageWrapper.SendMessage((uint)SystemMessageID.MSG_ID_UPDATE_TEMPMODELPARAMS, model);
}
public void NewWingModelInstance(string modelName)
{
var modelParam = new ModelParams();
modelParam.InstanceName = modelName;
modelParam.Model = "wing";
MessageWrapper.SendMessage((uint)SystemMessageID.MSG_ID_UPDATE_MODELPARAMS, modelParam);
}
public void UpdateTempModelParams(string modelName, string paramName, double paramValue)
{
var model = new ModelParams();
model.InstanceName = modelName;
model.Params[paramName] = paramValue;
MessageWrapper.SendMessage((uint)SystemMessageID.MSG_ID_UPDATE_TEMPMODELPARAMS, model);
}
public void CancelOrder(OrderVM orderVM)
{
var sendobjBld = new PBOrderRequest();
sendobjBld.Exchange = orderVM.Exchange;
sendobjBld.Contract = orderVM.Contract;
sendobjBld.OrderID = orderVM.OrderID;
sendobjBld.OrderSysID = orderVM.OrderSysID;
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_ORDER_CANCEL, sendobjBld);
}
public void CreatePortfolio(string portfolio)
{
var portfolioList = new PBPortfolioList();
portfolioList.Portfolio.Add(new PBPortfolio {
Name = portfolio
});
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_PORTFOLIO_NEW, portfolioList);
}
public Task <ObservableCollection <RiskVM> > QueryValuationRiskAsync(QueryValuation queryValuation, string portfolio, int timeout = 10000)
{
var sst = new PBValuationRisk();
var msgId = (uint)BusinessMessageID.MSG_ID_QUERY_VALUATION_RISK;
var tcs = new TaskCompletionSource <ObservableCollection <RiskVM> >(new CancellationTokenSource(timeout));
var serialId = NextSerialId;
sst.Header = new DataHeader {
SerialId = serialId
};
sst.Portfolio = portfolio;
sst.Interest = queryValuation.Interest.HasValue ? queryValuation.Interest.Value : -1;
if (queryValuation.DaysRemain.HasValue)
{
sst.DaysRemain = queryValuation.DaysRemain.Value;
}
foreach (var cv in queryValuation.ContractParams)
{
var valuation = new PBValuationContract()
{
Contract = cv.Key,
Price = cv.Value.Price
};
if (cv.Value.Volatitly != 0)
{
valuation.Volatility = cv.Value.Volatitly;
}
sst.ContractValue.Add(valuation);
}
MessageWrapper.RegisterAction <PBRiskList, ExceptionMessage>
(msgId,
(resp) =>
{
if (resp.Header?.SerialId == serialId)
{
tcs.TrySetResult(OnQueryRiskSuccessAction(resp));
}
},
(bizErr) =>
{
OnErrorAction(bizErr);
tcs.SetResult(null);
}
);
MessageWrapper.SendMessage(msgId, sst);
return(tcs.Task);
}
public void UpdateQuantity(string exchange, string contract, int quantity)
{
var userParamBd = new PBOTCUserParam();
userParamBd.Exchange = exchange;
userParamBd.Contract = contract;
userParamBd.Quantity = quantity;
var userParamListBd = new PBOTCUserParamList();
userParamListBd.Params.Add(userParamBd);
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_MODIFY_USER_PARAM, userParamListBd);
}
public void UpdateModelParams(string modelName, IDictionary <string, double> keyvalues)
{
var model = new ModelParams();
model.InstanceName = modelName;
foreach (var pair in keyvalues)
{
model.Params[pair.Key] = pair.Value;
}
MessageWrapper.SendMessage((uint)SystemMessageID.MSG_ID_UPDATE_MODELPARAMS, model);
}
public void UpdatePortfolio(PortfolioVM pVM)
{
var portfolio = new PBPortfolio();
portfolio.Name = pVM.Name;
portfolio.HedgeDelay = pVM.Delay;
portfolio.Threshold = pVM.Threshold;
portfolio.Hedging = pVM.Hedging;
portfolio.HedgeVolume = pVM.HedgeVolume;
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_MODIFY_PORTFOLIO, portfolio);
}
public void CreateOrder(OrderVM orderVM)
{
if (orderVM == null)
{
OnOrderError?.Invoke(new Exception("订单对象异常"));
return;
}
if (orderVM.Contract == null)
{
OnOrderError?.Invoke(new Exception("订单合约不能为空"));
return;
}
if (orderVM.Volume <= 0)
{
OnOrderError?.Invoke(new Exception("订单数量不正确"));
return;
}
double price = 0;
var contractInfo = ClientDbContext.FindContract(orderVM.Contract);
if (contractInfo != null)
{
price = Math.Round(orderVM.LimitPrice / contractInfo.PriceTick) * contractInfo.PriceTick;
}
else
{
OnOrderError?.Invoke(new Exception("输入合约不存在"));
return;
}
var pb = new PBOrderRequest();
pb.Contract = orderVM.Contract;
pb.LimitPrice = orderVM.LimitPrice;
pb.Tif = (int)orderVM.TIF;
pb.VolCond = (int)orderVM.VolCondition;
pb.Volume = orderVM.Volume;
pb.ExecType = (int)orderVM.ExecType;
pb.Direction = (int)orderVM.Direction;
pb.Openclose = (int)orderVM.OpenClose;
if (orderVM.Portfolio != null)
{
pb.Portfolio = orderVM.Portfolio;
}
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_ORDER_NEW, pb);
}
public void CreatePortfolios(IEnumerable <PortfolioVM> portfolios)
{
var portfolioList = new PBPortfolioList();
foreach (var portfolio in portfolios)
{
portfolioList.Portfolio.Add(new PBPortfolio {
Name = portfolio.Name, HedgeDelay = portfolio.Delay, Threshold = portfolio.Threshold
});
}
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_PORTFOLIO_NEW, portfolioList);
}
public void UpdateContractParam(ContractParamVM cpVM)
{
var cpBd = new PBContractParam
{
Exchange = cpVM.Exchange,
Contract = cpVM.Contract,
DepthVol = cpVM.DepthVol,
Gamma = cpVM.Gamma
};
var cpLstBd = new PBContractParamList();
cpLstBd.Params.Add(cpBd);
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_MODIFY_CONTRACT_PARAM, cpLstBd);
}
public void UpdateHedgeContracts(HedgeVM hVM, string PortfolioName)
{
var hedge = new PBHedgeContract();
hedge.Exchange = hVM.Exchange;
hedge.Contract = hVM.Contract;
hedge.Underlying = hVM.Underlying;
var portfolio = new PBPortfolio();
portfolio.Name = PortfolioName;
portfolio.HedgeContracts.Add(hedge);
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_HEDGE_CONTRACT_UPDATE, portfolio);
}
public void SendMessage(uint serialId, uint msgId, IEnumerable <ContractKeyVM> instrIDList)
{
var instr = new PBInstrumentList();
foreach (var instrID in instrIDList)
{
instr.Instrument.Add(new PBInstrument {
Exchange = instrID.Exchange, Contract = instrID.Contract
});
}
instr.Header = new DataHeader {
SerialId = serialId
};
MessageWrapper.SendMessage(msgId, instr);
}
public void UnsubMarketData(IEnumerable <string> instrIDList)
{
var instr = new NamedStringVector();
instr.Name = (FieldName.INSTRUMENT_ID);
foreach (string instrID in instrIDList)
{
instr.Entry.Add(instrID);
}
var sst = new SimpleStringTable();
sst.Columns.Add(instr);
MessageWrapper?.SendMessage((uint)BusinessMessageID.MSG_ID_UNSUB_MARKETDATA, sst);
}
public void SendSimMarketData(MarketDataOpt mdo)
{
if (mdo == null)
{
return;
}
var mktData = new PBMarketData();
mktData.Exchange = mdo.Exchange;
mktData.Contract = mdo.Contract;
mktData.AskPrice.Add(mdo.AskPrice);
mktData.BidPrice.Add(mdo.BidPrice);
mktData.AskVolume.Add(mdo.AskSize);
mktData.BidVolume.Add(mdo.BidSize);
MessageWrapper?.SendMessage((uint)BusinessMessageID.MSG_ID_RET_MARKETDATA, mktData);
}
public Task <bool> SyncContractInfoAsync(bool forced = false)
{
var today = DateTime.Now.Date.ToShortDateString();
var key = string.Format("{0}:{1}", nameof(ContractInfo), GetType().Name);
if (!forced && MFUtilities.GetSyncVersion(key) == today)
{
return(Task.FromResult(true));
}
var sst = new StringMap();
sst.Header = new DataHeader();
sst.Header.SerialId = NextSerialId;
var msgId = (uint)BusinessMessageID.MSG_ID_QUERY_INSTRUMENT;
var tcs = new TaskCompletionSource <bool>();
var serialId = NextSerialId;
sst.Header = new DataHeader {
SerialId = serialId
};
MessageWrapper.RegisterAction <PBContractInfoList, ExceptionMessage>
(msgId,
(resp) =>
{
if (resp.Header?.SerialId == serialId)
{
OnSyncContractInfo(key, resp);
tcs.TrySetResult(true);
}
},
(bizErr) =>
{
tcs.SetResult(false);
}
);
MessageWrapper.SendMessage(msgId, sst);
return(tcs.Task);
}
public Task <bool> ResetPassword(string newPassword, int timeout = 10000)
{
if (string.IsNullOrEmpty(newPassword))
{
return(Task.FromResult(false));
}
var msgId = (uint)AccountManageMessageID.MSG_ID_RESET_PASSWORD;
var tcs = new TaskCompletionSource <bool>(new CancellationTokenSource(timeout));
var serialId = NextSerialId;
var sst = new StringMap();
sst.Header = new DataHeader {
SerialId = serialId
};
_hashEncoder.Option.Iteration = MD5Round;
sst.Entry[FieldName.PASSWORD] = _hashEncoder.Encode(newPassword);
#region callback
MessageWrapper.RegisterAction <Result, ExceptionMessage>
(msgId,
(resp) =>
{
if (resp?.SerialId == serialId)
{
tcs.TrySetResult(true);
}
},
(ExceptionMessage bizErr) =>
{
tcs.SetResult(false);
}
);
#endregion
MessageWrapper.SendMessage(msgId, sst);
return(tcs.Task);
}
public void UpdateStrategyPricingContracts(StrategyVM sVM, StrategyVM.Model model)
{
var strategy = new PBStrategy();
strategy.Exchange = sVM.Exchange;
strategy.Contract = sVM.Contract;
strategy.Symbol = sVM.StrategySym;
if (model == StrategyVM.Model.PM)
{
foreach (var pc in sVM.PricingContractParams)
{
strategy.PricingContracts.Add(new PBPricingContract()
{
Exchange = pc.Exchange, Contract = pc.Contract, Adjust = pc.Adjust, Weight = pc.Weight
});
}
}
if (model == StrategyVM.Model.IVM)
{
foreach (var pc in sVM.IVMContractParams)
{
strategy.IvmContracts.Add(new PBPricingContract()
{
Exchange = pc.Exchange, Contract = pc.Contract, Adjust = pc.Adjust, Weight = pc.Weight
});
}
}
if (model == StrategyVM.Model.VM)
{
foreach (var pc in sVM.VMContractParams)
{
strategy.VolContracts.Add(new PBPricingContract()
{
Exchange = pc.Exchange, Contract = pc.Contract, Adjust = pc.Adjust, Weight = pc.Weight
});
}
}
MessageWrapper.SendMessage((uint)BusinessMessageID.MSG_ID_MODIFY_PRICING_CONTRACT, strategy);
}
public Task <int> QueryMaxLimitOrderAsync(int timeout = 10000)
{
const string LIMITORDERMAX = "LIMITORDER.MAXCOUNT";
var sst = new StringMap();
var msgId = (uint)SystemMessageID.MSG_ID_QUERY_SYSPARAMS;
var tcs = new TaskCompletionSource <int>(new CancellationTokenSource(timeout));
var serialId = NextSerialId;
sst.Header = new DataHeader {
SerialId = serialId
};
sst.Entry.Add(LIMITORDERMAX, string.Empty);
MessageWrapper?.RegisterAction <StringMap, ExceptionMessage>
(msgId,
(resp) =>
{
if (resp.Header?.SerialId == serialId)
{
string strMaxOrder;
if (resp.Entry.TryGetValue(LIMITORDERMAX, out strMaxOrder))
{
tcs.SetResult(int.Parse(strMaxOrder));
}
else
{
tcs.SetResult(0);
}
}
},
(bizErr) =>
{
OnErrorAction(bizErr);
tcs.SetResult(0);
}
);
MessageWrapper?.SendMessage(msgId, sst);
return(tcs.Task);
}
public Task <ModelParamsVM> QueryModelParamsAsync(string modelName, int timeout = 10000)
{
if (string.IsNullOrEmpty(modelName))
{
return(Task.FromResult <ModelParamsVM>(null));
}
var msgId = (uint)SystemMessageID.MSG_ID_QUERY_MODELPARAMS;
var tcs = new TaskCompletionSource <ModelParamsVM>(new CancellationTokenSource(timeout));
var serialId = NextSerialId;
ModelParams modelParams = new ModelParams();
modelParams.Header = new DataHeader {
SerialId = serialId
};
modelParams.InstanceName = modelName;
#region callback
MessageWrapper.RegisterAction <ModelParams, ExceptionMessage>
(msgId,
(resp) =>
{
if (resp.Header?.SerialId == serialId)
{
tcs.TrySetResult(OnQueryModelParamsSuccess(resp));
}
},
(ExceptionMessage bizErr) =>
{
OnErrorAction(bizErr);
tcs.SetResult(null);
}
);
#endregion
MessageWrapper.SendMessage(msgId, modelParams);
return(tcs.Task);
}
public Task <IDictionary <string, ObservableCollection <ModelParamsVM> > > QueryAllModelParamsAsync(int timeout = 10000)
{
var msgId = (uint)SystemMessageID.MSG_ID_QUERY_MODELPARAMS;
var tcs = new TaskCompletionSource <IDictionary <string, ObservableCollection <ModelParamsVM> > >(new CancellationTokenSource(timeout));
var serialId = NextSerialId;
ModelParams modelParams = new ModelParams();
modelParams.Header = new DataHeader()
{
SerialId = serialId
};
#region callback
MessageWrapper.RegisterAction <ModelParams, ExceptionMessage>
(msgId,
(resp) =>
{
if (resp.Header?.SerialId == serialId)
{
OnQueryModelParamsSuccess(resp);
if (resp.Header == null || !resp.Header.HasMore)
{
tcs.TrySetResult(_modelDict);
}
}
},
(ExceptionMessage bizErr) =>
{
OnErrorAction(bizErr);
tcs.SetResult(null);
}
);
#endregion
MessageWrapper.SendMessage(msgId, modelParams);
return(tcs.Task);
}
public virtual void SendMessage(uint serialId, uint msgId, IEnumerable <ContractKeyVM> instrIDList)
{
var instr = new NamedStringVector();
instr.Name = (FieldName.INSTRUMENT_ID);
foreach (var instrID in instrIDList)
{
instr.Entry.Add(instrID.Contract);
}
var sst = new SimpleStringTable();
sst.Header = new DataHeader {
SerialId = serialId
};
sst.Columns.Add(instr);
MessageWrapper.SendMessage(msgId, sst);
}
